ia-common 1.0.1-beta.21 → 1.0.1-beta.211

package/build/red-black-tree/red-black-tree.d.ts

@@ -0,0 +1,11 @@
+export declare class RedBlackTree<T, V> {
+    js_col: RedBlackTree<T, V>;
+    constructor(compare: any);
+    insert<T, V>(key: T, value: V): T;
+    remove(key: string): V;
+    getMin(): V;
+    isEmpty(): boolean;
+    getValues(): V[];
+    static getMinTree<T, V>(): RedBlackTree<T, V>;
+    static getMaxTree<T, V>(): RedBlackTree<T, V>;
+}

package/build/red-black-tree/red-black-tree.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedBlackTree = void 0;
+var _utils_1 = require("../@utils");
+var js_cols = require("./js-cols");
+var RedBlackTree = /** @class */ (function () {
+    function RedBlackTree(compare) {
+        this.js_col = new js_cols.RedBlackMap(compare);
+    }
+    RedBlackTree.prototype.insert = function (key, value) {
+        this.js_col.insert(key, value);
+        return key;
+    };
+    RedBlackTree.prototype.remove = function (key) {
+        return this.js_col.remove(key);
+    };
+    RedBlackTree.prototype.getMin = function () {
+        return this.js_col.getMin();
+    };
+    RedBlackTree.prototype.isEmpty = function () {
+        return this.js_col.isEmpty();
+    };
+    RedBlackTree.prototype.getValues = function () {
+        return this.js_col.getValues();
+    };
+    RedBlackTree.getMinTree = function () {
+        var compare = function (a, b) {
+            var _a = a.split("#"), aInteger = _a[0], aDecimal = _a[1];
+            var _b = b.split("#"), bInteger = _b[0], bDecimal = _b[1];
+            var aFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(aInteger)), "#").concat(Number(aDecimal));
+            var bFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(bInteger)), "#").concat(Number(bDecimal));
+            if (aFormatted < bFormatted)
+                return -1;
+            if (aFormatted > bFormatted)
+                return 1;
+            return 0;
+        };
+        return new RedBlackTree(compare);
+    };
+    RedBlackTree.getMaxTree = function () {
+        var compare = function (a, b) {
+            var _a = a.split("#"), aInteger = _a[0], aDecimal = _a[1];
+            var _b = b.split("#"), bInteger = _b[0], bDecimal = _b[1];
+            var aFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(aInteger)), "#").concat(Number(aDecimal));
+            var bFormatted = "".concat(_utils_1.StringUtil.PadStartToIntegerPart(Number(bInteger)), "#").concat(Number(bDecimal));
+            if (aFormatted < bFormatted)
+                return 1;
+            if (aFormatted > bFormatted)
+                return -1;
+            return 0;
+        };
+        return new RedBlackTree(compare);
+    };
+    return RedBlackTree;
+}());
+exports.RedBlackTree = RedBlackTree;

package/build/utils/date-util.d.ts

@@ -1,8 +1,22 @@
+import { INgbDateStruct } from "../@type";
 export declare class DateUtil {
     static isValidDate(dateCode: string): boolean;
     getDateCode(date: Date): string;
+    getTodayCode(): string;
     convertStringToDate(dateString: string, format?: string): Date;
     addNDaysToDate(date: Date, n: number): Date;
     addNDaysToDateCode(dateCode: string, n: number): string;
+    convertMonthsToNumber: (months: INgbDateStruct) => string;
+    convertNumberToNgbDateStruct: (numericDate: string) => INgbDateStruct | null;
+    formatDateCode(dateCode: string): string;
+    addYearsToDateCode(dateCode: string, noOfYear: number): string;
+    getDateTimeCode(date: Date): string;
+    formatCreatedOrUpdateOn(data: string): string;
+    convertToNgbDate(input: string): {
+        year: number;
+        month: number;
+        day: number;
+    };
+    dateCodeFormatter(dateCode: string, formatter: string): string;
 }
 export declare const dateUtil: DateUtil;

package/build/utils/date-util.js

@@ -4,6 +4,24 @@ exports.dateUtil = exports.DateUtil = void 0;
 var date_fns_1 = require("date-fns");
 var DateUtil = /** @class */ (function () {
     function DateUtil() {
+        this.convertMonthsToNumber = function (months) {
+            var year = months.year.toString().slice(2, 4);
+            var month = months.month.toString().padStart(2, "0");
+            var day = months.day.toString().padStart(2, "0");
+            var dates = year.concat(month).concat(day);
+            return "".concat(dates);
+        };
+        this.convertNumberToNgbDateStruct = function (numericDate) {
+            if (typeof numericDate === "string" && numericDate.length === 6) {
+                var year = parseInt(numericDate.slice(0, 2), 10);
+                var month = parseInt(numericDate.slice(2, 4), 10);
+                var day = parseInt(numericDate.slice(4, 6), 10);
+                if (!isNaN(year) && !isNaN(month) && !isNaN(day)) {
+                    return { year: 2000 + year, month: month, day: day };
+                }
+            }
+            return null;
+        };
     }
     DateUtil.isValidDate = function (dateCode) {
         if (dateCode.length !== 6)
@@ -23,6 +41,9 @@ var DateUtil = /** @class */ (function () {
     DateUtil.prototype.getDateCode = function (date) {
         return (0, date_fns_1.format)(date, "yyMMdd");
     };
+    DateUtil.prototype.getTodayCode = function () {
+        return (0, date_fns_1.format)(new Date(), "yyMMdd");
+    };
     DateUtil.prototype.convertStringToDate = function (dateString, format) {
         if (format === void 0) { format = "yyMMdd"; }
         var parsedDate = (0, date_fns_1.parse)(dateString, format, new Date());
@@ -36,6 +57,36 @@ var DateUtil = /** @class */ (function () {
     DateUtil.prototype.addNDaysToDateCode = function (dateCode, n) {
         return this.getDateCode(this.addNDaysToDate(this.convertStringToDate(dateCode, "yyMMdd"), n));
     };
+    DateUtil.prototype.formatDateCode = function (dateCode) {
+        var date = (0, date_fns_1.parse)(dateCode, "yyMMdd", new Date());
+        var d = (0, date_fns_1.format)(date, "dd-MMM (EE)");
+        return d.slice(0, d.length - 2) + d.slice(d.length - 1);
+    };
+    DateUtil.prototype.addYearsToDateCode = function (dateCode, noOfYear) {
+        var date = this.convertStringToDate(dateCode);
+        var nextYear = new Date(date);
+        nextYear.setFullYear(date.getFullYear() + 1);
+        return this.getDateCode(nextYear);
+    };
+    DateUtil.prototype.getDateTimeCode = function (date) {
+        return (0, date_fns_1.format)(date, "yyMMddHHmm");
+    };
+    DateUtil.prototype.formatCreatedOrUpdateOn = function (data) {
+        var datePart = data.slice(8, 10);
+        var monthPart = data.slice(5, 7);
+        var yearPart = data.slice(2, 4);
+        return "".concat(yearPart).concat(monthPart).concat(datePart);
+    };
+    DateUtil.prototype.convertToNgbDate = function (input) {
+        var year = 2000 + parseInt(input.substring(0, 2), 10);
+        var month = parseInt(input.substring(2, 4), 10);
+        var day = parseInt(input.substring(4, 6), 10);
+        return { year: year, month: month, day: day };
+    };
+    DateUtil.prototype.dateCodeFormatter = function (dateCode, formatter) {
+        var date = (0, date_fns_1.parse)(dateCode, "yyMMdd", new Date());
+        return (0, date_fns_1.format)(date, formatter);
+    };
     return DateUtil;
 }());
 exports.DateUtil = DateUtil;

package/build/utils/string-utils.d.ts

@@ -1,4 +1,10 @@
 export declare class StringUtil {
     generateRandomPassword(): string;
+    static convertToIdObjectResponse<T extends {
+        id: number;
+    }>(entities: T[]): {
+        [id: number]: T;
+    };
+    static PadStartToIntegerPart(number: number, length?: number): string;
 }
 export declare const stringUtil: StringUtil;

package/build/utils/string-utils.js

@@ -35,6 +35,24 @@ var StringUtil = /** @class */ (function () {
         }
         return passwordArray.join("");
     };
+    StringUtil.convertToIdObjectResponse = function (entities) {
+        var response = {};
+        entities.forEach(function (entity) {
+            if (!response[entity.id])
+                response[entity.id] = entity;
+        });
+        return response;
+    };
+    StringUtil.PadStartToIntegerPart = function (number, length) {
+        if (length === void 0) { length = 7; }
+        var numString = number.toString();
+        var _a = numString.split("."), integerPart = _a[0], decimalPart = _a[1];
+        var paddedIntegerPart = integerPart.padStart(length, "0");
+        var formattedNum = decimalPart
+            ? "".concat(paddedIntegerPart, ".").concat(decimalPart)
+            : paddedIntegerPart;
+        return formattedNum;
+    };
     return StringUtil;
 }());
 exports.StringUtil = StringUtil;

package/build/utils/validate-utils.d.ts

@@ -0,0 +1,4 @@
+import { CorporateActionsType } from "../@enum";
+export declare class ValidateUtils {
+    static validateCorporateActionType(corporateActionType: CorporateActionsType, expectedType: CorporateActionsType): void;
+}

package/build/utils/validate-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateUtils = void 0;
+var _model_1 = require("../@model");
+var ValidateUtils = /** @class */ (function () {
+    function ValidateUtils() {
+    }
+    ValidateUtils.validateCorporateActionType = function (corporateActionType, expectedType) {
+        if (corporateActionType !== expectedType) {
+            throw new _model_1.AppBadRequestException({
+                key: expectedType,
+                message: [
+                    "Corporate action entity with type does not belongs to ".concat(expectedType),
+                ],
+            });
+        }
+    };
+    return ValidateUtils;
+}());
+exports.ValidateUtils = ValidateUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ia-common",
-  "version": "1.0.1-beta.21",
+  "version": "1.0.1-beta.211",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/build/interface/api/login-interface.d.ts

@@ -1,22 +0,0 @@
-export interface ILoginResponse {
-    UIMessage: string;
-    tokenType: string;
-    accessToken: string;
-    id: string;
-    firstname: string;
-    status: string;
-    requireNewPassword: boolean;
-    userId: number;
-    role: string;
-    email: string | null;
-    imageUrl: string | null;
-    userPermissions: string[];
-    registrationId: number;
-    organizationId: number;
-    subscriptionStatus: string | null;
-    contact: string;
-}
-export interface ILoginRequest {
-    username: string;
-    password: string;
-}