@dflat-core/web 1.0.44 → 1.0.46

package/types/dflat-core-web-core-services.d.ts

@@ -0,0 +1,426 @@
+import { EnsureModuleLoadedOnceGuard, EnvironmentBase } from "@dflat-core/web/core";
+import * as i0 from "@angular/core";
+import { EventEmitter, InjectionToken, Injector } from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@dflat-core/web/core-model";
+import { ApiError, DictionnaryWrapper, IUserCredential, Message, Notification, User } from "@dflat-core/web/core-model";
+import { ActivatedRouteSnapshot, Route, Router, RouterStateSnapshot } from "@angular/router";
+import { Observable, ReplaySubject, Subject, Subscription } from "rxjs";
+import { HttpClient, HttpErrorResponse, HttpEvent, HttpHandler, HttpHeaders, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Title } from "@angular/platform-browser";
+import * as signalR from "@microsoft/signalr";
+export declare class CoreServicesModule extends EnsureModuleLoadedOnceGuard {
+  constructor(parentModule: CoreServicesModule);
+  static ɵfac: i0.ɵɵFactoryDeclaration<CoreServicesModule, [{
+    optional: true;
+    skipSelf: true;
+  }]>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<CoreServicesModule, never, [typeof i1.CommonModule, typeof i2.CoreModelModule], never>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<CoreServicesModule>;
+}
+export declare class AppKeys {
+  static readonly CURRENT_USER = "current_user";
+  static readonly ACCESS_TOKEN = "access_token";
+  static readonly REFRESH_TOKEN = "refresh_token";
+  static readonly TOKEN_EXPIRES_IN = "expires_in";
+  static readonly REMEMBER_ME = "remember_me";
+  static readonly PERMISSIONS = "permissions";
+  static readonly LAST_GEOLOCATIONS = "geolocations";
+  static readonly REFERENCE_SUPPLIER_ID = "refsuppid";
+  static readonly USER_COMPANY_ID = "companyid";
+  static readonly SELECTED_COMPANY = "selectedcompany";
+  static ɵfac: i0.ɵɵFactoryDeclaration<AppKeys, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class AppConfiguration {
+  searchText: string;
+  isSearchAllowed: boolean;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<AppConfiguration, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class BusMessageService {
+  private message$;
+  constructor();
+  publish<T>(message: T): void;
+  of<T>(messageType: new (...args: any[]) => T): Observable<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BusMessageService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class NotificationMqService {
+  private message$;
+  constructor();
+  publish<T extends Notification>(message: T): void;
+  of<T extends Notification>(channelKey: string): Observable<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMqService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class LocalStoreManager {
+  private static syncListenerInitialised;
+  private syncKeys;
+  private initEvent;
+  private reservedKeys;
+  static readonly DBKEY_USER_DATA = "user_data";
+  private static readonly DBKEY_SYNC_KEYS;
+  initialiseStorageSyncListener(): void;
+  deinitialiseStorageSyncListener(): void;
+  private sessionStorageTransferHandler;
+  private syncSessionStorage;
+  clearAllStorage(): void;
+  clearAllSessionsStorage(): void;
+  clearInstanceSessionStorage(): void;
+  clearLocalStorage(): void;
+  private addToSessionStorage;
+  private addToSessionStorageHelper;
+  private removeFromSessionStorage;
+  private removeFromSessionStorageHelper;
+  private testForInvalidKeys;
+  private syncKeysContains;
+  private loadSyncKeys;
+  private getSyncKeysFromStorage;
+  private addToSyncKeys;
+  private addToSyncKeysBackup;
+  private removeFromSyncKeysBackup;
+  private addToSyncKeysHelper;
+  private removeFromSyncKeys;
+  private removeFromSyncKeysHelper;
+  saveSessionData(data: any, key?: string): void;
+  saveSyncedSessionData(data: any, key?: string): void;
+  savePermanentData(data: any, key?: string): void;
+  moveDataToSessionStorage(key?: string): void;
+  moveDataToSyncedSessionStorage(key?: string): void;
+  moveDataToPermanentStorage(key?: string): void;
+  exists(key?: string): boolean;
+  getData(key?: string): any;
+  getDataObject<T>(key?: string, isDateType?: boolean): T;
+  deleteData(key?: string): void;
+  private localStorageSetItem;
+  private sessionStorageSetItem;
+  private localStorageGetItem;
+  private sessionStorageGetItem;
+  private onInit;
+  getInitEvent(): Observable<{}>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LocalStoreManager, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class HeadersService {
+  private localStorage;
+  constructor(localStorage: LocalStoreManager);
+  authJsonHeaders(): HttpHeaders;
+  authFormHeaders(): HttpHeaders;
+  authFileUploadHeaders(): HttpHeaders;
+  jsonHeaders(): HttpHeaders;
+  contentHeadersV2(): HttpHeaders;
+  get geJWTToken(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HeadersService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export interface IErrorHandler {
+  handleError(error: any): any;
+}
+export declare class MenuItem {
+  id?: number;
+  title?: string;
+  link?: string;
+  icon?: string;
+  sublinks?: MenuItem[];
+  permissionKey?: string;
+  external?: boolean;
+  target?: string;
+  constructor(title?: string, link?: string, icon?: string, sublinks?: MenuItem[], permissionKey?: string);
+}
+export interface NamedPosition {
+  formattedName: string;
+  placeId: string;
+  latitude: number;
+  longitude: number;
+}
+export interface ScreenConfiguration {
+  isSmallScreen: boolean;
+  isExtraSmallScreen: boolean;
+  isLargeScreen: boolean;
+}
+export declare class PermissionService {
+  private localStorage;
+  constructor(localStorage: LocalStoreManager);
+  hasPermission(permission: string): boolean;
+  get permissions(): Array<any>;
+  get isAdmin(): boolean;
+  get currentUser(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare abstract class MenuService {
+  private permissionService;
+  private current;
+  private _permissionRouteMap;
+  constructor(permissionService: PermissionService);
+  abstract getAllMenuItems(isAdmin: boolean): MenuItem[];
+  abstract getAccessGrantedMenuItems(): MenuItem[];
+  setCurrent(menu: MenuItem[]): void;
+  getCurrent(): ReplaySubject<MenuItem[]>;
+  get permissionRouteMap(): DictionnaryWrapper<string>;
+  resetPermissionMap(): void;
+  hasAccessToThisRoute(url: string): boolean;
+  pushItem(items: Array<MenuItem>, menuItem: MenuItem, isAdmin: boolean): void;
+  hasPermission: (permKey: string) => boolean;
+  hasAnyPermission: (permKeys: (string | undefined)[]) => boolean;
+  getMenuItems(isAdmin: boolean): MenuItem[];
+  private sortLinks;
+  private sortLinksSubLevel;
+  merge(Menus: MenuItem[]): MenuItem[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare enum AuthTokenType {
+  AccessToken = 0,
+  RefreshToken = 1
+}
+export declare class AuthService {
+  private headersService;
+  private busMsg;
+  private httpClient;
+  private router;
+  private localStorage;
+  private menuService;
+  private env;
+  baseUrl: string;
+  loginRedirectUrl: string;
+  private refreshTokenSubscription;
+  constructor(headersService: HeadersService, busMsg: BusMessageService, httpClient: HttpClient, router: Router, localStorage: LocalStoreManager, menuService: MenuService, env: EnvironmentBase);
+  login(username: string, password: string, rememberMe: boolean): Observable<IUserCredential>;
+  register(captchaToken: string, firstName: string, lastName: string, email: string, password: string, rememberMe: boolean): Observable<IUserCredential>;
+  activate(code: string): Observable<Response>;
+  saveUserInfos(user: any, userDetails: string, rememberMe?: boolean): void;
+  getPermissions(token: any): any[];
+  removeUserInfos(): void;
+  logout(pseudo: string): void;
+  disconnect(pseudo: string): Subscription;
+  ensureLogout(): void;
+  redirectLoginUser(): void;
+  invalidateCurrentTabId(): void;
+  scheduleRefreshToken(isAuthUserLoggedIn: boolean, calledFromLogin: boolean): void;
+  private refreshTokenTimerCheckId;
+  private setRefreshTokenTimerStopped;
+  private setRefreshTokenTimerStarted;
+  private deleteRefreshTokenTimerCheckId;
+  private isRefreshTokenTimerStartedInAnotherTab;
+  getCurrentTabId(): number;
+  getAccessTokenExpirationDateUtc(): Date | null;
+  isAccessTokenTokenExpired(): boolean;
+  getDecodedAccessToken(): any;
+  isEmptyString(value: string): boolean;
+  unscheduleRefreshToken(cancelTimerCheckToken: boolean): void;
+  updateToken(): Subscription;
+  hasPermission(permission: string): boolean;
+  get timerStat(): any;
+  get isLoggedIn(): boolean;
+  get isAdmin(): boolean;
+  get pseudo(): string;
+  get userId(): number;
+  get currentUser(): string;
+  get rememberMe(): boolean;
+  get token(): string;
+  get refreshToken(): string;
+  get permissions(): Array<any>;
+  get companyId(): number;
+  get referenceSupplierId(): number;
+  navigateToHome(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class AuthGuard {
+  private authService;
+  private menuService;
+  private router;
+  constructor(authService: AuthService, menuService: MenuService, router: Router);
+  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+  canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+  canLoad(route: Route): boolean;
+  checkLogin(url: string): boolean;
+  private hasAuthUserAccessToThisRoute;
+  private showAccessDenied;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class AuthInterceptor implements HttpInterceptor {
+  protected router: Router;
+  protected injector: Injector;
+  constructor(router: Router, injector: Injector);
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+  onError(errResponse: HttpErrorResponse, error: ApiError): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class BreadcrumbService {
+  protected title: Title;
+  current: ReplaySubject<any>;
+  private initialData;
+  constructor(title: Title);
+  setCurrent(data: any): void;
+  getCurrent(): ReplaySubject<any>;
+  clear(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class UserService {
+  private router;
+  private authService;
+  userChanged: EventEmitter<User>;
+  private current;
+  private editUser;
+  constructor(router: Router, authService: AuthService);
+  setCurrent(user: User): void;
+  getCurrent(): ReplaySubject<User>;
+  openEditUser(): void;
+  getEditUser(): ReplaySubject<any>;
+  get AuthenticatedUser(): User;
+  logout(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class CanActivateGuard {
+  private router;
+  private userService;
+  private connected;
+  constructor(router: Router, userService: UserService);
+  canActivate(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CanActivateGuard, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class GeolocationService {
+  protected localStore: LocalStoreManager;
+  positionsHistory: Array<NamedPosition>;
+  positionChanged: EventEmitter<NamedPosition>;
+  constructor(localStore: LocalStoreManager);
+  getCurrentPosition(): NamedPosition;
+  setCurrentPosition(formattedName: string, placeId: string, latitude: number, longitude: number): void;
+  /**
+   * Calcule la distance en mètres entre la position courante et le point dont les coordonnées GPS sont spécifiées en paramètre.
+   * @param latitude Latitude du point
+   * @param longitude Longitude du point
+   * @returns La distance en mètres entre la position courante et le point dont les coordonnées GPS sont spécifiées en paramètre.
+   */
+  getDistanceToCurrent(latitude: number, longitude: number): number;
+  /** Calcule la distance en mètres entre 2 points en coordonnées GPS.
+   * @param latitude1 Latitude du point 1
+   * @param longitude1 Longitude du point 1
+   * @param latitude2 Latitude du point 2
+   * @param longitude2 Longitude du point 2
+   * @returns Une estimation la distance en mètres entre les point GPS 1 et 2 dont les coordonnées sont spécifiées.
+   */
+  getDistance(latitude1: number, longitude1: number, latitude2: number, longitude2: number): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class NotificationsService {
+  private notificationsList;
+  newNotifications: Subject<Notification>;
+  notifications: ReplaySubject<Notification[]>;
+  updates: Subject<any>;
+  create: Subject<Notification>;
+  constructor();
+  addNotification(notification: Notification): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class HubService {
+  protected localStorage: LocalStoreManager;
+  protected notificationService: NotificationsService;
+  protected busMsg: BusMessageService;
+  protected mqMsg: NotificationMqService;
+  protected authService: AuthService;
+  protected env: EnvironmentBase;
+  protected hubUrl: string;
+  private timer$;
+  protected hubConnection: signalR.HubConnection;
+  isConnected: boolean;
+  isReconnect: boolean;
+  isInit: boolean;
+  isConnecting: boolean;
+  get hubOptions(): signalR.IHttpConnectionOptions;
+  constructor(localStorage: LocalStoreManager, notificationService: NotificationsService, busMsg: BusMessageService, mqMsg: NotificationMqService, authService: AuthService, env: EnvironmentBase);
+  init(): void;
+  disposeConnection(): void;
+  startHub(): void;
+  configure(): void;
+  scheduleStartingHub(): void;
+  publishEvents(notif: Notification): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HubService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class MessagesService {
+  private messagesList;
+  newMessages: Subject<Message>;
+  messages: ReplaySubject<Message[]>;
+  updates: Subject<any>;
+  create: Subject<Message>;
+  constructor();
+  addMessage(message: Message): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MessagesService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class ServerUrl {
+  static isProduction: boolean;
+  static baseUrl: string;
+  static apiUrl: string;
+  static hubUrl: string;
+  static loginPath: string;
+  static connectPath: string;
+  static registerPath: string;
+  static activatePath: string;
+  static refreshPath: string;
+  static disconnectPath: string;
+}
+export declare function trimChar(str: string, c: string): string;
+/**
+ * Menus des modules de l'application : chaque module racine ([module]-root) y déclare le sien,
+ * `{ provide: MODULE_MENU_SERVICES, useExisting: <Module>MenuService, multi: true }`.
+ * ApplicationMenuService les réunit en un seul menu.
+ */
+export declare const MODULE_MENU_SERVICES: InjectionToken<MenuService[]>;
+/**
+ * Menu de l'application : réunion des menus de tous ses modules (déclarés sous
+ * MODULE_MENU_SERVICES), dans l'ordre de déclaration. Les thèmes de même libellé sont fusionnés
+ * et leurs éléments réunis sans doublon (même lien). Chaque module filtre ses éléments selon les
+ * permissions de l'utilisateur connecté.
+ *
+ * Fourni sous MenuService par DflatAppModule.
+ */
+export declare class ApplicationMenuService extends MenuService {
+  private moduleMenus;
+  constructor(permissionService: PermissionService, moduleMenus: MenuService[] | null);
+  getAllMenuItems(isAdmin: boolean): MenuItem[];
+  getAccessGrantedMenuItems(): MenuItem[];
+  /** Éléments sans doublon : le premier élément de chaque lien est gardé. */
+  private distinctItems;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationMenuService, [null, {
+    optional: true;
+  }]>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class FilterService {
+  private displayFilterChangedSubject;
+  filterChanged$: import("rxjs").Observable<boolean>;
+  displayFilter: boolean;
+  get DisplayFilter(): boolean;
+  keywords: string;
+  get Keywords(): string;
+  set Keywords(value: string);
+  constructor();
+  setFilterDisplay(value: boolean): void;
+  toggleFilterDisplay(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FilterService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class ScreenService {
+  screenChanged: EventEmitter<ScreenConfiguration>;
+  scrollChanged: EventEmitter<Element>;
+  config: ScreenConfiguration;
+  constructor();
+  getScreenConfiguration(): ScreenConfiguration;
+  setScreenConfiguration(value: ScreenConfiguration): void;
+  scroll(elt: Element): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScreenService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}