x-tql-service 1.19.4

package/lib/models/default/default-dialog-component.d.ts

@@ -0,0 +1,35 @@
+import { Injector } from '@angular/core';
+import { DefaultComponent } from './default-component';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class DefaultDialogComponent extends DefaultComponent {
+    dialogRef: MatDialogRef<any>;
+    _Injector?: Injector | undefined;
+    static DEFAULT_WIDTH: any;
+    static DEFAULT_HEIGHT: any;
+    constructor(dialogRef: MatDialogRef<any>, _Injector?: Injector | undefined, ...args: unknown[]);
+    /**
+     *
+     * @param arg
+     */
+    onCancel(arg?: any): void;
+    /**
+     *
+     * @private
+     */
+    onClose(): void;
+    /**
+     *
+     * @private
+     * @param arg
+     */
+    onOk(arg?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDialogComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultDialogComponent, never, never, {}, {}, never, never, true, never>;
+}
+export declare namespace DefaultDialogComponent {
+    enum State {
+        OPENING = 0,
+        CLOSED = 1
+    }
+}

package/lib/models/default/default-directive.d.ts

@@ -0,0 +1,7 @@
+import { DefaultComponent } from './default-component';
+import * as i0 from "@angular/core";
+export declare class DefaultDirective extends DefaultComponent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultDirective, never, never, {}, {}, never, never, true, never>;
+}

package/lib/models/default/default-map-component.d.ts

@@ -0,0 +1,19 @@
+import { DefaultComponent } from './default-component';
+import * as i0 from "@angular/core";
+export declare class DefaultMapComponent extends DefaultComponent {
+    DEFAULT_ZOOM: number;
+    styles: any;
+    center: any;
+    zoom: any;
+    bounds: any;
+    google: any;
+    constructor();
+    /**
+     * reset map
+     */
+    resetMapBounds(): void;
+    setMapBounds(map: any, points?: any[], minZoom?: number | null): void;
+    getCenterOfArray(points?: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultMapComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultMapComponent, never, never, {}, {}, never, never, true, never>;
+}

package/lib/models/default/default-model.d.ts

@@ -0,0 +1,68 @@
+import { IDefaultModel } from './default-model.interface';
+export declare class DefaultModel implements IDefaultModel {
+    /**
+     * all keys are in lowercase
+     * @type {{}}
+     * @private
+     */
+    _data: any;
+    /**
+     * all keys are raw
+     * @type {{}}
+     * @private
+     */
+    _raw: any;
+    _idKey: string;
+    _id: any;
+    /**
+     *
+     * @param _data
+     * @param idKey
+     * @param isAutoAssign
+     */
+    constructor(_data?: any, idKey?: string, isAutoAssign?: boolean, isAssignRawData?: boolean);
+    /**
+     * get value of id
+     * @return {any}
+     */
+    getId(): string | number | null;
+    setId(id: string | number | null): void;
+    /**
+     * delete object property
+     * @param key: string
+     */
+    deleteProperty(key: string): void;
+    /**
+     * get key of id
+     * @returns {string}
+     */
+    getIdKey(): string;
+    /**
+     * get value of _data by key
+     * @param key: string
+     * @returns {any}
+     */
+    getValue(key: string): any;
+    /**
+     * set value of _data by key & value of this object's attribute if existed
+     * @param key: string
+     * @param value: string
+     * @returns {any}
+     */
+    setValue(key: string, value: any): any;
+    /**
+     * get raw value of _data by key
+     * @param key: string
+     * @returns {any}
+     */
+    getRawValue(key: string): any;
+    /**
+     * set value of _data by key
+     * @param key: string
+     * @param value: string
+     * @returns {any}
+     */
+    setRawValue(key: string, value: any): any;
+    static describe(instance: any): Array<string>;
+}
+export declare namespace DefaultModel { }

package/lib/models/default/default-model.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IDefaultModel {
+    _data: any;
+    getId(): string | number | null;
+}
+export type IDefaultModelConstructor = new (_data: any) => IDefaultModel;

package/lib/models/default/dynamic-model.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@angular/core';
+export interface IDynamicComponentModel {
+    data?: any;
+    reset?(): void;
+    onDataChange?(): void;
+}
+export declare class DynamicDataModel {
+    component: Type<IDynamicComponentModel>;
+    data: any;
+    constructor(component: Type<IDynamicComponentModel>, data?: any);
+}

package/lib/models/index.d.ts

@@ -0,0 +1,9 @@
+export * from './default/default-model.interface';
+export * from './default/default-model';
+export * from './default/default-component';
+export * from './default/default-directive';
+export * from './default/default-dialog-component';
+export * from './default/dynamic-model';
+export * from './default/default-map-component';
+export * from './payload.model';
+export * from './ws-payload.model';

package/lib/models/payload.model.d.ts

@@ -0,0 +1,33 @@
+import { IDefaultModelConstructor } from './default/default-model.interface';
+export declare class PayloadModel {
+    query: string;
+    objectName: string | undefined;
+    objectPath: string | undefined;
+    objectClass: IDefaultModelConstructor | undefined;
+    /**
+     *
+     * @param query
+     * @param objectName
+     * @param objectClass
+     * @param objectPath
+     */
+    constructor(query: string, objectName?: string, objectPath?: string, objectClass?: IDefaultModelConstructor);
+    /**
+     *
+     * @param params
+     * @returns {string}
+     */
+    buildPayload(params?: any[]): string;
+    /**
+     *
+     * @param dataObject
+     * @returns {string}
+     */
+    buildPayloadWithObject(dataObject: any): string;
+    /**
+     *
+     * @param array
+     * @returns {any[]}
+     */
+    parse(array?: never[]): any[];
+}

package/lib/models/ws-payload.model.d.ts

@@ -0,0 +1,13 @@
+export declare class WSPayloadModel {
+    id: string;
+    query: string;
+    $promise: Promise<any>;
+    promiseResolve: Function;
+    constructor(query: string, params?: string[], id?: string);
+    /**
+     *
+     * @param data
+     * @returns {boolean}
+     */
+    resolve(data: any): boolean;
+}

package/lib/services/api/tql-api-lib.service.d.ts

@@ -0,0 +1,81 @@
+import { HttpClient } from '@angular/common/http';
+import { PayloadModel } from '../../models';
+import { TqlErrorHandlerService } from '../error-handler/tql-error-handler.service';
+import { TqlLoggerService } from '../log/tql-logger.service';
+import * as i0 from "@angular/core";
+export declare class TqlApiLibService extends TqlLoggerService {
+    private _HttpClient;
+    private _TqlErrorHandlerService;
+    private _default_url;
+    constructor(_HttpClient: HttpClient, _TqlErrorHandlerService: TqlErrorHandlerService);
+    /**
+     *
+     * @param url
+     */
+    initialize(url: string): void;
+    /**
+     * reset all subscription
+     */
+    reset(): void;
+    /**
+     * get url
+     * @returns string
+     */
+    getUrl(): string;
+    /**
+     * Execute payload
+     * @param payload: Payload
+     * @param headers: Headers of query
+     * @param url: URL custom (optional)
+     * @returns {Promise<T | string>}
+     * @param params
+     * @param contentType
+     */
+    execute(payload: PayloadModel, params?: any[], headers?: any, url?: string, contentType?: string): Promise<any>;
+    /**
+     * Execute http client
+     * @param payload: Payload
+     * @param headers: Headers of query
+     * @param url: URL custom (optional)
+     * @param params
+     * @param contentType
+     * @returns {Observable<T | string>}
+     */
+    executeHttpClient(payload: PayloadModel, params?: any[], headers?: any, url?: string, contentType?: string): import("rxjs").Observable<any>;
+    get(url: string, contentType?: string, headers?: any): Promise<string | undefined>;
+    /**
+     *
+     * @param payload
+     * @param params
+     * @param headers
+     * @param url
+     * @param contentType
+     * @return {Promise<{data: any[], raw: {}} | {data: any[], raw: {}}>}
+     */
+    findRaw(payload: PayloadModel, params?: any, headers?: {}, url?: string, contentType?: string): Promise<{
+        data: any[];
+        raw: {};
+    }>;
+    /**
+     * find management and convert to management model
+     * @param payload: Payload
+     * @param params: any
+     * @param headers: any
+     * @param url: string
+     * @param contentType
+     * @return {Promise<any[]>}
+     */
+    find(payload: PayloadModel, params?: any, headers?: {}, url?: string, contentType?: string): Promise<any[]>;
+    /**
+     *
+     * @param payload
+     * @param params
+     * @param headers
+     * @param url
+     * @param contentType
+     * @returns {Promise<{}>}
+     */
+    post(payload: PayloadModel, params?: any, headers?: {}, url?: string, contentType?: string): Promise<{}>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlApiLibService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlApiLibService>;
+}

package/lib/services/config/tql-global-config.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class TqlGlobalConfigService {
+    private externalConfig;
+    private config;
+    constructor(externalConfig: any);
+    getConfig(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlGlobalConfigService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlGlobalConfigService>;
+}

package/lib/services/error-handler/tql-error-handler.service.d.ts

@@ -0,0 +1,69 @@
+import { Injector } from '@angular/core';
+import { TqlToastControllerService } from '../../controllers';
+import { HttpErrorResponse } from '@angular/common/http';
+import { TqlLoggerService } from '../log/tql-logger.service';
+import * as i0 from "@angular/core";
+export declare class TqlErrorHandlerService extends TqlLoggerService {
+    _TqlToastControllerService: TqlToastControllerService;
+    constructor(_Injector?: Injector);
+    /**
+     *
+     * @param error
+     * @returns {EErrorStatus.FORBIDDEN | null}
+     */
+    handleHttpError(error: HttpErrorResponse): any;
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleSimpleResponse(response: any): boolean;
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleAPIResponseMessage(response: any): boolean;
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleCreate(response: any): boolean;
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleUpdate(response: any): boolean;
+    /**
+     * show message base on status
+     * @param event
+     * @return {boolean}
+     */
+    handleStatusMessage(event: TqlErrorHandlerService.IStatusMessage): boolean;
+    /**
+     *
+     * @param message
+     */
+    _showSuccessMessage(message: any): void;
+    /**
+     *
+     * @param message
+     */
+    _showErrorMessage(message?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlErrorHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlErrorHandlerService>;
+}
+export declare namespace TqlErrorHandlerService {
+    enum EErrorStatus {
+        FORBIDDEN = 0,
+        SUCCESS = "Success",
+        ERROR = "Error"
+    }
+    interface IStatusMessage {
+        status: boolean;
+        message: string;
+        data?: any;
+    }
+}

package/lib/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from './utils/tql-utils.service';
+export * from './error-handler/tql-error-handler.service';
+export * from './log/tql-logger.service';
+export * from './api/tql-api-lib.service';
+export * from './ws/tql-ws.service';
+export * from './translate/tql-translate.service';
+export * from './config/tql-global-config.service';

package/lib/services/log/tql-logger.service.d.ts

@@ -0,0 +1,23 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TqlLoggerService {
+    log$: BehaviorSubject<string>;
+    constructor();
+    /**
+     * log result
+     * @param data: any
+     */
+    _logResult(...data: any): void;
+    /**
+     * log error
+     * @param error: any
+     */
+    _logError(...error: any): void;
+    /**
+     * log message
+     * @param message
+     */
+    log(message: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlLoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlLoggerService>;
+}

package/lib/services/translate/tql-translate.service.d.ts

@@ -0,0 +1,64 @@
+import { HttpClient } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { MissingTranslationHandler, MissingTranslationHandlerParams, TranslateLoader } from '@ngx-translate/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TqlTranslateService {
+    private http;
+    private injector;
+    constructor(http: HttpClient, injector: Injector);
+    translationDataLoaded$: BehaviorSubject<any>;
+    translationData: {
+        key: string;
+        data: any;
+    }[];
+    loaded$(): Subject<any>;
+    getDataTranslate(keyLang: string): Observable<any>;
+    translateGG(text: string): Observable<string>;
+    saveTextTranslate(rs: string, text: string): void;
+    static getDataLocalStorage(): any;
+    getLanguage(): string;
+    static getLanguage(): string;
+    static getJsonLocalStorage(keyLang?: string): any;
+    static updateKeyLanguage(keyLang: string): void;
+    static updateJsonDataLocalStorage(dataTranslate: any): void;
+    instant(data: string): Promise<any>;
+    static getTranslateHighCharts(type: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlTranslateService>;
+}
+export declare namespace TqlTranslateService {
+    class MyMissingTranslationHandler implements MissingTranslationHandler {
+        private _TqlTranslateService;
+        constructor(_TqlTranslateService: TqlTranslateService);
+        handle(params: MissingTranslationHandlerParams): any;
+    }
+    function HandleMyMissing(_TqlTranslateService: TqlTranslateService): MyMissingTranslationHandler;
+    function HttpLoaderFactory(_TqlTranslateService: TqlTranslateService): MultiTranslateHttpLoader;
+    class MultiTranslateHttpLoader implements TranslateLoader {
+        private _TqlTranslateService;
+        constructor(_TqlTranslateService: TqlTranslateService);
+        getTranslation(): Observable<any>;
+    }
+    function initializeTranslations(_TqlTranslateService: TqlTranslateService): () => Promise<any>;
+    const languageHighChart: {
+        lang: {
+            thousandsSep: string;
+            shortMonths: any;
+            months: any;
+            weekdays: any;
+        };
+    };
+}
+export declare class GoogleObj {
+    q: string;
+    readonly source: string;
+    target: string;
+    readonly format: string;
+    constructor(q: string);
+}
+export interface ITranslateDataLocalStorage {
+    key: string;
+    'en-US': any;
+    'pt-BR': any;
+}

package/lib/services/utils/tql-utils.service.d.ts

@@ -0,0 +1,138 @@
+import { DatePipe } from '@angular/common';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class TqlUtilsService {
+    static _DatePipe: DatePipe;
+    constructor();
+    /**
+     * replace all {find} inside {str} by {replace}
+     * @param text: string
+     * @param find: string
+     * @param replace: string
+     * @returns any
+     */
+    static replaceAll(text: any, find: any, replace: any): string;
+    /**
+     * replace all with params
+     * param format: {number}
+     * @param text
+     * @param params
+     * @returns {string}
+     */
+    static replaceWithParams(text: string, params: string[]): string;
+    /**
+     * check if is array, if is not, return [value]
+     * @param value: string
+     * @returns any
+     */
+    static toArray(value: any): any[];
+    /**
+     * parse string to object
+     * @param xmlString: string
+     * @param callback: function
+     * @returns Promise<any>
+     */
+    static parseXml(xmlString: any, callback?: (rs: any) => void): Promise<any>;
+    /**
+     * Clean management response
+     * @param data: management response
+     * @returns any
+     */
+    static transferData(data: any): any;
+    /**
+     * Check and convert management
+     * @param data: Data response
+     * @param modelType: Model type
+     * @param key: If model type of management response other than model type (optional)
+     * @returns Model[]
+     */
+    static convertData(data: any, modelType: any, key?: null): any[];
+    /**
+     * Convert management to Model Type
+     * ! { Model.name } is undefined in run build
+     * @param data: Data response
+     * @param modelType: Model type
+     * @param key: If model type of management response other than model type (optional)
+     * @returns Model[]
+     */
+    static convert(data: any, modelType: any, key: any): any[];
+    static jsonToModel(data: any, modelType: any): any[];
+    static signData(data: any, model: any, keyRepresent: any, key: any): any;
+    /**
+     * Return true if response is successful
+     * @param data: management
+     * @param path: string
+     * @returns ({message: undefined, status: boolean} | boolean | {message: undefined, status: boolean})
+     */
+    static isSuccess(data: any, path?: string): boolean | any;
+    /**
+     * Return true if response is failed
+     * @param data: management
+     * @returns boolean
+     */
+    static isError(data: any): boolean;
+    /**
+     * check if management is empty
+     * @param data: string
+     * @returns boolean
+     */
+    static isEmpty(data: any): boolean;
+    /**
+     * get file extension
+     * @param fileName: string
+     * @returns any
+     */
+    static getFileExtension(fileName: string): string | undefined;
+    /**
+     * set string to clipboard
+     * @param str: string
+     */
+    static copyStringToClipboard(str: any): void;
+    /**
+     * get enum key by its value
+     * @param myEnum
+     * @param enumValue
+     * @param isCaseSensitive
+     * @return {null}
+     */
+    static getEnumKeyByEnumValue(myEnum: any, enumValue: any, isCaseSensitive?: boolean): string | null;
+    /**
+     * shorten number
+     * @param value
+     * @returns {any}
+     */
+    static abbreviateNumber(value: any): string;
+    /**
+     * convert json to tree
+     * @param json
+     * @param key
+     * @returns {any}
+     */
+    static jsonToTree(data: any): any;
+    /**
+     * swap element in array
+     * @param array
+     * @param firstIndex
+     * @param secondIndex
+     */
+    static swap(array: any[], firstIndex: number, secondIndex: number): void;
+    static isObject(data: any): boolean;
+    static isArray(data: any): boolean;
+    static buildTreeFromChild(child: any): any;
+    static traversalTree(list: any[], callback: Function, parent?: any): void;
+    static traversalTreeReverse(node: any, callback: Function): void;
+    static findNodeOfTree(list: any[], condition: Function): any;
+    static filterNodeOfTree(list: any[], condition: Function): any;
+    /**
+     * get parent route when using in guard
+     * @param route
+     */
+    static getRedirectToRoute(route: ActivatedRouteSnapshot): string[];
+    static getResolvedUrl(route: ActivatedRouteSnapshot): string;
+    static getUrlFromSegments(segments: any[] | undefined): string;
+    static clearLineBreakR(s: string): string;
+    static transferToCapitalText(s: string, exceptions?: object): any;
+    static parsePayloadWithObject(query: string, dataObject: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TqlUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TqlUtilsService>;
+}