shareneus 1.0.5

package/dist/utils/tr-utils.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrUtils = void 0;
+// import { HttpClient } from '@angular/common/http';
+const enums_1 = require("../enums/enums");
+var deepEqual = require('deep-equal');
+// import { LaborStatusEnum } from '../enums/enums';
+class TrUtils {
+    static IsNull(Value) {
+        return Value === null || typeof Value === 'undefined';
+    }
+    static IsEmpty(Value) {
+        return Value === null || typeof Value === 'undefined' || Value === '';
+    }
+    static IsZero(Value) {
+        return Value === null || typeof Value === 'undefined' || Value === 0;
+    }
+    static IsFixedZero(Value) {
+        return Value === null || typeof Value === 'undefined' || Value === '0.00';
+    }
+    static Stringify(RecordData) {
+        if (this.IsNull(RecordData)) {
+            return RecordData;
+        }
+        let StringifiedResult = JSON.parse(JSON.stringify(RecordData));
+        return StringifiedResult;
+    }
+    static CombineProductDetails(product) {
+        return product.Model + ' ' + product.Year + ' ' + product.Var;
+    }
+    static GetProductRegistrationNo(product) {
+        if (!this.IsNull(product)) {
+            return product.RegNo;
+        }
+        else {
+            return null;
+        }
+    }
+    static GetEquipmentModel(product) {
+        return product.Make + ' ' + product.Model;
+    }
+    static GetEquipmentSerialNo(equipment) {
+        if (!this.IsNull(equipment)) {
+            return equipment.SNo;
+        }
+        else {
+            return null;
+        }
+    }
+    static ConcatObjects(obj1, obj2) {
+        // tslint:disable-next-line:forin
+        for (let key in obj2) {
+            obj1[key] = obj2[key];
+        }
+        return obj1;
+    }
+    static ConvertPercToVal(Discount, Total) {
+        if (this.IsNull(Total)) {
+            return null;
+        }
+        else {
+            if (this.IsNull(Discount)) {
+                Discount = 0;
+            }
+            if (this.IsNull(Total)) {
+                Total = 0;
+            }
+            let value = this.FixedTo(((Total * Discount) / 100));
+            if (isNaN(value)) {
+                value = 0;
+            }
+            return value;
+        }
+    }
+    static ConvertMinsToHour(Mins) {
+        let Num;
+        Mins = Number(Mins);
+        let Hrs = Mins / 60;
+        Num = this.FixedTo(Hrs);
+        return Num;
+    }
+    static ConvertHourToMin(HrsData) {
+        let Time = {};
+        if (!TrUtils.IsNull(HrsData)) {
+            // tslint:disable-next-line:radix
+            Time['Hrs'] = parseInt(HrsData.toString().split('.')[0]);
+            Time['Mins'] = (HrsData * 60) % 60;
+        }
+        return Time;
+    }
+    static FixedTo(value) {
+        if (this.IsNull(value)) {
+            value = 0;
+        }
+        value = Number(value);
+        let Result = value.toFixed(this.DecimalsNumber);
+        return Number(Result);
+    }
+    static FixPriceValue(Value) {
+        if (this.IsNull(Value)) {
+            Value = 0;
+        }
+        if (typeof Value === 'string') {
+            Value = Number(Value);
+        }
+        let Result = Value.toFixed(this.DecimalsNumber);
+        return Result;
+    }
+    static ConvertValToPerc(Discount, Total) {
+        if (this.IsNull(Total)) {
+            return null;
+        }
+        else {
+            if (this.IsNull(Discount)) {
+                Discount = 0;
+            }
+            if (this.IsNull(Total)) {
+                Total = 0;
+            }
+            let value = this.FixedTo(((Discount * 100) / Total));
+            if (isNaN(value)) {
+                value = 0;
+            }
+            return value;
+        }
+    }
+    static CheckARIndividualStatusValid(Part, Field) {
+        if (Part.Ind[Field] === enums_1.LaborStatusEnum.Cancelled || Part.Ind[Field] === enums_1.LaborStatusEnum.Declined) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    static CheckARIndividualStatusApproved(Part, Field) {
+        if (Part.Ind[Field] !== enums_1.LaborStatusEnum.New && Part.Ind[Field] !== enums_1.LaborStatusEnum.WtngForAppr &&
+            this.CheckARIndividualStatusValid(Part, Field)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    static CheckARIndividualStatusCompleted(Part, Field) {
+        if (Part.Ind[Field] === enums_1.LaborStatusEnum.Completed) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    static CheckAndUnsubscribeSubject(Subject) {
+        if (!this.IsNull(Subject)) {
+            Subject.unsubscribe();
+        }
+    }
+    static SetValueToZeroIfNull(Value) {
+        if (this.IsNull(Value)) {
+            Value = 0;
+        }
+        return Value;
+    }
+    static SetPercToStringIfNull(Value) {
+        if (this.IsNull(Value)) {
+            Value = '';
+        }
+        return Value;
+    }
+    static SetPercToTrueIfNull(Value) {
+        if (this.IsNull(Value)) {
+            Value = true;
+        }
+        return Value;
+    }
+    static CheckInvalidSelect(Value) {
+        return Value === null || typeof Value === 'undefined' || Value === '' || Value === -1 || Value === '-1';
+    }
+    static DateSorting(date1, date2) {
+        if (TrUtils.IsEmpty(date1) && TrUtils.IsEmpty(date2)) {
+            return 0;
+        }
+        if (TrUtils.IsEmpty(date1)) {
+            return -1;
+        }
+        if (TrUtils.IsEmpty(date2)) {
+            return 1;
+        }
+        let Date1 = date1.split('-');
+        let Date2 = date2.split('-');
+        let year1 = Number(Date1[2]);
+        let day1 = Number(Date1[0]);
+        let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec'];
+        let month1 = months.indexOf(Date1[1]);
+        let year2 = Number(Date2[2]);
+        let day2 = Number(Date2[0]);
+        let month2 = months.indexOf(Date2[1]);
+        let result1 = (year1 * 10000) + (month1 * 100) + day1;
+        let result2 = (year2 * 10000) + (month2 * 100) + day2;
+        let result = result1 - result2;
+        return result;
+    }
+    static DateSortingMonthandYear(date1, date2) {
+        if (TrUtils.IsEmpty(date1) && TrUtils.IsEmpty(date2)) {
+            return 0;
+        }
+        if (TrUtils.IsEmpty(date1)) {
+            return -1;
+        }
+        if (TrUtils.IsEmpty(date2)) {
+            return 1;
+        }
+        let Date1 = date1.split('/');
+        let Date2 = date2.split('/');
+        let year1 = Number(Date1[1]);
+        // let day1 = Number(Date1[0]);
+        let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec'];
+        let month1 = months.indexOf(Date1[0]);
+        let year2 = Number(Date2[1]);
+        // let day2 = Number(Date2[0]);
+        let month2 = months.indexOf(Date2[0]);
+        let result1 = (year1 * 10000) + (month1 * 100);
+        let result2 = (year2 * 10000) + (month2 * 100);
+        let result = result1 - result2;
+        return result;
+    }
+    static InvoiceIdSorting(data1, data2) {
+        if (!this.IsEmpty(data1) && !this.IsEmpty(data2)) {
+            let Data1 = data1.split('I');
+            let Data2 = data2.split('I');
+            return this.GridNumberSorting(Data1[1], Data2[1]);
+        }
+        else {
+            return 0;
+        }
+    }
+    static IdSorting(id, data1, data2) {
+        if (!this.IsEmpty(data1) && !this.IsEmpty(data2) && data1.includes(id) && data2.includes(id)) {
+            let Data1 = data1.split(id);
+            let Data2 = data2.split(id);
+            return this.GridNumberSorting(Data1[1], Data2[1]);
+        }
+        else {
+            return this.GridNumberSorting(data1, data2);
+            ;
+        }
+    }
+    static GridNumberSorting(num1, num2) {
+        let result = Number(num1) - Number(num2);
+        return result;
+    }
+    static AlphabetSorter(argDatalist, Identifier) {
+        let argList = TrUtils.Stringify(argDatalist);
+        argList.sort(function (a, b) {
+            var _a, _b, _c, _d;
+            // tslint:disable-next-line:curly
+            if (TrUtils.IsNull(a[Identifier])) {
+                a[Identifier] = '';
+            }
+            if (TrUtils.IsNull(b[Identifier])) {
+                b[Identifier] = '';
+            }
+            if (((_a = a[Identifier]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) < ((_b = b[Identifier]) === null || _b === void 0 ? void 0 : _b.toLowerCase()))
+                return -1;
+            // tslint:disable-next-line:curly
+            if (((_c = a[Identifier]) === null || _c === void 0 ? void 0 : _c.toLowerCase()) > ((_d = b[Identifier]) === null || _d === void 0 ? void 0 : _d.toLowerCase()))
+                return 1;
+            return 0;
+        });
+        return argList;
+    }
+    static ArrayAlphabetSorting(SortingList) {
+        SortingList.sort((a, b) => {
+            let fa = a.Name.toLowerCase(), fb = b.Name.toLowerCase();
+            if (fa < fb) {
+                return -1;
+            }
+            if (fa > fb) {
+                return 1;
+            }
+            return 0;
+        });
+        return SortingList;
+    }
+    static GetHours(hour, isPM) {
+        if (isPM === 'PM') {
+            let Amhours = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11'];
+            let Pmhours = ['13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23'];
+            if (hour >= 12) {
+                let Index = Pmhours.findIndex((val) => {
+                    return val === hour.toString();
+                });
+                return (Index === -1) ? '12' : Amhours[Index];
+            }
+            else {
+                let Index = Amhours.findIndex((val) => {
+                    return val === hour.toString();
+                });
+                return (Index === -1) ? '12' : Pmhours[Index];
+            }
+        }
+        else {
+            return hour === '12' ? '0' : hour.toString();
+        }
+    }
+    static isTaxable(tax) {
+        return (tax === 'TI') ? true : false;
+    }
+    static IsItemFromEstimate(ItemId) {
+        return !TrUtils.IsNull(ItemId) && (ItemId.split('E').length === 2);
+    }
+    static IsItemInsurance(PayBy) {
+        return PayBy === enums_1.PayTypeEnum.Insurance || PayBy === enums_1.PayTypeEnum.Shared;
+    }
+    static GetMonthsArray() {
+        let MonthName = new Array();
+        MonthName[0] = 'Jan';
+        MonthName[1] = 'Feb';
+        MonthName[2] = 'Mar';
+        MonthName[3] = 'Apr';
+        MonthName[4] = 'May';
+        MonthName[5] = 'Jun';
+        MonthName[6] = 'Jul';
+        MonthName[7] = 'Aug';
+        MonthName[8] = 'Sept';
+        MonthName[9] = 'Oct';
+        MonthName[10] = 'Nov';
+        MonthName[11] = 'Dec';
+        return MonthName;
+    }
+    static IsEqual(arg1, arg2) {
+        return deepEqual(arg1, arg2, true);
+    }
+    static GetDurationInHrsAndMins(duration) {
+        let Durationhr = Math.floor(duration / 60);
+        let Durationmin = duration % 60;
+        if (Durationhr === 0 && Durationmin === 0) {
+            return '-';
+        }
+        else {
+            let DurationInfo = '';
+            if (Durationhr !== 0) {
+                DurationInfo = Durationhr + ' hrs';
+            }
+            if (Durationmin !== 0) {
+                DurationInfo = DurationInfo + ' ' + Durationmin + ' mins';
+            }
+            return DurationInfo;
+        }
+    }
+}
+exports.TrUtils = TrUtils;
+// static laborEndPointAddress: string = 'https://b4721cf2655e.ngrok.io/';
+// static laborEndPointAddress: string = 'http://localhost:9000/';
+TrUtils.DecimalsNumber = 2;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "shareneus",
+  "version": "1.0.5",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.14.11",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "big.js": "^6.2.1",
+    "date-fns": "^2.30.0",
+    "date-fns-tz": "^2.0.0",
+    "jsbarcode": "^3.11.6",
+    "xlsx": "^0.18.5"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,109 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}