@btffamily/vacepey 1.0.1

package/build/utils/functions.util.js

@@ -0,0 +1,1032 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDecimal = exports.hasDecimal = exports.isPrecise = exports.isDefined = exports.notDefined = exports.generate = exports.daysFromDates = exports.yesterdayFromDate = exports.dateIsFuture = exports.dateIsPast = exports.dateIsEqual = exports.dateIsYesterday = exports.dateIsToday = exports.checkTimeFormat = exports.checkDateFormat = exports.isZero = exports.isNumber = exports.isNeg = exports.isPos = exports.isObjectId = exports.rearrangeArray = exports.sortData = exports.dateToday = exports.formatDate = exports.monthsOfYear = exports.daysOfWeek = exports.leadingNum = exports.urlToBase64 = exports.convertUrlToBase64 = exports.capitalize = exports.getBase64Mime = exports.isBase64 = exports.isEmptyObject = exports.dateToWordRaw = exports.dateToWord = exports.rangeFromMinutes = exports.timeToMinutes = exports.listIncludes = exports.arrayIncludes = exports.arrayIncludesEs6 = exports.strIncludesEs6 = exports.strIncludes = exports.strToArrayEs6 = exports.strToArray = exports.isArray = exports.isString = exports.isObject = exports.wordLen = exports.charLen = exports.slugit = void 0;
+exports.toMongoId = exports.weekEndDate = exports.weekStartDate = exports.dateFromWeekNumber = exports.base64ToString = exports.stringToBase64 = exports.arrayToSingleObject = exports.arrayToObject = exports.isJson = exports.objectToArray = exports.enumToArray = exports.hasSAC = exports.formatISO = exports.lastDayOfMonth = exports.firstDayOfMonth = exports.getDaysFromDates = exports.getCodeFromName = exports.validateBase64 = exports.getWeeksInMonth = exports.getDatesInRange = exports.getWeeksDates = exports.compareISODate = exports.UIID = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const slugify_1 = __importDefault(require("slugify"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+const weekOfYear_1 = __importDefault(require("dayjs/plugin/weekOfYear"));
+const weekYear_1 = __importDefault(require("dayjs/plugin/weekYear"));
+dayjs_1.default.extend(customParseFormat_1.default);
+dayjs_1.default.extend(weekOfYear_1.default);
+dayjs_1.default.extend(weekYear_1.default);
+// import https
+const https_1 = __importDefault(require("https"));
+const random_service_1 = __importDefault(require("../services/random.service"));
+const moment_1 = __importDefault(require("moment"));
+const mongo_service_1 = __importDefault(require("../services/mongo.service"));
+const axios_1 = __importDefault(require("axios"));
+const slugit = (payload) => {
+    let _op = { lowercase: true, separator: '-' };
+    const { data, options } = payload;
+    if (options && (0, exports.isDefined)(options.lowercase, true)) {
+        _op.lowercase = options.lowercase;
+    }
+    if (options && options.separator) {
+        _op.separator = options.separator;
+    }
+    const result = (0, slugify_1.default)(data, { lower: _op.lowercase, replacement: _op.separator });
+    return result;
+};
+exports.slugit = slugit;
+const charLen = (data) => {
+    return data.length;
+};
+exports.charLen = charLen;
+const wordLen = (data) => {
+    const array = data.trim().split(/\s+/);
+    return array.length;
+};
+exports.wordLen = wordLen;
+const isObject = (arg) => {
+    const ty = typeof arg;
+    return ty === 'object' ? true : false;
+};
+exports.isObject = isObject;
+const isString = (arg) => {
+    const ty = typeof arg;
+    return ty === 'string' ? true : false;
+};
+exports.isString = isString;
+const isArray = (arg) => {
+    let res = false;
+    if (Array.isArray) {
+        res = Array.isArray(arg);
+    }
+    return res;
+};
+exports.isArray = isArray;
+const strToArray = (arg, split) => {
+    return arg.split(split);
+};
+exports.strToArray = strToArray;
+const strToArrayEs6 = (arg, split) => {
+    return arg.split(split);
+};
+exports.strToArrayEs6 = strToArrayEs6;
+const strIncludes = (arg, inc) => {
+    return arg.indexOf(inc) ? true : false;
+};
+exports.strIncludes = strIncludes;
+const strIncludesEs6 = (arg, inc) => {
+    return arg.includes(inc) ? true : false;
+};
+exports.strIncludesEs6 = strIncludesEs6;
+const arrayIncludesEs6 = (arr, inc) => {
+    return arr.includes(inc) ? true : false;
+};
+exports.arrayIncludesEs6 = arrayIncludesEs6;
+const arrayIncludes = (arr, inc) => {
+    let flag = false;
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i].toString() === inc.toString()) {
+            flag = true;
+            break;
+        }
+    }
+    return flag;
+};
+exports.arrayIncludes = arrayIncludes;
+const listIncludes = (data) => {
+    let flag = false;
+    const { arr, list, type } = data;
+    if (type === 'some') {
+        flag = list.some((x) => arr.includes(x));
+    }
+    if (type === 'every') {
+        flag = list.every((x) => arr.includes(x));
+    }
+    return flag;
+};
+exports.listIncludes = listIncludes;
+const timeToMinutes = (data) => {
+    const seconds = (data.hr * 3600) + (data.min * 60) + data.sec;
+    const minutes = seconds / 60;
+    return parseFloat(minutes.toFixed(2));
+};
+exports.timeToMinutes = timeToMinutes;
+const rangeFromMinutes = (dur) => {
+    const start = new Date();
+    const end = new Date(start.getTime() + dur * 60 * 1000);
+    const msdiff = end.getTime() - start.getTime();
+    const mindiff = msdiff / (1000 * 60);
+    return { start, end, diff: mindiff };
+};
+exports.rangeFromMinutes = rangeFromMinutes;
+const dateToWord = (date) => {
+    const theDate = (0, dayjs_1.default)(date).toString();
+    return theDate;
+};
+exports.dateToWord = dateToWord;
+const dateToWordRaw = () => {
+    const theDate = (0, dayjs_1.default)().toString();
+    return theDate;
+};
+exports.dateToWordRaw = dateToWordRaw;
+const isEmptyObject = (obj) => {
+    return Object.keys(obj).length === 0;
+};
+exports.isEmptyObject = isEmptyObject;
+const isBase64 = (data) => {
+    let result = false;
+    const mime = data.split(';base64')[0].split(':')[1];
+    if (mime && mime !== '') {
+        result = true;
+    }
+    return result;
+};
+exports.isBase64 = isBase64;
+const getBase64Mime = (data) => {
+    let result = '';
+    if ((0, exports.isBase64)(data)) {
+        result = data.split(';base64')[0].split(':')[1];
+    }
+    return result;
+};
+exports.getBase64Mime = getBase64Mime;
+const capitalize = (word, each = false) => {
+    let result = '';
+    let tempList = [];
+    if (!each) {
+        result = word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    if (each) {
+        let split = word.split(' ');
+        split.forEach((x) => {
+            tempList.push(x.charAt(0).toUpperCase() + x.slice(1));
+        });
+        result = tempList.join(' ');
+    }
+    return result;
+};
+exports.capitalize = capitalize;
+const convertUrlToBase64 = async (url) => {
+    let body = null;
+    return new Promise((resolve, reject) => {
+        https_1.default.get(url, (resp) => {
+            resp.setEncoding('base64');
+            body = "data:" + resp.headers["content-type"] + ";base64,";
+            resp.on('data', (data) => { body += data; });
+            resp.on('end', () => {
+                try {
+                    resolve(body);
+                }
+                catch (e) {
+                    reject(e.message);
+                }
+            });
+        }).on('error', (e) => {
+            reject(`Got error: ${e.message}`);
+        });
+    });
+};
+exports.convertUrlToBase64 = convertUrlToBase64;
+const urlToBase64 = async (url, headers = {}) => {
+    try {
+        const response = await axios_1.default.get(url, {
+            responseType: 'arraybuffer',
+            headers: headers,
+        });
+        const contentType = response.headers['content-type'];
+        const buffer = Buffer.from(response.data);
+        const base64String = buffer.toString('base64');
+        return contentType ? `data:${contentType};base64,${base64String}` : base64String;
+    }
+    catch (err) {
+        console.error('Failed to get file from url:', err);
+    }
+};
+exports.urlToBase64 = urlToBase64;
+const leadingNum = (val, length = 2, pad = '0') => {
+    let lead = '';
+    if (val >= 0) {
+        lead = val.toString().padStart(length, pad);
+    }
+    return lead;
+};
+exports.leadingNum = leadingNum;
+const daysOfWeek = () => {
+    let result = [
+        { id: 0, name: 'sunday' },
+        { id: 1, name: 'monday' },
+        { id: 2, name: 'tuesday' },
+        { id: 3, name: 'wednesday' },
+        { id: 4, name: 'thursday' },
+        { id: 5, name: 'friday' },
+        { id: 6, name: 'saturday' },
+    ];
+    return result;
+};
+exports.daysOfWeek = daysOfWeek;
+const monthsOfYear = () => {
+    let result = [
+        { id: 0, name: 'january' },
+        { id: 1, name: 'february' },
+        { id: 2, name: 'march' },
+        { id: 3, name: 'april' },
+        { id: 4, name: 'may' },
+        { id: 5, name: 'june' },
+        { id: 6, name: 'july' },
+        { id: 7, name: 'august' },
+        { id: 8, name: 'september' },
+        { id: 9, name: 'october' },
+        { id: 10, name: 'november' },
+        { id: 11, name: 'december' },
+    ];
+    return result;
+};
+exports.monthsOfYear = monthsOfYear;
+const formatDate = (date, type) => {
+    let result = '';
+    if (type === 'basic') {
+        result = (0, moment_1.default)(date).format('Do MMM, YYYY');
+    }
+    if (type === 'datetime') {
+        result = (0, moment_1.default)(date).format('Do MMM, YYYY HH:mm:ss A');
+    }
+    if (type === 'datetime-slash') {
+        result = (0, moment_1.default)(date).format('YYYY/MM/DD HH:mm:ss');
+    }
+    if (type === 'datetime-separated') {
+        result = (0, moment_1.default)(date).format('YYYY-MM-DD HH:mm:ss');
+    }
+    if (type === 'localtime') {
+        result = (0, moment_1.default)(date).format('h:mm A');
+    }
+    if (type === 'separated') {
+        result = (0, moment_1.default)(date).format('YYYY-MM-DD');
+    }
+    if (type === 'slashed') {
+        result = (0, moment_1.default)(date).format('YYYY/MM/DD');
+    }
+    return result;
+};
+exports.formatDate = formatDate;
+const dateToday = (d = null) => {
+    const today = d !== null && d !== undefined && d !== '' ? new Date(d) : new Date();
+    const _dayjs = d !== null && d !== undefined && d !== '' ? (0, dayjs_1.default)(d) : (0, dayjs_1.default)();
+    const daysOfWeek = [
+        { id: 0, name: 'sunday' },
+        { id: 1, name: 'monday' },
+        { id: 2, name: 'tuesday' },
+        { id: 3, name: 'wednesday' },
+        { id: 4, name: 'thursday' },
+        { id: 5, name: 'friday' },
+        { id: 6, name: 'saturday' },
+    ];
+    const monthsOfYear = [
+        { id: 0, name: 'january' },
+        { id: 1, name: 'february' },
+        { id: 2, name: 'march' },
+        { id: 3, name: 'april' },
+        { id: 4, name: 'may' },
+        { id: 5, name: 'june' },
+        { id: 6, name: 'july' },
+        { id: 7, name: 'august' },
+        { id: 8, name: 'september' },
+        { id: 9, name: 'october' },
+        { id: 10, name: 'november' },
+        { id: 11, name: 'december' },
+    ];
+    const date = today.getDate();
+    const _d = today.getDay();
+    const day = today.getDay() + 1;
+    const dayName = daysOfWeek.find((d) => d.id === _d)?.name;
+    const _m = today.getMonth();
+    const month = today.getMonth() + 1;
+    const monthName = monthsOfYear.find((m) => m.id === _m)?.name;
+    const year = today.getFullYear();
+    const week = _dayjs.week();
+    const hour = today.getHours();
+    const min = today.getMinutes();
+    const sec = today.getSeconds();
+    const milli = today.getMilliseconds();
+    const iso = today.toISOString();
+    const timestamp = today.getTime();
+    return { year: year, month: month, monthName: monthName, date: date, week: week, day: day, dayName: dayName, hour: hour, min: min, sec: sec, milli: milli, ISO: iso, dayjs: today, dateTime: timestamp };
+};
+exports.dateToday = dateToday;
+const sortData = (data, prop = '') => {
+    let sorted = [];
+    if (prop !== '') {
+        sorted = data.sort((a, b) => {
+            if (a[prop].toString() < b[prop].toString()) {
+                return -1;
+            }
+            else if (a[prop].toString() > b[prop].toString()) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    if (prop === '') {
+        sorted = data.sort((a, b) => {
+            if (a.toString() < b.toString()) {
+                return -1;
+            }
+            else if (a.toString() > b.toString()) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    return sorted;
+};
+exports.sortData = sortData;
+const rearrangeArray = (from, to, arr) => {
+    let result = [];
+    let temp = [];
+    // save array temporarily
+    temp = [...arr];
+    // remove the item at the 'from' index in the array
+    // get that item and save it in variable 'item'
+    const item = arr.splice(from, 1)[0];
+    if (item && item !== undefined && item !== null) {
+        // copy the remaining items in the array into 'result'
+        result = [...arr];
+        // add the item removed above to the 'result' array but to a new index
+        result.splice(to, 0, item);
+    }
+    else {
+        result = [...temp];
+    }
+    return result;
+};
+exports.rearrangeArray = rearrangeArray;
+const isObjectId = (val) => {
+    let flag = false;
+    if (mongoose_1.default.Types.ObjectId.isValid(val) && (String)(new mongoose_1.default.Types.ObjectId(val)) === val) {
+        flag = true;
+    }
+    else {
+        flag === false;
+    }
+    return flag;
+};
+exports.isObjectId = isObjectId;
+const isPos = (val) => {
+    let flag = false;
+    if (!Number.isNaN(val) && val >= 0) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.isPos = isPos;
+const isNeg = (val) => {
+    let flag = false;
+    if (!Number.isNaN(val) && val < 0) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.isNeg = isNeg;
+const isNumber = (val) => {
+    let flag = false;
+    if (!Number.isNaN(val) && typeof (val) === 'number') {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.isNumber = isNumber;
+const isZero = (val) => {
+    let flag = false;
+    if ((0, exports.isNumber)(val)) {
+        if (val === 0) {
+            flag = true;
+        }
+        else {
+            flag = false;
+        }
+    }
+    return flag;
+};
+exports.isZero = isZero;
+const checkDateFormat = (date) => {
+    let flag = false;
+    if (!(0, exports.strIncludesEs6)(date, '-') && !(0, exports.strIncludesEs6)(date, '/')) {
+        flag = false;
+    }
+    else {
+        if ((0, exports.strIncludesEs6)(date, '-')) {
+            const split = date.split('-');
+            const y = split[0];
+            const m = split[1];
+            const d = split[2];
+            if (y.length !== 4) {
+                flag = false;
+            }
+            else if (m.length !== 2) {
+                flag = false;
+            }
+            else if (d.length !== 2) {
+                flag = false;
+            }
+            else {
+                flag = true;
+            }
+        }
+        if ((0, exports.strIncludesEs6)(date, '/')) {
+            const split = date.split('/');
+            const y = split[0];
+            const m = split[1];
+            const d = split[2];
+            if (y.length !== 4) {
+                flag = false;
+            }
+            else if (m.length !== 2) {
+                flag = false;
+            }
+            else if (d.length !== 2) {
+                flag = false;
+            }
+            else {
+                flag = true;
+            }
+        }
+    }
+    return flag;
+};
+exports.checkDateFormat = checkDateFormat;
+const checkTimeFormat = (time) => {
+    let flag = false;
+    if (!(0, exports.strIncludesEs6)(time, ':')) {
+        flag = false;
+    }
+    else {
+        const split = time.split(':');
+        const h = split[0];
+        const m = split[1];
+        if (h.length !== 2) {
+            flag = false;
+        }
+        else if (m.length !== 2) {
+            flag = false;
+        }
+        else {
+            flag = true;
+        }
+    }
+    return flag;
+};
+exports.checkTimeFormat = checkTimeFormat;
+const dateIsToday = (date) => {
+    let flag = false;
+    const today = Date.now();
+    const conv = (0, exports.dateToday)(today);
+    const dc = (0, exports.dateToday)(date);
+    const format = `${conv.year}-${(0, exports.leadingNum)(conv.month)}-${(0, exports.leadingNum)(conv.date)}`;
+    const check = `${dc.year}-${(0, exports.leadingNum)(dc.month)}-${(0, exports.leadingNum)(dc.date)}`;
+    if (format.toString() === check.toString()) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.dateIsToday = dateIsToday;
+const dateIsYesterday = (date) => {
+    let flag = false;
+    const today = Date.now();
+    const conv = (0, exports.dateToday)(today);
+    const dc = (0, exports.dateToday)(date);
+    const diffDate = conv.date - 1;
+    if (dc.date === diffDate) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.dateIsYesterday = dateIsYesterday;
+const dateIsEqual = (fDate, lDate) => {
+    let flag = false;
+    const fConv = (0, exports.dateToday)(fDate);
+    const lConv = (0, exports.dateToday)(lDate);
+    const format = `${fConv.year}-${(0, exports.leadingNum)(fConv.month)}-${(0, exports.leadingNum)(fConv.date)}`;
+    const check = `${lConv.year}-${(0, exports.leadingNum)(lConv.month)}-${(0, exports.leadingNum)(lConv.date)}`;
+    if (format.toString() === check.toString()) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.dateIsEqual = dateIsEqual;
+const dateIsPast = (data) => {
+    let flag = false;
+    const { currentDate, compareDate } = data;
+    const today = (0, exports.dateToday)(currentDate);
+    const compare = (0, exports.dateToday)(compareDate);
+    if (today.year > compare.year) {
+        flag = true;
+    }
+    else if (today.month > compare.month) {
+        flag = true;
+    }
+    else if (today.date > compare.date) {
+        flag = true;
+    }
+    return flag;
+};
+exports.dateIsPast = dateIsPast;
+const dateIsFuture = (today, date) => {
+    let flag = false;
+    const tDate = (0, exports.dateToday)(today);
+    const cDate = (0, exports.dateToday)(date);
+    const yearFq = (cDate.year === tDate.year) || (cDate.year > tDate.year);
+    const monthFq = (cDate.month === tDate.month) || (cDate.month > tDate.month);
+    const dateFq = cDate.date > tDate.date;
+    if (yearFq && monthFq && dateFq) {
+        flag = true;
+    }
+    else {
+        flag = false;
+    }
+    return flag;
+};
+exports.dateIsFuture = dateIsFuture;
+const yesterdayFromDate = (date) => {
+    const today = (0, exports.dateToday)(date);
+    const formatted = `${today.year}-${(0, exports.leadingNum)(today.month)}-${(0, exports.leadingNum)(today.date - 1)}`;
+    const yesterday = (0, exports.dateToday)(formatted);
+    return yesterday.ISO;
+};
+exports.yesterdayFromDate = yesterdayFromDate;
+const daysFromDates = (data) => {
+    let result = 0;
+    const startDate = new Date(data.start);
+    const endDate = new Date(data.end);
+    if (data.dir === 'default') {
+        result = Math.round((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24));
+    }
+    else if (data.dir === 'reverse') {
+        result = Math.round((startDate.getTime() - endDate.getTime()) / (1000 * 3600 * 24));
+    }
+    return result;
+};
+exports.daysFromDates = daysFromDates;
+const generate = (size, options) => {
+    let result = '';
+    if (options.type === 'code') {
+        result = random_service_1.default.randomCode(size, options.alpha);
+    }
+    if (options.type === 'alpha') {
+        result = random_service_1.default.randomAlpha(size);
+    }
+    if (options.type === 'num') {
+        result = random_service_1.default.randomNum(size);
+    }
+    return result;
+};
+exports.generate = generate;
+const notDefined = (val, truthy = false) => {
+    let result = false;
+    if (!truthy) {
+        if (val === undefined || val === null || val.toString() === '') {
+            result = true;
+        }
+    }
+    if (truthy) {
+        if (val.toString() !== 'true' && val.toString() !== 'false') {
+            result = true;
+        }
+        else if (val === undefined || val === null || val.toString() === '') {
+            result = true;
+        }
+    }
+    return result;
+};
+exports.notDefined = notDefined;
+const isDefined = (val, truthy = false) => {
+    let result = false;
+    if (!truthy) {
+        if (val !== undefined && val !== null && val.toString() !== '') {
+            result = true;
+        }
+    }
+    if (truthy) {
+        if (val !== undefined && val !== null && (val.toString() === 'true' || val.toString() === 'false')) {
+            result = true;
+        }
+        else if (val !== undefined && val !== null && val.toString() !== '') {
+            result = true;
+        }
+    }
+    return result;
+};
+exports.isDefined = isDefined;
+const isPrecise = (data) => {
+    let result = false;
+    const { value, length } = data;
+    const converted = value.toString();
+    if ((0, exports.strIncludesEs6)(converted, '.')) {
+        const split = converted.split('.');
+        const deci = split[1].length;
+        if (deci === length) {
+            result = true;
+        }
+    }
+    return result;
+};
+exports.isPrecise = isPrecise;
+const hasDecimal = (value) => {
+    let result = false;
+    const converted = value.toString();
+    if ((0, exports.strIncludesEs6)(converted, '.')) {
+        const split = converted.split('.');
+        if (split.length > 1) {
+            result = true;
+        }
+    }
+    return result;
+};
+exports.hasDecimal = hasDecimal;
+const toDecimal = (value, places) => {
+    let result = value;
+    const converted = value.toFixed(places);
+    result = parseFloat(converted);
+    return result;
+};
+exports.toDecimal = toDecimal;
+const UIID = (batch = 0) => {
+    let result = '';
+    const uid = crypto_1.default.randomUUID();
+    const split = uid.split('-');
+    if (batch === 0) {
+        result = uid;
+    }
+    else {
+        if (batch === 1) {
+            result = split[0];
+        }
+        else if (batch === 2) {
+            result = `${split[0]}-${split[1]}${split[2]}`;
+        }
+        else if (batch === 3) {
+            result = `${split[0]}-${split[1]}${split[2]}-${split[split.length - 1]}`;
+        }
+        else {
+            result = uid;
+        }
+    }
+    return result;
+};
+exports.UIID = UIID;
+const compareISODate = (dateA, dateB, type) => {
+    let result = false;
+    const dt = (0, exports.dateToday)(dateA);
+    const dn = (0, exports.dateToday)(dateB);
+    if (type === 'equal') {
+        if (dt.year === dn.year && dt.month === dn.month && dt.date === dn.date) {
+            result = true;
+        }
+        else {
+            result = false;
+        }
+    }
+    if (type === 'greaterthan') {
+        if (dt.dateTime > dn.dateTime) {
+            result = true;
+        }
+        else {
+            result = false;
+        }
+    }
+    if (type === 'greaterequal') {
+        if (dt.dateTime >= dn.dateTime) {
+            result = true;
+        }
+        else {
+            result = false;
+        }
+    }
+    if (type === 'lessthan') {
+        if (dt.dateTime < dn.dateTime) {
+            result = true;
+        }
+        else {
+            result = false;
+        }
+    }
+    if (type === 'lessequal') {
+        if (dt.dateTime <= dn.dateTime) {
+            result = true;
+        }
+        else {
+            result = false;
+        }
+    }
+    return result;
+};
+exports.compareISODate = compareISODate;
+const getWeeksDates = (year, month, data) => {
+    let result = [];
+    if (data.length > 0) {
+        for (let i = 0; i < data.length; i++) {
+            const week = data[i];
+            result.push({
+                label: `Week ${i + 1}`,
+                start: (0, exports.dateToday)(`${year}-${month}-${week.start}`).ISO,
+                end: (0, exports.dateToday)(`${year}-${month}-${week.end}`).ISO,
+                dates: []
+            });
+            week.dates.forEach((dt) => {
+                let p = (0, exports.dateToday)(`${year}-${month}-${dt}`);
+                result[i].dates.push(p.ISO);
+            });
+        }
+    }
+    return result;
+};
+exports.getWeeksDates = getWeeksDates;
+const getDatesInRange = (start, end) => {
+    let result = [];
+    let dates = [];
+    let currentDate = new Date(start);
+    let endDate = new Date(end);
+    while (currentDate <= endDate) {
+        dates.push(new Date(currentDate)); // avoid modifying original date 
+        currentDate.setDate(currentDate.getDate() + 1); // increase
+    }
+    dates.forEach((d) => {
+        result.push((0, exports.dateToday)(d).ISO);
+    });
+    return result;
+};
+exports.getDatesInRange = getDatesInRange;
+const getWeeksInMonth = (year, month) => {
+    let weeks = [];
+    let dwc = 0;
+    const fd = new Date(year, month, 1); // first date
+    const ld = new Date(year, month + 1, 0); // last date
+    const nod = ld.getDate(); // number of days
+    dwc = fd.getDate(); // init counter ( this always gives 1)
+    for (let i = 1; i <= nod; i++) {
+        // NB: {i} is the date here
+        if (weeks.length === 0) {
+            weeks.push([]);
+        }
+        if (weeks[weeks.length - 1].length < 7) {
+            weeks[weeks.length - 1].push(i);
+        }
+        else {
+            weeks.push([]);
+            weeks[weeks.length - 1].push(i);
+        }
+        dwc = (dwc + 1) % 7;
+    }
+    const rs = weeks.map((w) => ({
+        start: w[0],
+        end: w[w.length - 1],
+        dates: w
+    }));
+    return rs;
+};
+exports.getWeeksInMonth = getWeeksInMonth;
+const validateBase64 = (data) => {
+    const mime = data.split(';base64')[0].split(':')[1];
+    return mime && mime !== undefined && mime !== null ? true : false;
+};
+exports.validateBase64 = validateBase64;
+const getCodeFromName = (name) => {
+    let result = '';
+    if (name) {
+        const split = name.split(' ');
+        if (split.length > 1) {
+            for (let i = 0; i < split.length; i++) {
+                result = result + split[i].substring(0, 1).toUpperCase();
+            }
+        }
+        else {
+            result = name.substring(0, 3).toUpperCase();
+        }
+    }
+    return result;
+};
+exports.getCodeFromName = getCodeFromName;
+/**
+ * @name getDaysFromDates
+ * @param prev
+ * @param next
+ * @returns
+ */
+const getDaysFromDates = (then, now) => {
+    let result = 0;
+    const thenDate = new Date(then);
+    const nowDate = new Date(now);
+    const dateThen = (0, exports.dateToday)(thenDate);
+    const covNow = (0, exports.dateToday)(nowDate);
+    const dateNow = (0, dayjs_1.default)(covNow.ISO);
+    const diff = dateNow.diff(dateThen.ISO, 'day', true);
+    result = Math.floor(diff);
+    return result;
+};
+exports.getDaysFromDates = getDaysFromDates;
+/**
+ * @name firstDayOfMonth
+ * @param d
+ * @returns
+ */
+const firstDayOfMonth = (d = '') => {
+    const today = d ? new Date(d) : new Date();
+    const convToday = (0, exports.dateToday)(today);
+    const first = new Date(convToday.year, (convToday.month - 1), 1);
+    const convFirst = (0, exports.dateToday)(first);
+    return { date: first, converted: convFirst };
+};
+exports.firstDayOfMonth = firstDayOfMonth;
+/**
+ * @name lastDayOfMonth
+ * @param d
+ * @returns
+ */
+const lastDayOfMonth = (d = '') => {
+    const today = d ? new Date(d) : new Date();
+    const convToday = (0, exports.dateToday)(today);
+    const last = new Date(convToday.year, convToday.month, 1);
+    const convLast = (0, exports.dateToday)(last);
+    return { date: last, converted: convLast };
+};
+exports.lastDayOfMonth = lastDayOfMonth;
+const formatISO = (ISO) => {
+    let result = { date: '', time: '' };
+    const split = ISO.split('T');
+    if (split.length > 0) {
+        result.date = split[0];
+        result.time = split[1].split('.')[0];
+    }
+    return result;
+};
+exports.formatISO = formatISO;
+const hasSAC = (value) => {
+    let result = false;
+    const match = /^[a-zA-Z0-9-_]+$/;
+    if (!match.test(value)) {
+        result = true;
+    }
+    return result;
+};
+exports.hasSAC = hasSAC;
+const enumToArray = (data, type) => {
+    let result = [];
+    const list = Object.entries(data).map(([key, value]) => ({ key, value }));
+    if (type === 'all') {
+        result = list;
+    }
+    else if (type === 'values-only') {
+        result = list.map((x) => x.value);
+    }
+    else if (type === 'keys-only') {
+        result = list.map((x) => x.key);
+    }
+    return result;
+};
+exports.enumToArray = enumToArray;
+const objectToArray = (data) => {
+    const _keys = Object.keys(data);
+    const _values = Object.values(data);
+    let hook = [];
+    for (let i = 0; i < _keys.length; i++) {
+        if (typeof (_values[i]) === 'object') {
+            hook.push({ key: _keys[i], value: JSON.stringify(_values[i]), type: typeof (_values[i]) });
+        }
+        else {
+            hook.push({ key: _keys[i], value: _values[i], type: typeof (_values[i]) });
+        }
+    }
+    return hook;
+};
+exports.objectToArray = objectToArray;
+const isJson = (value) => {
+    let result = false;
+    try {
+        const data = JSON.parse(value);
+        result = true;
+    }
+    catch (error) {
+        result = false;
+    }
+    return result;
+};
+exports.isJson = isJson;
+const arrayToObject = (data) => {
+    let result = {};
+    for (let i = 0; i < data.length; i++) {
+        let item = data[i];
+        let value = item.value;
+        if (item.type === 'object') {
+            if (typeof (item.value) === 'string' && (0, exports.isJson)(item.value)) {
+                value = JSON.parse(item.value);
+            }
+        }
+        let _m = {};
+        _m[item.key] = value;
+        Object.assign(result, _m);
+    }
+    return result;
+};
+exports.arrayToObject = arrayToObject;
+const arrayToSingleObject = (data) => {
+    let keyList = [];
+    let valList = [];
+    let result = {};
+    // get keys
+    data.forEach((x) => {
+        if (typeof (x) === 'object') {
+            keyList = keyList.concat(Object.keys(x));
+        }
+    });
+    // get values
+    data.forEach((x) => {
+        if (typeof (x) === 'object') {
+            valList = valList.concat(Object.values(x));
+        }
+    });
+    if (keyList.length > 0) {
+        for (let i = 0; i < keyList.length; i++) {
+            result[keyList[i]] = valList[i];
+        }
+    }
+    else {
+        result = Object.assign({}, data);
+    }
+    return result;
+};
+exports.arrayToSingleObject = arrayToSingleObject;
+const stringToBase64 = (data) => {
+    let result = '';
+    const { type, payload } = data;
+    if (type === 'buffer') {
+        const buffered = Buffer.from(payload).toString('base64');
+        result = buffered;
+    }
+    if (type === 'direct') {
+        result = payload;
+    }
+    return result;
+};
+exports.stringToBase64 = stringToBase64;
+const base64ToString = (data) => {
+    let result = '';
+    const { type, payload } = data;
+    if (type === 'buffer') {
+        const buffered = Buffer.from(payload, 'base64').toString('ascii');
+        result = buffered;
+    }
+    if (type === 'direct') {
+        result = payload;
+    }
+    return result;
+};
+exports.base64ToString = base64ToString;
+const dateFromWeekNumber = (weekNum) => {
+    const dw = (0, dayjs_1.default)().week(weekNum);
+    const weekDate = (0, exports.dateToday)(dw);
+    return weekDate;
+};
+exports.dateFromWeekNumber = dateFromWeekNumber;
+const weekStartDate = (date) => {
+    const dx = new Date(date);
+    const day = dx.getDay();
+    const diff = dx.getDate() - day + (0); // week starts on sunday
+    // const diff = dx.getDate() - day + (day === 0 ? 0 : 1); // week starts on monday
+    const newDate = new Date(dx.setDate(diff));
+    const weekStart = (0, exports.dateToday)(newDate);
+    return weekStart;
+};
+exports.weekStartDate = weekStartDate;
+const weekEndDate = (date) => {
+    const startDate = (0, exports.weekStartDate)(date);
+    const start = new Date(startDate.ISO);
+    let first = start.getDate() - start.getDay();
+    let last = first + 6;
+    const lastDate = new Date(start.setDate(last));
+    const weekEnd = (0, exports.dateToday)(lastDate);
+    return weekEnd;
+};
+exports.weekEndDate = weekEndDate;
+const toMongoId = (id) => {
+    return mongo_service_1.default.toMongoId(id);
+};
+exports.toMongoId = toMongoId;