cat-qw-lib 0.64.16 → 1.0.0

package/ng-package.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/cat-qw-lib",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "assets": [
+ "src/assets"
+  ]
+}

package/package.json

@@ -1,25 +1,16 @@
-{
-  "name": "cat-qw-lib",
-  "version": "0.64.16",
-  "peerDependencies": {
-    "@angular/common": "^19.0.0",
-    "@angular/core": "^19.0.0"
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
-  },
-  "typings": "index.d.ts",
-  "main": "bundles/cat-qw-lib.umd.js",
-  "module": "fesm2022/cat-qw-lib.mjs",
-  "es2015": "fesm2015/cat-qw-lib.js",
-  "sideEffects": false,
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/cat-qw-lib.mjs"
-    }
-  }
-}
+{
+  "name": "cat-qw-lib",
+  "version": "1.0.0",
+  "peerDependencies": {
+    "@angular/common": "^19.0.0",
+    "@angular/core": "^19.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "typings": "index.d.ts",
+  "main": "bundles/cat-qw-lib.umd.js",
+  "module": "fesm2015/cat-qw-lib.js",
+  "es2015": "fesm2015/cat-qw-lib.js",
+  "sideEffects": false
+}

package/src/lib/admin/action-admin/action-admin.module.ts

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AdminActionListComponent } from './components/admin-action-list/admin-action-list.component';
+import { CheckBoxComponent, SharedModule, TablePrimaryComponent } from '../../shared';
+import { AdminActionFormComponent } from './components/admin-action-form/admin-action-form.component';
+import { FormsModule } from '@angular/forms';
+import { TextAreaComponent } from '../../shared/controls/text-area/text-area.component';
+import { ButtonModule } from 'primeng/button';
+
+
+
+@NgModule({
+  declarations: [AdminActionListComponent, AdminActionFormComponent],
+  imports: [
+    CommonModule,
+    FormsModule,
+    SharedModule,
+    TablePrimaryComponent,
+    TextAreaComponent,
+    ButtonModule,
+    CheckBoxComponent
+  ],
+  exports: [AdminActionListComponent, AdminActionFormComponent]
+})
+export class ActionAdminModule { }

package/src/lib/admin/action-admin/components/admin-action-form/admin-action-form.component.html

@@ -0,0 +1,113 @@
+<form-container
+  [record]="record"
+  [headerText]="'Actions / Actions Form'"
+  [messages]="messages"
+  (onSave)="handleSubmit()"
+  [showSave]="true"
+  (onCancel)="handleCancel()"
+>
+    <div class="card p-fluid p-formgrid grid ">
+      <h4 class="font-bold col-12 md:col-12">Actions Form</h4>
+      <div class="col-12 md:col-5">
+        <text-box
+          [store]="adminActionStore"
+          [record]="record"
+          [attributeModel]="{
+            readonly: false,
+            name: 'name',
+            isRequired: true,
+            displayText: 'Action Name',
+            placeholder: 'Enter Action Name'
+          }"
+        ></text-box>
+      </div>
+    
+      <div class="col-12 md:col-5">
+        <dropdown
+        [store]="adminActionStore"
+        [record]="record"
+        [attributeModel]="{
+          name: 'apiConfigId',
+          readonly: false,
+          isRequired: true,
+          displayText: 'End Point',
+          placeholder: 'Select End Point'
+        }"></dropdown>
+      </div>
+
+      <div class="col-2 md:col-2 mt-5">
+        <check-box [store]="adminActionStore" [record]="record" [attributeModel]="{
+                                                      name:'isActive',
+                                                      displayText : 'Active',
+                                                    }">
+        </check-box>
+    </div>
+
+       <div class="col-12 md:col-6">
+        <dropdown
+        [store]="adminActionStore"
+        [record]="record"
+        [attributeModel]="{
+          name:'queueId',
+          isRequired: true,
+          displayText : 'Queue',
+          placeholder: 'Select Queue',
+          readonly: false
+        }"></dropdown>
+       </div>
+
+       <div class="col-12 md:col-6">
+        <text-box
+          [store]="adminActionStore"
+          [record]="record"
+          [attributeModel]="{
+            readonly: false,
+            name: 'apiDocsUrl',
+            isRequired: false,
+            displayText: 'API Docs URL',
+            placeholder: 'Enter API Docs URL'
+          }"
+        ></text-box>
+       </div>
+
+      <div class="col-12 md:col-12">
+        <text-area
+         [store]="adminActionStore"
+         [record]="record"
+         [attributeModel]="{
+           readonly: false,
+           name: 'prompt',
+           isRequired: true,
+           displayText: 'Prompt',
+           placeholder: 'Enter prompt'
+         }"
+       ></text-area>
+       </div>
+
+       <div class="w-full flex justify-content-end px-2 mt-2">
+        <button
+          pButton
+          pRipple
+          type="button"
+          label="Validate"
+          class="p-button-raised validate-btn-wrapper"
+          (click)="handleValidateAction()"
+        ></button>
+       </div>
+
+       <div class="col-12 md:col-12">
+        <text-area
+         [store]="adminActionStore"
+         [record]="record"
+         [attributeModel]="{
+           readonly: false,
+           name: 'formFields',
+           isRequired: true,
+           displayText: 'Form Configuration',
+           placeholder: 'Enter form fields'
+         }"
+       ></text-area>
+       </div>
+    </div>
+      
+</form-container>

package/src/lib/admin/action-admin/components/admin-action-form/admin-action-form.component.scss

@@ -0,0 +1,4 @@
+.validate-btn-wrapper{
+    width: 15%;
+    padding: 0.8rem 1rem !important;
+  }

package/src/lib/admin/action-admin/components/admin-action-form/admin-action-form.component.spec.ts

@@ -0,0 +1,119 @@
+import { ComponentFixture, fakeAsync, TestBed, tick } from '@angular/core/testing';
+import { AdminActionFormComponent } from './admin-action-form.component';
+import { ActivatedRoute } from '@angular/router';
+import { AppConfigService, BaseService, ERROR, ROUTES, SHARED, TextBoxComponent } from '../../../../shared';
+import { FormContainerComponent } from '../../../../shared/components/form-container/form-container.component';
+import { DropdownComponent } from '../../../../shared/controls/dropdown/dropdown.component';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { TextAreaComponent } from '../../../../shared/controls/text-area/text-area.component';
+import { AdminActionService } from '../../state/admin-action.service';
+import { MESSAGE } from '../../../../shared/constant/MESSAGES';
+import { of, throwError } from 'rxjs';
+import { AdminActionModel } from '../../models/admin-action.model';
+import { ValidatorService } from '../../../../shared/services/validator.service';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+
+describe('AdminActionFormComponent', () => {
+  let component: AdminActionFormComponent;
+  let fixture: ComponentFixture<AdminActionFormComponent>;
+  let adminActionService: jasmine.SpyObj<AdminActionService>;
+  let appConfigService: jasmine.SpyObj<AppConfigService>;
+  let activatedRouteMock: any;
+  let baseService: jasmine.SpyObj<BaseService<any>>;
+  let validatorService: jasmine.SpyObj<any>;
+
+  beforeEach(async () => {
+    const adminActionServiceSpy = jasmine.createSpyObj('AdminActionService', ['handleValidateAction', 'handleSubmit', 'initList']);
+    const appConfigServiceSpy = jasmine.createSpyObj('AppConfigService', ['swaggerUrl']);
+    const baseServiceSpy = jasmine.createSpyObj('BaseService', ['create', 'update']);
+    const validatorServiceSpy = jasmine.createSpyObj('ValidatorService', ['handleValidateRecords']);
+    await TestBed.configureTestingModule({
+      declarations: [AdminActionFormComponent],
+      imports: [HttpClientTestingModule, FormContainerComponent, TextBoxComponent, DropdownComponent, TextAreaComponent],
+      providers: [
+        { provide: ActivatedRoute, useValue: activatedRouteMock },
+        { provide: AdminActionService, useValue: adminActionServiceSpy },
+        { provide: AppConfigService, useValue: appConfigServiceSpy },
+        { provide: BaseService, useValue: baseServiceSpy },
+        { provide: ValidatorService, useValue: validatorServiceSpy }
+      ],
+      schemas: [NO_ERRORS_SCHEMA]
+    }).compileComponents();
+  
+    component = TestBed.createComponent(AdminActionFormComponent).componentInstance;
+    adminActionService = TestBed.inject(AdminActionService) as jasmine.SpyObj<AdminActionService>;
+    baseService = TestBed.inject(BaseService) as jasmine.SpyObj<BaseService<any>>;
+    validatorService = TestBed.inject(ValidatorService) as jasmine.SpyObj<any>;
+    appConfigService = TestBed.inject(AppConfigService) as jasmine.SpyObj<AppConfigService>;
+    Object.defineProperty(appConfigService, 'swaggerUrl', {
+      get: () => 'mock-url',
+      configurable: true
+    });
+    adminActionService.initList.and.returnValue(Promise.resolve());
+    fixture = TestBed.createComponent(AdminActionFormComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create the component', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should call handleValidateAction and set success message when response is successful', fakeAsync(() => {
+    const mockResponse: AdminActionModel[] = [
+      {
+        name: 'Action 1', apiConfigId: '1', prompt: 'Prompt 1', queueId: 'Q1', formFields: 'Field1', status: 'Enable', isActive: true,
+     
+        apiDocsUrl: 'test'
+      },
+      {
+        name: 'Action 2', apiConfigId: '2', prompt: 'Prompt 2', queueId: 'Q2', formFields: 'Field2', status: 'Disable', isActive: false,
+        
+        apiDocsUrl: 'test'
+      }
+    ];
+    adminActionService.handleValidateAction.and.returnValue(of(mockResponse));
+    component.record = {  name: 'Action 1', apiConfigId: '123', prompt: 'Prompt 1', queueId: 'Q1',apiDocsUrl:'', formFields: 'Field1', status: 'Enable', isActive: true }
+    component.handleValidateAction();
+
+    expect(adminActionService.handleValidateAction).toHaveBeenCalledOnceWith(
+      ROUTES.VALIDATE_ACTIONS, '123', { path: 'mock-url' }
+    );
+    expect(component.messages).toEqual([
+      { severity: SHARED.SUCCESS, detail: MESSAGE.VALIDATE_ACTION_SUCCESS_MESSAGE }
+    ]);
+
+    tick(3000);
+    expect(component.messages).toEqual(SHARED.EMPTYARRAY);
+  }));
+
+  it('should call handleValidateAction and set error message when response fails', fakeAsync(() => {
+    const errorResponse = { message: 'Error' };
+    adminActionService.handleValidateAction.and.returnValue(throwError(() => errorResponse));
+    component.record = { apiConfigId: '1', name: 'Action 1', prompt: 'Prompt 1', queueId: 'Q1', formFields: 'Field1', status: 'Enable', isActive: true, apiDocsUrl:'test' };
+    component.handleValidateAction();
+
+    expect(adminActionService.handleValidateAction).toHaveBeenCalledOnceWith(
+      ROUTES.VALIDATE_ACTIONS, '1', { path: 'mock-url' }
+    );
+
+    expect(component.messages).toEqual([
+      { severity: SHARED.ERROR, detail: ERROR.VALIDATE_ACTION_API_FAILED }
+    ]);
+
+    tick(3000); 
+    expect(component.messages).toEqual(SHARED.EMPTYARRAY);
+  }));
+
+  it('should stringify formFields and call super.handleSubmit', () => {
+    component.record = { _id: null, apiConfigId: '1', name: 'Action 1', formFields: 'testing', status: 'Enable', isActive: true, prompt: 'test', queueId: '123', apiDocsUrl:'test' };
+    const mockFormFields = 'testing';
+    spyOn(component, 'handleSubmit').and.callThrough();
+    
+    baseService.create.and.returnValue(of({ ...component.record, _id: '123' }));
+    component.handleSubmit();
+
+    expect(component.record.formFields).toEqual(JSON.stringify(mockFormFields));
+    expect(component.handleSubmit).toHaveBeenCalled();
+  });
+});

package/src/lib/admin/action-admin/components/admin-action-form/admin-action-form.component.ts

@@ -0,0 +1,79 @@
+import { Component, OnDestroy, OnInit } from '@angular/core';
+import { BaseFormComponent } from '../../../../shared/_base/base-form/base-form.component';
+import { AdminActionModel } from '../../models/admin-action.model';
+import { Message } from 'primeng/api';
+import { SHARED } from '../../../../shared/constant/SHARED';
+import { AdminActionService } from '../../state/admin-action.service';
+import { ValidatorService } from '../../../../shared/services/validator.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AdminActionStore } from '../../state/admin-action.store';
+import { AppConfigService, BaseQuery, BaseStore, ROUTES } from '../../../../shared';
+import { MESSAGE } from '../../../../shared/constant/MESSAGES';
+
+@Component({
+  selector: 'lib-admin-action-form',
+  standalone : false,
+  templateUrl: './admin-action-form.component.html',
+  styleUrl: './admin-action-form.component.scss'
+})
+export class AdminActionFormComponent extends BaseFormComponent<AdminActionModel> implements OnInit, OnDestroy{
+  messages: Message[] = SHARED.EMPTYARRAY;
+  apiConfigList: any[] = [];
+  queueList: any[] = [];
+
+  constructor(public adminActionService: AdminActionService, override validatorService: ValidatorService, override router: Router, override activatedRoute: ActivatedRoute, public adminActionStore: AdminActionStore, private appConfigService: AppConfigService, override baseStore: BaseStore<AdminActionModel>, override baseQuery: BaseQuery<AdminActionModel>) {
+    super(adminActionService, validatorService, router, activatedRoute)
+    this.record = new AdminActionModel();
+    this.record.isActive = true;
+  }
+
+  ngOnInit() {
+    this.init();
+    this.baseStore.setIsApiValidated(null);
+  }
+
+  handleValidateAction() {
+    const payload = {path: this.record.apiDocsUrl};
+    this.adminActionService.handleValidateAction(ROUTES.VALIDATE_ACTIONS,this.record.apiConfigId,payload)
+    .subscribe({
+        next: (res: any) => {
+          if (res) {
+          if (typeof res !== SHARED.STRING) {
+            this.record.formFields = JSON.stringify(res);
+          } else {
+            this.record.formFields = res;
+          }
+            this.messages = [{ severity: SHARED.SUCCESS, detail: MESSAGE.VALIDATE_ACTION_SUCCESS_MESSAGE }];
+            setTimeout(() => {
+              this.messages = SHARED.EMPTYARRAY;
+            }, 3000);
+            // this.baseStore.setIsApiValidated(SHARED.TRUE);
+          }
+        },
+        error: (error: any) => {
+            // this.baseStore.setIsApiValidated(SHARED.FALSE);
+        },
+      });
+  }
+
+  override handleSubmit(): void {
+    if (typeof this.record.formFields !== SHARED.STRING && !this.isValidJSONArray(this.record.formFields)) {
+      this.record.formFields = JSON.stringify(this.record.formFields);
+    }
+    super.handleSubmit();
+  }
+  
+  private isValidJSONArray(value: string): boolean {
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  override ngOnDestroy(): void {
+    this.record = {} as AdminActionModel;
+    super.ngOnDestroy();
+  }
+}

package/src/lib/admin/action-admin/components/admin-action-list/admin-action-list.component.html

@@ -0,0 +1,5 @@
+<div class="dicitonary-list-wrapper">
+    @if(table){
+        <lib-table-primary [table]="table" [pathName]="pathName" [metaData]="metaData"></lib-table-primary>
+    }
+</div>

package/src/lib/admin/action-admin/components/admin-action-list/admin-action-list.component.spec.ts

@@ -0,0 +1,36 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { AdminActionListComponent } from './admin-action-list.component';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { TablePrimaryComponent } from '../../../../shared';
+import { AdminActionService } from '../../state/admin-action.service';
+import { of } from 'rxjs';
+
+describe('AdminActionListComponent', () => {
+  let component: AdminActionListComponent;
+  let fixture: ComponentFixture<AdminActionListComponent>;
+  let mockActionAdminService: jasmine.SpyObj<AdminActionService>;
+    
+  beforeEach(async () => {
+    const mockData = [{ _id: 1, name: 'Test API' }];
+    mockActionAdminService = jasmine.createSpyObj("AdminActionService", ['getAll']);
+    mockActionAdminService.getAll.and.returnValue(of(mockData) as any);
+    await TestBed.configureTestingModule({
+    declarations: [AdminActionListComponent],
+    imports:[HttpClientTestingModule, TablePrimaryComponent],
+    providers : [{provide : AdminActionService , useValue : mockActionAdminService}]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(AdminActionListComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create the component', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should initialize table with data', () => {
+    expect(mockActionAdminService.getAll).toHaveBeenCalled();
+    expect(component.table).toBeDefined();
+  });
+});

package/src/lib/admin/action-admin/components/admin-action-list/admin-action-list.component.ts

@@ -0,0 +1,33 @@
+import { Component, OnInit } from '@angular/core';
+import { BaseListComponent } from '../../../../shared/_base/base-list/base-list.component';
+import { AdminActionModel } from '../../models/admin-action.model';
+import { TableBuilder } from '../../../../shared/services/table.builder';
+import { AdminActionService } from '../../state/admin-action.service';
+import { actionHiddenHeaderList, actionList, actionTableColumnWidthList } from '../../../../shared/constant/SHARED';
+import { DATASOURCES } from '../../../../shared';
+import { PERMISSION } from '../../../../shared/constant/PERMISSION';
+
+/**
+ * Admin Action List Component
+ */
+@Component({
+  selector: 'lib-admin-action-list',
+  standalone : false,
+  templateUrl: './admin-action-list.component.html',
+  styleUrl: './admin-action-list.component.scss'
+})
+export class AdminActionListComponent extends BaseListComponent<AdminActionModel>{
+  
+  pathName:string = DATASOURCES.ACTIONS;
+  override editPermission: string = PERMISSION.ACTIONCONFIG_PUT
+  override deletePermission: string = PERMISSION.ACTIONCONFIG_DELETE
+  constructor(service: AdminActionService, private tableBuilder: TableBuilder){
+    super(service, tableBuilder)
+    this.tableBuilder.hiddenHeaders = actionHiddenHeaderList;
+  } 
+
+  ngOnInit() {
+    this.init(actionTableColumnWidthList);
+  }
+ 
+}

package/src/lib/admin/action-admin/models/admin-action.model.ts

@@ -0,0 +1,14 @@
+import { BaseModel } from "../../../shared/models/base.model";
+
+export class AdminActionModel extends BaseModel {
+    name!: string;
+    apiConfigId!: string;
+    prompt!: string;
+    queueId!: string;
+    formFields!: string;
+    status!: StatusType;
+    isActive!: boolean;
+    apiDocsUrl!: string;
+}
+
+export type StatusType = "Enable" | "Disable";

package/src/lib/admin/action-admin/state/admin-action.query.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import { AdminActionModel } from '../models/admin-action.model';
+import { AdminActionStore } from './admin-action.store';
+import { BaseQuery } from '../../../shared/state/base.query';
+
+@Injectable({ providedIn: 'root' })
+export class AdminActionQuery extends BaseQuery<AdminActionModel> {
+    constructor(protected override store: AdminActionStore) {
+        super(store);
+    }
+}

package/src/lib/admin/action-admin/state/admin-action.service.spec.ts

@@ -0,0 +1,66 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { AdminActionService } from './admin-action.service';
+import { AdminActionStore } from './admin-action.store';
+import { AdminActionModel } from '../models/admin-action.model';
+import { AppConfigService } from '../../../shared';
+
+describe('AdminActionService', () => {
+  let service: AdminActionService;
+  let httpMock: HttpTestingController;
+  let appConfigService: jasmine.SpyObj<AppConfigService>;
+  let actionStoreSpy: jasmine.SpyObj<AdminActionStore>;
+
+  const mockApiUrl = 'http://mock-api-url.com/';
+  const mockAppConfig = {
+    baseApi: mockApiUrl,
+    visibilityOption: [],
+    swaggerUrl: 'https://mock-swagger-url.com/',
+  };
+  beforeEach(() => {
+    const actionStoreSpyObj = jasmine.createSpyObj('ActionStore', ['set']);
+    const appConfigSpy = jasmine.createSpyObj('AppConfigService', ['apiBaseUrl', 'swaggerUrl']);
+
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [
+        AdminActionService,
+        { provide: AdminActionStore, useValue: actionStoreSpyObj },
+        { provide: AppConfigService, useValue: appConfigSpy },
+      ],
+    });
+
+    service = TestBed.inject(AdminActionService);
+    httpMock = TestBed.inject(HttpTestingController);
+    appConfigService = TestBed.inject(AppConfigService) as jasmine.SpyObj<AppConfigService>;
+    actionStoreSpy = TestBed.inject(AdminActionStore) as jasmine.SpyObj<AdminActionStore>;
+
+    Object.defineProperty(appConfigService, 'apiBaseUrl', { get: () => mockAppConfig.baseApi });
+    Object.defineProperty(appConfigService, 'swaggerUrl', { get: () => mockAppConfig.swaggerUrl });
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should make a POST request and call actionStore.set with the response data', () => {
+    const mockName = 'validate-action';
+    const mockId = '123';
+    const mockRecord = { key: 'value' };
+    const mockResponse: AdminActionModel[] = [
+      { name: 'Action 1', apiConfigId: '123', prompt: '', queueId: '', formFields: '', status: 'Enable', isActive: true, apiDocsUrl:"test"},
+      { name: 'Action 2', apiConfigId: '124', prompt: '', queueId: '', formFields: '', status: 'Disable', isActive: false, apiDocsUrl : "test" },
+    ];
+
+    service.handleValidateAction(mockName, mockId, mockRecord).subscribe((response) => {
+      expect(response).toEqual(mockResponse);
+      expect(actionStoreSpy.set).toHaveBeenCalledWith(mockResponse);
+    });
+
+    const req = httpMock.expectOne(`${mockApiUrl}${mockName}/${encodeURIComponent(mockId)}`);
+    expect(req.request.method).toBe('POST');
+    expect(req.request.body).toEqual(mockRecord);
+
+    req.flush(mockResponse);
+  });
+});

package/src/lib/admin/action-admin/state/admin-action.service.ts

@@ -0,0 +1,29 @@
+
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { AdminActionModel } from '../models/admin-action.model';
+import { AdminActionStore } from './admin-action.store';
+import { DATASOURCES } from '../../../shared/constant/DATASOURCES';
+import { BaseService } from '../../../shared/state/base.service';
+import { AppConfigService } from '../../../shared/services/app-config.service';
+import { ListService } from '../../../shared/services/list.service';
+import { LISTCONFIG } from '../../../shared/constant/LIST-CONFIG';
+import { Observable, tap } from 'rxjs';
+
+@Injectable({ providedIn: 'root' })
+export class AdminActionService extends BaseService<AdminActionModel> {
+
+    protected override list : any= [...LISTCONFIG.QUEUEAPICONFIG, ...LISTCONFIG.ACTIONQUEUECONFIG];
+
+    constructor(protected actionStore: AdminActionStore, http: HttpClient, appConfigService : AppConfigService, listService:ListService) {
+        super(http, actionStore, appConfigService,listService);
+        this._pathName = DATASOURCES.ACTIONS;
+    }
+
+    handleValidateAction(name:string, id: string, record:any): Observable<AdminActionModel[]> {
+    const apiUrl = `${this.apiUrl}${name}/${encodeURIComponent(id)}`;
+      return this.http.post<AdminActionModel[]>(`${apiUrl}`, record).pipe(
+          tap((entities: AdminActionModel[]) => this.actionStore.set(entities))
+      );
+    }
+}

package/src/lib/admin/action-admin/state/admin-action.state.ts

@@ -0,0 +1,14 @@
+import { BaseState } from "../../../shared/state/base.state";
+import { AdminActionModel } from "../models/admin-action.model";
+
+export interface AdminActionState extends BaseState {
+    actions: AdminActionModel[];
+}
+
+export function createInitialState(): AdminActionState {
+    return {
+        actions: [],
+        records: [],
+        lists: []
+    };
+}

package/src/lib/admin/action-admin/state/admin-action.store.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { StoreConfig } from '@datorama/akita';
+import { BaseStore } from '../../../shared/state/base.store';
+import { AdminActionModel } from '../models/admin-action.model';
+
+@Injectable({ providedIn: 'root' })
+@StoreConfig({ name: 'action' })
+export class AdminActionStore extends BaseStore<AdminActionModel> {
+
+  constructor() {
+    super();
+  }
+
+}

package/src/lib/admin/admin.module.ts

@@ -0,0 +1,22 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AppConfigService } from '../shared';
+
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ],
+  providers: [
+    {
+      provide: APP_INITIALIZER,
+      useFactory: (configService: AppConfigService) => () =>
+        configService.loadAppConfig(),
+      deps: [AppConfigService],
+      multi: true,
+    },
+  ],
+})
+export class AdminModule { }