emilsoftware-utilities 1.0.0

package/.idea/.name

@@ -0,0 +1 @@
+emilsoftware-utilities

package/.idea/emilsoftware-utilities.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/emilsoftware-utilities.iml" filepath="$PROJECT_DIR$/.idea/emilsoftware-utilities.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/dist/decorators/autobind.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+export declare function boundMethod(target: any, key: any, descriptor: any): {
+    configurable: boolean;
+    get(): any;
+    set(value: any): void;
+};
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+export declare function boundClass(target: any): any;
+export default function autobind(...args: any[]): any;

package/dist/decorators/autobind.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boundClass = exports.boundMethod = void 0;
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+function boundMethod(target, key, descriptor) {
+    var fn = descriptor === null || descriptor === void 0 ? void 0 : descriptor.value;
+    if (typeof fn !== 'function') {
+        throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(typeof fn));
+    }
+    // In IE11 calling Object.defineProperty has a side effect of evaluating the
+    // getter for the property which is being replaced. This causes infinite
+    // recursion and an "Out of stack space" error.
+    var definingProperty = false;
+    return {
+        configurable: true,
+        get: function () {
+            // eslint-disable-next-line no-prototype-builtins
+            if (definingProperty || this === target.prototype || this.hasOwnProperty(key) ||
+                typeof fn !== 'function') {
+                return fn;
+            }
+            var boundFn = fn.bind(this);
+            definingProperty = true;
+            if (key) {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    get: function () {
+                        return boundFn;
+                    },
+                    set: function (value) {
+                        fn = value;
+                        // @ts-ignore
+                        delete this[key];
+                    }
+                });
+            }
+            definingProperty = false;
+            return boundFn;
+        },
+        set: function (value) {
+            fn = value;
+        }
+    };
+}
+exports.boundMethod = boundMethod;
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+function boundClass(target) {
+    // (Using reflect to get all keys including symbols)
+    var keys;
+    // Use Reflect if exists
+    if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+        keys = Reflect.ownKeys(target.prototype);
+    }
+    else {
+        keys = Object.getOwnPropertyNames(target.prototype);
+        // Use symbols if support is provided
+        if (typeof Object.getOwnPropertySymbols === 'function') {
+            // @ts-ignore
+            keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
+        }
+    }
+    keys.forEach(function (key) {
+        // Ignore special case target method
+        if (key === 'constructor') {
+            return;
+        }
+        var descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
+        // Only methods need binding
+        if (typeof (descriptor === null || descriptor === void 0 ? void 0 : descriptor.value) === 'function') {
+            Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
+        }
+    });
+    return target;
+}
+exports.boundClass = boundClass;
+function autobind() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (args.length === 1) {
+        // @ts-ignore
+        return boundClass.apply(void 0, args);
+    }
+    // @ts-ignore
+    return boundMethod.apply(void 0, args);
+}
+exports.default = autobind;

package/dist/decorators/log-execution-time.d.ts

@@ -0,0 +1 @@
+export declare function logExecutionTime(fileName?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/decorators/log-execution-time.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logExecutionTime = void 0;
+var logger_1 = require("../logger");
+function logExecutionTime(fileName) {
+    if (fileName === void 0) { fileName = ""; }
+    return function (target, propertyKey, descriptor) {
+        var logger = new logger_1.Logger(fileName);
+        var originalMethod = descriptor.value;
+        descriptor.value = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var start, result, end, durationInMilliseconds, error_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            start = process.hrtime();
+                            logger.info(" ".concat(propertyKey, " method execution started . . ."));
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, originalMethod.apply(this, args)];
+                        case 2:
+                            result = _a.sent();
+                            end = process.hrtime(start);
+                            durationInMilliseconds = end[0] * 1000 + end[1] / 1e6;
+                            logger.info(" ".concat(propertyKey, " method took ").concat(durationInMilliseconds.toFixed(2), " ms to execute"));
+                            return [2 /*return*/, result];
+                        case 3:
+                            error_1 = _a.sent();
+                            throw error_1;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return descriptor;
+    };
+}
+exports.logExecutionTime = logExecutionTime;

package/dist/logger.d.ts

@@ -0,0 +1,20 @@
+export declare enum LogLevels {
+    INFO = "INFO",
+    ERROR = "ERROR",
+    DEBUG = "DEBUG",
+    LOG = "LOG"
+}
+export declare class Logger {
+    private readonly winstonLogger;
+    tag: string;
+    private logFormat;
+    constructor(tag: string);
+    private getFileName;
+    execStart(prefix?: string): any;
+    execStop(prefix: string, startTime: any, error?: boolean): any;
+    info(...data: any): void;
+    debug(...data: any): void;
+    log(...data: any): void;
+    error(...data: any): void;
+    private print;
+}

package/dist/logger.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevels = void 0;
+var winston_1 = __importDefault(require("winston"));
+var path = __importStar(require("path"));
+var fs = __importStar(require("fs"));
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["INFO"] = "INFO";
+    LogLevels["ERROR"] = "ERROR";
+    LogLevels["DEBUG"] = "DEBUG";
+    LogLevels["LOG"] = "LOG";
+})(LogLevels || (exports.LogLevels = LogLevels = {}));
+var Logger = /** @class */ (function () {
+    function Logger(tag) {
+        this.tag = "[UNTAGGED]";
+        this.logFormat = winston_1.default.format.printf(function (tmp) {
+            var time = tmp.time, file = tmp.file, level = tmp.level, message = tmp.message;
+            return "".concat(JSON.stringify({ time: time, file: file === null || file === void 0 ? void 0 : file.replaceAll("\\", "/"), level: level, message: message }), ",");
+        });
+        var fileName = this.getFileName();
+        var logsDirectory = "logs";
+        var logFilePath = path.join(logsDirectory, fileName + ".json");
+        if (!fs.existsSync(logsDirectory)) {
+            fs.mkdirSync(logsDirectory);
+        }
+        this.tag = tag;
+        this.winstonLogger = winston_1.default.createLogger({
+            format: winston_1.default.format.json(),
+            transports: [new winston_1.default.transports.File({ filename: logFilePath, format: this.logFormat })],
+        });
+    }
+    Logger.prototype.getFileName = function () {
+        var now = new Date();
+        return now.getDate() + "-" + (now.getMonth() + 1) + "-" + now.getFullYear();
+    };
+    Logger.prototype.execStart = function (prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.print(LogLevels.INFO, "".concat(prefix, " - Execution started"));
+        return performance.now();
+    };
+    Logger.prototype.execStop = function (prefix, startTime, error) {
+        if (prefix === void 0) { prefix = ""; }
+        if (error === void 0) { error = false; }
+        switch (error) {
+            case true: {
+                this.print(LogLevels.ERROR, "".concat(prefix, " - Execution ended due to an error. Execution time: ").concat(performance.now() - startTime, " ms"));
+                break;
+            }
+            case false: {
+                this.print(LogLevels.INFO, "".concat(prefix, " - Execution ended successfully. Execution time: ").concat(performance.now() - startTime, " ms"));
+                break;
+            }
+        }
+    };
+    Logger.prototype.info = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.INFO], data, false));
+    };
+    Logger.prototype.debug = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.DEBUG], data, false));
+    };
+    Logger.prototype.log = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.LOG], data, false));
+    };
+    Logger.prototype.error = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.ERROR], data, false));
+    };
+    Logger.prototype.print = function (level) {
+        var _a;
+        if (level === void 0) { level = LogLevels.INFO; }
+        var data = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            data[_i - 1] = arguments[_i];
+        }
+        var now = new Date();
+        // Utilities.getNowDateString();
+        this.winstonLogger.defaultMeta = {
+            file: this.tag, time: now,
+            level: level
+        };
+        (_a = this.winstonLogger)[level.toLowerCase()].apply(_a, data);
+        // @ts-ignore
+        console[level.toLowerCase()].apply(console, __spreadArray(["[".concat(level, "][").concat(now, "][").concat(this.tag.split("\\").pop(), "]")], data, false));
+    };
+    return Logger;
+}());
+exports.Logger = Logger;

package/dist/orm.d.ts

@@ -0,0 +1,8 @@
+export declare class Orm {
+    static RESULT_EXEC_OK: string;
+    static quote(value: string): string;
+    static testConnection(options: any): Promise<any>;
+    static query(options: any, query: any, parameters?: any[]): Promise<any>;
+    static execute(options: any, query: any, parameters?: any): Promise<unknown>;
+    static trimParam(param: any): any;
+}

package/dist/orm.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orm = void 0;
+// @ts-ignore
+var Firebird = __importStar(require("es-node-firebird"));
+var logger_1 = require("./logger");
+var Orm = /** @class */ (function () {
+    function Orm() {
+    }
+    Orm.quote = function (value) {
+        return "\"" + value + "\"";
+    };
+    ;
+    Orm.testConnection = function (options) {
+        var logger = new logger_1.Logger(__filename);
+        return new Promise(function (resolve, reject) {
+            Firebird.attach(options, function (err, db) {
+                if (err) {
+                    logger.error("La connessione con il DATABASE non è andata a buon fine.");
+                    return resolve(false);
+                }
+                logger.info("DATABASE connesso.");
+                return resolve(true);
+            });
+        });
+    };
+    Orm.query = function (options, query, parameters) {
+        if (parameters === void 0) { parameters = []; }
+        return new Promise(function (resolve, reject) {
+            Firebird.attach(options, function (err, db) {
+                if (err) {
+                    return reject(err);
+                }
+                db.query(query, parameters, function (error, result) {
+                    if (error) {
+                        db.detach();
+                        return reject(error);
+                    }
+                    db.detach();
+                    return resolve(result);
+                });
+            });
+        });
+    };
+    Orm.execute = function (options, query, parameters) {
+        var _this = this;
+        if (parameters === void 0) { parameters = []; }
+        return new Promise(function (resolve, reject) {
+            Firebird.attach(options, function (err, db) {
+                if (err) {
+                    // tslint:disable-next-line:no-console
+                    console.error(err);
+                    return reject(err);
+                }
+                db.execute(query, parameters, function (error, result) {
+                    if (error) {
+                        db.detach();
+                        // tslint:disable-next-line:no-console
+                        console.log(query);
+                        parameters.forEach(function (param, i) {
+                            // tslint:disable-next-line:no-console
+                            console.log(i + 1, param);
+                        });
+                        // tslint:disable-next-line:no-console
+                        console.error(error);
+                        return reject(error);
+                    }
+                    db.detach();
+                    return resolve(_this.RESULT_EXEC_OK);
+                });
+            });
+        });
+    };
+    Orm.trimParam = function (param) {
+        if (typeof param === "string" || param instanceof String) {
+            return param.trim();
+        }
+        return param;
+    };
+    Orm.RESULT_EXEC_OK = "ok!";
+    return Orm;
+}());
+exports.Orm = Orm;

package/dist/utilities.d.ts

@@ -0,0 +1,21 @@
+export declare class Utilities {
+    static parseDate(date: string): Date;
+    static STATUS_CODE: {
+        OK: number;
+        WARNING: number;
+        ERROR: number;
+    };
+    static sendOKMessage(res: any, message: any): any;
+    static getNowDateString(): string;
+    static sendErrorMessage(res: any, err: any, tag?: string, status?: number): any;
+    static sendOpenResponse(res: any, payload: any): any;
+    static sendOpenErrorMessage(res: any, err: any, tag?: string, status?: number): any;
+    private static toCamel;
+    private static isArray;
+    private static isObject;
+    static keysToCamel(o: any): any;
+    static addStartingZeros(num: number, totalLength: number): string;
+    static dateToMoncler(dData: Date, bAddMs?: boolean): string;
+    static dateToSql(dData: Date, bAddMs?: boolean): string;
+    static dateToSimple(dData: Date): string;
+}

package/dist/utilities.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utilities = void 0;
+var Utilities = /** @class */ (function () {
+    function Utilities() {
+    }
+    Utilities.parseDate = function (date) {
+        var parts = date.split("/");
+        return new Date(Number(parts[2]), Number(parts[1]) - 1, Number(parts[0]));
+    };
+    Utilities.sendOKMessage = function (res, message) {
+        return res.send({
+            severity: "success", status: 200, statusCode: this.STATUS_CODE.OK,
+            message: message,
+        });
+    };
+    Utilities.getNowDateString = function () {
+        var now = new Date();
+        var day = now.getDate() < 9 ? "0" + now.getDate() : now.getDate();
+        var month = (now.getMonth() + 1) < 9 ? "0" + (now.getMonth() + 1) : (now.getMonth() + 1);
+        var year = now.getFullYear();
+        var hours = now.getHours() < 9 ? "0" + now.getHours() : now.getHours();
+        var minutes = now.getMinutes() < 9 ? "0" + now.getMinutes() : now.getMinutes();
+        var seconds = now.getSeconds() < 9 ? "0" + now.getSeconds() : now.getSeconds();
+        return day + "." + month + "." + year + " " + hours + ":" + minutes + ":" + seconds;
+    };
+    Utilities.sendErrorMessage = function (res, err, tag, status) {
+        if (tag === void 0) { tag = "[BASE ERROR]"; }
+        if (status === void 0) { status = 500; }
+        // tslint:disable-next-line:no-console
+        console.error(err);
+        return res.status(status).send({
+            severity: "error",
+            status: 500,
+            statusCode: this.STATUS_CODE.ERROR,
+            message: " Si è verificato un errore",
+            error: tag + ": " + err,
+        });
+    };
+    // Risposte per funzioni in stile ES
+    Utilities.sendOpenResponse = function (res, payload) {
+        try {
+            payload = JSON.parse(JSON.stringify(payload));
+            var clearPayload = payload; // this.keysToCamel(payload);
+            var response = {
+                Status: {
+                    errorCode: "0", errorDescription: "",
+                }, Result: clearPayload, Message: ""
+            };
+            return res.send(response);
+        }
+        catch (error) {
+            return this.sendOpenErrorMessage(res, "Errore nell'invio della risposta: " + error, "[UTILITIES]", 500);
+        }
+    };
+    Utilities.sendOpenErrorMessage = function (res, err, tag, status) {
+        if (tag === void 0) { tag = "[BASE ERROR]"; }
+        if (status === void 0) { status = 500; }
+        return res.status(status).send({
+            Status: {
+                errorCode: "500", errorDescription: err,
+            }, Result: [], Message: err,
+        });
+    };
+    Utilities.toCamel = function (s) {
+        return s.replace(/([-_][a-z])/gi, function ($1) {
+            return $1.toUpperCase().replace("-", "").replace("_", "");
+        });
+    };
+    ;
+    Utilities.isArray = function (a) {
+        return Array.isArray(a);
+    };
+    ;
+    Utilities.isObject = function (o) {
+        return o === Object(o) && !this.isArray(o) && typeof o !== "function";
+    };
+    ;
+    Utilities.keysToCamel = function (o) {
+        var _this = this;
+        if (this.isObject(o)) {
+            var n_1 = {};
+            Object.keys(o).forEach(function (k) {
+                // @ts-ignore
+                n_1[_this.toCamel(k)] = _this.keysToCamel(o[k]);
+            });
+            return n_1;
+        }
+        else if (this.isArray(o)) {
+            return o.map(function (i) {
+                return _this.keysToCamel(i);
+            });
+        }
+        return o;
+    };
+    ;
+    Utilities.addStartingZeros = function (num, totalLength) {
+        return String(num).padStart(totalLength, '0');
+    };
+    Utilities.dateToMoncler = function (dData, bAddMs) {
+        if (bAddMs === void 0) { bAddMs = false; }
+        var yy = dData.getFullYear();
+        var mm = this.addStartingZeros(dData.getMonth() + 1, 2);
+        var dd = this.addStartingZeros(dData.getDate(), 2);
+        var hh = this.addStartingZeros(dData.getHours(), 2);
+        var nn = this.addStartingZeros(dData.getMinutes(), 2);
+        var ss = this.addStartingZeros(dData.getSeconds(), 2);
+        var ms = this.addStartingZeros(dData.getMilliseconds(), 3);
+        if (bAddMs) {
+            return yy + mm + dd + hh + nn + ss + ms;
+        }
+        else {
+            return yy + mm + dd + hh + nn + ss;
+        }
+    };
+    Utilities.dateToSql = function (dData, bAddMs) {
+        if (bAddMs === void 0) { bAddMs = false; }
+        var yy = dData.getFullYear();
+        var mm = this.addStartingZeros(dData.getMonth() + 1, 2);
+        var dd = this.addStartingZeros(dData.getDate(), 2);
+        var hh = this.addStartingZeros(dData.getHours(), 2);
+        var nn = this.addStartingZeros(dData.getMinutes(), 2);
+        var ss = this.addStartingZeros(dData.getSeconds(), 2);
+        var ms = this.addStartingZeros(dData.getMilliseconds(), 3);
+        if (bAddMs) {
+            return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss + '.' + ms;
+        }
+        else {
+            return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss;
+        }
+    };
+    Utilities.dateToSimple = function (dData) {
+        var yy = dData.getFullYear();
+        var mm = this.addStartingZeros(dData.getMonth() + 1, 2);
+        var dd = this.addStartingZeros(dData.getDate(), 2);
+        return dd + '-' + mm + '-' + yy;
+    };
+    Utilities.STATUS_CODE = {
+        OK: 0, WARNING: 1, ERROR: 2,
+    };
+    return Utilities;
+}());
+exports.Utilities = Utilities;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "emilsoftware-utilities",
+  "version": "1.0.0",
+  "description": "Utilities for EmilSoftware",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mttdev382/emilsoftware-utilities.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/mttdev382/emilsoftware-utilities/issues"
+  },
+  "homepage": "https://github.com/mttdev382/emilsoftware-utilities#readme",
+  "dependencies": {
+    "es-node-firebird": "^1.1.8",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "typescript": "^5.3.3"
+  }
+}

package/src/decorators/autobind.ts

@@ -0,0 +1,92 @@
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+export function boundMethod(target:any, key: any, descriptor: any) {
+    let fn = descriptor?.value;
+
+    if (typeof fn !== 'function') {
+        throw new TypeError(`@boundMethod decorator can only be applied to methods not: ${typeof fn}`);
+    }
+
+    // In IE11 calling Object.defineProperty has a side effect of evaluating the
+    // getter for the property which is being replaced. This causes infinite
+    // recursion and an "Out of stack space" error.
+    let definingProperty = false;
+
+    return {
+        configurable: true,
+        get() {
+            // eslint-disable-next-line no-prototype-builtins
+            if (definingProperty || this === target.prototype || this.hasOwnProperty(key as string | number | symbol) ||
+                typeof fn !== 'function') {
+                return fn;
+            }
+
+            const boundFn = fn.bind(this);
+            definingProperty = true;
+            if (key) {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    get() {
+                        return boundFn;
+                    },
+                    set(value) {
+                        fn = value;
+                        // @ts-ignore
+                        delete this[key];
+                    }
+                });
+            }
+            definingProperty = false;
+            return boundFn;
+        },
+        set(value: any) {
+            fn = value;
+        }
+    };
+}
+
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+export function boundClass(target: any) {
+    // (Using reflect to get all keys including symbols)
+    let keys;
+    // Use Reflect if exists
+    if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+        keys = Reflect.ownKeys(target.prototype);
+    } else {
+        keys = Object.getOwnPropertyNames(target.prototype);
+        // Use symbols if support is provided
+        if (typeof Object.getOwnPropertySymbols === 'function') {
+            // @ts-ignore
+            keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
+        }
+    }
+
+    keys.forEach(key => {
+        // Ignore special case target method
+        if (key === 'constructor') {
+            return;
+        }
+
+        const descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
+
+        // Only methods need binding
+        if (typeof descriptor?.value === 'function') {
+            Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
+        }
+    });
+    return target;
+}
+
+export default function autobind(...args: any[]) {
+    if (args.length === 1) {
+        // @ts-ignore
+        return boundClass(...args);
+    }
+    // @ts-ignore
+    return boundMethod(...args);
+}

package/src/decorators/log-execution-time.ts

@@ -0,0 +1,24 @@
+import {Logger} from "../logger";
+
+export function logExecutionTime(fileName: string = "") {
+    return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+        const logger: Logger = new Logger(fileName);
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            const start = process.hrtime();
+            logger.info(` ${propertyKey} method execution started . . .`);
+            try {
+                const result = await originalMethod.apply(this, args);
+                const end = process.hrtime(start);
+                const durationInMilliseconds = end[0] * 1000 + end[1] / 1e6;
+                logger.info(` ${propertyKey} method took ${durationInMilliseconds.toFixed(2)} ms to execute`)
+                return result;
+            } catch (error) {
+                throw error;
+            }
+        };
+        return descriptor;
+
+    }
+
+}

package/src/logger.ts

@@ -0,0 +1,83 @@
+import {Utilities} from "./utilities";
+import winston from "winston";
+import * as path from "path";
+import * as fs from "fs";
+
+export enum LogLevels {
+    INFO = "INFO", ERROR = "ERROR", DEBUG = "DEBUG", LOG = "LOG"
+}
+
+export class Logger {
+    private readonly winstonLogger: any;
+    public tag: string = "[UNTAGGED]";
+
+    private logFormat: winston.Logform.Format = winston.format.printf((tmp: winston.Logform.TransformableInfo): string => {
+        const {time, file, level, message} = tmp;
+        return `${JSON.stringify({time, file: file?.replaceAll("\\", "/"), level, message})},`;
+    });
+
+    constructor(tag: string) {
+        const fileName: string = this.getFileName();
+        const logsDirectory = "logs";
+        const logFilePath = path.join(logsDirectory, fileName + ".json");
+
+        if (!fs.existsSync(logsDirectory)) {
+            fs.mkdirSync(logsDirectory);
+        }
+        this.tag = tag;
+        this.winstonLogger = winston.createLogger({
+            format: winston.format.json(),
+            transports: [new winston.transports.File({filename: logFilePath, format: this.logFormat})],
+        });
+    }
+
+    private getFileName(): string {
+        const now = new Date();
+        return now.getDate() + "-" + (now.getMonth() + 1) + "-" + now.getFullYear();
+    }
+
+    public execStart(prefix: string = ""): any {
+        this.print(LogLevels.INFO, `${prefix} - Execution started`);
+        return performance.now();
+    }
+
+    public execStop(prefix: string = "", startTime: any, error: boolean = false): any {
+        switch (error) {
+            case true: {
+                this.print(LogLevels.ERROR, `${prefix} - Execution ended due to an error. Execution time: ${performance.now() - startTime} ms`);
+                break;
+            }
+            case false: {
+                this.print(LogLevels.INFO, `${prefix} - Execution ended successfully. Execution time: ${performance.now() - startTime} ms`);
+                break;
+            }
+        }
+    }
+
+    public info(...data: any): void {
+        this.print(LogLevels.INFO, ...data);
+    }
+
+    public debug(...data: any): void {
+        this.print(LogLevels.DEBUG, ...data);
+    }
+
+    public log(...data: any): void {
+        this.print(LogLevels.LOG, ...data);
+    }
+
+    public error(...data: any): void {
+        this.print(LogLevels.ERROR, ...data);
+    }
+
+    private print(level: LogLevels = LogLevels.INFO, ...data: any): void {
+        const now = new Date();
+        // Utilities.getNowDateString();
+        this.winstonLogger.defaultMeta = {
+            file: this.tag, time: now, level
+        };
+        this.winstonLogger[level.toLowerCase()](...data);
+        // @ts-ignore
+        console[level.toLowerCase()](`[${level}][${now}][${this.tag.split("\\").pop()}]`, ...data);
+    }
+}

package/src/orm.ts

@@ -0,0 +1,87 @@
+// @ts-ignore
+import * as Firebird from "es-node-firebird";
+import {Logger} from "./logger";
+
+export class Orm {
+    public static RESULT_EXEC_OK = "ok!";
+
+    public static quote(value: string) {
+        return "\"" + value + "\"";
+    };
+
+    public static testConnection(options: any): Promise<any> {
+        const logger: Logger = new Logger(__filename);
+        return new Promise((resolve, reject): void => {
+            Firebird.attach(options, (err: any, db: any): void => {
+                if (err) {
+                    logger.error("La connessione con il DATABASE non è andata a buon fine.");
+                    return resolve(false);
+                }
+                logger.info("DATABASE connesso.");
+                return resolve(true);
+            })
+        })
+    }
+
+
+    public static query(options: any, query: any, parameters: any[] = []): Promise<any> {
+        return new Promise((resolve, reject): void => {
+            Firebird.attach(options, (err: any, db: {
+                query: (arg0: any, arg1: any[], arg2: (err: any, result: any) => void) => void; detach: () => void;
+            }) => {
+                if (err) {
+                    return reject(err);
+                }
+                db.query(query, parameters, (error: any, result: any) => {
+                    if (error) {
+                        db.detach();
+                        return reject(error);
+                    }
+                    db.detach();
+                    return resolve(result);
+                });
+            });
+        });
+    }
+
+
+    public static execute(options: any, query: any, parameters: any = []) {
+        return new Promise((resolve, reject) => {
+            Firebird.attach(options, (err: any, db: {
+                execute: (arg0: any, arg1: any, arg2: (error: any, result: any) => void) => void; detach: () => void;
+            }) => {
+                if (err) {
+                    // tslint:disable-next-line:no-console
+                    console.error(err);
+                    return reject(err);
+                }
+
+                db.execute(query, parameters, (error, result) => {
+                    if (error) {
+                        db.detach();
+                        // tslint:disable-next-line:no-console
+                        console.log(query);
+                        parameters.forEach((param: any, i: any) => {
+                            // tslint:disable-next-line:no-console
+                            console.log(i + 1, param);
+                        })
+                        // tslint:disable-next-line:no-console
+                        console.error(error);
+                        return reject(error);
+                    }
+                    db.detach();
+                    return resolve(this.RESULT_EXEC_OK);
+                });
+            });
+        });
+    }
+
+    public static trimParam(param: any) {
+        if (typeof param === "string" || param instanceof String) {
+            return param.trim();
+        }
+        return param;
+    }
+}
+
+

package/src/utilities.ts

@@ -0,0 +1,144 @@
+export class Utilities {
+
+    public static parseDate(date: string) {
+        const parts: string[] = date.split("/");
+        return new Date(Number(parts[2]), Number(parts[1]) - 1, Number(parts[0]));
+    }
+
+    public static STATUS_CODE = {
+        OK: 0, WARNING: 1, ERROR: 2,
+    };
+
+    public static sendOKMessage(res: any, message: any) {
+        return res.send({
+            severity: "success", status: 200, statusCode: this.STATUS_CODE.OK, message,
+        });
+    }
+
+    public static getNowDateString() {
+        const now: Date = new Date();
+        const day: string | number = now.getDate() < 9 ? "0" + now.getDate() : now.getDate();
+        const month: string | number = (now.getMonth() + 1) < 9 ? "0" + (now.getMonth() + 1) : (now.getMonth() + 1);
+        const year: number = now.getFullYear();
+        const hours: string | number = now.getHours() < 9 ? "0" + now.getHours() : now.getHours();
+        const minutes: string | number = now.getMinutes() < 9 ? "0" + now.getMinutes() : now.getMinutes();
+        const seconds: string | number = now.getSeconds() < 9 ? "0" + now.getSeconds() : now.getSeconds();
+        return day + "." + month + "." + year + " " + hours + ":" + minutes + ":" + seconds;
+    }
+
+
+    public static sendErrorMessage(res: any, err: any, tag: string = "[BASE ERROR]", status: number = 500) {
+        // tslint:disable-next-line:no-console
+        console.error(err);
+        return res.status(status).send({
+            severity: "error",
+            status: 500,
+            statusCode: this.STATUS_CODE.ERROR,
+            message: " Si è verificato un errore",
+            error: tag + ": " + err,
+        });
+    }
+
+    // Risposte per funzioni in stile ES
+    public static sendOpenResponse(res: any, payload: any) {
+        try {
+            payload = JSON.parse(JSON.stringify(payload));
+            const clearPayload = payload;           // this.keysToCamel(payload);
+            const response = {
+                Status: {
+                    errorCode: "0", errorDescription: "",
+                }, Result: clearPayload, Message: ""
+            };
+            return res.send(response);
+        } catch (error) {
+            return this.sendOpenErrorMessage(res, "Errore nell'invio della risposta: " + error, "[UTILITIES]", 500);
+        }
+    }
+
+
+    public static sendOpenErrorMessage(res: any, err: any, tag = "[BASE ERROR]", status = 500) {
+        return res.status(status).send({
+            Status: {
+                errorCode: "500", errorDescription: err,
+            }, Result: [], Message: err,
+        });
+    }
+
+    private static toCamel(s: any) {
+        return s.replace(/([-_][a-z])/gi, ($1: string) => {
+            return $1.toUpperCase().replace("-", "").replace("_", "");
+        });
+    };
+
+    private static isArray(a: any) {
+        return Array.isArray(a);
+    };
+
+    private static isObject(o: any) {
+        return o === Object(o) && !this.isArray(o) && typeof o !== "function";
+    };
+
+    public static keysToCamel(o: any) {
+        if (this.isObject(o)) {
+            const n = {};
+
+            Object.keys(o).forEach((k: any) => {
+                // @ts-ignore
+                n[this.toCamel(k)] = this.keysToCamel(o[k]);
+            });
+
+            return n;
+        } else if (this.isArray(o)) {
+            return o.map((i: any) => {
+                return this.keysToCamel(i);
+            });
+        }
+
+        return o;
+    };
+
+    public static addStartingZeros(num: number, totalLength: number) {
+        return String(num).padStart(totalLength, '0');
+    }
+
+    public static dateToMoncler(dData: Date, bAddMs: boolean = false) {
+        const yy: number = dData.getFullYear();
+        const mm: string = this.addStartingZeros(dData.getMonth() + 1, 2);
+        const dd: string = this.addStartingZeros(dData.getDate(), 2);
+        const hh: string = this.addStartingZeros(dData.getHours(), 2);
+        const nn: string = this.addStartingZeros(dData.getMinutes(), 2);
+        const ss: string = this.addStartingZeros(dData.getSeconds(), 2);
+        const ms: string = this.addStartingZeros(dData.getMilliseconds(), 3);
+        if (bAddMs) {
+            return yy + mm + dd + hh + nn + ss + ms;
+        } else {
+            return yy + mm + dd + hh + nn + ss;
+        }
+    }
+
+    public static dateToSql(dData: Date, bAddMs: boolean = false) {
+        const yy: number = dData.getFullYear();
+        const mm: string = this.addStartingZeros(dData.getMonth() + 1, 2);
+        const dd: string = this.addStartingZeros(dData.getDate(), 2);
+        const hh: string = this.addStartingZeros(dData.getHours(), 2);
+        const nn: string = this.addStartingZeros(dData.getMinutes(), 2);
+        const ss: string = this.addStartingZeros(dData.getSeconds(), 2);
+        const ms: string = this.addStartingZeros(dData.getMilliseconds(), 3);
+        if (bAddMs) {
+            return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss + '.' + ms;
+        } else {
+            return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss;
+
+        }
+    }
+
+    public static dateToSimple(dData: Date) {
+        const yy: number = dData.getFullYear();
+        const mm: string = this.addStartingZeros(dData.getMonth() + 1, 2);
+        const dd: string = this.addStartingZeros(dData.getDate(), 2);
+        return dd + '-' + mm + '-' + yy;
+    }
+
+
+}
+

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "esModuleInterop": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}