264 lines
9.7 KiB
TypeScript
264 lines
9.7 KiB
TypeScript
import { InsufficientPermissions, formatDate, getDayOfWeekIndex, getHumanDate, getHumanTime, getIsWeekend } from "./utils";
|
|
import { ClientData, Locations, Restaurants, Menu, DepartureTime } from "../../types";
|
|
import getStorage from "./storage";
|
|
import { getMenuSladovnicka, getMenuTechTower, getMenuUMotliku } from "./restaurants";
|
|
import { getTodayMock } from "./mock";
|
|
|
|
const storage = getStorage();
|
|
|
|
/** Vrátí dnešní datum, případně fiktivní datum pro účely vývoje a testování. */
|
|
export function getToday(): Date {
|
|
if (process.env.MOCK_DATA === 'true') {
|
|
return new Date(getTodayMock());
|
|
}
|
|
return new Date();
|
|
}
|
|
|
|
/** Vrátí datum v aktuálním týdnu na základě předaného indexu (0 = pondělí). */
|
|
export const getDateForWeekIndex = (index: number) => {
|
|
if (index < 0 || index > 4) {
|
|
// Nechceme shodit server, vrátíme dnešek
|
|
console.log('Neplatný index dne v týdnu: ' + index);
|
|
return getToday();
|
|
}
|
|
const date = getToday();
|
|
date.setDate(date.getDate() - getDayOfWeekIndex(date) + index);
|
|
return date;
|
|
}
|
|
|
|
/** Vrátí "prázdná" (implicitní) data pro předaný den. */
|
|
function getEmptyData(date?: Date): ClientData {
|
|
const usedDate = date || getToday();
|
|
return {
|
|
date: getHumanDate(usedDate),
|
|
isWeekend: getIsWeekend(usedDate),
|
|
weekIndex: getDayOfWeekIndex(usedDate),
|
|
todayWeekIndex: getDayOfWeekIndex(getToday()),
|
|
choices: {},
|
|
departureTimes: Object.values(DepartureTime),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Vrátí veškerá klientská data pro předaný den, nebo aktuální den, pokud není předán.
|
|
*/
|
|
export async function getData(date?: Date): Promise<ClientData> {
|
|
const dateString = formatDate(date ?? getToday());
|
|
const data = await storage.getData(dateString) || getEmptyData(date);
|
|
// Dotažení jídel, pokud je ještě nemáme
|
|
if (!data.menus) {
|
|
data.menus = {
|
|
[Restaurants.SLADOVNICKA]: await getRestaurantMenu(Restaurants.SLADOVNICKA, date ?? getToday()),
|
|
[Restaurants.UMOTLIKU]: await getRestaurantMenu(Restaurants.UMOTLIKU, date ?? getToday()),
|
|
[Restaurants.TECHTOWER]: await getRestaurantMenu(Restaurants.TECHTOWER, date ?? getToday()),
|
|
}
|
|
await storage.setData(dateString, data);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
// TODO přesun do restaurants.ts
|
|
/**
|
|
* Vrátí menu dané restaurace pro předaný den. Pokud neexistuje, provede jeho stažení a uložení do DB.
|
|
*
|
|
* @param restaurant restaurace
|
|
* @param date datum
|
|
* @param mock příznak, zda chceme pouze mock data
|
|
*/
|
|
export async function getRestaurantMenu(restaurant: Restaurants, date?: Date): Promise<Menu> {
|
|
await initIfNeeded(date);
|
|
const selectedDay = formatDate(date ?? getToday());
|
|
const clientData: ClientData = await storage.getData(selectedDay);
|
|
if (!clientData.menus) {
|
|
clientData.menus = {};
|
|
storage.setData(selectedDay, clientData);
|
|
}
|
|
if (!clientData.menus[restaurant]) {
|
|
clientData.menus[restaurant] = {
|
|
lastUpdate: getHumanTime(new Date()),
|
|
closed: false,
|
|
food: [],
|
|
};
|
|
const mock = process.env.MOCK_DATA === 'true';
|
|
switch (restaurant) {
|
|
case Restaurants.SLADOVNICKA:
|
|
clientData.menus[restaurant]!.food = await getMenuSladovnicka(date, mock);
|
|
break;
|
|
case Restaurants.UMOTLIKU:
|
|
const uMotlikuFood = await getMenuUMotliku(date, mock);
|
|
clientData.menus[restaurant]!.food = uMotlikuFood;
|
|
if (uMotlikuFood.length === 1 && uMotlikuFood[0].name.toLowerCase() === 'zavřeno') {
|
|
clientData.menus[restaurant]!.closed = true;
|
|
}
|
|
break;
|
|
case Restaurants.TECHTOWER:
|
|
clientData.menus[restaurant]!.food = await getMenuTechTower(date, mock);
|
|
break;
|
|
}
|
|
storage.setData(selectedDay, clientData);
|
|
}
|
|
return clientData.menus[restaurant]!;
|
|
}
|
|
|
|
export async function initIfNeeded(date?: Date) {
|
|
const usedDate = formatDate(date ?? getToday());
|
|
const hasData = await storage.hasData(usedDate);
|
|
if (!hasData) {
|
|
await storage.setData(usedDate, getEmptyData(date || getToday()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Odstraní kompletně volbu uživatele (včetně případných podřízených jídel).
|
|
*
|
|
* @param login login uživatele
|
|
* @param trusted příznak, zda se jedná o ověřeného uživatele
|
|
* @param location vybrané "umístění"
|
|
* @param date datum, ke kterému se volba vztahuje
|
|
* @returns
|
|
*/
|
|
export async function removeChoices(login: string, trusted: boolean, location: Locations, date?: Date) {
|
|
const selectedDay = formatDate(date ?? getToday());
|
|
let data: ClientData = await storage.getData(selectedDay);
|
|
validateTrusted(data, login, trusted);
|
|
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(selectedDay, 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 trusted příznak, zda se jedná o ověřeného 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
|
|
* @param date datum, ke kterému se volba vztahuje
|
|
* @returns
|
|
*/
|
|
export async function removeChoice(login: string, trusted: boolean, location: Locations, foodIndex: number, date?: Date) {
|
|
const selectedDay = formatDate(date ?? getToday());
|
|
let data: ClientData = await storage.getData(selectedDay);
|
|
validateTrusted(data, login, trusted);
|
|
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(selectedDay, data);
|
|
}
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Odstraní kompletně volbu uživatele.
|
|
*
|
|
* @param login login uživatele
|
|
*/
|
|
async function removeChoiceIfPresent(login: string, date: string) {
|
|
let data: ClientData = await storage.getData(date);
|
|
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(date, data);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Ověří, zda se neověřený uživatel nepokouší přepsat údaje ověřeného a případně vyhodí chybu.
|
|
*
|
|
* @param data aktuální klientská data
|
|
* @param login přihlašovací jméno uživatele
|
|
* @param trusted příznak, zda se jedná o ověřeného uživatele
|
|
*/
|
|
function validateTrusted(data: ClientData, login: string, trusted: boolean) {
|
|
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 new InsufficientPermissions("Nelze změnit volbu ověřeného uživatele");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Přidá volbu uživatele.
|
|
*
|
|
* @param login login uživatele
|
|
* @param trusted příznak, zda se jedná o ověřeného 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
|
|
* @param date datum, ke kterému se volba vztahuje
|
|
* @returns aktuální data
|
|
*/
|
|
export async function addChoice(login: string, trusted: boolean, location: Locations, foodIndex?: number, date?: Date) {
|
|
await initIfNeeded();
|
|
const selectedDate = formatDate(date ?? getToday());
|
|
let data: ClientData = await storage.getData(selectedDate);
|
|
validateTrusted(data, login, trusted);
|
|
// Pokud měníme pouze lokaci, mažeme případné předchozí
|
|
if (foodIndex == null) {
|
|
data = await removeChoiceIfPresent(login, selectedDate);
|
|
}
|
|
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(selectedDate, data);
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Aktualizuje preferovaný čas odchodu strávníka.
|
|
*
|
|
* @param login login uživatele
|
|
* @param time preferovaný čas odchodu
|
|
* @param date datum, ke kterému se čas vztahuje
|
|
*/
|
|
export async function updateDepartureTime(login: string, time?: string, date?: Date) {
|
|
const selectedDate = formatDate(date ?? getToday());
|
|
let clientData: ClientData = await storage.getData(selectedDate);
|
|
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 {
|
|
if (!Object.values<string>(DepartureTime).includes(time)) {
|
|
throw Error(`Neplatný čas odchodu ${time}`);
|
|
}
|
|
found[login].departureTime = time;
|
|
}
|
|
await storage.setData(selectedDate, clientData);
|
|
}
|
|
return clientData;
|
|
} |