@acorex/core 5.1.2 → 5.1.6

package/src/lib/core.module.ts

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { AXDateTimePipe } from './pipe/datetime.pipe';
+import { AXEventService } from './services/event.service';
+import { AXStorageService } from './services/storage.service';
+import { AXScrollModule } from './utils/scroll/scroll.module';
+import { AXTranslatorModule } from './translator/translator.module';
+
+const PIPES = [AXDateTimePipe];
+const MODULES = [AXScrollModule, AXTranslatorModule];
+const SERVICES = [AXEventService,
+  AXStorageService
+];
+
+
+@NgModule({
+  declarations: [...PIPES],
+  imports: [...MODULES],
+  exports: [...PIPES],
+  providers: [...SERVICES]
+})
+export class AXCoreModule { }

package/src/lib/error/error.class.ts

@@ -0,0 +1,4 @@
+export interface AXError {
+    message: string;
+    code: string;
+}

package/src/lib/error/error.module.ts

@@ -0,0 +1,13 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AXErrorService } from './error.service';
+
+@NgModule({
+    declarations: [],
+    imports: [CommonModule],
+    exports: [],
+    providers: [AXErrorService],
+})
+export class AXErrorModule {
+
+}

package/src/lib/error/error.service.ts

@@ -0,0 +1,23 @@
+import { InjectionToken, Injectable, Injector } from '@angular/core';
+
+export const  AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken<AXErrorDisplayInterceptor>('ax.error');
+
+export interface AXErrorDisplayInterceptor {
+    show(message: string);
+}
+
+@Injectable({providedIn: 'root'})
+export class AXErrorService {
+
+    constructor(private injector: Injector) {
+
+    }
+
+    handle(message: string) {
+        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
+        if (instance) {
+            instance.show(message);
+        }
+    }
+
+}

package/src/lib/error/index.ts

@@ -0,0 +1,3 @@
+export * from './error.class';
+export * from './error.service';
+export * from './error.module';

package/src/lib/events/keyboard.ts

@@ -0,0 +1,5 @@
+
+// tslint:disable-next-line: no-empty-interface
+export interface AXKeyboardEvent extends KeyboardEvent {
+
+}

package/src/lib/http/http-error.class.ts

@@ -0,0 +1,7 @@
+export interface IHttpError {
+    message?: string;
+    status?: number;
+    code?: string;
+    handled: boolean;
+    error: any | null
+}

package/src/lib/http/http-events.interceptor.ts

@@ -0,0 +1,14 @@
+import { IHttpError } from './http-error.class';
+import { InjectionToken } from '@angular/core';
+import { AXHttpRequestOptions } from './http-request.class';
+
+export const AX_HTTP_EVENT_INTERCEPTOR = new InjectionToken<AXHttpEventInterceptor>('ax.http.events');
+
+export interface AXHttpEventInterceptor {
+    begin(request: AXHttpRequestOptions): Promise<AXHttpRequestOptions>;
+    success(request: AXHttpRequestOptions, result: any): Promise<any>;
+    complete(request: AXHttpRequestOptions);
+    error(request: AXHttpRequestOptions, error: IHttpError);
+}
+
+

package/src/lib/http/http-request.class.ts

@@ -0,0 +1,14 @@
+export interface AXHttpRequestOptions {
+    url?: any,
+    params?: {
+        [param: string]: any;
+    },
+    body?: {
+        [param: string]: any;
+    },
+    headers?: {
+        [header: string]: any;
+    },
+    method?: 'get' | 'post' | 'put' | 'delete';
+    responseType?: any;
+}

package/src/lib/http/http-result.class.ts

@@ -0,0 +1,34 @@
+import { IHttpError } from './http-error.class';
+
+export class HttpResult<T> {
+    private _executor: (result: (e?: T) => void, error: (e?: IHttpError) => void, complete: () => void) => void;
+    constructor(
+        executor: (
+            result: (e?: T) => void,
+            error: (e?: IHttpError) => void,
+            complete: () => void
+        ) => void
+    ) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.resultAction, this.errorAction, this.completeAction);
+        }, 50);
+    }
+
+    private resultAction: (e?: T) => void;
+    private errorAction: (e?: IHttpError) => void;
+    private completeAction: () => void;
+
+    result(action: (e?: T) => void): HttpResult<T> { 
+        this.resultAction = action;
+        return this;
+    }
+    error(action: (e?: IHttpError) => void): HttpResult<T> {
+        this.errorAction = action;
+        return this;
+    }
+    complete(action: () => void): HttpResult<T> {
+        this.completeAction = action;
+        return this;
+    }
+}

package/src/lib/http/http.module.ts

@@ -0,0 +1,25 @@
+import { NgModule, ModuleWithProviders } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { AXHttpService } from './http.service';
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule,
+    HttpClientModule
+  ],
+  exports: [HttpClientModule],
+  providers: [
+    AXHttpService
+  ]
+})
+export class AXHttpModule {
+  static forRoot(): ModuleWithProviders<AXHttpModule> {
+    return {
+      ngModule: AXHttpModule,
+      providers: [AXHttpService]
+    };
+  }
+}

package/src/lib/http/http.service.ts

@@ -0,0 +1,159 @@
+import { Injectable, Injector, InjectFlags } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';
+import { HttpResult } from './http-result.class';
+import { IHttpError } from './http-error.class';
+import { AXHttpRequestOptions } from './http-request.class';
+import {
+    AX_HTTP_EVENT_INTERCEPTOR, AXHttpEventInterceptor
+} from './http-events.interceptor';
+// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
+// import { of, concat, throwError } from 'rxjs';
+
+
+@Injectable()
+export class AXHttpService {
+
+    private interceptor: AXHttpEventInterceptor;
+    constructor(private http: HttpClient, private injector: Injector) {
+        this.interceptor = this.injector.get(AX_HTTP_EVENT_INTERCEPTOR);
+    }
+
+
+    get<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "get";
+        return this.request(config);
+    }
+
+    post<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "post";
+        return this.request(config);
+    }
+
+    delete<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "delete";
+        return this.request(config);
+    }
+
+    put<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "put";
+        return this.request(config);
+    }
+
+
+    request<T>(config: AXHttpRequestOptions): HttpResult<T> {
+        return new HttpResult<T>((result?, error?, complete?) => {
+            this.handleBegin(config).then(c => {
+                this.http
+                    .request<T>(config.method, config.url, this.mapOptions(config))
+                    //.pipe(this.retry)
+                    .subscribe(data => {
+                        this.handleResult(data, result, complete, config);
+                    }, c => {
+                        this.handleError(c, error, complete, config);
+                    });
+            });
+        })
+    }
+
+
+    private handleResult(data, result, complete, config: AXHttpRequestOptions) {
+        if (this.interceptor) {
+            this.interceptor.success(config, data).then(c => {
+                if (result)
+                    result(c);
+                this.handleComplete(complete, config);
+            });
+        }
+        else {
+            //
+            if (result)
+                result(data);
+            this.handleComplete(complete, config);
+        }
+    }
+
+    private handleBegin(config: AXHttpRequestOptions): Promise<AXHttpRequestOptions> {
+        return new Promise((resolve) => {
+            if (!config.headers)
+                config.headers = {};
+            if (!config.params)
+                config.params = {};
+            //
+            if (this.interceptor) {
+                this.interceptor.begin(config).then(c => {
+                    resolve(c);
+                });
+            }
+            else {
+                resolve(config)
+            }
+        })
+    }
+
+    private handleComplete(complete: Function, config: AXHttpRequestOptions) {
+        if (complete)
+            complete();
+        if (this.interceptor)
+            this.interceptor.complete(config);
+    }
+
+    private handleError(c: HttpErrorResponse, error: Function, complete: Function, config: AXHttpRequestOptions) {
+        let r: IHttpError = {
+            message: c.message,
+            status: c.status,
+            code: c.status?.toString(),
+            handled: false,
+            error: c.error
+        }
+        if (error) {
+            error(r);
+        }
+        if (!r.handled) {
+            if (this.interceptor)
+                this.interceptor.error(config, r);
+        }
+        this.handleComplete(complete, config);
+    }
+
+    private mapOptions(options: AXHttpRequestOptions) {
+        let headers = new HttpHeaders();
+
+        for (const key in options.headers) {
+            if (options.headers.hasOwnProperty(key)) {
+                const value = options.headers[key];
+                headers = headers.set(key, value)
+            }
+        }
+        let params = new HttpParams();
+        for (const key in options.params) {
+            if (options.params.hasOwnProperty(key)) {
+                const value = options.params[key];
+                params = params.set(key, value);
+            }
+        }
+        return {
+            headers: headers,
+            params: params,
+            body: options.body,
+            responseType: options.responseType || 'json'
+        };
+        // if (options.method == "get") {
+        //     return {
+        //         headers: headers,
+        //         params: params
+        //     };
+        // }
+        // else {
+        //     return {
+        //         headers: headers,
+        //         params: params,
+        //         body: options.body
+        //     };
+        // }
+    }
+
+}

package/src/lib/locale/en.json

@@ -0,0 +1,255 @@
+{
+    "common": {
+        "search": "Search",
+        "yes": "yes",
+        "no": "No",
+        "confirm": "Confirm",
+        "okay": "Okay",
+        "cancel": "Cancel",
+        "remove": "Remove",
+        "edit": "Edit",
+        "configs": "Configs",
+        "noDataFound": "No data found!",
+        "searching": "searching ...",
+        "save": "Save",
+        "save-as": "Save As...",
+        "title": "Title",
+        "description": "Description",
+        "name": "Name",
+        "uniquename": "Unique Name",
+        "size": "Size",
+        "add-item": "Add Item",
+        "color": "Color",
+        "display": "Display",
+        "min-value": "Min Value",
+        "value": "Value",
+        "max-value": "Max Value",
+        "refresh-rate": "Refresh Rate",
+        "refresh": "Refresh",
+        "reload": "Reload",
+        "condition":"Condition",
+        "next":"Next",
+        "prev":"Prev"
+    },
+    "dateTime": {
+        "weekdaysShort": {
+            "sun": "Sun",
+            "mon": "Mon",
+            "tue": "Tue",
+            "wed": "Wed",
+            "thu": "Thu",
+            "fri": "Fri",
+            "sat": "Sat"
+        },
+        "dayTime": {
+            "am": "am",
+            "pm": "pm",
+            "m": "m",
+            "a": "a",
+            "p": "p"
+        },
+        "today": "today",
+        "duration": {
+            "format_second": "{0} second(s)",
+            "format_minute": "{0} minute(s)"
+        }
+    },
+    "queryBuilder": {
+        "contains": "contains",
+        "not-contains":"not-contains",
+        "contains-all":"contains-all",
+        "start-with": "start-with",
+        "end-with": "end-with",
+        "equal": "equal",
+        "not-equal": "not-equal",
+        "null": "null",
+        "not-null": "not-null",
+        "greater-than": "greater-than",
+        "gt": "greater-than",
+        "greater-than-equal": "greater-than-equal",
+        "gte": "greater-than-equal",
+        "less-than": "less-than",
+        "lt": "less-than",
+        "less-than-equal": "less-than-equal",
+        "lte": "less-than-equal",
+        "true": "true",
+        "false": "false",
+        "empty": "empty"
+    },
+    "validation": {
+        "messages": {
+            "required": "This field is required!",
+            "email": "Please enter a valid email address!",
+            "phone": "Please enter a valid phone number!"
+        }
+    },
+    "dataGrid": {
+        "page": "page",
+        "more": "more",
+        "to": "To",
+        "of": "Of",
+        "next": "next",
+        "last": "last",
+        "first": "first",
+        "previous": "previous",
+        "loadingOoo": "Loading...",
+        "selectAll": "selectAll",
+        "searchOoo": "Search...",
+        "blanks": "blanks",
+        "filterOoo": "Filter...",
+        "equals": "Equals",
+        "notEqual": "NotEqual",
+        "lessThan": "LessThan",
+        "greaterThan": "GreaterThan",
+        "lessThanOrEqual": "LessThanOrEqual",
+        "greaterThanOrEqual": "GreaterThanOrEqual",
+        "inRange": "InRange",
+        "inRangeStart": "To",
+        "inRangeEnd": "From",
+        "contains": "Contains",
+        "notContains": "NotContains",
+        "startsWith": "Starts with",
+        "endsWith": "Ends with",
+        "andCondition": "AND",
+        "orCondition": "OR",
+        "applyFilter": "Apply",
+        "resetFilter": "Reset",
+        "clearFilter": "Clear",
+        "group": "Group",
+        "columns": "Columns",
+        "filters": "Filters",
+        "groups": "Groups",
+        "values": "Values",
+        "enabled": "Enabled",
+        "pinColumn": "Pin Column",
+        "groupBy": "Group by",
+        "ungroupBy": "UnGroup by",
+        "resetColumns": "ResetColumns",
+        "expandAll": "ExpandAll",
+        "collapseAll": "CollapseAll",
+        "toolPanel": "ToolPanel",
+        "export": "Exporto",
+        "csvExport": "csv Export",
+        "excelExport": "Excel Export (.xlsx)",
+        "excelXmlExport": "Excel Exporto (.xml)",
+        "chartRange": "Chart Range",
+        "columnChart": "Column",
+        "groupedColumn": "Grouped",
+        "stackedColumn": "Stacked",
+        "normalizedColumn": "normalized Column",
+        "barChart": "bar Chart",
+        "groupedBar": "Grouped",
+        "stackedBar": "Stacked",
+        "normalizedBar": "normalized Bar",
+        "pie": "Pie",
+        "doughnut": "Doughnut",
+        "line": "Line",
+        "xyChart": "X Y (Scatter)",
+        "scatter": "Scatter",
+        "bubble": "Bubble",
+        "areaChart": "Area",
+        "area": "Area",
+        "stackedArea": "Stacked",
+        "normalizedArea": "100% Stacked",
+        "histogramChart": "Histogram",
+        "pinLeft": "Pin Left",
+        "pinRight": "Pin Right",
+        "noPin": "Dont Pin",
+        "sum": "Sum",
+        "min": "Min",
+        "max": "Max",
+        "none": "None",
+        "count": "Count",
+        "avg": "Average",
+        "filteredRows": "Filtered",
+        "selectedRows": "Selected",
+        "totalRows": "Total Rows",
+        "totalAndFilteredRows": "Rows",
+        "copy": "Copy",
+        "copyWithHeaders": "Copy With Headers",
+        "ctrlC": "Ctrl C",
+        "paste": "Paste",
+        "ctrlV": "Ctrl V",
+        "pivotChartTitle": "Pivot Chart",
+        "rangeChartTitle": "Range Chart",
+        "settings": "Settings",
+        "data": "Data",
+        "format": "Format",
+        "categories": "Categories",
+        "series": "Series",
+        "xyValues": "X Y Values",
+        "paired": "Paired Mode",
+        "axis": "Axis",
+        "color": "Color",
+        "thickness": "Thickness",
+        "xType": "X Type",
+        "automatic": "Automatic",
+        "category": "Category",
+        "number": "Number",
+        "time": "Time",
+        "xRotation": "X Rotation",
+        "yRotation": "Y Rotation",
+        "ticks": "Ticks",
+        "width": "Width",
+        "length": "Length",
+        "padding": "Padding",
+        "chart": "Chart",
+        "title": "Title",
+        "background": "Background",
+        "font": "Font",
+        "top": "Top",
+        "right": "Right",
+        "bottom": "Bottom",
+        "left": "Left",
+        "labels": "Labels",
+        "size": "Size",
+        "minSize": "Minimum Size",
+        "maxSize": "Maximum Size",
+        "legend": "Legend",
+        "position": "Position",
+        "markerSize": "Marker Size",
+        "markerStroke": "Marker Stroke",
+        "markerPadding": "Marker Padding",
+        "itemPaddingX": "Item Padding X",
+        "itemPaddingY": "Item Padding Y",
+        "strokeWidth": "Stroke Width",
+        "offset": "Offset",
+        "offsets": "Offsets",
+        "tooltips": "Tooltips",
+        "callout": "Callout",
+        "markers": "Markers",
+        "shadow": "Shadow",
+        "blur": "Blur",
+        "xOffset": "X Offset",
+        "yOffset": "Y Offset",
+        "lineWidth": "Line Width",
+        "normal": "Normal",
+        "bold": "Bold",
+        "italic": "Italic",
+        "boldItalic": "Bold Italic",
+        "predefined": "Predefined",
+        "fillOpacity": "Fill Opacity",
+        "strokeOpacity": "Line Opacity",
+        "histogramBinCount": "Bin Count",
+        "columnGroup": "Column",
+        "barGroup": "Bar",
+        "pieGroup": "Pie",
+        "lineGroup": "Line",
+        "scatterGroup": "Scatter",
+        "areaGroup": "Area",
+        "histogramGroup": "Histogram",
+        "groupedColumnTooltip": "Grouped",
+        "stackedColumnTooltip": "Stacked",
+        "normalizedColumnTooltip": "100% Stacked",
+        "groupedBarTooltip": "Grouped",
+        "stackedBarTooltip": "Stacked",
+        "pieTooltip": "Pie",
+        "doughnutTooltip": "Doughnut",
+        "lineTooltip": "Line",
+        "groupedAreaTooltip": "Grouped",
+        "stackedAreaTooltip": "Stacked",
+        "scatterTooltip": "Scatter",
+        "bubbleTooltip": "Bubble",
+        "histogramTooltip": "Histogram"
+    }
+}