@futdevpro/fsm-dynamo 1.15.20 → 1.15.22

package/src/_modules/ngx-models/_models/control-models/chat/chat-column-layout-settings.control-model.ts

@@ -0,0 +1,28 @@
+/**
+ * CCAP-mirror Wave-1a — ChatColumnLayout POJO.
+ *
+ * A `DyNX_ChatColumnLayout_Component` (3-slot flex container) konfigurációja.
+ * Wave-1 minimal: csak height-override, header/composer slot-flag.
+ *
+ * @see _specifications/ccap-mirror/02-architecture-spec.md (G + L szakasz)
+ */
+export class DyFM_ChatColumnLayout_Settings {
+  /** Header slot megjelenjen-e (ha hamis, csak content + composer). Default true. */
+  headerSlotEnabled?: boolean;
+
+  /** Composer slot megjelenjen-e. Default true. */
+  composerSlotEnabled?: boolean;
+
+  /** Overlay anchor slot megjelenjen-e (FAB/panel-stack az composer felett). Default true. */
+  overlaySlotEnabled?: boolean;
+
+  /** Container height override. Pl. `'100vh'` vagy `'500px'`. Default: `'100%'`. */
+  heightCss?: string;
+
+  /** `data-testid`. */
+  testId?: string;
+
+  constructor(set: Partial<DyFM_ChatColumnLayout_Settings> = {}) {
+    Object.assign(this, set);
+  }
+}

package/src/_modules/ngx-models/_models/control-models/data-handler-settings.control-model.spec.ts

@@ -0,0 +1,91 @@
+/* 
+import { DyFM_Metadata } from '../../../..';
+
+import { DyFM_SignalDataHandler, DyFM_SignalDataHandler_Settings } from './data-handler-settings.control-model';
+
+interface TestMetadata extends DyFM_Metadata {
+  _id: string;
+}
+
+describe('| DyFM_SignalDataHandler', () => {
+  let dataHandler: DyFM_SignalDataHandler<TestMetadata>;
+  let mockSettings: DyFM_SignalDataHandler_Settings<TestMetadata>;
+
+  beforeEach(() => {
+    mockSettings = {
+      name: 'TestHandler',
+      get: async (loadBy?: string) => ({ _id: loadBy || 'default' }),
+      set: async (data: TestMetadata) => data,
+      successfulLoadCallBack: jasmine.createSpy('successfulLoadCallBack'),
+      getPostProcess: (data: any) => data as TestMetadata,
+      noId: false,
+      debugLog: false,
+    };
+
+    dataHandler = new (class extends DyFM_SignalDataHandler<TestMetadata> {
+      data_$ = {
+        set: jasmine.createSpy('set'),
+        (): TestMetadata {
+          return { _id: 'default' };
+        },
+      };
+      loadInProgress_$ = {
+        set: jasmine.createSpy('set'),
+        (): false | { loadBy: string; progress: Promise<any> } {
+          return false;
+        },
+      };
+    })(mockSettings);
+  });
+
+  it('| should initialize with provided settings', () => {
+    expect(dataHandler.dhName).toBe('TestHandler');
+    expect(dataHandler.noId).toBe(false);
+    expect(dataHandler.debugLog).toBe(false);
+  });
+
+  it('| should call get function and process result on reloadData', async () => {
+    const result = await dataHandler.reloadData('testId');
+    expect(result._id).toBe('testId');
+    expect(dataHandler.data_$.set).toHaveBeenCalledWith(result);
+    expect(mockSettings.successfulLoadCallBack).toHaveBeenCalledWith(result);
+  });
+
+  it('| should throw error if no ID is provided and noId is false', async () => {
+    dataHandler.noId = false;
+    await expectAsync(dataHandler.reloadData()).toBeRejectedWithError('DynamoERROR: Missing ID! (TestHandler)');
+  });
+
+  it('| should update data using set function', async () => {
+    const newData: TestMetadata = { _id: 'newId' };
+    await dataHandler.updateData(newData);
+    expect(dataHandler.data_$.set).toHaveBeenCalledWith(newData);
+  });
+
+  it('| should clear data and lastLoadedBy', () => {
+    dataHandler.clear();
+    expect(dataHandler.data_$.set).toHaveBeenCalledWith(undefined);
+    expect(dataHandler.lastLoadedBy).toBeUndefined();
+  });
+
+  it('| should add dependency data handler', () => {
+    const dependentHandler = new (class extends DyFM_SignalDataHandler<TestMetadata> {
+      data_$ = {
+        set: jasmine.createSpy('set'),
+        (): TestMetadata {
+          return { _id: 'dependent' };
+        },
+      };
+      loadInProgress_$ = {
+        set: jasmine.createSpy('set'),
+        (): false | { loadBy: string; progress: Promise<any> } {
+          return false;
+        },
+      };
+    })(mockSettings);
+
+    dataHandler.addDependencyDataHandler(dependentHandler);
+    expect(dependentHandler.successfulLoadCallBacks.length).toBeGreaterThan(0);
+  });
+});
+ */

package/src/_modules/ngx-models/_models/control-models/data-handler-settings.control-model.ts

@@ -0,0 +1,135 @@
+import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult } from '../../../..';
+import { BehaviorSubject } from 'rxjs';
+
+import { DyFM_WritableSignalPlaceholder } from '../../_collections/angular-placeholders';
+import { DyFM_SignalDataHandler, DyFM_SignalDataHandlerDataLoadPostProcess } from './data-handler.control-model';
+
+
+/**
+ * DyFM_DataHandler_Settings
+ * @param apiService any service can be used as apiService
+ * as long as the function, you pass in getDataFunctionName exists,
+ * uses (or not uses an ID as input) and returns the data as Promise<Type>
+ * @param getDataFunctionName the function name on the apiService,
+ * that will be used as get api call
+ *
+ * @param successfulReloadCallBack you can create direct callback for successful reloads
+ * by passing it here
+ *
+ * @param getPostPreprocessLoad post processes can be implemented to ensure special conditions on data
+ *
+ * @param defaultValue you can set default value that will be used before any load
+ * @param noId this flag needs to be true, when using api function without id
+ *
+ * @example
+ * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
+ *   apiService: this.accountApiService,
+ *   getDataFunctionName: 'getPersonalInformation',
+ * });
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export class DyFM_SignalDataHandler_Settings<
+  T extends DyFM_Metadata | DyFM_Metadata[],
+  T_Dependency extends DyFM_Metadata = any,
+  T_LoadBy = string
+> {
+  name?: string;
+
+  /** this will be used to get the data from the API
+   * while creating arrow function for this, dont forget to use async n await! */
+  get?: (loadBy?: T_LoadBy) => Promise<any>;
+  /** this will be used to set the data to the data handler
+   * while creating arrow function for this, dont forget to use async n await! */
+  set?: (data: T) => Promise<T>;
+  /* patch?: (data: T) => Promise<T>; */
+
+  // TODO
+  /* directApiSetup?: { set, get,}; */
+  // AVAGY
+  /* apiCallSettings?: DyNX_ApiCall_Settings; */
+
+  /* successfulLoadCallBack?: (data: T) => void; */
+
+  /**
+   * post processes will be called as pipes after data is loaded by get function,
+   * but before data is set to data handler by data_$.set (after get, before Signal triggers)
+   */
+  getPostProcess?: DyFM_SignalDataHandlerDataLoadPostProcess<T_LoadBy>;
+
+  dependencyDataHandler?: DyFM_SignalDataHandler<T_Dependency>;
+  dependentDataHandlers?: DyFM_SignalDataHandler<any>[];
+
+  defaultValue?: T;
+  noId?: boolean;
+  createObservable?: boolean;
+
+  /** if set to 0, loop safety will be disabled */
+  loopSafety?: number;
+  debugLog?: boolean;
+}
+
+/**
+ * DyFM_SignalDataListHandler_Settings
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export class DyFM_SignalDataListHandler_Settings<
+  T_DataItem extends DyFM_Metadata,
+  T_DependencyData extends DyFM_Metadata = any,
+  T_DataLoadBy = string,
+  T_UpdateItemBy = string,
+> extends DyFM_SignalDataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
+  /** this will be used to send the item update to the API
+   * while creating arrow function for this, dont forget to use async n await! */
+  setItem?: (item: T_DataItem, updateBy?: T_UpdateItemBy) => Promise<T_DataItem>;
+  /** this will be used to send the item delete to the API
+   * while creating arrow function for this, dont forget to use async n await! */
+  deleteItem?: (id: string, updateBy?: T_UpdateItemBy) => Promise<void>;
+
+  /** if true, the active item will not be set by default */
+  dontDefaultSetActiveItem?: boolean;
+}
+
+/**
+ * DyFM_SignalDataSearchHandler_Settings
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export class DyFM_SignalDataSearchHandler_Settings<
+  T_DataItem extends DyFM_Metadata,
+  T_DataLoadBy extends DyFM_SearchQuery<any> = DyFM_SearchQuery<T_DataItem>,
+  /* T_Result extends DyFM_SearchResult<any> = DyFM_SearchResult<T_DataItem>, */
+  T_DependencyData extends DyFM_Metadata = any,
+> extends DyFM_SignalDataHandler_Settings<T_DataItem[], T_DependencyData, T_DataLoadBy> {
+  defaultQuery?: T_DataLoadBy;
+  defaultPageSize?: number;
+  cacheSize?: number;
+  queryUpdateDebounceTime?: number;
+  searchOnInit?: boolean;
+}
+
+/**
+ * DyFM_SignalListCollectorDataHandler_Settings
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export class DyFM_SignalListCollectorDataHandler_Settings<
+  T_ListCollectorData extends DyFM_Metadata,
+  T_DataItem extends DyFM_Metadata,
+  T_DependencyData extends DyFM_Metadata = any,
+  T_DataLoadBy = string,
+> extends DyFM_SignalDataHandler_Settings<T_ListCollectorData, T_DependencyData, T_DataLoadBy> {
+  /** this will be used to send the item update to the API
+   * while creating arrow function for this, dont forget to use async n await! */
+  setItem?: (item: T_DataItem, collectorId?: string) => Promise<T_DataItem>;
+  /** this will be used to send the item delete to the API
+   * while creating arrow function for this, dont forget to use async n await! */
+  deleteItem?: (id: string, collectorId?: string) => Promise<void>;
+
+  listKey: string;
+}