cmat 0.0.3

package/esm2022/services/title/title.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { filter, map, mergeMap } from 'rxjs/operators';
+import { CmatUtilsService } from 'cmat/services/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "@angular/router";
+export class CmatTitleService {
+    constructor(_titleService, _router) {
+        this._titleService = _titleService;
+        this._router = _router;
+        this.sub = this._router.events.pipe(filter((event) => event instanceof NavigationEnd), map(() => this._router.routerState.root), map((route) => {
+            while (route.firstChild) {
+                route = route.firstChild;
+            }
+            return route;
+        }), mergeMap(route => route.data))
+            .subscribe((data) => {
+            let title = data['title'];
+            if (title) {
+                const fragment = this._router.url.split('#')[1];
+                if (fragment) {
+                    title += ' | ' + CmatUtilsService.toTitleCase(fragment);
+                }
+            }
+            if (title && this.appName) {
+                title += ' - ' + this.appName;
+            }
+            else if (this.appName) {
+                title = this.appName;
+            }
+            if (title) {
+                this._titleService.setTitle(title);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTitleService, deps: [{ token: i1.Title }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTitleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTitleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Title }, { type: i2.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/translation/cmat-services-translation.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy10cmFuc2xhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdHJhbnNsYXRpb24vY21hdC1zZXJ2aWNlcy10cmFuc2xhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/translation/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './translation.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdHJhbnNsYXRpb24vcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90cmFuc2xhdGlvbi5zZXJ2aWNlJztcclxuIl19

package/esm2022/services/translation/translation.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class CmatTranslationService {
+    constructor(_translate) {
+        this._translate = _translate;
+        this._defaultLanguage = 'zh';
+        this._onLanguageChanged = new Subject();
+        this.setDefaultLanguage(this._defaultLanguage);
+    }
+    get languageChanged$() {
+        return this._onLanguageChanged.asObservable();
+    }
+    addLanguages(lang) {
+        this._translate.addLangs(lang);
+    }
+    setDefaultLanguage(lang) {
+        this._translate.setDefaultLang(lang);
+    }
+    getDefaultLanguage() {
+        return this._translate.defaultLang;
+    }
+    getBrowserLanguage() {
+        return this._translate.getBrowserLang();
+    }
+    useBrowserLanguage() {
+        const browserLang = this.getBrowserLanguage();
+        if (browserLang && browserLang.match(/en|zh/)) {
+            this.changeLanguage(browserLang);
+            return browserLang;
+        }
+        return browserLang;
+    }
+    changeLanguage(language = 'zh') {
+        if (!language) {
+            language = this._translate.defaultLang;
+        }
+        if (language !== this._translate.currentLang) {
+            setTimeout(() => {
+                this._translate.use(language);
+                this._onLanguageChanged.next(language);
+            });
+        }
+        return language;
+    }
+    getTranslation(key, interpolateParams) {
+        return this._translate.instant(key, interpolateParams);
+    }
+    getTranslationAsync(key, interpolateParams) {
+        return this._translate.get(key, interpolateParams);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTranslationService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTranslationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatTranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/utils/cmat-services-utils.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdXRpbHMvY21hdC1zZXJ2aWNlcy11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/utils/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './utils.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdXRpbHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi91dGlscy5zZXJ2aWNlJztcclxuIl19

package/esm2022/services/utils/utils.service.mjs

@@ -0,0 +1,391 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpHeaders, HttpResponse, HttpResponseBase } from '@angular/common/http';
+import AES from 'crypto-js/aes';
+import UTF8 from 'crypto-js/enc-utf8';
+import Hex from 'crypto-js/enc-hex';
+import Base64 from 'crypto-js/enc-base64';
+import Pkcs7 from 'crypto-js/pad-pkcs7';
+import CryptoJSCore from 'crypto-js/core';
+import { throwError } from 'rxjs';
+import { isUndefined } from 'lodash-es';
+import { CMAT_VERSION } from 'cmat/version';
+import * as i0 from "@angular/core";
+export class CmatUtilsService {
+    static { this.captionAndMessageSeparator = ':'; }
+    static { this.noNetworkMessageCaption = '无网络'; }
+    static { this.noNetworkMessageDetail = '无法连接服务器'; }
+    static { this.accessDeniedMessageCaption = '拒绝访问!'; }
+    static { this.accessDeniedMessageDetail = ''; }
+    static { this.key = UTF8.parse('14789632236987411478963223698741'); } //32位
+    static { this.iv = UTF8.parse('1478963223698741'); } //16位
+    get exactMatchOptions() {
+        return {
+            paths: 'exact',
+            fragment: 'ignored',
+            matrixParams: 'ignored',
+            queryParams: 'exact'
+        };
+    }
+    get subsetMatchOptions() {
+        return {
+            paths: 'subset',
+            fragment: 'ignored',
+            matrixParams: 'ignored',
+            queryParams: 'subset'
+        };
+    }
+    static getRequestHeaders() {
+        return new HttpHeaders()
+            .append('Access-Control-Allow-Origin', '*')
+            .append('Content-Type', 'application/json')
+            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)
+            .append('App-Version', CMAT_VERSION);
+    }
+    static getRequestBypassHeaders() {
+        return new HttpHeaders()
+            .append('Access-Control-Allow-Origin', '*')
+            .append('Content-Type', 'application/json')
+            .append('bypass', 'true')
+            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)
+            .append('App-Version', CMAT_VERSION);
+    }
+    static getRequestCryptoHeaders(params) {
+        return new HttpHeaders()
+            .append('Access-Control-Allow-Origin', '*')
+            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)
+            .append('App-Version', this.getEncryptData('partymanageApi' + params).toString());
+    }
+    static getRequestCryptoBypassHeaders(params) {
+        return new HttpHeaders()
+            .append('Access-Control-Allow-Origin', '*')
+            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)
+            .append('bypass', 'true')
+            .append('App-Version', this.getEncryptData('partymanageApi' + params).toString());
+    }
+    static getEncryptData(data) {
+        const src = UTF8.parse(data);
+        return AES.encrypt(src, this.key, {
+            iv: this.iv,
+            mode: CryptoJSCore.mode.CBC,
+            padding: Pkcs7
+        }).ciphertext.toString();
+    }
+    static getDecryptData(data) {
+        const encryptedHexStr = Hex.parse(data);
+        return AES.decrypt(Base64.stringify(encryptedHexStr), this.key, {
+            iv: this.iv,
+            mode: CryptoJSCore.mode.CBC,
+            padding: Pkcs7
+        }).toString(UTF8).toString();
+    }
+    static handleError(error) {
+        if (error.error instanceof ErrorEvent) {
+            // A client-side or network error occurred. Handle it accordingly.
+            console.error('Client side network error occurred:', error.message);
+        }
+        else {
+            // The backend returned an unsuccessful response code.
+            // The response body may contain clues as to what went wrong,
+            console.error('Backend - ' +
+                `status: ${error.status}, ` +
+                `statusText: ${error.statusText}, ` +
+                `message: ${error.message}`);
+        }
+        // return an observable with a user-facing error message
+        return throwError(() => error || 'server error');
+    }
+    static getHttpResponseMessage(data) {
+        const responses = [];
+        if (data instanceof HttpResponseBase) {
+            if (this.checkNoNetwork(data)) {
+                responses.push(`${this.noNetworkMessageCaption}${this.captionAndMessageSeparator} ${this.noNetworkMessageDetail}`);
+            }
+            else {
+                const responseObject = this.getResponseBody(data);
+                if (responseObject && (typeof responseObject === 'object' || responseObject instanceof Object)) {
+                    for (const key in responseObject) {
+                        if (Object.prototype.hasOwnProperty.call(responseObject, key)) {
+                            if (key) {
+                                responses.push(`${key}${this.captionAndMessageSeparator} ${responseObject[key]}`);
+                            }
+                            else if (responseObject[key]) {
+                                responses.push(responseObject[key].toString());
+                            }
+                        }
+                    }
+                }
+            }
+            if (!responses.length && this.getResponseBody(data)) {
+                responses.push(`${this.getResponseBody(data).toString()}`);
+            }
+        }
+        if (!responses.length) {
+            responses.push(data.toString());
+        }
+        if (this.checkAccessDenied(data)) {
+            responses.splice(0, 0, `${this.accessDeniedMessageCaption}${this.captionAndMessageSeparator} ${this.accessDeniedMessageDetail}`);
+        }
+        return responses;
+    }
+    static findHttpResponseMessage(messageToFind, data, seachInCaptionOnly = true, includeCaptionInResult = false) {
+        const searchString = messageToFind.toLowerCase();
+        const httpMessages = this.getHttpResponseMessage(data);
+        for (const message of httpMessages) {
+            const fullMessage = CmatUtilsService.splitInTwo(message, this.captionAndMessageSeparator);
+            if (fullMessage.firstPart && fullMessage.firstPart.toLowerCase().indexOf(searchString) !== -1) {
+                return includeCaptionInResult ? message : fullMessage.secondPart || fullMessage.firstPart;
+            }
+        }
+        if (!seachInCaptionOnly) {
+            for (const message of httpMessages) {
+                if (message.toLowerCase().indexOf(searchString) !== -1) {
+                    if (includeCaptionInResult) {
+                        return message;
+                    }
+                    else {
+                        const fullMessage = CmatUtilsService.splitInTwo(message, this.captionAndMessageSeparator);
+                        return fullMessage.secondPart || fullMessage.firstPart;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    static getResponseBody(response) {
+        if (response instanceof HttpResponse) {
+            return response.body;
+        }
+        if (response instanceof HttpErrorResponse) {
+            return response.error || response.message || response.statusText;
+        }
+        return response;
+    }
+    static checkNoNetwork(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status === 0;
+        }
+        return false;
+    }
+    static checkAccessDenied(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status === 403;
+        }
+        return false;
+    }
+    static checkNotFound(response) {
+        if (response instanceof HttpResponseBase) {
+            return response.status === 404;
+        }
+        return false;
+    }
+    static checkIsLocalHost(url, base) {
+        if (url) {
+            const location = new URL(url, base);
+            return location.hostname === 'localhost' || location.hostname === '127.0.0.1';
+        }
+        return false;
+    }
+    static getQueryParamsFromString(paramString) {
+        if (!paramString) {
+            return null;
+        }
+        const params = {};
+        for (const param of paramString.split('&')) {
+            const keyValue = CmatUtilsService.splitInTwo(param, '=');
+            params[keyValue.firstPart] = keyValue.secondPart;
+        }
+        return params;
+    }
+    static splitInTwo(text, separator) {
+        const separatorIndex = separator ? text.indexOf(separator) : -1;
+        if (separatorIndex === -1) {
+            return { firstPart: text, secondPart: null };
+        }
+        const part1 = text.substring(0, separatorIndex).trim();
+        const part2 = text.substring(separatorIndex + 1).trim();
+        return { firstPart: part1, secondPart: part2 };
+    }
+    static safeStringify(object) {
+        let result;
+        try {
+            result = JSON.stringify(object);
+            return result;
+        }
+        catch (error) { /* empty */ }
+        const simpleObject = {};
+        for (const prop in object) {
+            if (!Object.prototype.hasOwnProperty.call(object, prop)) {
+                continue;
+            }
+            if (typeof (object[prop]) == 'object') {
+                continue;
+            }
+            if (typeof (object[prop]) == 'function') {
+                continue;
+            }
+            simpleObject[prop] = object[prop];
+        }
+        result = '[***Sanitized Object***]: ' + JSON.stringify(simpleObject);
+        return result;
+    }
+    static jsonTryParse(value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            if (isUndefined(value)) {
+                return void 0;
+            }
+            return value;
+        }
+    }
+    static capitalizeFirstLetter(text) {
+        if (text) {
+            return text.charAt(0).toUpperCase() + text.slice(1);
+        }
+        else {
+            return text;
+        }
+    }
+    static toTitleCase(text) {
+        return text.replace(/\w\S*/g, subString => subString.charAt(0).toUpperCase() + subString.substring(1).toLowerCase());
+    }
+    static toLowerCase(items) {
+        if (items instanceof Array) {
+            const loweredRoles = [];
+            for (let i = 0; i < items.length; i++) {
+                loweredRoles[i] = items[i].toLowerCase();
+            }
+            return loweredRoles;
+        }
+        else if (typeof items === 'string' || items instanceof String) {
+            return items.toLowerCase();
+        }
+        return void 0;
+    }
+    static uniqueId() {
+        return this.randomNumber(1000000, 9000000).toString();
+    }
+    static randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static baseUrl() {
+        let base;
+        if (window.location.origin) {
+            base = window.location.origin;
+        }
+        else {
+            base = window.location.protocol + '//' + window.location.hostname + (window.location.port ? ':' + window.location.port : '');
+        }
+        return base.replace(/\/$/, '');
+    }
+    static newGuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            // eslint-disable-next-line no-bitwise
+            const r = (Math.random() * 16) | 0;
+            // eslint-disable-next-line no-bitwise
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static testIsAbsoluteUrl(url) {
+        const r = new RegExp('^(?:[a-z]+:)?//', 'i');
+        return r.test(url);
+    }
+    static convertToAbsoluteUrl(url) {
+        return CmatUtilsService.testIsAbsoluteUrl(url) ? url : '//' + url;
+    }
+    static urlBase64Decode(str) {
+        let output = str.replace(/-/g, '+').replace(/_/g, '/');
+        switch (output.length % 4) {
+            case 0: {
+                break;
+            }
+            case 2: {
+                output += '==';
+                break;
+            }
+            case 3: {
+                output += '=';
+                break;
+            }
+        }
+        return this._base64DecodeUnicode(output);
+    }
+    static decodeToken(token) {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error('JWT must have 3 parts');
+        }
+        const decoded = this.urlBase64Decode(parts[1]);
+        if (!decoded) {
+            throw new Error('Cannot decode the token');
+        }
+        return JSON.parse(decoded);
+    }
+    static getTokenExpirationDate(token) {
+        const decoded = this.decodeToken(token);
+        if (!Object.prototype.hasOwnProperty.call(decoded, 'exp')) {
+            return null;
+        }
+        const date = new Date(0); // The 0 here is the key, which sets the date to the epoch
+        date.setUTCSeconds(decoded.exp);
+        return date;
+    }
+    static isTokenExpired(token, offsetSeconds) {
+        const date = this.getTokenExpirationDate(token);
+        offsetSeconds = offsetSeconds || 0;
+        if (date == null) {
+            return false;
+        }
+        // Token expired?
+        return !(date.valueOf() > (new Date().valueOf() + (offsetSeconds * 1000)));
+    }
+    static readAsDataURL(file) {
+        // Return a new promise
+        return new Promise((resolve, reject) => {
+            // Create a new reader
+            const reader = new FileReader();
+            // Resolve the promise on success
+            reader.onload = () => {
+                resolve(reader.result);
+            };
+            // Reject the promise on error
+            reader.onerror = (e) => {
+                reject(e);
+            };
+            // Read the file as the
+            reader.readAsDataURL(file);
+        });
+    }
+    static dataURIToBlob(dataURI) {
+        const splitDataURI = dataURI.split(',');
+        const byteString = splitDataURI[0].indexOf('base64') >= 0 ? atob(splitDataURI[1]) : decodeURI(splitDataURI[1]);
+        const mimeString = splitDataURI[0].split(':')[1].split(';')[0];
+        const ia = new Uint8Array(byteString.length);
+        for (let i = 0; i < byteString.length; i++) {
+            ia[i] = byteString.charCodeAt(i);
+        }
+        return new Blob([ia], { type: mimeString });
+    }
+    static _base64DecodeUnicode(str) {
+        return decodeURIComponent(Array.prototype.map.call(atob(str), (c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));
+    }
+    randomId(stringLength = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let id = '';
+        for (let i = 0; i < stringLength; i++) {
+            id += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return id;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatUtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatUtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../projects/cmat/services/utils/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpErrorResponse, HttpHeaders, HttpResponse, HttpResponseBase } from '@angular/common/http';\r\nimport { IsActiveMatchOptions } from '@angular/router';\r\nimport AES from 'crypto-js/aes';\r\nimport UTF8 from 'crypto-js/enc-utf8';\r\nimport Hex from 'crypto-js/enc-hex';\r\nimport Base64 from 'crypto-js/enc-base64';\r\nimport Pkcs7 from 'crypto-js/pad-pkcs7';\r\nimport CryptoJSCore from 'crypto-js/core';\r\nimport { throwError, Observable } from 'rxjs';\r\nimport { isUndefined } from 'lodash-es';\r\nimport { CMAT_VERSION } from 'cmat/version';\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class CmatUtilsService {\r\n    public static readonly captionAndMessageSeparator = ':';\r\n    public static readonly noNetworkMessageCaption = '无网络';\r\n    public static readonly noNetworkMessageDetail = '无法连接服务器';\r\n    public static readonly accessDeniedMessageCaption = '拒绝访问!';\r\n    public static readonly accessDeniedMessageDetail = '';\r\n    private static readonly key = UTF8.parse('14789632236987411478963223698741');//32位\r\n    private static readonly iv = UTF8.parse('1478963223698741');//16位\r\n\r\n    get exactMatchOptions(): IsActiveMatchOptions {\r\n        return {\r\n            paths: 'exact',\r\n            fragment: 'ignored',\r\n            matrixParams: 'ignored',\r\n            queryParams: 'exact'\r\n        };\r\n    }\r\n\r\n    get subsetMatchOptions(): IsActiveMatchOptions {\r\n        return {\r\n            paths: 'subset',\r\n            fragment: 'ignored',\r\n            matrixParams: 'ignored',\r\n            queryParams: 'subset'\r\n        };\r\n    }\r\n\r\n    public static getRequestHeaders(): HttpHeaders {\r\n        return new HttpHeaders()\r\n            .append('Access-Control-Allow-Origin', '*')\r\n            .append('Content-Type', 'application/json')\r\n            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)\r\n            .append('App-Version', CMAT_VERSION);\r\n    }\r\n\r\n    public static getRequestBypassHeaders(): HttpHeaders {\r\n        return new HttpHeaders()\r\n            .append('Access-Control-Allow-Origin', '*')\r\n            .append('Content-Type', 'application/json')\r\n            .append('bypass', 'true')\r\n            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)\r\n            .append('App-Version', CMAT_VERSION);\r\n    }\r\n\r\n    public static getRequestCryptoHeaders(params: string): HttpHeaders {\r\n        return new HttpHeaders()\r\n            .append('Access-Control-Allow-Origin', '*')\r\n            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)\r\n            .append('App-Version', this.getEncryptData('partymanageApi' + params).toString());\r\n    }\r\n\r\n    public static getRequestCryptoBypassHeaders(params: string): HttpHeaders {\r\n        return new HttpHeaders()\r\n            .append('Access-Control-Allow-Origin', '*')\r\n            .append('Accept', `application/vnd.iman.v${CMAT_VERSION}+json, application/json, text/plain, */*`)\r\n            .append('bypass', 'true')\r\n            .append('App-Version', this.getEncryptData('partymanageApi' + params).toString());\r\n    }\r\n\r\n    public static getEncryptData(data: string): string {\r\n        const src = UTF8.parse(data);\r\n\r\n        return AES.encrypt(src, this.key, {\r\n            iv: this.iv,\r\n            mode: CryptoJSCore.mode.CBC,\r\n            padding: Pkcs7\r\n        }).ciphertext.toString();\r\n    }\r\n\r\n    public static getDecryptData(data: string): string {\r\n        const encryptedHexStr = Hex.parse(data);\r\n        return AES.decrypt(Base64.stringify(encryptedHexStr), this.key, {\r\n            iv: this.iv,\r\n            mode: CryptoJSCore.mode.CBC,\r\n            padding: Pkcs7\r\n        }).toString(UTF8).toString();\r\n    }\r\n\r\n    public static handleError(error: any): Observable<never> {\r\n        if (error.error instanceof ErrorEvent) {\r\n            // A client-side or network error occurred. Handle it accordingly.\r\n            console.error('Client side network error occurred:', error.message);\r\n        } else {\r\n            // The backend returned an unsuccessful response code.\r\n            // The response body may contain clues as to what went wrong,\r\n            console.error('Backend - ' +\r\n                `status: ${error.status}, ` +\r\n                `statusText: ${error.statusText}, ` +\r\n                `message: ${error.message}`);\r\n        }\r\n\r\n        // return an observable with a user-facing error message\r\n        return throwError(() => error || 'server error');\r\n    }\r\n\r\n    public static getHttpResponseMessage(data: HttpResponseBase | any): string[] {\r\n\r\n        const responses: string[] = [];\r\n\r\n        if (data instanceof HttpResponseBase) {\r\n            if (this.checkNoNetwork(data)) {\r\n                responses.push(`${this.noNetworkMessageCaption}${this.captionAndMessageSeparator} ${this.noNetworkMessageDetail}`);\r\n            } else {\r\n                const responseObject = this.getResponseBody(data);\r\n\r\n                if (responseObject && (typeof responseObject === 'object' || responseObject instanceof Object)) {\r\n\r\n                    for (const key in responseObject) {\r\n                        if (Object.prototype.hasOwnProperty.call(responseObject, key)) {\r\n                            if (key) {\r\n                                responses.push(`${key}${this.captionAndMessageSeparator} ${responseObject[key]}`);\r\n                            } else if (responseObject[key]) {\r\n                                responses.push(responseObject[key].toString());\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (!responses.length && this.getResponseBody(data)) {\r\n                responses.push(`${this.getResponseBody(data).toString()}`);\r\n            }\r\n        }\r\n\r\n        if (!responses.length) {\r\n            responses.push(data.toString());\r\n        }\r\n\r\n        if (this.checkAccessDenied(data)) {\r\n            responses.splice(0, 0, `${this.accessDeniedMessageCaption}${this.captionAndMessageSeparator} ${this.accessDeniedMessageDetail}`);\r\n        }\r\n\r\n        return responses;\r\n    }\r\n\r\n\r\n    public static findHttpResponseMessage(messageToFind: string, data: HttpResponse<any> | any, seachInCaptionOnly = true, includeCaptionInResult = false): string | null {\r\n        const searchString = messageToFind.toLowerCase();\r\n        const httpMessages = this.getHttpResponseMessage(data);\r\n\r\n        for (const message of httpMessages) {\r\n            const fullMessage = CmatUtilsService.splitInTwo(message, this.captionAndMessageSeparator);\r\n\r\n            if (fullMessage.firstPart && fullMessage.firstPart.toLowerCase().indexOf(searchString) !== -1) {\r\n                return includeCaptionInResult ? message : fullMessage.secondPart || fullMessage.firstPart;\r\n            }\r\n        }\r\n\r\n        if (!seachInCaptionOnly) {\r\n            for (const message of httpMessages) {\r\n\r\n                if (message.toLowerCase().indexOf(searchString) !== -1) {\r\n                    if (includeCaptionInResult) {\r\n                        return message;\r\n                    } else {\r\n                        const fullMessage = CmatUtilsService.splitInTwo(message, this.captionAndMessageSeparator);\r\n                        return fullMessage.secondPart || fullMessage.firstPart;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    public static getResponseBody(response: HttpResponseBase): any {\r\n        if (response instanceof HttpResponse) {\r\n            return response.body;\r\n        }\r\n\r\n        if (response instanceof HttpErrorResponse) {\r\n            return response.error || response.message || response.statusText;\r\n        }\r\n        return response;\r\n    }\r\n\r\n\r\n    public static checkNoNetwork(response: HttpResponseBase): boolean {\r\n        if (response instanceof HttpResponseBase) {\r\n            return response.status === 0;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    public static checkAccessDenied(response: HttpResponseBase): boolean {\r\n        if (response instanceof HttpResponseBase) {\r\n            return response.status === 403;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    public static checkNotFound(response: HttpResponseBase): boolean {\r\n        if (response instanceof HttpResponseBase) {\r\n            return response.status === 404;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    public static checkIsLocalHost(url: string, base?: string): boolean {\r\n        if (url) {\r\n            const location = new URL(url, base);\r\n            return location.hostname === 'localhost' || location.hostname === '127.0.0.1';\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    public static getQueryParamsFromString(paramString: string): { [key: string]: string | null } | null {\r\n        if (!paramString) {\r\n            return null;\r\n        }\r\n\r\n        const params: { [key: string]: string | null } = {};\r\n\r\n        for (const param of paramString.split('&')) {\r\n            const keyValue = CmatUtilsService.splitInTwo(param, '=');\r\n            params[keyValue.firstPart] = keyValue.secondPart;\r\n        }\r\n\r\n        return params;\r\n    }\r\n\r\n    public static splitInTwo(text: string, separator?: string): { firstPart: string; secondPart: string | null } {\r\n        const separatorIndex = separator ? text.indexOf(separator) : -1;\r\n\r\n        if (separatorIndex === -1) {\r\n            return { firstPart: text, secondPart: null };\r\n        }\r\n\r\n        const part1 = text.substring(0, separatorIndex).trim();\r\n        const part2 = text.substring(separatorIndex + 1).trim();\r\n\r\n        return { firstPart: part1, secondPart: part2 };\r\n    }\r\n\r\n    public static safeStringify(object: any): string {\r\n        let result: string;\r\n\r\n        try {\r\n            result = JSON.stringify(object);\r\n            return result;\r\n        } catch (error) { /* empty */ }\r\n\r\n        const simpleObject: any = {};\r\n\r\n        for (const prop in object) {\r\n            if (!Object.prototype.hasOwnProperty.call(object, prop)) {\r\n                continue;\r\n            }\r\n            if (typeof (object[prop]) == 'object') {\r\n                continue;\r\n            }\r\n            if (typeof (object[prop]) == 'function') {\r\n                continue;\r\n            }\r\n            simpleObject[prop] = object[prop];\r\n        }\r\n\r\n        result = '[***Sanitized Object***]: ' + JSON.stringify(simpleObject);\r\n\r\n        return result;\r\n    }\r\n\r\n    public static jsonTryParse(value: string): string | void {\r\n        try {\r\n            return JSON.parse(value);\r\n        } catch (e) {\r\n            if (isUndefined(value)) {\r\n                return void 0;\r\n            }\r\n\r\n            return value;\r\n        }\r\n    }\r\n\r\n    public static capitalizeFirstLetter(text: string): string {\r\n        if (text) {\r\n            return text.charAt(0).toUpperCase() + text.slice(1);\r\n        } else {\r\n            return text;\r\n        }\r\n    }\r\n\r\n\r\n    public static toTitleCase(text: string): string {\r\n        return text.replace(/\\w\\S*/g, subString => subString.charAt(0).toUpperCase() + subString.substring(1).toLowerCase());\r\n    }\r\n\r\n    public static toLowerCase(items: string | string[]): string;\r\n    public static toLowerCase(items: any): string | string[] | void {\r\n        if (items instanceof Array) {\r\n            const loweredRoles: string[] = [];\r\n\r\n            for (let i = 0; i < items.length; i++) {\r\n                loweredRoles[i] = items[i].toLowerCase();\r\n            }\r\n\r\n            return loweredRoles;\r\n        } else if (typeof items === 'string' || items instanceof String) {\r\n            return items.toLowerCase();\r\n        }\r\n\r\n        return void 0;\r\n    }\r\n\r\n    public static uniqueId(): string {\r\n        return this.randomNumber(1000000, 9000000).toString();\r\n    }\r\n\r\n    public static randomNumber(min: number, max: number): number {\r\n        return Math.floor(Math.random() * (max - min + 1) + min);\r\n    }\r\n\r\n    public static baseUrl(): string {\r\n        let base: string;\r\n\r\n        if (window.location.origin) {\r\n            base = window.location.origin;\r\n        } else {\r\n            base = window.location.protocol + '//' + window.location.hostname + (window.location.port ? ':' + window.location.port : '');\r\n        }\r\n\r\n        return base.replace(/\\/$/, '');\r\n    }\r\n\r\n    public static newGuid(): string {\r\n        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\r\n            // eslint-disable-next-line no-bitwise\r\n            const r = (Math.random() * 16) | 0;\r\n            // eslint-disable-next-line no-bitwise\r\n            const v = c === 'x' ? r : (r & 0x3) | 0x8;\r\n            return v.toString(16);\r\n        });\r\n    }\r\n\r\n    public static testIsAbsoluteUrl(url: string): boolean {\r\n        const r = new RegExp('^(?:[a-z]+:)?//', 'i');\r\n        return r.test(url);\r\n    }\r\n\r\n    public static convertToAbsoluteUrl(url: string): string {\r\n        return CmatUtilsService.testIsAbsoluteUrl(url) ? url : '//' + url;\r\n    }\r\n\r\n    public static urlBase64Decode(str: string): string {\r\n        let output = str.replace(/-/g, '+').replace(/_/g, '/');\r\n        switch (output.length % 4) {\r\n            case 0: {\r\n                break;\r\n            }\r\n            case 2: {\r\n                output += '==';\r\n                break;\r\n            }\r\n            case 3: {\r\n                output += '=';\r\n                break;\r\n            }\r\n        }\r\n        return this._base64DecodeUnicode(output);\r\n    }\r\n\r\n    public static decodeToken(token: string): any {\r\n        const parts = token.split('.');\r\n\r\n        if (parts.length !== 3) {\r\n            throw new Error('JWT must have 3 parts');\r\n        }\r\n\r\n        const decoded = this.urlBase64Decode(parts[1]);\r\n        if (!decoded) {\r\n            throw new Error('Cannot decode the token');\r\n        }\r\n\r\n        return JSON.parse(decoded);\r\n    }\r\n\r\n    public static getTokenExpirationDate(token: string): Date | null {\r\n        const decoded = this.decodeToken(token);\r\n\r\n        if (!Object.prototype.hasOwnProperty.call(decoded, 'exp')) {\r\n            return null;\r\n        }\r\n\r\n        const date = new Date(0); // The 0 here is the key, which sets the date to the epoch\r\n        date.setUTCSeconds(decoded.exp);\r\n\r\n        return date;\r\n    }\r\n\r\n    public static isTokenExpired(token: string, offsetSeconds?: number): boolean {\r\n        const date = this.getTokenExpirationDate(token);\r\n        offsetSeconds = offsetSeconds || 0;\r\n\r\n        if (date == null) {\r\n            return false;\r\n        }\r\n\r\n        // Token expired?\r\n        return !(date.valueOf() > (new Date().valueOf() + (offsetSeconds * 1000)));\r\n    }\r\n\r\n    public static readAsDataURL(file: File): Promise<any> {\r\n        // Return a new promise\r\n        return new Promise((resolve, reject) => {\r\n\r\n            // Create a new reader\r\n            const reader = new FileReader();\r\n\r\n            // Resolve the promise on success\r\n            reader.onload = (): void => {\r\n                resolve(reader.result);\r\n            };\r\n\r\n            // Reject the promise on error\r\n            reader.onerror = (e): void => {\r\n                reject(e);\r\n            };\r\n\r\n            // Read the file as the\r\n            reader.readAsDataURL(file);\r\n        });\r\n    }\r\n\r\n    public static dataURIToBlob(dataURI: string): Blob {\r\n        const splitDataURI = dataURI.split(',');\r\n\r\n        const byteString = splitDataURI[0].indexOf('base64') >= 0 ? atob(splitDataURI[1]) : decodeURI(splitDataURI[1]);\r\n        const mimeString = splitDataURI[0].split(':')[1].split(';')[0];\r\n\r\n        const ia = new Uint8Array(byteString.length);\r\n        for (let i = 0; i < byteString.length; i++) {\r\n            ia[i] = byteString.charCodeAt(i);\r\n        }\r\n\r\n        return new Blob([ia], { type: mimeString });\r\n    }\r\n\r\n    private static _base64DecodeUnicode(str: any): string {\r\n        return decodeURIComponent(Array.prototype.map.call(atob(str), (c: any) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));\r\n    }\r\n\r\n    randomId(stringLength: number = 10): string {\r\n        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n        let id = '';\r\n\r\n        for (let i = 0; i < stringLength; i++) {\r\n            id += chars.charAt(Math.floor(Math.random() * chars.length));\r\n        }\r\n\r\n        return id;\r\n    }\r\n}\r\n\r\n\r\n"]}

package/esm2022/validators/cmat-validators.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC12YWxpZGF0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC92YWxpZGF0b3JzL2NtYXQtdmFsaWRhdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/validators/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './validators';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvdmFsaWRhdG9ycy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi92YWxpZGF0b3JzJztcclxuIl19