@messaia/cdk 0.0.0-CDK

package/lib/base/components/generic-list.component.d.ts

@@ -0,0 +1,273 @@
+import { ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { ActivatedRoute } from '@angular/router';
+import { Subscription } from 'rxjs';
+import { IEntity } from '../../common/models/entity';
+import { GenericService } from '../../http/services/generic.service';
+import { VdDynamicTableComponent } from '../../table/components/dynamic-table/dynamic-table.component';
+import { TableColumn } from '../../table/models/table-column';
+import { TableMenuItem } from '../../table/models/table-menu-item';
+import { TableDataSource } from '../../table/table.data-source';
+import { BaseComponent } from './base.component';
+import * as i0 from "@angular/core";
+/**
+ * A base list component for components with pagination support
+ */
+export declare abstract class GenericListComponent<TEntity extends IEntity | any, TService extends GenericService<TEntity>> extends BaseComponent implements OnDestroy {
+    service: TService;
+    protected route: ActivatedRoute;
+    protected changeDetectorRef: ChangeDetectorRef;
+    classType?: {
+        new (): TEntity;
+    };
+    /**
+     * List title
+     */
+    subtitle: string;
+    /**
+     * A reference to MdPaginator element
+     */
+    paginator: MatPaginator;
+    /**
+     * A reference to MdSort attribute
+     */
+    sort: MatSort;
+    /**
+     * Page size options
+     */
+    pageSizeOptions: Array<number>;
+    /**
+     * The navigations to includes
+     */
+    includes: Array<string>;
+    /**
+     * The navigations to includes
+     */
+    excludedColumns: Array<string>;
+    /**
+     * Get params
+     */
+    query: any;
+    /**
+     * Data-table datasource
+     */
+    dataSource: TableDataSource<TEntity, TService> | null;
+    /**
+     * Current sort column
+     */
+    sortActive: string;
+    /**
+     * Current sort direction
+     */
+    sortDirection: string;
+    /**
+     * An instance of the class to create the table for
+     */
+    classInstance: any;
+    /**
+     * columns: TableColumn[]
+     */
+    columns: (TableColumn | string)[];
+    /**
+     * A reference to MdSort attribute
+     */
+    dynamicTable: VdDynamicTableComponent;
+    /**
+     * The type of the dialog for creation
+     */
+    addDialogType: any;
+    /**
+     * Shows the column 'Checkbox'
+     */
+    selectable: boolean;
+    /**
+     * If true, show the button 'Add'
+     */
+    addable: boolean;
+    /**
+     * If true, show the menu 'Edit'
+     */
+    editable: boolean;
+    /**
+     * If true, show the menu 'Delete'
+     */
+    deletable: boolean;
+    /**
+     * If true, show the menu 'Download'
+     */
+    downloadable: boolean;
+    /**
+     * If true, show the menu 'Duplicate'
+     */
+    duplicable: boolean;
+    /**
+     * rowNgClass: Function
+     */
+    rowNgClass: Function;
+    /**
+     * rowClick: Function
+     */
+    rowClick: Function;
+    /**
+     * detailsTemplate: Function
+     */
+    detailsTemplate: string;
+    /**
+     * Toolbar menu items
+     */
+    toolbarMenuItems: TableMenuItem[];
+    /**
+     * Table row menu items
+     */
+    rowMenuItems: TableMenuItem[];
+    /**
+     * DataLoaded event subscription
+     */
+    protected dataLoadedSubscription: Subscription;
+    /**
+     * Constructor
+     * @param service
+     */
+    constructor(service: TService, route: ActivatedRoute, changeDetectorRef: ChangeDetectorRef, classType?: {
+        new (): TEntity;
+    });
+    /**
+     * Lifecycle hook that is called after data-bound properties
+     * of a directive are initialized.
+     */
+    ngOnInit(): void;
+    /**
+     * Reloads items
+     */
+    loadList(resetSelection?: boolean): void;
+    /**
+     * Search
+     * @param filter
+     */
+    search(filter: string): void;
+    /**
+     * Navigates to the add page.
+     */
+    add(): void;
+    /**
+     * Navigates to the edit page.
+     * @param item The id of the item
+     */
+    edit(item: TEntity): void;
+    /**
+     * Patches the entity
+     * Patches the entity
+     * @param id The ID of the entity
+     * @param fields The fields to patch
+     * @param value The (optional) value to change
+     * @param includes Includes some navigations
+     */
+    patch(id: number, fields: Array<string>, value: any, includes: any): void;
+    /**
+     * Patches the entity
+     * @param id The ID of the entity
+     * @param fields The fields to patch
+     * @param value The (optional) value to change
+     * @param includes Includes some navigations
+     * @param successCallback A callback function to e called on success
+     */
+    protected _patch(id: number, fields: Array<string>, value: any, includes: any, successCallback?: Function): void;
+    /**
+     * Deletes an item from the database.
+     */
+    deleteItem(item: TEntity): void;
+    /**
+     * Deletes an item from the database.
+     */
+    deleteItems(): void;
+    /**
+     * Toggles a property
+     * @param item
+     * @param property
+     */
+    toggle(item: TEntity, property?: string): void;
+    /**
+     * Uploads tarnsfers csv files
+     * @param file The file to upload
+     * @param reload If true, reload items
+     */
+    upload(file: File, reload?: boolean): void;
+    /**
+     * Downloads a document
+     * @param item
+     */
+    download(item: TEntity, path?: string): void;
+    /**
+     * Duplicates a record
+     * @param item
+     */
+    duplicate(item: TEntity): void;
+    /**
+     * This informs the table how to uniquely identify rows to
+     * track how the data changes with each update.
+     * @param index
+     * @param item
+     */
+    trackById(_: number, item: any): any;
+    /**
+     * Includes some navigations
+     * @param inc
+     */
+    protected include(...inc: string[]): void;
+    /**
+     * Add toolbar menu items
+     */
+    protected addToolbarMenuItems(): void;
+    /**
+     * Add row menu items
+     */
+    protected addRowMenuItems(): void;
+    /**
+     * Check if the item is selectable
+     */
+    protected canSelectItem(entity: TEntity): boolean;
+    /**
+     * Check if the item is deletable
+     */
+    protected canDeleteItem(entity: TEntity): boolean;
+    /**
+     * Check if the item is editable
+     */
+    protected canEditItem(entity: TEntity): boolean;
+    /**
+     * Check if the item is downloadable
+     */
+    protected canDownloadItem(entity: TEntity): boolean;
+    /**
+     * Check if the item is duplicable
+     */
+    protected canDuplicateItem(entity: TEntity): boolean;
+    /**
+     * Returns NgClass object for select column
+     */
+    protected selectRowNgClass(_: TEntity): any;
+    /**
+     * Check if the there any selected row
+     * @returns
+     */
+    protected hasSelectedRows(): boolean;
+    /**
+     * Checks if the user can perform multiple operations (Like 'delete selected').
+     * @param action
+     * @returns
+     */
+    protected canExecuteMultipleOperations(action?: Function): boolean;
+    /**
+     * Responds to user-initiated events
+     * @param event
+     */
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    /**
+     * A callback used for any custom cleanup that needs to occur
+     * when the instance is destroyed.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericListComponent<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GenericListComponent<any, any>, never, never, {}, {}, never>;
+}

package/lib/base/components/generic-reactive-form.component.d.ts

@@ -0,0 +1,47 @@
+import { ChangeDetectorRef, Type } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
+import { IEntity } from '../../common/common.module';
+import { FormBuilderConfiguration } from '../../form-validators/models';
+import { RxFormBuilder } from '../../form-validators/public_api';
+import { GenericService } from '../../http/http.module';
+import { GenericFormBaseComponent } from './generic-form-base.component';
+import * as i0 from "@angular/core";
+export declare abstract class GenericReactiveFormComponent<TEntity extends IEntity, TService extends GenericService<TEntity>> extends GenericFormBaseComponent<TEntity, TService> {
+    entityCtor: Type<TEntity>;
+    protected service: TService;
+    protected route: ActivatedRoute;
+    protected changeDetectorRef: ChangeDetectorRef;
+    /**
+     * Form group
+     */
+    form: FormGroup;
+    /**
+     * Form builder
+     */
+    protected formBuilder: RxFormBuilder;
+    /**
+     * formBuilderConfig: FormBuilderConfiguration
+     */
+    protected formBuilderConfig: FormBuilderConfiguration;
+    /**
+     * Gets form value
+     */
+    get formValue(): TEntity | any;
+    /**
+     * Constructor
+     * @param service
+     */
+    constructor(entityCtor: Type<TEntity>, service: TService, route: ActivatedRoute, changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Builds a new form
+     */
+    protected buildForm(): void;
+    /**
+     * Shows form errors
+     * @param form
+     */
+    protected debugForm(form?: FormGroup): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericReactiveFormComponent<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GenericReactiveFormComponent<any, any>, never, never, {}, {}, never>;
+}

package/lib/base/constants/common.d.ts

@@ -0,0 +1,9 @@
+export declare const Common: {
+    allowedExtensions: string[];
+    editorPlugins: string;
+    editorToolbar: string;
+    months: {
+        name: string;
+        id: number;
+    }[];
+};

package/lib/base/enums/message-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum MessageType {
+    Success = 0,
+    Warning = 1,
+    Error = 2
+}

package/lib/base/helpers/auth-helper.d.ts

@@ -0,0 +1,26 @@
+import { AuthUser } from "../models/auth-user";
+export declare class AuthHelper {
+    /**
+     * Authenticated user
+     */
+    static user: AuthUser;
+    /**
+     * Checks if the current user is authenticated
+     */
+    static isAuthenticated(): boolean;
+    /**
+     * Checks if the user has the specified permission
+     * @param permission The permission to check
+     */
+    static isPermitted(...permissions: string[]): boolean;
+    /**
+     * Checks if the current user has on of the specified roles
+     * @param roles
+     */
+    static hasRole(...roles: string[]): boolean;
+    /**
+     * Checks if the specified variable is a string
+     * @param str
+     */
+    static isString(str: any): boolean;
+}

package/lib/base/interceptors/base.interceptor.d.ts

@@ -0,0 +1,40 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Observable } from 'rxjs';
+import { AppSetting } from '../../common/models/app-setting';
+import * as i0 from "@angular/core";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export declare class BaseInterceptor implements HttpInterceptor {
+    private appSetting;
+    private snackBar;
+    /**
+     * Constructor
+     */
+    constructor(appSetting: AppSetting, snackBar: MatSnackBar);
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    /**
+     * Parses http response errors
+     * @param error
+     */
+    protected parseErrors(error: Object): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseInterceptor>;
+}

package/lib/base/interceptors/caching-interceptor.d.ts

@@ -0,0 +1,35 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export declare class CachingInterceptor implements HttpInterceptor {
+    /**
+     * Cache container
+     */
+    private cache;
+    /**
+     * Constructor
+     */
+    constructor();
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CachingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CachingInterceptor>;
+}

package/lib/base/interceptors/loading.interceptor.d.ts

@@ -0,0 +1,30 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { LoadingScreenService } from "../services/loading-screen.service";
+import * as i0 from "@angular/core";
+export declare class LoadingScreenInterceptor implements HttpInterceptor {
+    private loadingScreenService;
+    /**
+     * activeRequests: number
+     */
+    activeRequests: number;
+    /**
+     * URLs for which the loading screen should not be enabled
+     */
+    skippUrls: string[];
+    /**
+     * Constructor
+     * @param loadingScreenService
+     */
+    constructor(loadingScreenService: LoadingScreenService);
+    /**
+    * Identifies and handles a given HTTP request.
+    * @param req The outgoing request object to handle.
+    * @param next The next interceptor in the chain, or the backend
+    * if no interceptors remain in the chain.
+    * @returns An observable of the event stream.
+    */
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingScreenInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingScreenInterceptor>;
+}

package/lib/base/models/auth-user.d.ts

@@ -0,0 +1,15 @@
+export declare class AuthUser {
+    id: number;
+    sub: number;
+    name: string;
+    displayName: string;
+    letter: string;
+    email: string;
+    role: string;
+    permission: Array<string>;
+    access_token: string;
+    isAuthenticated: boolean;
+    postLoginRoute: string;
+    clientId: number;
+    departmentId: number;
+}

package/lib/base/public_api.d.ts

@@ -0,0 +1 @@
+export * from './base.module';

package/lib/base/services/file.service.d.ts

@@ -0,0 +1,10 @@
+import { GenericService } from '../../http/services/generic.service';
+import * as i0 from "@angular/core";
+export declare class FileService extends GenericService<any> {
+    /**
+     * Constructor
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileService>;
+}

package/lib/base/services/loading-screen.service.d.ts

@@ -0,0 +1,30 @@
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class LoadingScreenService {
+    /**
+     * _loading: boolean
+     */
+    private _loading;
+    /**
+     * loadingStatus: Subject<any>
+     */
+    loadingStatus: Subject<any>;
+    /**
+     * Gets the loading
+     */
+    get loading(): boolean;
+    /**
+     * Sets the loading
+     */
+    set loading(value: boolean);
+    /**
+     * Starts the loding
+     */
+    startLoading(): void;
+    /**
+     * Stops the loading
+     */
+    stopLoading(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingScreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingScreenService>;
+}

package/lib/base/services/print.service.d.ts

@@ -0,0 +1,23 @@
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class PrintService {
+    private router;
+    isPrinting: boolean;
+    /**
+     * Constructor
+     * @param router
+     */
+    constructor(router: Router);
+    /**
+     * Print document
+     * @param documentName
+     * @param documentData
+     */
+    printDocument(documentName: string, documentData: string[]): void;
+    /**
+     * On data ready
+     */
+    onDataReady(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrintService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrintService>;
+}

package/lib/chips/chips.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/chips.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/chips";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/input";
+import * as i7 from "@angular/material/select";
+import * as i8 from "@angular/material/autocomplete";
+import * as i9 from "@angular/material/progress-spinner";
+export declare class VdChipsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdChipsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VdChipsModule, [typeof i1.VdChipsComponent, typeof i1.VdAutocompleteOptionDirective, typeof i1.VdChipDirective], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4.MatChipsModule, typeof i5.MatIconModule, typeof i6.MatInputModule, typeof i7.MatSelectModule, typeof i8.MatAutocompleteModule, typeof i9.MatProgressSpinnerModule], [typeof i1.VdChipsComponent, typeof i1.VdAutocompleteOptionDirective, typeof i1.VdChipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VdChipsModule>;
+}