spiderly 0.0.8 → 19.0.1

package/src/lib/enums/verification-type-codes.ts

@@ -0,0 +1,5 @@
+export enum VerificationTypeCodes
+{
+    Login = 0,
+	Registration = 1,
+}

package/src/lib/guards/auth.guard.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { CanActivate, Router } from '@angular/router';
+import { Observable, map } from 'rxjs';
+import { AuthBaseService } from '../services/auth-base.service';
+import { ConfigBaseService } from '../services/config-base.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AuthGuard implements CanActivate {
+  constructor(
+    private authService: AuthBaseService, 
+    private router: Router,
+    private config: ConfigBaseService
+  ) {
+
+  }
+
+  canActivate(): Observable<boolean> {
+    return this.checkAuth();
+  }
+
+  private checkAuth(): Observable<boolean> {
+    return this.authService.user$.pipe(
+      map((user) => {
+        if (user) {
+          return true;
+        } else {
+          // const returnUrl = this.router.getCurrentNavigation()?.extractedUrl.toString() || '/';
+          // this.router.navigate(['login'], {
+          //    queryParams: { returnUrl },
+          // });
+          this.router.navigate([this.config.loginSlug]);
+          return false;
+        }
+      })
+    );
+  }
+}

package/src/lib/guards/not-auth.guard.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { CanActivate } from '@angular/router';
+import { Observable, map } from 'rxjs';
+import { AuthBaseService } from '../services/auth-base.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class NotAuthGuard implements CanActivate {
+  constructor(
+    private authService: AuthBaseService, 
+  ) {
+
+  }
+
+  canActivate(): Observable<boolean> {
+    return this.checkAuth();
+  }
+
+  private checkAuth(): Observable<boolean> {
+    return this.authService.user$.pipe(
+      map((user) => {
+        if (user) {
+          this.authService.navigateToDashboard(); // FT: If there is a user and he went to the login page, push him to the dashboard i try to load partner.
+          return false;
+        } else {
+          return true;
+        }
+      })
+    );
+  }
+}

package/src/lib/handlers/spiderly-error-handler.ts

@@ -0,0 +1,32 @@
+import { TranslocoService } from '@jsverse/transloco';
+import { ErrorHandler, Injectable } from '@angular/core';
+import { SpiderlyMessageService } from '../services/spiderly-message.service';
+import { HttpErrorResponse } from '@angular/common/http';
+import { ConfigBaseService } from '../services/config-base.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SpiderlyErrorHandler implements ErrorHandler {
+  constructor(
+    private messageService: SpiderlyMessageService, 
+    private translocoService: TranslocoService, 
+    private config: ConfigBaseService,
+  ) {
+
+  }
+
+  handleError(error: any): void {
+    if(this.config.production == false){
+      console.error(error);
+    }
+
+    if(error instanceof HttpErrorResponse == false){
+      this.messageService.errorMessage(
+        this.translocoService.translate('UnexpectedErrorDetails'),
+        this.translocoService.translate('UnexpectedErrorTitle'),
+      );
+    }
+
+  }
+}

package/src/lib/handlers/spiderly-transloco-fallback-strategy.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { TranslocoFallbackStrategy, TranslocoService } from '@jsverse/transloco';
+
+import { HashMap, TranslocoMissingHandler, TranslocoMissingHandlerData } from "@jsverse/transloco";
+
+@Injectable({
+    providedIn: 'root'
+})
+export class SpiderlyTranslocoFallbackStrategy implements TranslocoFallbackStrategy {
+  getNextLangs(failedLang: string): string[] {
+    return ['sr-Latn-RS.generated'];
+  }
+
+}
+
+export class SpiderlyTranslocoMissingHandler implements TranslocoMissingHandler {
+  constructor(private translocoService: TranslocoService) {
+    
+  }
+
+  handle(key: string, data: TranslocoMissingHandlerData, params?: HashMap) {
+      return this.translocoService.translate(key, params, `${this.translocoService.getActiveLang()}.generated`);
+  }
+
+}

package/src/lib/interceptors/http-loading.interceptor.ts

@@ -0,0 +1,21 @@
+import { HttpEvent, HttpInterceptorFn } from "@angular/common/http";
+import { inject } from "@angular/core";
+import { NgxSpinnerService } from "ngx-spinner";
+import { Observable, finalize } from "rxjs";
+
+export const httpLoadingInterceptor: HttpInterceptorFn = (req, next) => {
+  const spinner = inject(NgxSpinnerService);
+  
+  const shouldSkipSpinner = req.params.has('X-Skip-Spinner'); // Using this for multiautocomplete, autocomplete, dropdown, table etc...
+
+  if (!shouldSkipSpinner)
+    spinner.show();
+
+  return next(req).pipe(
+    finalize(() => {
+      if (!shouldSkipSpinner){
+        spinner.hide();
+      }
+    })
+  ) as Observable<HttpEvent<any>>;
+}

package/src/lib/interceptors/json-parser.interceptor.ts

@@ -0,0 +1,44 @@
+import { HttpEvent, HttpResponse, HttpInterceptorFn } from '@angular/common/http';
+import { tap } from 'rxjs';
+
+export const jsonHttpInterceptor: HttpInterceptorFn = (req, next) => {
+  const dateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+
+  const convertDates = (
+    object: unknown,
+    parent?: Record<string, unknown> | unknown[],
+    key?: number | string,
+  ) => {
+    if (object === null) return;
+
+    if (typeof object === 'string') {
+      if (dateRegex.test(object)) {
+        /**
+         * @see https://stackoverflow.com/a/54733846/1306679
+         */
+
+        parent[key] = new Date(object);
+      }
+    } else if (Array.isArray(object)) {
+      for (let i = 0; i < object.length; i++)
+        convertDates(object[i], object, i);
+    } else {
+      for (const key of Object.keys(object as Record<string, unknown>)) {
+        convertDates(
+          (object as Record<string, unknown>)[key],
+          object as Record<string, unknown>,
+          key,
+        );
+      }
+    }
+  }
+
+  return next(req)
+    .pipe(
+      tap((event: HttpEvent<any>) => {
+        if (event instanceof HttpResponse) {
+          convertDates(event.body);
+        }
+      }
+  ));
+}

package/src/lib/interceptors/jwt.interceptor.ts

@@ -0,0 +1,18 @@
+import { inject } from '@angular/core';
+import { HttpInterceptorFn } from '@angular/common/http';
+import { ConfigBaseService } from '../services/config-base.service';
+
+export const jwtInterceptor: HttpInterceptorFn = (req, next) => {
+  const config = inject(ConfigBaseService);
+
+  const accessToken = localStorage.getItem('access_token');
+  const isApiUrl = req.url.startsWith(config.apiUrl);
+
+  if (accessToken && isApiUrl) {
+    req = req.clone({
+      setHeaders: { Authorization: `Bearer ${accessToken}` },
+    });
+  }
+
+  return next(req);
+}

package/src/lib/interceptors/unauthorized.interceptor.ts

@@ -0,0 +1,77 @@
+import { inject } from '@angular/core';
+import { HttpRequest, HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
+import { Observable, of, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { SpiderlyMessageService } from '../services/spiderly-message.service';
+import { TranslocoService } from '@jsverse/transloco';
+import { ConfigBaseService } from '../services/config-base.service';
+
+export const unauthorizedInterceptor: HttpInterceptorFn = (req, next) => {
+  const messageService = inject(SpiderlyMessageService);
+  const translocoService = inject(TranslocoService);
+  const config = inject(ConfigBaseService);
+
+  const handleAuthError = (err: HttpErrorResponse, request: HttpRequest<any>): Observable<any> => {
+    if (!config.production) {
+      console.error(err);
+    }
+
+    let errorResponse = err.error;
+
+    if (request.responseType != 'json')
+      errorResponse= JSON.parse(err.error);
+
+    if (err.status == 0) {
+      messageService.warningMessageWithTimeout( // FT: Had problem when the server is shut down, and try to refresh token, warning message didn't appear
+        translocoService.translate('ServerLostConnectionDetails'),
+        translocoService.translate('ServerLostConnectionTitle'),
+      );
+      return of(err.message);
+    } 
+    else if (err.status == 403) {
+      messageService.warningMessage(
+        translocoService.translate('PermissionErrorDetails'),
+        translocoService.translate('PermissionErrorTitle'),
+      );
+      return of(err.message);
+    } 
+    else if (err.status == 404) {
+      messageService.warningMessage(
+        translocoService.translate('NotFoundDetails'),
+        translocoService.translate('NotFoundTitle'),
+      );
+      return of(err.message);
+    } 
+    else if (err.status == 400 || err.status == 401) {
+      messageService.warningMessage(
+        errorResponse.message ?? translocoService.translate('BadRequestDetails'),
+        translocoService.translate('Warning'),
+      );
+
+      if(err.status == 401) {
+        // authService.logout();
+      }
+
+      return of(err.message);
+    } 
+    else if (err.status == 419) { // FT: We don't want to show error message to the user, we just log him out.
+      return of(err.message);
+    } 
+    else {
+      messageService.errorMessage(
+        errorResponse.message,
+        translocoService.translate('UnexpectedErrorTitle'),
+      );
+
+      return of(err.message);
+    }
+
+    return throwError(err);
+  }
+  
+  return next(req).pipe(
+    catchError((err) => {
+      return handleAuthError(err, req);
+    })
+  );
+}

package/src/lib/modules/core.module.ts

@@ -0,0 +1,22 @@
+import { EnvironmentProviders, makeEnvironmentProviders, APP_INITIALIZER, ErrorHandler } from "@angular/core";
+import { MessageService, ConfirmationService } from "primeng/api";
+import { authInitializer } from "../services/app-initializer";
+import { AuthBaseService } from "../services/auth-base.service";
+import { SpiderlyErrorHandler } from "../handlers/spiderly-error-handler";
+
+export function provideSpiderlyCore(): EnvironmentProviders {
+  return makeEnvironmentProviders([
+    MessageService,
+    ConfirmationService,
+    {
+      provide: APP_INITIALIZER,
+      useFactory: authInitializer,
+      multi: true,
+      deps: [AuthBaseService],
+    },
+    {
+      provide: ErrorHandler,
+      useClass: SpiderlyErrorHandler,
+    },
+  ]);
+}

package/src/lib/modules/primeng.module.ts

@@ -0,0 +1,122 @@
+import { NgModule } from '@angular/core';
+import { ButtonModule } from 'primeng/button';
+import { CheckboxModule } from 'primeng/checkbox';
+import { DialogModule } from 'primeng/dialog';
+import { SelectModule } from 'primeng/select';
+import { InputSwitchModule } from 'primeng/inputswitch';
+import { InputTextModule } from 'primeng/inputtext';
+import { TextareaModule } from 'primeng/textarea';
+import { MultiSelectModule } from 'primeng/multiselect';
+import { PasswordModule } from 'primeng/password';
+import { TableModule } from 'primeng/table';
+import { ToastModule } from 'primeng/toast';
+import { TooltipModule } from 'primeng/tooltip';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { SidebarModule } from 'primeng/sidebar';
+import { BadgeModule } from 'primeng/badge';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import { RippleModule } from 'primeng/ripple';
+import { DialogService } from 'primeng/dynamicdialog';
+import { PanelModule } from 'primeng/panel';
+import { AutoCompleteModule } from 'primeng/autocomplete';
+import { AvatarModule } from 'primeng/avatar';
+import { AvatarGroupModule } from 'primeng/avatargroup';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { DividerModule } from 'primeng/divider';
+import { InputNumberModule } from 'primeng/inputnumber';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { MenuModule } from 'primeng/menu';
+import { PaginatorModule } from 'primeng/paginator';
+import { EditorModule } from 'primeng/editor';
+import { InputGroupModule } from 'primeng/inputgroup';
+import { InputGroupAddonModule } from 'primeng/inputgroupaddon';
+import { TimelineModule } from 'primeng/timeline';
+import { CardModule } from 'primeng/card';
+import { ColorPickerModule } from 'primeng/colorpicker';
+import { FileUploadModule } from 'primeng/fileupload';
+import { DataViewModule } from 'primeng/dataview';
+import { DatePickerModule } from 'primeng/datepicker';
+
+@NgModule({
+  imports: [
+    TableModule,
+    ButtonModule,
+    MultiSelectModule,
+    InputTextModule,
+    TextareaModule,
+    SelectModule,
+    TooltipModule,
+    InputSwitchModule,
+    DialogModule,
+    DatePickerModule,
+    CheckboxModule,
+    PasswordModule,
+    ToastModule,
+    ConfirmDialogModule,
+    SidebarModule,
+    BadgeModule,
+    RadioButtonModule,
+    RippleModule,
+    PanelModule,
+    AutoCompleteModule,
+    AvatarModule,
+    AvatarGroupModule,
+    ProgressBarModule,
+    DividerModule,
+    InputNumberModule,
+    OverlayPanelModule,
+    MenuModule,
+    PaginatorModule,
+    EditorModule,
+    InputGroupModule,
+    InputGroupAddonModule,
+    TimelineModule,
+    CardModule,
+    ColorPickerModule,
+    FileUploadModule,
+    DataViewModule,
+  ],
+  exports: [
+    TableModule,
+    ButtonModule,
+    MultiSelectModule,
+    InputTextModule,
+    TextareaModule,
+    SelectModule,
+    TooltipModule,
+    InputSwitchModule,
+    DialogModule,
+    DatePickerModule,
+    CheckboxModule,
+    PasswordModule,
+    ToastModule,
+    ConfirmDialogModule,
+    SidebarModule,
+    BadgeModule,
+    RadioButtonModule,
+    RippleModule,
+    PanelModule,
+    AutoCompleteModule,
+    AvatarModule,
+    AvatarGroupModule,
+    ProgressBarModule,
+    DividerModule,
+    InputNumberModule,
+    OverlayPanelModule,
+    MenuModule,
+    PaginatorModule,
+    EditorModule,
+    InputGroupModule,
+    InputGroupAddonModule,
+    TimelineModule,
+    CardModule,
+    ColorPickerModule,
+    FileUploadModule,
+    DataViewModule
+  ],
+  declarations: [],
+  providers: [
+    DialogService,
+  ],
+})
+export class PrimengModule {}

package/src/lib/modules/spiderly-transloco.module.ts

@@ -0,0 +1,50 @@
+import { provideTransloco, TranslocoModule } from '@jsverse/transloco';
+import { EnvironmentProviders, importProvidersFrom, ModuleWithProviders, NgModule } from '@angular/core';
+
+import { SpiderlyTranslocoLoader } from '../services/spiderly-transloco-loader';
+import { provideTranslocoPreloadLangs } from '@jsverse/transloco-preload-langs';
+
+export function provideSpiderlyTransloco(config?: SpiderlyTranslocoConfig): EnvironmentProviders {
+  return importProvidersFrom(
+    SpiderlyTranslocoModule.forRoot(config)
+  );
+}
+
+@NgModule({
+  imports: [TranslocoModule],
+  exports: [TranslocoModule],
+})
+export class SpiderlyTranslocoModule {
+
+  static forRoot(config?: SpiderlyTranslocoConfig): ModuleWithProviders<SpiderlyTranslocoModule> {
+    return {
+      ngModule: SpiderlyTranslocoModule,
+      providers: [
+        provideTranslocoPreloadLangs(['sr-Latn-RS']),
+        provideTransloco({
+          config: {
+            availableLangs: config?.availableLangs ?? [
+              'en', 'en.generated',
+              'sr-Latn-RS', 'sr-Latn-RS.generated', 
+            ],
+            defaultLang: config?.defaultLang ?? 'en',
+            fallbackLang: config?.fallbackLang ?? 'en.generated',
+            missingHandler: {
+              useFallbackTranslation: true,
+              logMissingKey: false,
+            },
+            reRenderOnLangChange: true,
+          },
+          loader: SpiderlyTranslocoLoader
+        }),
+      ],
+    };
+  }
+
+}
+
+export interface SpiderlyTranslocoConfig {
+  availableLangs: string[];
+  defaultLang: string;
+  fallbackLang: string;
+}

package/src/lib/services/api.service.security.ts

@@ -0,0 +1,120 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Namebook } from '../entities/namebook';
+import { TableFilter } from '../entities/table-filter';
+import { Login, Registration, RegistrationVerificationResult, RefreshTokenRequest, AuthResult, Role, User, ExternalProvider, VerificationTokenRequest, RoleSaveBody, RoleMainUIForm } from '../entities/security-entities';
+import { ConfigBaseService } from './config-base.service';
+import { TableResponse } from '../entities/table-response';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ApiSecurityService {
+
+    constructor(
+        protected http: HttpClient,
+        protected config: ConfigBaseService
+    ) {
+        
+    }
+
+    //#region Authentication
+
+    register = (request: VerificationTokenRequest): Observable<AuthResult> => { 
+        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/Register`, request, this.config.httpOptions);
+    }
+
+    sendRegistrationVerificationEmail = (registrationDTO: Registration): Observable<RegistrationVerificationResult> => { 
+        return this.http.post<RegistrationVerificationResult>(`${this.config.apiUrl}/Security/SendRegistrationVerificationEmail`, registrationDTO, this.config.httpOptions);
+    }
+    
+    login = (request: VerificationTokenRequest): Observable<AuthResult> => { 
+        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/Login`, request, this.config.httpOptions);
+    }
+
+    loginExternal = (externalProviderDTO: ExternalProvider): Observable<AuthResult> => { 
+        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/LoginExternal`, externalProviderDTO, this.config.httpOptions);
+    }
+
+    sendLoginVerificationEmail = (loginDTO: Login): Observable<any> => { 
+        return this.http.post<any>(`${this.config.apiUrl}/Security/SendLoginVerificationEmail`, loginDTO, this.config.httpOptions);
+    }
+
+
+    logout = (browserId: string): Observable<any> => { 
+        return this.http.get<any>(`${this.config.apiUrl}/Security/Logout?browserId=${browserId}`);
+    }
+
+    refreshToken = (request: RefreshTokenRequest): Observable<AuthResult> => { 
+        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/RefreshToken`, request, this.config.httpOptions);
+    }
+
+    //#endregion
+
+    //#region User
+
+    getCurrentUser = (): Observable<User> => { 
+        return this.http.get<User>(`${this.config.apiUrl}/Security/GetCurrentUser`, this.config.httpSkipSpinnerOptions);
+    }
+
+    getCurrentUserPermissionCodes = (): Observable<string[]> => { 
+        return this.http.get<string[]>(`${this.config.apiUrl}/Security/GetCurrentUserPermissionCodes`, this.config.httpSkipSpinnerOptions);
+    }
+
+    //#endregion
+
+    //#region Role
+
+    getRoleTableData = (dto: TableFilter): Observable<TableResponse> => { 
+        return this.http.post<TableResponse>(`${this.config.apiUrl}/Security/GetRoleTableData`, dto, this.config.httpSkipSpinnerOptions);
+    }
+
+    exportRoleTableDataToExcel = (dto: TableFilter): Observable<any> => { 
+        return this.http.post<any>(`${this.config.apiUrl}/Security/ExportRoleTableDataToExcel`, dto, this.config.httpOptions);
+    }
+
+    deleteRole = (id: number): Observable<any> => { 
+        return this.http.delete<any>(`${this.config.apiUrl}/Security/DeleteRole?id=${id}`);
+    }
+
+    getRoleMainUIFormDTO = (id: number): Observable<RoleMainUIForm> => {
+        return this.http.get<RoleMainUIForm>(`${this.config.apiUrl}/Security/GetRoleMainUIFormDTO?id=${id}`);
+    }
+
+    getRole = (id: number): Observable<Role> => {
+        return this.http.get<Role>(`${this.config.apiUrl}/Security/GetRole?id=${id}`);
+    }
+
+    saveRole = (dto: RoleSaveBody): Observable<Role> => { 
+        return this.http.put<Role>(`${this.config.apiUrl}/Security/SaveRole`, dto, this.config.httpOptions);
+    }
+
+    getUsersNamebookListForRole = (roleId: number): Observable<Namebook[]> => {
+        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetUsersNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);
+    }
+
+    getPermissionsDropdownListForRole = (): Observable<Namebook[]> => {
+        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetPermissionsDropdownListForRole`, this.config.httpSkipSpinnerOptions);
+    }
+
+    getPermissionsNamebookListForRole = (roleId: number): Observable<Namebook[]> => {
+        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetPermissionsNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);
+    }
+
+    getUsersAutocompleteListForRole = (limit: number, query: string): Observable<Namebook[]> => {
+        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetUsersAutocompleteListForRole?limit=${limit}&query=${query}`, this.config.httpSkipSpinnerOptions);
+    }
+
+    //#endregion
+
+    //#region Notification
+
+    getUnreadNotificationsCountForCurrentUser = (): Observable<number> => { 
+        return this.http.get<number>(`${this.config.apiUrl}/Notification/GetUnreadNotificationsCountForCurrentUser`, this.config.httpSkipSpinnerOptions);
+    }
+
+    //#endregion
+
+}
+

package/src/lib/services/app-initializer.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { AuthBaseService } from './auth-base.service';
+import { AuthResult } from '../entities/security-entities';
+
+export function authInitializer(authService: AuthBaseService): () => Observable<AuthResult> {
+  return () => {
+    return authService.refreshToken();
+  };
+}