@dflat-core/web 1.0.0-beta

package/assets/variables.scss

@@ -0,0 +1,91 @@
+@import "./bootswatch.scss";
+
+$header_height: 50px;
+$footer_height: 30px;
+$sidebar_width: 230px;
+
+$main_bg_color: #4465C9;
+
+
+
+
+// $header_height: 70px;
+$footer_height: 30px;
+// $sidebar_width: 480px;
+
+$mobile-screen: 480px;
+$small-screen: 768px;
+$large-screen: 980px;
+$wide-screen: 1200px;
+
+// Thème de couleurs Elnour
+$old-main: #FC9930;
+$main: #FC9324;
+$main-hover: #F97803; // à voir
+$main-opacity: #F3E0CB;
+
+// $primary: #24BE9f;
+
+$black_text: #272C5D;
+$black_text_light: #535353;
+$grey_text_light: #888888;
+$grey-border: #707070;
+$light-grey-border: #c3c3c3;
+$placeholder: #c3c3c3;
+
+$warning: #ffa500;
+
+// SVG Filters
+// See: https://codepen.io/sosuke/pen/Pjoqqp
+$main-svg-filter: invert(60%) sepia(99%) saturate(501%) hue-rotate(336deg) brightness(102%) contrast(98%);
+$primary-svg-filter: invert(67%) sepia(51%) saturate(566%) hue-rotate(117deg) brightness(82%) contrast(95%);
+$sidebar-back-active-filter: invert(11%) sepia(6%) saturate(2516%) hue-rotate(152deg) brightness(91%) contrast(88%);
+$white-filter: invert(100%) sepia(100%) saturate(18%) hue-rotate(251deg) brightness(104%) contrast(104%);
+$black-filter: invert(0%) sepia(76%) saturate(20%) hue-rotate(294deg) brightness(105%) contrast(104%);
+$black_text_filter: invert(17%) sepia(8%) saturate(6702%) hue-rotate(203deg) brightness(91%) contrast(93%);
+$black_text_light_filter: invert(33%) sepia(9%) saturate(15%) hue-rotate(336deg) brightness(90%) contrast(88%);
+$primary-hover-filter: invert(43%) sepia(97%) saturate(1264%) hue-rotate(133deg) brightness(101%) contrast(94%);
+$darkgrey-filter:invert(70%) sepia(0%) saturate(3789%) hue-rotate(32deg) brightness(91%) contrast(108%);
+$red-filter: invert(23%) sepia(96%) saturate(5276%) hue-rotate(354deg) brightness(104%) contrast(127%);
+$grey_text_light_filter: invert(62%) sepia(2%) saturate(0%) hue-rotate(356deg) brightness(87%) contrast(88%);
+$darkgrey: #a5a5a5;
+$darkgrey-2: #d5d5d5;
+$darkgrey-3: #d6d6d6;
+
+$form-grey: #fafafa;
+$grey: whitesmoke;
+$lightgrey: #f1f3f4;
+$disabled-grey-back: #E6E5E5;
+$disabled-grey-front: #bababa;
+
+$action-button-grey: #e6e6e6;
+$action-separator-grey: #e5e5e5;
+
+$action-button-grey-hover : #f6f6f6;
+
+$background-grey: #f5f5f5;
+$lightblue: #00C6F7;
+$white: #ffffff;
+
+$red-error: #da2128;
+$violet: #663999;
+// $algorima-blue: #2C52C9;
+$algorima-blue: #0A66C2;
+$job-offer-color: rgba(39,44,93,1);
+
+
+
+
+// $main-svg-filter: invert(24%) sepia(83%) saturate(1788%) hue-rotate(212deg) brightness(96%) contrast(90%);
+// $primary-svg-filter: invert(67%) sepia(51%) saturate(566%) hue-rotate(117deg) brightness(82%) contrast(95%);
+// $sidebar-back-active-filter: invert(11%) sepia(6%) saturate(2516%) hue-rotate(152deg) brightness(91%) contrast(88%);
+// $white-filter: invert(100%) sepia(100%) saturate(18%) hue-rotate(251deg) brightness(104%) contrast(104%);
+// $black-filter: invert(0%) sepia(76%) saturate(20%) hue-rotate(294deg) brightness(105%) contrast(104%);
+// $black_text_filter: invert(17%) sepia(8%) saturate(6702%) hue-rotate(203deg) brightness(91%) contrast(93%);
+// $black_text_light_filter: invert(33%) sepia(9%) saturate(15%) hue-rotate(336deg) brightness(90%) contrast(88%);
+// $primary-hover-filter: invert(43%) sepia(97%) saturate(1264%) hue-rotate(133deg) brightness(101%) contrast(94%);
+
+
+
+
+

package/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/core.module';
+export * from './lib/services/utilities.service';
+export * from './lib/services/ensuremoduleloadedonceguard';
+export * from './lib/nameof.function';
+export * from './lib/array.function';
+export * from './lib/global/EnvironmentBase';

package/core/lib/array.function.d.ts

@@ -0,0 +1,8 @@
+export declare function groupBy<TItem>(xs: TItem[], key: Extract<keyof TItem, string>): {
+    [key: string]: TItem[];
+};
+export declare function groupByFunc<TItem, TKey>(xs: TItem[], func: ((i: TItem) => string)): {
+    [key: string]: TItem[];
+};
+export declare function sumOf<TItem>(xs: TItem[], func: ((i: TItem) => number)): number;
+export declare function distinct(array: (number | string)[]): (number | string)[];

package/core/lib/core.module.d.ts

@@ -0,0 +1,9 @@
+import { EnsureModuleLoadedOnceGuard } from './services/ensuremoduleloadedonceguard';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export declare class CoreModule extends EnsureModuleLoadedOnceGuard {
+    constructor(parentModule: CoreModule);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, [{ optional: true; skipSelf: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
+}

package/core/lib/global/EnvironmentBase.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class EnvironmentBase {
+    abstract readonly production: boolean;
+    abstract readonly fileUrl: string;
+    abstract readonly baseUrl: string;
+    abstract readonly apiUrl: string;
+    abstract readonly hubUrl: string;
+}

package/core/lib/nameof.function.d.ts

@@ -0,0 +1,4 @@
+export type valueOf<T> = T[keyof T];
+export declare function nameof<T, V extends T[keyof T]>(f: (x: T) => V): valueOf<{
+    [K in keyof T]: T[K] extends V ? K : never;
+}>;

package/core/lib/services/ensuremoduleloadedonceguard.d.ts

@@ -0,0 +1,3 @@
+export declare class EnsureModuleLoadedOnceGuard {
+    constructor(targetModule: any);
+}

package/core/lib/services/utilities.service.d.ts

@@ -0,0 +1,87 @@
+import { HttpResponse, HttpResponseBase } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare const isArray: (x: any) => boolean;
+export declare function isNumeric(val: any): boolean;
+export declare function sleep(ms: any): Promise<unknown>;
+export declare class Utilities {
+    static delay(arg0: number): void;
+    static readonly captionAndMessageSeparator = ":";
+    static readonly noNetworkMessageCaption = "No Network";
+    static readonly noNetworkMessageDetail = "The server cannot be reached";
+    static readonly accessDeniedMessageCaption = "Access Denied!";
+    static readonly accessDeniedMessageDetail = "";
+    static getHttpResponseMessage(data: HttpResponseBase | any): string[];
+    static findHttpResponseMessage(messageToFind: string, data: HttpResponse<any> | any, seachInCaptionOnly?: boolean, includeCaptionInResult?: boolean): string;
+    static getResponseBody(response: HttpResponseBase): any;
+    static checkNoNetwork(response: HttpResponseBase): boolean;
+    static checkAccessDenied(response: HttpResponseBase): boolean;
+    static checkNotFound(response: HttpResponseBase): boolean;
+    static checkIsLocalHost(url: string, base?: string): boolean;
+    static getQueryParamsFromString(paramString: string): {
+        [key: string]: string;
+    };
+    static splitInTwo(text: string, separator: string): {
+        firstPart: string;
+        secondPart: string;
+    };
+    static safeStringify(object: any): string;
+    static JSonTryParse(value: string): any;
+    static isNonEmptyString(str: string): boolean;
+    static isEmptyString(str: string): boolean;
+    static areValuesEqual(a: any, b: any): boolean;
+    static TestIsObjectEmpty(obj: any): boolean;
+    static IsUndefined(value: any): value is undefined;
+    static IsNil(value: any): boolean;
+    static TestIsString(value: any): value is string | String;
+    static capitalizeFirstLetter(text: string): string;
+    static toTitleCase(text: string): string;
+    static toLowerCase(items: string): any;
+    static toLowerCase(items: string[]): any;
+    static uniqueId(): string;
+    static randomNumber(min: number, max: number): number;
+    static baseUrl(): string;
+    static printDateOnly(date: Date): string;
+    static printTimeOnly(date: Date): string;
+    static printDate(date: Date, separator?: string): string;
+    static printFriendlyDate(date: Date, separator?: string): string;
+    static printShortDate(date: Date, separator?: string, dateTimeSeparator?: string): string;
+    static parseDate(date: any): Date;
+    static Format2Digits(n: any): string;
+    static printDuration(start: Date, end: Date): string;
+    static getAge(birthDate: any, otherDate: any): number;
+    static isDateAEarlierThanDateB(dateA: Date, dateB: Date): boolean;
+    static searchArray(searchTerm: string, caseSensitive: boolean, ...values: any[]): boolean;
+    static moveArrayItem(array: any[], oldIndex: any, newIndex: any): void;
+    static expandCamelCase(text: string): string;
+    static testIsAbsoluteUrl(url: string): boolean;
+    static convertToAbsoluteUrl(url: string): string;
+    static removeNulls(obj: any): any;
+    static debounce(func: (...args: any[]) => any, wait: number, immediate?: boolean): () => void;
+    static cookies: {
+        getItem: (sKey: any) => string;
+        setItem: (sKey: any, sValue: any, vEnd: any, sPath: any, sDomain: any, bSecure: any) => boolean;
+        removeItem: (sKey: any, sPath: any, sDomain: any) => boolean;
+        hasItem: (sKey: any) => boolean;
+        keys: () => string[];
+    };
+    static isNumber(field: any): field is number | Number;
+    static changeName(item: any): string;
+    static transform<T>(value: T, args?: any[]): {
+        key: keyof T;
+        value: any;
+    }[];
+    static GetChannel(entityTypeKey: string): string;
+    static getProp<T, K extends keyof T>(object: T, property: K): T[K];
+    /**
+     * static getCustomDvalue: stringate
+     */
+    static getCustomDate(value: string): Date;
+    static isLowerThan(value1: string | Date, value2: string | Date): boolean;
+    static getLogClass(log: string): "" | "log-info" | "log-data" | "log-error" | "log-warning";
+    static deepCopy(obj: any): any;
+    static getCleanNumber(initial: string): number;
+    static addDays(date: Date, days: number): Date;
+    static getFormattedParams(params: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Utilities, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Utilities>;
+}

package/core-data/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/core-data.module';
+export * from './lib/services/data-service';
+export * from './lib/services/entity-data-service';

package/core-data/lib/core-data.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export declare class CoreDataModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreDataModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreDataModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreDataModule>;
+}

package/core-data/lib/services/data-service.d.ts

@@ -0,0 +1,68 @@
+import { EnvironmentBase } from '@dflat-core/web/core';
+import { ActionDescriptor, ColumnDescriptor, EntityViewModelWithFields, EntityWithSpecifics, ExtendedProperty, FilterDescriptor, PagedList, SaveResult, SaveResults, TrackRecordProperty } from '@dflat-core/web/core-model';
+import { HeadersService } from '@dflat-core/web/core-services';
+import { HttpClient, HttpParams, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DataService {
+    private env;
+    private headerService;
+    baseUrl: string;
+    httpClient: HttpClient;
+    data: any[];
+    constructor(env: EnvironmentBase, httpClient: HttpClient, headerService: HeadersService);
+    getFormattedParams(params: any): any;
+    getUrlQueryParams(filter: any): HttpParams;
+    getViewFilterDescriptors(entityKey: string): Observable<FilterDescriptor[]>;
+    getViewColumns(entityKey: string): Observable<ColumnDescriptor[]>;
+    search<TData>(entityKey: string, filter: any): Observable<PagedList<TData>>;
+    getDetails<TData>(entityKey: string, id: number): Observable<TData>;
+    getEmptyFilter<T>(entityKey: string): Observable<T>;
+    /**
+     * fonction "async" liant le front(Angular) et le back(C#)
+     * - Principalement appelée par "src.app.core.layout.BaseEditorComponent.loadEntityViewModel()" lorsque l'on cherche à afficher un Objet de type "EntityViewModel"
+     * - C'est elle qui lance l'appel à la fonction "back" BaseFilterController.GetEntityViewModel<TData>(id).
+     * - Puis elle crée un observable avec la réponse qu'elle obtient du "back"
+     *
+     * @async
+     * @function
+     * @name getEntityViewModel<TData>
+     * @param {string} entityKey
+     * @param {number} id
+     * @returns {(Observable)EntityViewModelWithFields<TData>}
+     * @memberof DataService
+     * @summary Demande les données d'une entité au back(C#) à travers "getEntityViewModel".
+     * @see {@link src.app.core.layout.BaseEditorComponent.loadEntityViewModel()} for more information
+     * @throws new Error("The parameter 'id' must be defined and cannot be null.") if (id === undefined ou id === null)
+     */
+    getEntityViewModel<TData>(entityKey: string, id: number): Observable<EntityViewModelWithFields<TData>>;
+    getExtendedProperties(entityKey: string, entityIds: number[]): Observable<ExtendedProperty[]>;
+    getExtendedActions(entityKey: string): Observable<ActionDescriptor[]>;
+    getTrackRecordProperties(entityKey: string, entityIds: number[]): Observable<TrackRecordProperty[]>;
+    saveEntity<TData>(entityKey: string, entity: TData): Observable<SaveResult>;
+    deleteEntity<TData>(entityKey: string, entity: TData): Observable<SaveResult>;
+    deleteEntities<TData>(entityKey: string, entities: TData[]): Observable<SaveResults<TData>>;
+    saveEntities<TData>(entityKey: string, entities: TData[]): Observable<SaveResults<TData>>;
+    SaveEntityWithSpecifics<TData>(entityKey: string, DataToSave: EntityWithSpecifics<TData>): Observable<{
+        success: boolean;
+        rowVersion?: Date;
+    }>;
+    exportAll<TData>(entityKey: string, filter: any): Observable<{
+        fileBlob: Blob;
+        fileName: string;
+    }>;
+    exportResults<TData>(entityKey: string, exportModel: any): Observable<{
+        fileBlob: Blob;
+        fileName: string;
+    }>;
+    getFileInfo(resp: HttpResponse<Blob>): {
+        fileBlob: Blob;
+        fileName: string;
+    };
+    uploadFileToExtract(file: File, inputId: number, correlationId: string): Observable<any>;
+    uploadFilesWithParams(files: File[], customParams?: {}, forceMultipleFiles?: boolean): Observable<any>;
+    uploadFiles(url: string, files: File[], customParams?: {}, forceMultipleFiles?: boolean): Observable<any>;
+    uploadFilesWithEvents(url: string, files: File[], customParams?: {}, forceMultipleFiles?: boolean): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;
+}

package/core-data/lib/services/entity-data-service.d.ts

@@ -0,0 +1,37 @@
+import { ActionDescriptor, ColumnDescriptor, EntityViewModel, EntityViewModelWithFields, EntityWithSpecifics, ExportModel, ExtendedProperty, FilterDescriptor, FilterViewModel, PagedList, SaveResult, SaveResults, TrackRecordProperty } from '@dflat-core/web/core-model';
+import { DataService } from './data-service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class EntityDataService<TData extends EntityViewModel, TFilter extends FilterViewModel> {
+    protected dataService: DataService;
+    abstract getEntityKey(): string;
+    constructor(dataService: DataService);
+    deleteEntities(sources: TData[]): Observable<SaveResults<TData>>;
+    deleteEntity(source: TData): Observable<SaveResult>;
+    exportAll(filter: TFilter): Observable<{
+        fileBlob: Blob;
+        fileName: string;
+    }>;
+    exportResults(model: ExportModel<TFilter>): Observable<{
+        fileBlob: Blob;
+        fileName: string;
+    }>;
+    getAlternateEntityViewModel(id: number): Observable<EntityViewModelWithFields<TData>>;
+    getCacheManager(): Observable<TData[]>;
+    getColumns(): Observable<ColumnDescriptor[]>;
+    getDetails(id: number): Observable<TData>;
+    getEmptyFilter(): Observable<TFilter>;
+    getEntityViewModel(id: number): Observable<EntityViewModelWithFields<TData>>;
+    getExtendedActions(): Observable<ActionDescriptor[]>;
+    getExtendedProperties(entityIds: number[]): Observable<ExtendedProperty[]>;
+    getFilterDescriptors(): Observable<FilterDescriptor[]>;
+    getSortColumn(col: string): Observable<string>;
+    getTrackRecordProperties(entityIds: number[]): Observable<TrackRecordProperty[]>;
+    saveEntities(sources: TData[]): Observable<SaveResults<TData>>;
+    saveEntity(source: TData): Observable<SaveResult>;
+    saveEntityWithSpecifics(source: EntityWithSpecifics<TData>): Observable<any>;
+    search(filter: TFilter): Observable<PagedList<TData>>;
+    toggleFavorite(filter: TFilter): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataService<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntityDataService<any, any>, never, never, {}, {}, never, never, true, never>;
+}

package/core-model/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/core-model.module';
+export * from './lib/model/interface.generated';
+export * from './lib/interface';
+export * from './lib/model/model';

package/core-model/lib/core-model.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export declare class CoreModelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModelModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModelModule>;
+}

package/core-model/lib/interface.d.ts

@@ -0,0 +1,140 @@
+import { ComponentRef, TemplateRef, Type } from '@angular/core';
+import { ActionDescriptor, ColumnDescriptor, EntityViewModel, EntityViewModelWithFields, FieldDescriptor, FieldValidators, FilterDescriptor, FilterViewModel } from './model/interface.generated';
+export interface IIdentifiable {
+    Id?: number;
+}
+export declare class UserUpdatedMessage {
+    userKey: string;
+    constructor(userKey: string);
+}
+export interface IUserCredential extends IIdentifiable {
+    AccessToken: string;
+    RefreshToken: string;
+    Username?: string;
+    FirstName?: string;
+    LastName?: string;
+    Email?: string;
+    IsAdmin?: boolean;
+    IsDelivery?: boolean;
+    IsPartner?: boolean;
+    PhoneNumber?: string;
+    IsActive?: boolean;
+    IsPartnerActive?: boolean;
+    IsDeliveryActive?: boolean;
+    Id?: number;
+    CompanyId?: number;
+    Permissions: string[];
+    ProfileImageUrl: string;
+    AvatarUrl: string;
+}
+export declare class User implements IUserCredential {
+    AccessToken: string;
+    RefreshToken: string;
+    Username?: string;
+    FirstName?: string;
+    LastName?: string;
+    Email?: string;
+    PhoneNumber?: string;
+    IsAdmin?: boolean;
+    IsDelivery?: boolean;
+    IsPartner?: boolean;
+    Id?: number;
+    CompanyId?: number;
+    Permissions: string[];
+    ProfileImageUrl: string;
+    IsActive?: boolean;
+    IsPartnerActive?: boolean;
+    IsDeliveryActive?: boolean;
+    IsConnected: boolean;
+    AvatarUrl: string;
+    constructor(data: IUserCredential);
+    getName(): string;
+}
+export interface INotification {
+    id: string;
+    content: string;
+    class: string;
+    link: string;
+    entityType: string;
+    entityId?: number;
+}
+export declare class Notification implements INotification {
+    id: string;
+    content: string;
+    class: string;
+    link: string;
+    entityType: string;
+    entityId?: number;
+    constructor(data?: Partial<INotification>);
+}
+export declare class ChannelData<T> {
+    Channel: string;
+    Data: T;
+    constructor(channel: string, data: T);
+}
+export declare class IMessage {
+    Channel: string;
+    Data: any;
+}
+export declare class Message implements IMessage {
+    Channel: string;
+    Data: any;
+    constructor(channel: string, data: any);
+}
+export interface NumberDictionary<T> {
+    [Key: number]: T;
+}
+export interface Dictionary<T> {
+    [Key: string]: T;
+}
+export declare class NumberDictionnaryWrapper<T> {
+    dictionary: NumberDictionary<T>;
+    get(key: number): T;
+    containsKey(key: number): boolean;
+}
+export declare class DictionnaryWrapper<T> {
+    dictionary: Dictionary<T>;
+    get(key: string): T;
+    containsKey(key: string): boolean;
+    getPartKey(key: string): T;
+    containsKeyOrPartKey(key: string): boolean;
+    getValues(): T[];
+}
+export interface SpecificSection {
+    Name?: string;
+    IconUrl?: string;
+    Template?: Type<any> | TemplateRef<any> | ComponentRef<any> | any;
+    Context?: {};
+    Data?: any[];
+    Component?: any;
+    refreshFunction?: () => void;
+}
+export interface SectionError {
+    Name?: string;
+    FieldValidators?: FieldValidators;
+    Errors?: string[];
+}
+export interface IFilterDescriptorExtra {
+    Field?: FilterDescriptor;
+    DisplayedValue?: string;
+}
+export interface TextZoneButtonEvent {
+    Field: FieldDescriptor;
+    Value: string;
+}
+export interface FieldEvent {
+    Field: FieldDescriptor;
+    Event: Event;
+}
+export interface EntityConfig {
+    actions: ActionDescriptor[];
+    columns: ColumnDescriptor[];
+    emptyFilter: FilterViewModel;
+    filterDescriptors: FilterDescriptor[];
+    viewModel: EntityViewModelWithFields<EntityViewModel>;
+}
+export interface PropertyEditorEvent {
+    field: FieldDescriptor;
+    value: any;
+    type: 'value' | 'pending' | 'file' | 'selector' | 'button' | 'reset';
+}