taon 21.0.52 → 21.0.54

package/lib-prod/entity-process.js

@@ -0,0 +1,225 @@
+import { JSON10 } from 'json10/lib-prod';
+import { walk } from 'lodash-walk-object/lib-prod';
+import { Mapping__NS__decode } from 'ng2-rest/lib-prod';
+import { ___NS__isArray, ___NS__isBoolean, ___NS__isDate, ___NS__isFunction, ___NS__isNil, ___NS__isNull, ___NS__isNumber, ___NS__isObject, ___NS__isString, ___NS__set } from 'tnp-core/lib-prod';
+import { config } from 'tnp-core/lib-prod';
+import { ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getControllerConfigs, ClassHelpers__NS__getName, ClassHelpers__NS__getUniqueKey, ClassHelpers__NS__isContextClassObject } from './helpers/class-helpers';
+import { Symbols__NS__old } from './symbols';
+//#endregion
+//#region get transform function
+/**
+ * @deprecated
+ */
+export const getTransformFunction = (target) => {
+    if (!target) {
+        return;
+    }
+    // const className = ClassHelpers__NS__getName(target)
+    // target = ClassHelpers.getBy(className);
+    if (!target) {
+        return void 0;
+    }
+    const configs = ClassHelpers__NS__getControllerConfigs(target);
+    // console.log(`CONFIGS TO CHECK`, configs)
+    const functions = configs
+        .map(c => {
+        if (___NS__isFunction(c.browserTransformFn)) {
+            return c.browserTransformFn;
+        }
+    })
+        .filter(f => ___NS__isFunction(f));
+    return functions.length === 0
+        ? void 0
+        : function (entity) {
+            for (let index = functions.length - 1; index >= 0; index--) {
+                const transformFun = functions[index];
+                transformFun(entity);
+            }
+            return entity;
+        };
+};
+//#endregion
+//#region single transform
+/**
+ * @deprecated
+ */
+export const singleTransform = (json) => {
+    let ptarget = ClassHelpers__NS__getClassFnFromObject(json);
+    let pbrowserTransformFn = getTransformFunction(ptarget);
+    if (pbrowserTransformFn) {
+        const newValue = pbrowserTransformFn(json);
+        if (!___NS__isObject(newValue)) {
+            console.error(`Please return object in transform function for class: ` +
+                `${ClassHelpers__NS__getName(json)}`);
+        }
+        else {
+            json = newValue;
+        }
+    }
+    return json;
+};
+//#endregion
+export class EntityProcess {
+    //#region init
+    static async init(result, response) {
+        return await new EntityProcess(result, response).run();
+    }
+    //#endregion
+    //#region constructor
+    constructor(
+    /**
+     * Data from backend
+     */
+    result, response) {
+        this.result = result;
+        this.response = response;
+        /**
+         * Say yes to:
+         * - circural object
+         * - transform browser fn in decorator
+         */
+        this.advancedManipulation = false;
+        this.circural = [];
+    }
+    //#endregion
+    //#region check advanced manipulation
+    checkAdvancedManiupulation() {
+        if (___NS__isFunction(this.result)) {
+            this.advancedManipulation = true;
+            this.result = this.result();
+        }
+    }
+    //#endregion
+    //#region run
+    async run() {
+        this.checkAdvancedManiupulation();
+        this.data = this.result;
+        if (___NS__isObject(this.result)) {
+            if (this.advancedManipulation) {
+                this.applayTransformFn();
+            }
+            this.setHeaders();
+        }
+        this.send();
+    }
+    //#endregion
+    //#region apply transform function
+    applayTransformFn() {
+        if (___NS__isObject(this.data) && !___NS__isArray(this.data)) {
+            this.data = singleTransform(this.data);
+        }
+        const { include } = { include: [] };
+        walk.Object(this.data, (value, lodashPath, changeValue, { skipObject, isCircural }) => {
+            // console.log(`${isCircural ? 'CIR' : 'NOT'} : ${lodashPath}`)
+            if (!isCircural) {
+                if (!___NS__isArray(value) && ___NS__isObject(value)) {
+                    changeValue(singleTransform(value));
+                }
+            }
+        }, { checkCircural: true, breadthWalk: true, include });
+        const { circs } = walk.Object(this.data, void 0, {
+            checkCircural: true,
+            breadthWalk: true,
+            include,
+        });
+        this.circural = circs;
+    }
+    //#endregion
+    //#region set headers
+    setHeaders() {
+        const { include } = { include: [] };
+        const className = ClassHelpers__NS__getName(this.data);
+        const doNothing = ___NS__isNil(this.data) ||
+            [
+                'Object',
+                '',
+                //  void 0, null // TODO  not sure about commenting this
+            ].includes(className);
+        // console.log('doNothing', doNothing)
+        if (!doNothing) {
+            const cleaned = JSON10.cleaned(this.data, void 0, {
+                breadthWalk: true,
+                include,
+            });
+            this.entityMapping = Mapping__NS__decode(cleaned, !this.advancedManipulation);
+            this.response.set(Symbols__NS__old.MAPPING_CONFIG_HEADER, JSON.stringify(this.entityMapping));
+            if (this.advancedManipulation) {
+                this.response.set(Symbols__NS__old.CIRCURAL_OBJECTS_MAP_BODY, JSON.stringify(this.circural));
+            }
+        }
+    }
+    //#endregion
+    //#region send
+    send() {
+        if (this.advancedManipulation) {
+            const browserKey = config.folder.browser;
+            let toSend = ___NS__isArray(this.data) ? [] : {};
+            const { include = [], exclude = [] } = { include: [], exclude: [] };
+            walk.Object(this.data, (value, lodashPath, changeVAlue, { isCircural, skipObject }) => {
+                // console.log(`${isCircural ? 'CIR' : 'NOT'} ${lodashPath}`)
+                if (isCircural) {
+                    ___NS__set(toSend, lodashPath, null);
+                }
+                else {
+                    const fun = getTransformFunction(ClassHelpers__NS__getClassFnFromObject(value));
+                    if (___NS__isFunction(fun)) {
+                        ___NS__set(toSend, `${lodashPath}.${browserKey}`, value[browserKey]);
+                        const indexProp = ClassHelpers__NS__getUniqueKey(value);
+                        ___NS__set(toSend, `${lodashPath}.${indexProp}`, value[indexProp]);
+                        // skipObject()
+                    }
+                    else {
+                        ___NS__set(toSend, lodashPath, value);
+                    }
+                }
+            }, { checkCircural: true, breadthWalk: true, include });
+            if (!___NS__isArray(this.data)) {
+                let funParent = getTransformFunction(ClassHelpers__NS__getClassFnFromObject(this.data));
+                // if (this.mdc && this.mdc.exclude && this.mdc.exclude.length > 0) {
+                //   console.log(`funParent !!! have fun? ${!!funParent} `)
+                // }
+                if (___NS__isFunction(funParent)) {
+                    toSend = {
+                        [browserKey]: toSend[browserKey],
+                    };
+                }
+                Object.keys(this.data).forEach(prop => {
+                    if (prop !== browserKey) {
+                        const v = this.data[prop];
+                        if (!((include.length > 0 && !include.includes(prop)) ||
+                            (exclude.length > 0 && exclude.includes(prop)))) {
+                            if (ClassHelpers__NS__isContextClassObject(v) &&
+                                ___NS__isFunction(getTransformFunction(ClassHelpers__NS__getClassFnFromObject(v)))) {
+                                toSend[prop] = {
+                                    [browserKey]: v[browserKey],
+                                };
+                                const indexProp = ClassHelpers__NS__getUniqueKey(v);
+                                toSend[prop][indexProp] = this.data[prop][indexProp];
+                                for (const key in v) {
+                                    if (___NS__isObject(v) &&
+                                        v.hasOwnProperty(key) &&
+                                        ![indexProp, config.folder.browser].includes(key) &&
+                                        (___NS__isString(v[key]) ||
+                                            ___NS__isNumber(v[key]) ||
+                                            ___NS__isDate(v[key]) ||
+                                            ___NS__isNull(v[key]) ||
+                                            ___NS__isBoolean(v[key]))) {
+                                        toSend[prop][key] = v[key];
+                                    }
+                                }
+                            }
+                            else {
+                                toSend[prop] = v;
+                            }
+                        }
+                    }
+                });
+            }
+            // toSend = Helpers.JSON.cleaned(toSend, void 0, { breadthWalk: true })
+            this.response.json(toSend);
+        }
+        else {
+            this.response.json(this.data);
+        }
+    }
+}

package/lib-prod/env/{env.angular-node-app.ts → env.angular-node-app.js}

@@ -63,4 +63,4 @@ export const ENV_ANGULAR_NODE_APP_IS_CI_PROCESS = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.docs-webapp.ts → env.docs-webapp.js}

@@ -63,4 +63,4 @@ export const ENV_DOCS_WEBAPP_IS_CI_PROCESS = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.electron-app.ts → env.electron-app.js}

@@ -63,4 +63,4 @@ export const ENV_ELECTRON_APP_IS_CI_PROCESS = undefined;
 export const ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.mobile-app.ts → env.mobile-app.js}

@@ -63,4 +63,4 @@ export const ENV_MOBILE_APP_IS_CI_PROCESS = undefined;
 export const ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.npm-lib-and-cli-tool.ts → env.npm-lib-and-cli-tool.js}

@@ -63,4 +63,4 @@ export const ENV_NPM_LIB_AND_CLI_TOOL_IS_CI_PROCESS = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.vscode-plugin.ts → env.vscode-plugin.js}

@@ -63,4 +63,4 @@ export const ENV_VSCODE_PLUGIN_IS_CI_PROCESS = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/express-types.js

@@ -0,0 +1 @@
+export {};

package/lib-prod/formly/formly.models.js

@@ -0,0 +1 @@
+export {};

package/lib-prod/formly/fromly.js

@@ -0,0 +1,205 @@
+import { Mapping__NS__getModelsMapping } from 'ng2-rest/lib-prod';
+import { ___NS__first, ___NS__isArray, ___NS__isBoolean, ___NS__isDate, ___NS__isFunction, ___NS__isString, ___NS__isUndefined, ___NS__startCase } from 'tnp-core/lib-prod';
+import { CLASS } from 'typescript-class-helpers/lib-prod';
+import { findTypeForEntity } from './type-from-entity';
+export function getFromlyConfigFor(target, options = {}) {
+    const { formType = 'material', keysPathesToExclude = [], keysPathesToInclude = [], parentModel, relativePath = '', level = 0, maxLevel = 4, } = options;
+    if (level === maxLevel) {
+        return [];
+    }
+    const mapping = Mapping__NS__getModelsMapping(target);
+    // console.log('mapping', mapping)
+    const fieldNames = CLASS.describeProperites(target);
+    const checkExclude = ___NS__isArray(keysPathesToExclude) && keysPathesToExclude.length > 0;
+    const checkInclude = ___NS__isArray(keysPathesToInclude) && keysPathesToInclude.length > 0;
+    if (checkExclude && checkInclude) {
+        throw new Error(`In Taon function getFromlyConfigFor(...) please use keysPathesToInclude or keysPathesToExclude, `);
+    }
+    // if (checkInclude) {
+    //   console.log('check include', keysPathesToExclude)
+    // }
+    // if (checkExclude) {
+    //   console.log('check exclude', keysPathesToExclude)
+    // }
+    let fields = [];
+    //#region input to push
+    function inputToPush(key, type, model, inptToPushOptions) {
+        const { targetChild, selectOptions } = inptToPushOptions || {};
+        // console.log(`key(${key}) type: ${type} | model: ${model} targetChild: ${targetChild && targetChild.name}`)
+        let res;
+        if (type === 'repeat') {
+            const fieldGroup = getFromlyConfigFor(targetChild, {
+                formType,
+                keysPathesToInclude,
+                keysPathesToExclude,
+                relativePath: `${relativePath}.${key}`,
+                level: level + 1,
+                maxLevel,
+            });
+            if (fieldGroup.length > 0) {
+                res = {
+                    key,
+                    type,
+                    defaultValue: [],
+                    fieldArray: {
+                        fieldGroupClassName: 'row',
+                        templateOptions: {
+                            label: `Add new ${___NS__startCase(key)}`,
+                        },
+                        fieldGroup,
+                    },
+                };
+            }
+        }
+        else if (type === 'group') {
+            const fieldGroup = getFromlyConfigFor(targetChild, {
+                formType,
+                keysPathesToInclude,
+                keysPathesToExclude,
+                parentModel: model,
+                relativePath: `${relativePath}.${key}`,
+                level: level + 1,
+                maxLevel,
+            });
+            if (fieldGroup.length > 0) {
+                res = {
+                    fieldGroupClassName: 'row',
+                    templateOptions: {
+                        label: `${___NS__startCase(key)}`,
+                    },
+                    wrappers: ['groupwrap'],
+                    fieldGroup,
+                };
+            }
+        }
+        else {
+            res = {
+                key,
+                model,
+                type,
+                defaultValue: !___NS__isUndefined(target.prototype[key])
+                    ? target.prototype[key]
+                    : undefined,
+                templateOptions: {
+                    label: ___NS__isString(model)
+                        ? `${model
+                            .split('.')
+                            .map(l => ___NS__startCase(l))
+                            .join(' / ')} / ${___NS__startCase(key)}`
+                        : ___NS__startCase(key),
+                    options: selectOptions,
+                },
+            };
+        }
+        if (res) {
+            Object.keys(res).forEach(key => res[key] === undefined ? delete res[key] : '');
+        }
+        return res;
+    }
+    //#endregion
+    //#region is allowed path
+    function isAlowedPath(key) {
+        let isAlowed = true;
+        const matchPath = relativePath === '' ? key : `${relativePath}:${key}`;
+        if (checkExclude) {
+            if (keysPathesToExclude.includes(matchPath)) {
+                // console.log(`Not allowed key: ${key}`)
+                isAlowed = false;
+            }
+            else {
+                isAlowed = true;
+            }
+        }
+        else if (checkInclude) {
+            if (keysPathesToInclude.includes(matchPath)) {
+                // console.log(`Allowed key: ${key}`)
+                isAlowed = true;
+            }
+            else {
+                isAlowed = false;
+            }
+        }
+        // console.log(`Is allowed;${matchPath} `, isAlowed)
+        return isAlowed;
+    }
+    //#endregion
+    const simpleResolved = [];
+    //#region resolve simple types
+    function resolveSimpleTypes() {
+        for (const key in target.prototype) {
+            if (target.prototype.hasOwnProperty(key) &&
+                !___NS__isFunction(target.prototype[key])) {
+                if (!isAlowedPath(key)) {
+                    continue;
+                }
+                if (!___NS__isUndefined(mapping[key])) {
+                    continue;
+                }
+                const element = target.prototype[key];
+                let type = 'input';
+                if (___NS__isBoolean(element)) {
+                    type = 'switch';
+                }
+                else if (___NS__isDate(element)) {
+                    type = 'datepicker';
+                }
+                else if (___NS__isFunction(target['getOptionsFor'])) {
+                    var selectOptions = target['getOptionsFor'](key);
+                    if (!___NS__isUndefined(selectOptions)) {
+                        type = 'select';
+                    }
+                }
+                else if (___NS__isFunction(target.prototype?.getOptionsFor)) {
+                    var selectOptions = target.prototype?.getOptionsFor(key);
+                    if (!___NS__isUndefined(selectOptions)) {
+                        type = 'select';
+                    }
+                }
+                fields.push(inputToPush(key, type, parentModel, { selectOptions }));
+                simpleResolved.push(key);
+            }
+        }
+    }
+    //#endregion
+    //#region resolve complex types
+    function resolveComplexTypes() {
+        fieldNames
+            .filter(key => !simpleResolved.includes(key))
+            .forEach(key => {
+            if (isAlowedPath(key) && !___NS__isUndefined(mapping[key])) {
+                let className = mapping[key];
+                const isArray = ___NS__isArray(className);
+                className = isArray ? ___NS__first(className) : className;
+                if (className === 'Date') {
+                    fields.push(inputToPush(key, 'datepicker', parentModel));
+                }
+                else {
+                    const targetChild = CLASS.getBy(className);
+                    if (targetChild) {
+                        const ftype = findTypeForEntity(targetChild, isArray);
+                        if (ftype) {
+                            fields = fields.concat(inputToPush(key, ftype.name, key));
+                        }
+                        else {
+                            if (isArray) {
+                                fields = fields.concat(inputToPush(key, 'repeat', key, { targetChild }));
+                            }
+                            else {
+                                fields = fields.concat(inputToPush(key, 'group', key, { targetChild }));
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    //#endregion
+    function generate() {
+        resolveSimpleTypes();
+        // console.log('after simple', fields);
+        resolveComplexTypes();
+        // console.log('after complext', fields);
+    }
+    generate();
+    return fields.filter(f => !!f);
+}

package/lib-prod/formly/type-from-entity.js

@@ -0,0 +1,51 @@
+import { ClassHelpers__NS__getName, ClassHelpers__NS__setName } from '../helpers/class-helpers';
+import { ___NS__first, ___NS__isArray } from 'tnp-core/lib-prod';
+export function findTypeForEntity(entity, isArray = false) {
+    if (!___NS__isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return getRegisteredComponents().find(c => c.entity === entity && c.isArray === isArray);
+}
+export function typeFromEntity(component, entity) {
+    const isArray = ___NS__isArray(entity);
+    if (isArray) {
+        entity = ___NS__first(entity);
+    }
+    let name = ClassHelpers__NS__getName(component);
+    let res = { name, component, entity, isArray };
+    // console.log(res);
+    return res;
+}
+export function typeFromName(component, name) {
+    let res = { name, component };
+    return res;
+}
+export function RegisterComponentTypeForEntity(entity) {
+    if (!___NS__isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return function (target, propertyKey, descriptor) {
+        RegisterComponentType.prototype.types.push(typeFromEntity(target, entity));
+    };
+}
+export function RegisterComponentType(className, ...optionslNames) {
+    if (!___NS__isArray(RegisterComponentType.prototype.types)) {
+        RegisterComponentType.prototype.types = [];
+    }
+    return function (target, propertyKey, descriptor) {
+        ClassHelpers__NS__setName(target, className);
+        RegisterComponentType.prototype.types.push(typeFromEntity(target));
+        optionslNames.forEach(name => {
+            RegisterComponentType.prototype.types.push(typeFromName(target, name));
+        });
+    };
+}
+// RegisterComponentType.prototype.types = []
+export function getRegisteredComponents() {
+    let registered = RegisterComponentType.prototype.types;
+    if (!Array.isArray(registered)) {
+        return [];
+    }
+    // console.log(registered)
+    return registered;
+}

package/lib-prod/get-response-value.js

@@ -0,0 +1,22 @@
+export const getResponseValue = (response, options) => {
+    //#region @websqlFunc
+    const { req, res } = options || {};
+    return new Promise(async (resolve, reject) => {
+        //#region @websql
+        if (typeof response === 'function') {
+            const asyncResponse = response;
+            try {
+                const result = await asyncResponse(req, res);
+                resolve(result);
+            }
+            catch (e) {
+                reject(e);
+            }
+        }
+        else {
+            reject(`[taon] Not recognized type of response ${response}`);
+        }
+        //#endregion
+    });
+    //#endregion
+};

package/lib-prod/global-state/taon-global-state/{index.ts → index.js}

@@ -1,6 +1,6 @@
-/* */                                                         
+/* */
 export * from './taon-global-state.constants';
 export * from './taon-global-state.entity';
 export * from './taon-global-state.controller';
 export * from './taon-global-state.repository';
-export * from './taon-global-state.abstract.context';
+export * from './taon-global-state.abstract.context';

package/lib-prod/global-state/taon-global-state/{taon-global-state.abstract.context.ts → taon-global-state.abstract.context.js}

@@ -1,5 +1,4 @@
 //#region imports
-
 import { createContext } from '../../create-context';
 import { TAON_GLOBAL_STATE } from './taon-global-state.entity';
 import { TaonGlobalStateController } from './taon-global-state.controller';
@@ -8,14 +7,13 @@ import { TaonGlobalStateProvider } from './taon-global-state.provider';
 import { TaonGlobalStateMiddleware } from './taon-global-state.middleware';
 import { TaonGlobalStateSubscriber } from './taon-global-state.subscriber';
 //#endregion
-
 export const TaonGlobalStateContext = createContext(() => ({
-  contextName: 'TaonGlobalStateContext',
-  abstract: true,
-  entities: { TAON_GLOBAL_STATE },
-  controllers: { TaonGlobalStateController },
-  repositories: { TaonGlobalStateRepository },
-  providers: { TaonGlobalStateProvider },
-  middlewares: { TaonGlobalStateMiddleware },
-  subscribers: { TaonGlobalStateSubscriber },
-}));
+    contextName: 'TaonGlobalStateContext',
+    abstract: true,
+    entities: { TAON_GLOBAL_STATE },
+    controllers: { TaonGlobalStateController },
+    repositories: { TaonGlobalStateRepository },
+    providers: { TaonGlobalStateProvider },
+    middlewares: { TaonGlobalStateMiddleware },
+    subscribers: { TaonGlobalStateSubscriber },
+}));

package/lib-prod/global-state/taon-global-state/taon-global-state.constants.js

@@ -0,0 +1,7 @@
+import { TaonGlobalStateStatus } from './taon-global-state.models';
+export const TaonGlobalStateDefaultsValues = {
+    description: '',
+    version: 0,
+    id: void 0,
+    status: TaonGlobalStateStatus.NORMAL,
+};

package/lib-prod/global-state/taon-global-state/taon-global-state.controller.js

@@ -0,0 +1,42 @@
+//#region imports
+import { TaonController } from '../../decorators/classes/controller-decorator';
+import { TaonBaseCrudController } from '../../base-classes/base-crud-controller';
+import { Query } from '../../decorators/http/http-params-decorators';
+import { GET } from '../../decorators/http/http-methods-decorators';
+import { POST } from '../../decorators/http/http-methods-decorators';
+import { TAON_GLOBAL_STATE } from './taon-global-state.entity';
+import { TaonGlobalStateRepository } from './taon-global-state.repository';
+//#endregion
+let TaonGlobalStateController = class TaonGlobalStateController extends TaonBaseCrudController {
+    constructor() {
+        super(...arguments);
+        this.entityClassResolveFn = () => TAON_GLOBAL_STATE;
+        this.taonGlobalStateRepository = this.injectCustomRepo(TaonGlobalStateRepository);
+    }
+    getStatus() {
+        return async () => {
+            //#region @websqlFunc
+            const stateEntity = await this.taonGlobalStateRepository.getLastStatus();
+            return stateEntity.status;
+            //#endregion
+        };
+    }
+    setDraining(secondsBeforeReadonly = 0) {
+        return async () => {
+            await this.taonGlobalStateRepository.setDraining(secondsBeforeReadonly);
+        };
+    }
+};
+__decorate([
+    GET()
+], TaonGlobalStateController.prototype, "getStatus", null);
+__decorate([
+    POST(),
+    __param(0, Query('secondsBeforeReadonly'))
+], TaonGlobalStateController.prototype, "setDraining", null);
+TaonGlobalStateController = __decorate([
+    TaonController({
+        className: 'TaonGlobalStateController',
+    })
+], TaonGlobalStateController);
+export { TaonGlobalStateController };