397 lines
14 KiB
TypeScript
397 lines
14 KiB
TypeScript
import { formatDate, getHumanDate, getIsWeekend } from "./utils";
|
|
import { callNotifikace } from "./notifikace";
|
|
import { generateQr } from "./qr";
|
|
import { ClientData, PizzaDayState, UdalostEnum, Pizza, PizzaSize, Order, PizzaOrder, Locations } from "../../types";
|
|
import getStorage from "./storage";
|
|
|
|
const storage = getStorage();
|
|
|
|
/** Vrátí dnešní datum, případně fiktivní datum pro účely vývoje a testování. */
|
|
function getToday(): Date {
|
|
if (process.env.MOCK_DATA) {
|
|
return new Date('2023-05-31');
|
|
}
|
|
return new Date();
|
|
}
|
|
|
|
/** Vrátí "prázdná" (implicitní) data, pokud ještě nikdo nehlasoval. */
|
|
function getEmptyData(): ClientData {
|
|
return { date: getHumanDate(getToday()), isWeekend: getIsWeekend(getToday()), choices: {} };
|
|
}
|
|
|
|
/**
|
|
* Vrátí veškerá klientská data pro aktuální den.
|
|
*/
|
|
export async function getData(): Promise<ClientData> {
|
|
return await storage.getData(formatDate(getToday())) || getEmptyData();
|
|
}
|
|
|
|
/**
|
|
* Vytvoří pizza day pro aktuální den a vrátí data pro klienta.
|
|
*/
|
|
export async function createPizzaDay(creator: string): Promise<ClientData> {
|
|
await initIfNeeded();
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den již existuje");
|
|
}
|
|
const data: ClientData = { pizzaDay: { state: PizzaDayState.CREATED, creator, orders: [] }, ...clientData };
|
|
await storage.setData(today, data);
|
|
callNotifikace({ input: { udalost: UdalostEnum.ZAHAJENA_PIZZA, user: creator } })
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Smaže pizza day pro aktuální den.
|
|
*/
|
|
export async function deletePizzaDay(login: string): Promise<ClientData> {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.creator !== login) {
|
|
throw Error("Login uživatele se neshoduje se zakladatelem Pizza Day");
|
|
}
|
|
delete clientData.pizzaDay;
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Přidá objednávku pizzy uživateli.
|
|
*
|
|
* @param login login uživatele
|
|
* @param pizza zvolená pizza
|
|
* @param size zvolená velikost pizzy
|
|
*/
|
|
export async function addPizzaOrder(login: string, pizza: Pizza, size: PizzaSize) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
|
|
}
|
|
let order: Order | undefined = clientData.pizzaDay.orders.find(o => o.customer === login);
|
|
if (!order) {
|
|
order = {
|
|
customer: login,
|
|
pizzaList: [],
|
|
totalPrice: 0,
|
|
}
|
|
clientData.pizzaDay.orders.push(order);
|
|
}
|
|
const pizzaOrder: PizzaOrder = {
|
|
varId: size.varId,
|
|
name: pizza.name,
|
|
size: size.size,
|
|
price: size.price,
|
|
}
|
|
order.pizzaList.push(pizzaOrder);
|
|
order.totalPrice += pizzaOrder.price;
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Odstraní danou objednávku pizzy.
|
|
*
|
|
* @param login login uživatele
|
|
* @param pizzaOrder objednávka pizzy
|
|
*/
|
|
export async function removePizzaOrder(login: string, pizzaOrder: PizzaOrder) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
const orderIndex = clientData.pizzaDay.orders.findIndex(o => o.customer === login);
|
|
if (orderIndex < 0) {
|
|
throw Error("Nebyly nalezeny žádné objednávky pro uživatele " + login);
|
|
}
|
|
const order = clientData.pizzaDay.orders[orderIndex];
|
|
const index = order.pizzaList.findIndex(o => o.name === pizzaOrder.name && o.size === pizzaOrder.size);
|
|
if (index < 0) {
|
|
throw Error("Objednávka s danými parametry nebyla nalezena");
|
|
}
|
|
const price = order.pizzaList[index].price;
|
|
order.pizzaList.splice(index, 1);
|
|
order.totalPrice -= price;
|
|
if (order.pizzaList.length == 0) {
|
|
clientData.pizzaDay.orders.splice(orderIndex, 1);
|
|
}
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Uzamkne možnost editovat objednávky pizzy.
|
|
*
|
|
* @param login login uživatele
|
|
* @returns aktuální data pro uživatele
|
|
*/
|
|
export async function lockPizzaDay(login: string) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.creator !== login) {
|
|
throw Error("Pizza day není spravován uživatelem " + login);
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.CREATED && clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED + " nebo " + PizzaDayState.ORDERED);
|
|
}
|
|
clientData.pizzaDay.state = PizzaDayState.LOCKED;
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Odekmne možnost editovat objednávky pizzy.
|
|
*
|
|
* @param login login uživatele
|
|
* @returns aktuální data pro uživatele
|
|
*/
|
|
export async function unlockPizzaDay(login: string) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.creator !== login) {
|
|
throw Error("Pizza day není spravován uživatelem " + login);
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
|
|
}
|
|
clientData.pizzaDay.state = PizzaDayState.CREATED;
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Nastaví stav pizza day na "pizzy objednány".
|
|
*
|
|
* @param login login uživatele
|
|
* @returns aktuální data pro uživatele
|
|
*/
|
|
export async function finishPizzaOrder(login: string) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.creator !== login) {
|
|
throw Error("Pizza day není spravován uživatelem " + login);
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
|
|
}
|
|
clientData.pizzaDay.state = PizzaDayState.ORDERED;
|
|
await storage.setData(today, clientData);
|
|
callNotifikace({ input: { udalost: UdalostEnum.OBJEDNANA_PIZZA, user: clientData?.pizzaDay?.creator } })
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Nastaví stav pizza day na "pizzy doručeny".
|
|
* Vygeneruje QR kódy pro všechny objednatele, pokud objednávající má vyplněné číslo účtu a jméno.
|
|
*
|
|
* @param login login uživatele
|
|
* @returns aktuální data pro uživatele
|
|
*/
|
|
export async function finishPizzaDelivery(login: string, bankAccount?: string, bankAccountHolder?: string) {
|
|
const today = formatDate(getToday());
|
|
const clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.creator !== login) {
|
|
throw Error("Pizza day není spravován uživatelem " + login);
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.ORDERED);
|
|
}
|
|
clientData.pizzaDay.state = PizzaDayState.DELIVERED;
|
|
|
|
// Vygenerujeme QR kód, pokud k tomu máme data
|
|
// TODO berka je potřeba počkat na resolve promises z generateQr a až poté volat save do DB
|
|
if (bankAccount?.length && bankAccountHolder?.length) {
|
|
for (const order of clientData.pizzaDay.orders) {
|
|
if (order.customer !== login) { // zatím platí creator = objednávající, a pro toho nemá QR kód smysl
|
|
let message = order.pizzaList.map(pizza => `Pizza ${pizza.name} (${pizza.size})`).join(', ');
|
|
const price = order.pizzaList.map(pizza => pizza.price).reduce((partial, a) => partial + a, 0);
|
|
generateQr(order.customer, bankAccount, bankAccountHolder, price, message).then(() => order.hasQr = true);
|
|
}
|
|
}
|
|
}
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
export async function initIfNeeded() {
|
|
const today = formatDate(getToday());
|
|
const hasData = await storage.hasData(today);
|
|
if (!hasData) {
|
|
await storage.setData(today, getEmptyData());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Odstraní kompletně volbu uživatele (včetně případných podřízených jídel).
|
|
*
|
|
* @param login login uživatele
|
|
* @param location vybrané "umístění"
|
|
* @returns
|
|
*/
|
|
export async function removeChoices(login: string, location: Locations) {
|
|
const today = formatDate(getToday());
|
|
let data: ClientData = await storage.getData(today);
|
|
// TODO zajistit, že neověřený uživatel se stejným loginem nemůže mazat volby ověřeného
|
|
if (location in data.choices) {
|
|
if (login in data.choices[location]) {
|
|
delete data.choices[location][login]
|
|
if (Object.keys(data.choices[location]).length === 0) {
|
|
delete data.choices[location]
|
|
}
|
|
await storage.setData(today, data);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Odstraní konkrétní volbu jídla uživatele.
|
|
* Neodstraňuje volbu samotnou, k tomu slouží {@link removeChoices}.
|
|
*
|
|
* @param login login uživatele
|
|
* @param location vybrané "umístění"
|
|
* @param foodIndex index jídla v jídelním lístku daného umístění, pokud existuje
|
|
* @returns
|
|
*/
|
|
export async function removeChoice(login: string, location: Locations, foodIndex: number) {
|
|
const today = formatDate(getToday());
|
|
let data: ClientData = await storage.getData(today);
|
|
// TODO řešit ověření uživatele
|
|
if (location in data.choices) {
|
|
if (login in data.choices[location]) {
|
|
const index = data.choices[location][login].options.indexOf(foodIndex);
|
|
if (index > -1) {
|
|
data.choices[location][login].options.splice(index, 1)
|
|
await storage.setData(today, data);
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Odstraní kompletně volbu uživatele.
|
|
*
|
|
* @param login login uživatele
|
|
*/
|
|
async function removeChoiceIfPresent(login: string) {
|
|
const today = formatDate(getToday());
|
|
let data: ClientData = await storage.getData(today);
|
|
for (const key of Object.keys(data.choices)) {
|
|
if (login in data.choices[key]) {
|
|
delete data.choices[key][login];
|
|
if (Object.keys(data.choices[key]).length === 0) {
|
|
delete data.choices[key];
|
|
}
|
|
await storage.setData(today, data);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Přidá volbu uživatele.
|
|
*
|
|
* @param login login uživatele
|
|
* @param location vybrané "umístění"
|
|
* @param foodIndex volitelný index jídla v daném umístění
|
|
* @param trusted příznak, zda se jedná o ověřeného uživatele
|
|
* @returns aktuální data
|
|
*/
|
|
export async function addChoice(login: string, trusted: boolean, location: Locations, foodIndex?: number) {
|
|
await initIfNeeded();
|
|
const today = formatDate(getToday());
|
|
let data: ClientData = await storage.getData(today);
|
|
// Ověření, že se neověřený užívatel nepokouší přepsat údaje ověřeného
|
|
const locations = Object.values(data?.choices);
|
|
let found = false;
|
|
if (!trusted) {
|
|
for (const location of locations) {
|
|
if (Object.keys(location).includes(login) && location[login].trusted) {
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
if (!trusted && found) {
|
|
throw Error("Nelze změnit volbu ověřeného uživatele");
|
|
}
|
|
// Pokud měníme pouze lokaci, mažeme případné předchozí
|
|
if (foodIndex == null) {
|
|
data = await removeChoiceIfPresent(login);
|
|
}
|
|
if (!(location in data.choices)) {
|
|
data.choices[location] = {};
|
|
}
|
|
if (!(login in data.choices[location])) {
|
|
data.choices[location][login] = {
|
|
trusted,
|
|
options: []
|
|
};
|
|
}
|
|
if (foodIndex != null && !data.choices[location][login].options.includes(foodIndex)) {
|
|
data.choices[location][login].options.push(foodIndex);
|
|
}
|
|
await storage.setData(today, data);
|
|
return data;
|
|
}
|
|
|
|
// TODO přejmenovat, ať je jasné že to patří k pizza day
|
|
export async function updateNote(login: string, note?: string) {
|
|
const today = formatDate(getToday());
|
|
let clientData: ClientData = await storage.getData(today);
|
|
if (!clientData.pizzaDay) {
|
|
throw Error("Pizza day pro dnešní den neexistuje");
|
|
}
|
|
if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
|
|
throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
|
|
}
|
|
const myOrder = clientData.pizzaDay.orders.find(o => o.customer === login);
|
|
if (!myOrder || !myOrder.pizzaList.length) {
|
|
throw Error("Pizza day neobsahuje žádné objednávky uživatele " + login);
|
|
}
|
|
myOrder.note = note;
|
|
await storage.setData(today, clientData);
|
|
return clientData;
|
|
}
|
|
|
|
/**
|
|
* Aktualizuje preferovaný čas odchodu strávníka.
|
|
*
|
|
* @param login login uživatele
|
|
* @param time preferovaný čas odchodu
|
|
*/
|
|
export async function updateDepartureTime(login: string, time?: string) {
|
|
const today = formatDate(getToday());
|
|
let clientData: ClientData = await storage.getData(today);
|
|
const found = Object.values(clientData.choices).find(location => login in location);
|
|
// TODO validace, že se jedná o restauraci
|
|
if (found) {
|
|
if (!time?.length) {
|
|
delete found[login].departureTime;
|
|
} else {
|
|
found[login].departureTime = time;
|
|
}
|
|
await storage.setData(today, clientData);
|
|
}
|
|
return clientData;
|
|
} |