@qbs-origin/origin-form 0.5.0

package/README.md

@@ -0,0 +1,24 @@
+# OriginForm
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project origin-form` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project origin-form`.
+> Note: Don't forget to add `--project origin-form` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build origin-form` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build origin-form`, go to the dist folder `cd dist/origin-form` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test origin-form` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2022/lib/action-step-handler.mjs

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core';
+import { Subject, firstValueFrom } from 'rxjs';
+import { FluxType } from './models/forms.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/applicationData.service";
+import * as i2 from "./services/dialog.service";
+export class ActionStepHandler {
+    constructor(applicationDataService, dialog) {
+        this.applicationDataService = applicationDataService;
+        this.dialog = dialog;
+        this.isExecuting = false;
+        this.executionCompleted = new Subject();
+        this.actionExecuting$ = new Subject();
+        this.actionCompleted$ = this.executionCompleted.asObservable();
+    }
+    /**
+     * Checks if a step is an action step that should be handled automatically
+     */
+    isActionStep(step) {
+        return step.type === FluxType.Status || step.type === FluxType.Action;
+    }
+    /**
+     * Filters out action steps from the visible steps array
+     */
+    filterVisibleSteps(steps, stepIds = []) {
+        var visibleSteps = steps.filter((step) => !this.isActionStep(step));
+        if (stepIds?.length > 0) {
+            visibleSteps = visibleSteps.filter((s) => stepIds.includes(s.identifier));
+        }
+        return visibleSteps;
+    }
+    /**
+     * Gets action steps that should be executed when moving to the next step
+     */
+    getActionStepsAtIndex(allSteps, currentVisibleStepIndex) {
+        const visibleSteps = this.filterVisibleSteps(allSteps);
+        const actionSteps = [];
+        // Find the current visible step in the original flux
+        if (currentVisibleStepIndex < visibleSteps.length) {
+            const currentVisibleStep = visibleSteps[currentVisibleStepIndex];
+            const currentVisibleStepIndexInFlux = allSteps.findIndex((step) => step.identifier === currentVisibleStep.identifier);
+            // Check for action steps immediately after current step in the original flux
+            for (let i = currentVisibleStepIndexInFlux + 1; i < allSteps.length; i++) {
+                const step = allSteps[i];
+                if (this.isActionStep(step)) {
+                    actionSteps.push(step);
+                }
+                else {
+                    // Stop at first non-action step (next visible step)
+                    break;
+                }
+            }
+        }
+        return actionSteps;
+    }
+    /**
+     * Executes action steps automatically
+     */
+    async executeActionSteps(actionSteps, appDataUuid, onStepStart) {
+        if (this.isExecuting || actionSteps.length === 0) {
+            return { success: true };
+        }
+        this.isExecuting = true;
+        this.actionExecuting$.next(true);
+        try {
+            for (let i = 0; i < actionSteps.length; i++) {
+                const step = actionSteps[i];
+                const isLastStep = i === actionSteps.length - 1;
+                const shouldSetNextStep = !isLastStep;
+                if (onStepStart) {
+                    onStepStart(step);
+                }
+                console.log(`🎬 Executing action step ${i + 1}/${actionSteps.length}: ${step.identifier}, setNextStep: ${shouldSetNextStep}`);
+                const result = await this.executeActionStep(step, appDataUuid, shouldSetNextStep);
+                if (!result.success) {
+                    console.error(`❌ Action step ${step.identifier} failed:`, result.error);
+                    let errorContent = 'unknown';
+                    if (result.error) {
+                        errorContent = result.error;
+                    }
+                    else if (result.data.errorMessage) {
+                        errorContent = result.data.errorMessage;
+                    }
+                    this.dialog.popError('flux.components.action.failedToExecuteWithParams', errorContent);
+                    this.isExecuting = false;
+                    this.actionExecuting$.next(false);
+                    this.executionCompleted.next(result);
+                    return result;
+                }
+                console.log(`✅ Action step ${step.identifier} completed successfully`);
+                // Add a small delay between action steps to prevent change detection conflicts
+                if (!isLastStep) {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+            }
+            const successResult = { success: true };
+            // Use setTimeout to ensure the completion notification happens outside the current change detection cycle
+            setTimeout(() => {
+                this.isExecuting = false;
+                this.actionExecuting$.next(false);
+                this.executionCompleted.next(successResult);
+            }, 0);
+            return successResult;
+        }
+        catch (error) {
+            const errorResult = { success: false, error };
+            // Use setTimeout to ensure the error notification happens outside the current change detection cycle
+            setTimeout(() => {
+                this.isExecuting = false;
+                this.actionExecuting$.next(false);
+                this.executionCompleted.next(errorResult);
+            }, 0);
+            return errorResult;
+        }
+    }
+    /**
+     * Executes a single action step
+     */
+    async executeActionStep(step, appDataUuid, setNextStep = false) {
+        try {
+            let result;
+            if (step.type === FluxType.Action) {
+                const actionRequest = {
+                    appDataId: appDataUuid,
+                    stepId: step.identifier,
+                    setNextStep: setNextStep,
+                };
+                result = await firstValueFrom(this.applicationDataService.makeActionApiCall(actionRequest));
+                return { success: result.success, data: result };
+            }
+            else if (step.type === FluxType.Status) {
+                result = await firstValueFrom(this.applicationDataService.makeStatusApiCall(appDataUuid, step.identifier, setNextStep));
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            console.error(`Error executing action step ${step.identifier}:`, error);
+            return { success: false, error };
+        }
+    }
+    /**
+     * Checks if currently executing actions
+     */
+    get isExecutingActions() {
+        return this.isExecuting;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.executionCompleted.complete();
+        this.actionExecuting$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ActionStepHandler, deps: [{ token: i1.ApplicationDataService }, { token: i2.DialogService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ActionStepHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ActionStepHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ApplicationDataService }, { type: i2.DialogService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-step-handler.js","sourceRoot":"","sources":["../../../../projects/origin-form/src/lib/action-step-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject, firstValueFrom } from 'rxjs';\nimport { MakeActionRequest } from './models/application.model';\nimport { FluxType } from './models/forms.model';\nimport { ApplicationDataService } from './services/applicationData.service';\nimport { DialogService } from './services/dialog.service';\nimport { StepData } from './models/flux.model';\n\nexport interface ActionStepResult {\n  success: boolean;\n  data?: any;\n  error?: any;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ActionStepHandler {\n  private isExecuting = false;\n  private executionCompleted = new Subject<ActionStepResult>();\n\n  public actionExecuting$ = new Subject<boolean>();\n  public actionCompleted$ = this.executionCompleted.asObservable();\n\n  constructor(private applicationDataService: ApplicationDataService, private dialog: DialogService) { }\n\n  /**\n   * Checks if a step is an action step that should be handled automatically\n   */\n  isActionStep(step: StepData): boolean {\n    return step.type === FluxType.Status || step.type === FluxType.Action;\n  }\n\n  /**\n   * Filters out action steps from the visible steps array\n   */\n  filterVisibleSteps(steps: StepData[], stepIds: string[] = []): StepData[] {\n    var visibleSteps = steps.filter((step) => !this.isActionStep(step));\n    if (stepIds?.length > 0) {\n      visibleSteps = visibleSteps.filter((s) => stepIds.includes(s.identifier));\n    }\n    return visibleSteps;\n  }\n\n  /**\n   * Gets action steps that should be executed when moving to the next step\n   */\n  getActionStepsAtIndex(\n    allSteps: StepData[],\n    currentVisibleStepIndex: number\n  ): StepData[] {\n    const visibleSteps = this.filterVisibleSteps(allSteps);\n    const actionSteps: StepData[] = [];\n\n    // Find the current visible step in the original flux\n    if (currentVisibleStepIndex < visibleSteps.length) {\n      const currentVisibleStep = visibleSteps[currentVisibleStepIndex];\n      const currentVisibleStepIndexInFlux = allSteps.findIndex(\n        (step) => step.identifier === currentVisibleStep.identifier\n      );\n\n      // Check for action steps immediately after current step in the original flux\n      for (\n        let i = currentVisibleStepIndexInFlux + 1;\n        i < allSteps.length;\n        i++\n      ) {\n        const step = allSteps[i];\n        if (this.isActionStep(step)) {\n          actionSteps.push(step);\n        } else {\n          // Stop at first non-action step (next visible step)\n          break;\n        }\n      }\n    }\n\n    return actionSteps;\n  }\n\n  /**\n   * Executes action steps automatically\n   */\n  async executeActionSteps(\n    actionSteps: StepData[],\n    appDataUuid: string,\n    onStepStart?: (step: any) => void\n  ): Promise<ActionStepResult> {\n    if (this.isExecuting || actionSteps.length === 0) {\n      return { success: true };\n    }\n\n    this.isExecuting = true;\n    this.actionExecuting$.next(true);\n\n    try {\n      for (let i = 0; i < actionSteps.length; i++) {\n        const step = actionSteps[i];\n        const isLastStep = i === actionSteps.length - 1;\n        const shouldSetNextStep = !isLastStep;\n        if (onStepStart) {\n          onStepStart(step);\n        }\n\n        console.log(\n          `🎬 Executing action step ${i + 1}/${actionSteps.length}: ${step.identifier\n          }, setNextStep: ${shouldSetNextStep}`\n        );\n\n        const result = await this.executeActionStep(\n          step,\n          appDataUuid,\n          shouldSetNextStep\n        );\n\n        if (!result.success) {\n          console.error(`❌ Action step ${step.identifier} failed:`, result.error);\n          let errorContent = 'unknown';\n          if (result.error) {\n            errorContent = result.error;\n          }\n          else if (result.data.errorMessage) {\n            errorContent = result.data.errorMessage;\n          }\n          this.dialog.popError('flux.components.action.failedToExecuteWithParams', errorContent);\n          this.isExecuting = false;\n          this.actionExecuting$.next(false);\n          this.executionCompleted.next(result);\n          return result;\n        }\n\n        console.log(`✅ Action step ${step.identifier} completed successfully`);\n\n        // Add a small delay between action steps to prevent change detection conflicts\n        if (!isLastStep) {\n          await new Promise((resolve) => setTimeout(resolve, 10));\n        }\n      }\n\n      const successResult: ActionStepResult = { success: true };\n\n      // Use setTimeout to ensure the completion notification happens outside the current change detection cycle\n      setTimeout(() => {\n        this.isExecuting = false;\n        this.actionExecuting$.next(false);\n        this.executionCompleted.next(successResult);\n      }, 0);\n\n      return successResult;\n    } catch (error) {\n      const errorResult: ActionStepResult = { success: false, error };\n\n      // Use setTimeout to ensure the error notification happens outside the current change detection cycle\n      setTimeout(() => {\n        this.isExecuting = false;\n        this.actionExecuting$.next(false);\n        this.executionCompleted.next(errorResult);\n      }, 0);\n\n      return errorResult;\n    }\n  }\n\n  /**\n   * Executes a single action step\n   */\n  private async executeActionStep(\n    step: StepData,\n    appDataUuid: string,\n    setNextStep: boolean = false\n  ): Promise<ActionStepResult> {\n    try {\n      let result: any;\n      if (step.type === FluxType.Action) {\n        const actionRequest: MakeActionRequest = {\n          appDataId: appDataUuid,\n          stepId: step.identifier,\n          setNextStep: setNextStep,\n        };\n\n        result = await firstValueFrom(\n          this.applicationDataService.makeActionApiCall(actionRequest)\n        );\n        return { success: result.success, data: result };\n      } else if (step.type === FluxType.Status) {\n        result = await firstValueFrom(\n          this.applicationDataService.makeStatusApiCall(\n            appDataUuid,\n            step.identifier,\n            setNextStep,\n          )\n        );\n      }\n      return { success: true, data: result };\n    } catch (error) {\n      console.error(`Error executing action step ${step.identifier}:`, error);\n      return { success: false, error };\n    }\n  }\n\n  /**\n   * Checks if currently executing actions\n   */\n  get isExecutingActions(): boolean {\n    return this.isExecuting;\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    this.executionCompleted.complete();\n    this.actionExecuting$.complete();\n  }\n}\n"]}

package/esm2022/lib/auth-client.service.mjs

@@ -0,0 +1,69 @@
+import { HttpHeaders, } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { catchError, throwError } from 'rxjs';
+import { ConfigService } from './others/config-service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+export class AuthenticationClient {
+    constructor(http, router) {
+        this.http = http;
+        this.router = router;
+        this.configService = inject(ConfigService);
+        this.headers = new HttpHeaders({
+            'Content-Type': 'application/x-www-form-urlencoded',
+        });
+    }
+    // public login(
+    //   username: string,
+    //   password: string
+    // ): Observable<AuthResponseDto> {
+    //   const formData: UserForAuthenticationDto = {
+    //     client_id: this.configService.readConfig().clientId,
+    //     client_secret: this.configService.readConfig().clientSecret,
+    //     grant_type: 'password',
+    //     username: username,
+    //     password: password,
+    //     scope: this.configService.readConfig().clientScope,
+    //   };
+    //   return this.http.post<AuthResponseDto>(
+    //     this.configService.readConfig().baseUrlGateway + '/connect/token',
+    //     this.urlEncodeFormData(formData),
+    //     { headers: this.headers }
+    //   );
+    // }
+    refreshToken(refreshToken) {
+        var clientId = this.configService.readConfig().clientId;
+        const formData = {
+            client_id: clientId,
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+        };
+        return this.http
+            .post(this.configService.readConfig().baseUrlGateway + '/connect/token', this.urlEncodeFormData(formData), { headers: this.headers })
+            .pipe(catchError((error) => {
+            if (error.status === 401 || error.status === 400) {
+                this.router.navigate(['/login']);
+            }
+            return throwError(error);
+        }));
+    }
+    urlEncodeFormData(formData) {
+        const urlEncodedParams = new URLSearchParams();
+        for (const key in formData) {
+            if (Object.prototype.hasOwnProperty.call(formData, key)) {
+                urlEncodedParams.append(key, formData[key]);
+            }
+        }
+        return urlEncodedParams.toString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationClient, deps: [{ token: i1.HttpClient }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationClient, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.Router }] });
+//# sourceMappingURL=data:application/json;base64,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