@alizadefaig/pos-server 1.2.25 → 1.2.27

package/app/core/services/ShiftService.js

@@ -0,0 +1,199 @@
+const SnapshotRepository = require('../repositories/SnapshotRepository');
+const ReportService = require('./ReportService');
+const telegram = require('../support/telegram');
+const telegramReport = require('../support/telegramReport');
+const {HttpError} = require('../errors');
+const {money, toBool} = require('../support/num');
+const {fromTimestamp, nowSql, toSql, diffInSeconds} = require('../support/time');
+const {uuid, isUuid} = require('../support/ids');
+const {isoDate} = require('../support/php');
+const {DEFAULT_TIMEZONE} = require('../support/tz');
+const {cashShiftLabels} = require('../resources/ShiftResource');
+
+// ShiftService::sendTelegramReport — те же разбивки, что и в Laravel.
+const REPORT_FORMATS = [
+    'by_table',
+    'by_workshop',
+    'by_employee',
+    'by_category',
+    'by_product',
+    'by_payment_method',
+    'by_order_source',
+];
+
+const param = (params, name, fallback = null) => {
+    const value = params ? params[name] : undefined;
+    return value === undefined || value === null ? fallback : value;
+};
+
+/**
+ * Кассовые и рабочие смены — порт App\Services\Platform\ShiftService и ShiftController.
+ * Один код для обоих контуров: облако (Postgres Laravel) и касса (SQLite, офлайн-обработчики).
+ *
+ * Колонка `deleted_at` у `shifts` есть в обеих схемах, поэтому мягко удалённые смены отсекаются
+ * всегда (SoftDeletes модели).
+ *
+ * Отчёт о закрытой смене в Telegram шлёт только облако: на кассе смена уедет наверх push'ем, и
+ * отчёт отправит облако при приёме (SyncService), как это делает Laravel.
+ */
+class ShiftService {
+    constructor({db, context}) {
+        this.db = db;
+        this.context = context;
+    }
+
+    /** Лениво: ядро (index.js) само требует сервисы, прямой require замкнул бы цикл. */
+    cloud() {
+        return require('../index').mode() === 'cloud' && this.db.dialect === 'pgsql';
+    }
+
+    /** ShiftService::getCashShift — открытая кассовая смена заведения, если смены включены. */
+    async cashShift() {
+        if (!toBool(this.context.setting('manage.use_cash_shift', false))) {
+            return null;
+        }
+        return new SnapshotRepository(this.db).findOpenCashShift(this.context.teamId, this.context.companyId);
+    }
+
+    /**
+     * ShiftService::getWorkShift. PHP ищет по заголовку employee-id (а кэширует по id сотрудника),
+     * поэтому на разблокировке другим сотрудником отдавал чужую смену. Здесь — по сотруднику.
+     */
+    async workShift(teamUserId) {
+        if (!toBool(this.context.setting('manage.use_work_shift', false))) {
+            return null;
+        }
+        return this.db.get(
+            `SELECT * FROM shifts
+                WHERE team_id = ? AND company_id = ? AND opened_by = ? AND type = 'work'
+                  AND ended_at IS NULL AND deleted_at IS NULL
+                ORDER BY started_at DESC
+                LIMIT 1`,
+            [this.context.teamId, this.context.companyId, teamUserId]
+        );
+    }
+
+    /** ShiftController::getCashShifts — все смены заведения (без фильтра по типу, как в PHP). */
+    async cashShifts() {
+        const team = this.context.getTeam();
+        const rows = await this.db.all(
+            `SELECT id, started_at, ended_at FROM shifts
+                WHERE team_id = ? AND company_id = ? AND deleted_at IS NULL
+                ORDER BY started_at DESC`,
+            [this.context.teamId, this.context.companyId]
+        );
+        return {success: true, data: cashShiftLabels(rows, (team && team.timezone) || DEFAULT_TIMEZONE)};
+    }
+
+    /**
+     * ShiftController::openCashShift. `user` — модель сразу после create(): только заполненные
+     * атрибуты, в порядке Eloquent (fillable, затем id из HasUuids, затем метки времени).
+     * На кассе смена уедет в облако push'ем раньше чеков (sync_dirty).
+     */
+    async openCashShift(params) {
+        const now = nowSql();
+        const shift = {
+            id: uuid(),
+            team_id: this.context.teamId,
+            company_id: this.context.companyId,
+            type: 'cash',
+            opened_by: this.context.employeeId,
+            // MoneyCast::set — round((float) $value, 3): пусто и мусор дают 0.
+            start_amount: money(param(params, 'amount', 0)),
+            end_amount: 0,
+            started_at: toSql(fromTimestamp(this.context.timestamp)),
+            created_at: now,
+            updated_at: now,
+        };
+        await this.db.insert('shifts', shift);
+        return {
+            success: true,
+            user: {
+                team_id: shift.team_id,
+                company_id: shift.company_id,
+                type: shift.type,
+                opened_by: shift.opened_by,
+                start_amount: shift.start_amount,
+                started_at: isoDate(shift.started_at),
+                id: shift.id,
+                updated_at: isoDate(shift.updated_at),
+                created_at: isoDate(shift.created_at),
+            },
+        };
+    }
+
+    /**
+     * ShiftController::closeCashShift — смена по id, иначе открытая кассовая. Ответ пустой.
+     * Отличия от PHP: смена ищется только в своей команде; смены нет — 404, а не 500.
+     */
+    async closeCashShift(params) {
+        const id = param(params, 'id');
+        let shift = id && isUuid(String(id))
+            ? await this.db.get(
+                'SELECT * FROM shifts WHERE id = ? AND team_id = ? AND deleted_at IS NULL',
+                [String(id), this.context.teamId]
+            )
+            : null;
+        if (!shift) {
+            shift = await this.cashShift();
+        }
+        if (!shift) {
+            throw new HttpError(404, {success: false, message: 'Shift not found'});
+        }
+
+        const endedAt = toSql(fromTimestamp(this.context.timestamp));
+        await this.db.update('shifts', shift.id, {
+            closed_by: this.context.employeeId,
+            end_amount: money(param(params, 'amount', 0)),
+            ended_at: endedAt,
+            // ceil($shift->started_at->diffInMinutes($endAt)); отрицательное (часы терминала
+            // отстали) PHP записал бы как есть — здесь 0.
+            minutes: Math.max(0, Math.ceil(diffInSeconds(shift.started_at, endedAt) / 60)),
+            updated_at: nowSql(),
+        });
+
+        if (this.cloud()) {
+            // PHP слал отчёт внутри запроса (Telegram до 30 с держал ответ кассе). Здесь — после.
+            const settings = this.context.settings();
+            setImmediate(() => {
+                ShiftService.sendTelegramReport({db: this.db, context: this.context}, shift.id, settings);
+            });
+        }
+        return null;
+    }
+
+    /**
+     * ShiftService::sendTelegramReport — отчёт по закрытой кассовой смене в чат команды.
+     * Статический: он же нужен приёму смен с кассы. Никогда не бросает, ждёт только сборку
+     * текста — отправка уходит в очередь чата (`support/telegram.js`).
+     *
+     * @param {{db, context}} services контекст команды и заведения смены
+     * @returns {Promise<boolean>} поставлен ли отчёт в очередь
+     */
+    static async sendTelegramReport({db, context}, shiftId, settings) {
+        const chatId = telegram.chatIdOf(settings);
+        if (!chatId) {
+            return false;
+        }
+        try {
+            const reports = new ReportService({db, context});
+            const timeZone = reports.timezone();
+            const params = {type: 'cash_shift', shift: shiftId, formats: REPORT_FORMATS};
+            const window = await reports.resolveWindow(params, timeZone);
+            if (!window.shift) {
+                console.warn(`[telegram] отчёт смены ${shiftId}: смена не найдена`);
+                return false;
+            }
+            const report = await reports.generate(window, params, timeZone);
+            telegram.send(chatId, telegramReport.render(report));
+            return true;
+        } catch (e) {
+            console.warn(`[telegram] отчёт смены ${shiftId}: не собран — ${e.message}`);
+            return false;
+        }
+    }
+}
+
+ShiftService.REPORT_FORMATS = REPORT_FORMATS;
+
+module.exports = ShiftService;

package/app/core/services/StorageService.js

@@ -0,0 +1,425 @@
+const {round, qty, toFloat, toBool} = require('../support/num');
+const {nowSql} = require('../support/time');
+const {uuid} = require('../support/ids');
+const {withLock} = require('../support/lock');
+
+/**
+ * Склад при продаже — порт App\Services\Platform\StorageService + StockService::register +
+ * UnitConverter (cafepos-admin).
+ *
+ * Работает только в облачном контуре (`CORE_MODE=cloud`): там ядро пишет в ту же базу, что и
+ * Laravel, и событие можно возить между ними через CORE_EVENTS — остатки обязаны меняться
+ * одинаково. Поэтому правила учёта общие с PHP, и правятся они в обоих местах сразу. На кассе
+ * (SQLite) складских таблиц нет: там это no-op, а движения по проданному облако делает само при
+ * приёме чеков (SyncService::moveStock).
+ *
+ * Правило: по позиции со склада списано held(quantity, workshop_print_quantity) единиц.
+ * Добавили — списываем. Сняли то, что кухня ещё не получала, — возвращаем сразу (rollback).
+ * Сняли напечатанное — возвращаем, когда отмена уйдёт в цех или закроется чек (refund в
+ * OrderService.syncWorkshopCount). Тех. карта блюда и количество модификатора — на одну порцию,
+ * движение умножается на количество позиции. Прежние ошибки учёта (блюдо списывало одну порцию
+ * на любое количество, возврат при печати считался от напечатанного и повторялся на каждой
+ * печати) исправлены по этому правилу и здесь, и в PHP.
+ *
+ * Отличия от PHP, не меняющие результат:
+ *   - остаток меняется атомарным `UPDATE … quantity + ?`, а не чтением и записью (в PHP два
+ *     параллельных движения по одному товару теряли одно из них);
+ *   - товар без единицы, удалённый ингредиент, модификатор без товара: PHP падал 500 уже после
+ *     вставки позиции, здесь такое движение пропускается с предупреждением, чек не срывается.
+ */
+const TYPE_PRODUCT = 'product';
+const TYPE_DISH = 'dish';
+
+const TX_SALE = 'sale';
+const TX_SALE_ROLLBACK = 'sale_rollback';
+const TX_SALE_REFUND = 'sale_refund';
+
+const PIECE_CODE = 'piece';
+const LITER_CODE = 'liter';
+const KILOGRAM_CODE = 'kilogram';
+const MILLILITER_CODE = 'milliliter';
+const GRAM_CODE = 'gram';
+
+// Справочник единиц общий для всех команд и меняется в админке раз в год. PHP держит его
+// статикой на запрос; здесь — на процесс с коротким сроком жизни.
+const UNITS_TTL_MS = 60000;
+let unitsCache = null;
+
+const loadUnits = async (db) => {
+    if (unitsCache && unitsCache.until > Date.now()) {
+        return unitsCache.units;
+    }
+    // Порядок нужен только base(): у единицы без родителя берётся первая дочерняя.
+    const rows = await db.all(
+        'SELECT id, code, parent_id, unit FROM units WHERE deleted_at IS NULL ORDER BY created_at, id'
+    );
+    const units = new Map(rows.map((row) => [String(row.id), row]));
+    unitsCache = {units, until: Date.now() + UNITS_TTL_MS};
+    return units;
+};
+
+/** UnitConverter::base — единица с родителем уже базовая, иначе её первая дочерняя. */
+const baseUnit = (units, unit) => {
+    if (unit.parent_id) {
+        return unit;
+    }
+    for (const candidate of units.values()) {
+        if (candidate.parent_id && String(candidate.parent_id) === String(unit.id)) {
+            return candidate;
+        }
+    }
+    return unit;
+};
+
+/** UnitConverter::factor / toBase. */
+const toBase = (units, value, unit) => {
+    const base = baseUnit(units, unit);
+    let factor = 1;
+    if (String(base.id) !== String(unit.id)) {
+        const baseSize = toFloat(base.unit) || 1;
+        const ownSize = toFloat(unit.unit) || 1;
+        factor = baseSize <= 0 ? 1 : ownSize / baseSize;
+    }
+    return qty(toFloat(value) * factor);
+};
+
+/** Хелпер getByUnit() из bootstrap/helpers.php. */
+const getByUnit = (value, fromUnit, toUnit) => {
+    const num = toFloat(value);
+    if (toUnit.code === PIECE_CODE || String(fromUnit.id) === String(toUnit.id)) {
+        return round(num, 3);
+    }
+    if (fromUnit.code === KILOGRAM_CODE || fromUnit.code === LITER_CODE) {
+        return round(num * 1000, 3);
+    }
+    if (fromUnit.code === GRAM_CODE || fromUnit.code === MILLILITER_CODE) {
+        return round(num / 1000, 3);
+    }
+    return round(num, 3);
+};
+
+/** Пропуск движения: PHP здесь падал бы, чек при этом уже изменён. */
+class SkipMove extends Error {}
+
+class StorageService {
+    constructor({db, context}) {
+        this.db = db;
+        this.context = context;
+    }
+
+    /** Лениво: ядро (index.js) само требует сервисы заказа, прямой require замкнул бы цикл. */
+    active() {
+        return require('../index').mode() === 'cloud' && this.db.dialect === 'pgsql';
+    }
+
+    /**
+     * Сколько единиц позиции должно лежать списанным: всё, что в чеке, и напечатанное, но снятое,
+     * пока отмена не ушла в цех. Порт StorageService::held.
+     */
+    static held(quantity, printed) {
+        return round(Math.max(toFloat(quantity), toFloat(printed), 0), 3);
+    }
+
+    /**
+     * Довести списание позиции от `before` до `after` (оба — held()): больше — продажа, меньше —
+     * возврат типом `returnType` ('rollback' — снятие до печати, 'refund' — отмена ушла в цех).
+     * Вне облачного контура — no-op, как и сами движения.
+     */
+    async settle(orderProduct, before, after, returnType = 'rollback') {
+        if (!this.active()) {
+            return;
+        }
+        const delta = round(toFloat(after) - toFloat(before), 3);
+        if (delta > 0) {
+            await this.withdraw(orderProduct, delta);
+        } else if (delta < 0) {
+            if (returnType === 'refund') {
+                await this.refund(orderProduct, -delta);
+            } else {
+                await this.rollback(orderProduct, -delta);
+            }
+        }
+    }
+
+    withdraw(orderProduct, quantity = 1) {
+        return this.run(orderProduct, quantity, TX_SALE, -1);
+    }
+
+    rollback(orderProduct, quantity = 1) {
+        return this.run(orderProduct, quantity, TX_SALE_ROLLBACK, 1);
+    }
+
+    refund(orderProduct, quantity = 1) {
+        return this.run(orderProduct, quantity, TX_SALE_REFUND, 1);
+    }
+
+    /**
+     * Смена модификаторов позиции (orderProducts.updateModifiers): по старым модификаторам
+     * списанное возвращается (rollback), по новым (уже записанным) списывается, оба раза на
+     * held позиции. Тех. карта не трогается; двигаются только модификаторы блюда — как в apply().
+     *
+     * @param {Array} previous строки order_product_modifier_sets до замены
+     */
+    async swapModifiers(orderProduct, previous, held) {
+        if (!this.active() || !(round(toFloat(held), 3) > 0)) {
+            return;
+        }
+        const id = typeof orderProduct === 'object' && orderProduct ? orderProduct.id : orderProduct;
+        await this.run(orderProduct, held, TX_SALE_ROLLBACK, 1, previous);
+        await this.run(orderProduct, held, TX_SALE, -1, await this.liveModifiers(id));
+    }
+
+    async liveModifiers(orderProductId) {
+        return this.db.all(
+            `SELECT opms.quantity, opms.modifier_set_modifier_id
+               FROM order_product_modifier_sets opms
+              WHERE opms.order_product_id = ? AND opms.deleted_at IS NULL`,
+            [orderProductId]
+        );
+    }
+
+    /**
+     * Общая часть withdraw/rollback/refund. Ошибка склада чек не срывает: позиция уже
+     * записана, а 500 на этом месте в PHP оставлял чек изменённым без ответа терминалу.
+     *
+     * @param {Array|null} modifiers задан — движение только по этим модификаторам (swapModifiers)
+     */
+    async run(orderProduct, quantity, type, sign, modifiers = null) {
+        if (!this.active()) {
+            return false;
+        }
+        try {
+            if (modifiers) {
+                await this.applyModifiers(orderProduct, modifiers, toFloat(quantity), type, sign);
+            } else {
+                await this.apply(orderProduct, toFloat(quantity), type, sign);
+            }
+        } catch (e) {
+            const id = typeof orderProduct === 'object' && orderProduct ? orderProduct.id : orderProduct;
+            console.warn(`[storage] ${type} для позиции ${id} не проведён: ${e.message}`);
+        }
+        return false;
+    }
+
+    /** Позиция, её товар, склад и единицы; null — склада нет, двигать некуда. */
+    async prepare(orderProductOrId) {
+        const orderProductId = typeof orderProductOrId === 'object' && orderProductOrId
+            ? orderProductOrId.id
+            : orderProductOrId;
+        // Позицию перечитываем всегда: нужен product_id, а строку из сервиса могли уже изменить.
+        // withTrashed — как связь OrderProduct::product и findOrFail по id (мягко удалённая
+        // позиция в PHP тоже находилась бы только через withTrashed на product).
+        const orderProduct = await this.db.get(
+            'SELECT id, product_id FROM order_products WHERE id = ?',
+            [orderProductId]
+        );
+        if (!orderProduct) {
+            throw new Error('позиция не найдена');
+        }
+        const product = await this.db.get(
+            'SELECT id, type, unit_id FROM products WHERE id = ?',
+            [orderProduct.product_id]
+        );
+        if (!product) {
+            throw new Error('товар не найден');
+        }
+
+        const storageId = await this.storageId();
+        if (!storageId) {
+            return null;
+        }
+        const units = await loadUnits(this.db);
+        return {orderProduct, product, storageId, units};
+    }
+
+    /** Только модификаторы из списка — тех. карту блюда и сам товар не трогает. */
+    async applyModifiers(orderProductOrId, modifiers, quantity, type, sign) {
+        const target = await this.prepare(orderProductOrId);
+        if (!target || target.product.type !== TYPE_DISH) {
+            return;
+        }
+        await this.moveModifiers(target, modifiers, quantity, type, sign);
+    }
+
+    async apply(orderProductOrId, quantity, type, sign) {
+        const target = await this.prepare(orderProductOrId);
+        if (!target) {
+            return;
+        }
+        const {orderProduct, product, storageId, units} = target;
+
+        if (product.type === TYPE_PRODUCT) {
+            await this.move(orderProduct, product, type, sign * quantity, storageId, units);
+            return;
+        }
+        if (product.type !== TYPE_DISH) {
+            return;
+        }
+
+        // Тех. карта — на одну порцию, поэтому всё умножается на количество позиции.
+        const ingredients = await this.db.all(
+            `SELECT pi.gross, pi.unit_id, pi.ingredient_id
+               FROM product_ingredients pi
+              WHERE pi.product_id = ? AND pi.deleted_at IS NULL`,
+            [product.id]
+        );
+        for (const ingredient of ingredients) {
+            await this.safely(async () => {
+                const ingredientProduct = await this.liveProduct(ingredient.ingredient_id);
+                const fromUnit = this.unit(units, ingredient.unit_id, 'единица ингредиента');
+                const toUnit = this.unit(units, ingredientProduct.unit_id, 'единица товара-ингредиента');
+                const perPortion = getByUnit(toFloat(ingredient.gross), fromUnit, toUnit);
+                const amount = round(quantity * perPortion, 3);
+                await this.move(orderProduct, ingredientProduct, type, sign * amount, storageId, units);
+            }, type, orderProduct.id);
+        }
+
+        await this.moveModifiers(target, await this.liveModifiers(orderProduct.id), quantity, type, sign);
+    }
+
+    /** Движения по выбранным модификаторам блюда (`quantity`, `modifier_set_modifier_id`). */
+    async moveModifiers({orderProduct, storageId, units}, modifiers, quantity, type, sign) {
+        for (const selected of modifiers) {
+            await this.safely(async () => {
+                const modifier = await this.db.get(
+                    `SELECT id, product_id, unit_id, gross, is_without_debit
+                       FROM modifier_set_modifiers WHERE id = ? AND deleted_at IS NULL`,
+                    [selected.modifier_set_modifier_id]
+                );
+                if (!modifier) {
+                    throw new SkipMove('модификатор удалён');
+                }
+                if (toBool(modifier.is_without_debit)) {
+                    return;
+                }
+                const modifierProduct = await this.liveProduct(modifier.product_id);
+                const fromUnit = this.unit(units, modifier.unit_id, 'единица модификатора');
+                const toUnit = this.unit(units, modifierProduct.unit_id, 'единица товара модификатора');
+                // quantity модификатора — на одну порцию блюда.
+                const perPortion = toFloat(selected.quantity) * getByUnit(toFloat(modifier.gross), fromUnit, toUnit);
+                const amount = round(quantity * perPortion, 3);
+                await this.move(orderProduct, modifierProduct, type, sign * amount, storageId, units);
+            }, type, orderProduct.id);
+        }
+    }
+
+    /** Одно движение блюда не мешает остальным ингредиентам. */
+    async safely(fn, type, orderProductId) {
+        try {
+            await fn();
+        } catch (e) {
+            console.warn(`[storage] ${type} для позиции ${orderProductId}: пропущено движение — ${e.message}`);
+        }
+    }
+
+    async liveProduct(id) {
+        const product = id
+            ? await this.db.get(
+                'SELECT id, type, unit_id FROM products WHERE id = ? AND deleted_at IS NULL',
+                [id]
+            )
+            : null;
+        if (!product) {
+            throw new SkipMove('товар удалён или не задан');
+        }
+        return product;
+    }
+
+    unit(units, id, what) {
+        const unit = id ? units.get(String(id)) : null;
+        if (!unit) {
+            throw new SkipMove(`${what} не задана`);
+        }
+        return unit;
+    }
+
+    /** Склад заведения (`company_storage`), иначе первый склад команды. */
+    async storageId() {
+        const {teamId, companyId} = this.context;
+        if (companyId) {
+            const storageId = await this.db.value(
+                'SELECT storage_id FROM company_storage WHERE company_id = ? LIMIT 1',
+                [companyId]
+            );
+            if (storageId) {
+                return storageId;
+            }
+        }
+        if (!teamId) {
+            return null;
+        }
+        return await this.db.value(
+            'SELECT id FROM storages WHERE team_id = ? AND deleted_at IS NULL LIMIT 1',
+            [teamId]
+        );
+    }
+
+    /** StockService::register без суммы (продажа себестоимость не меняет) + applyToStock. */
+    async move(orderProduct, product, type, quantity, storageId, units) {
+        // Нулевое движение не пишется (как в PHP — до проверки единицы).
+        if (round(quantity, 3) === 0) {
+            return;
+        }
+        const teamId = this.context.teamId;
+        const productUnit = product.unit_id ? units.get(String(product.unit_id)) : null;
+        if (!productUnit) {
+            // В PHP: unit_id движения = null → нарушение NOT NULL, 500.
+            throw new SkipMove(`у товара ${product.id} нет единицы`);
+        }
+        const baseQuantity = toBase(units, quantity, productUnit);
+        const timestamp = nowSql();
+
+        await this.db.insert('storage_stock_transactions', {
+            id: uuid(),
+            type,
+            storage_id: storageId,
+            team_id: teamId,
+            product_id: product.id,
+            unit_id: baseUnit(units, productUnit).id,
+            quantity: baseQuantity,
+            form_unit_id: productUnit.id,
+            form_quantity: qty(quantity),
+            amount: null,
+            datetime: timestamp,
+            external_id: orderProduct.id,
+            created_at: timestamp,
+            updated_at: timestamp,
+        });
+
+        // Строка остатка создаётся при первом движении — под локом, чтобы два движения
+        // одного товара не создали две. Межпроцессной защиты нет, как и в PHP.
+        await withLock(`stock:${teamId}:${product.id}:${storageId}`, async () => {
+            const stockId = await this.db.value(
+                `SELECT id FROM storage_stocks
+                  WHERE team_id = ? AND product_id = ? AND storage_id = ? AND deleted_at IS NULL
+                  LIMIT 1`,
+                [teamId, product.id, storageId]
+            );
+            if (stockId) {
+                await this.db.run(
+                    'UPDATE storage_stocks SET quantity = ROUND(quantity + ?, 3), updated_at = ? WHERE id = ?',
+                    [baseQuantity, timestamp, stockId]
+                );
+                return;
+            }
+            await this.db.insert('storage_stocks', {
+                id: uuid(),
+                team_id: teamId,
+                product_id: product.id,
+                storage_id: storageId,
+                unit_id: product.unit_id,
+                quantity: qty(baseQuantity),
+                cost: 0,
+                created_at: timestamp,
+                updated_at: timestamp,
+            });
+        });
+    }
+}
+
+StorageService.getByUnit = getByUnit;
+StorageService.flushUnits = () => {
+    unitsCache = null;
+};
+
+module.exports = StorageService;