@smartsoft001/crud-shell-angular 1.2.91 → 2.69.0

package/src/lib/services/crud/crud.service.spec.ts

@@ -0,0 +1,303 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';
+import { HttpClient } from '@angular/common/http';
+import {
+  HttpTestingController,
+  HttpClientTestingModule,
+} from '@angular/common/http/testing';
+import { TestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+import { IEntity } from '@smartsoft001/domain-core';
+
+import { CrudService } from './crud.service';
+import { CrudConfig } from '../../crud.config';
+import { ICrudCreateManyOptions, ICrudFilter } from '../../models';
+
+interface TestEntity extends IEntity<string> {
+  id: string;
+  name: string;
+}
+
+describe('crud-shell-angular: CrudService', () => {
+  let service: CrudService<TestEntity>;
+  let httpMock: HttpTestingController;
+  let httpClient: HttpClient;
+  let config: CrudConfig<TestEntity>;
+
+  // Mock URL.createObjectURL globally before tests
+  const mockCreateObjectURL = jest.fn().mockReturnValue('blob-url');
+  global.URL.createObjectURL = mockCreateObjectURL;
+
+  TestBed.initTestEnvironment(
+    BrowserDynamicTestingModule,
+    platformBrowserDynamicTesting(),
+    {
+      teardown: { destroyAfterEach: true },
+    },
+  );
+
+  beforeEach(() => {
+    config = new CrudConfig<TestEntity>();
+    config.entity = '';
+    config.apiUrl = 'http://api.test/entities';
+
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [
+        {
+          provide: CrudConfig,
+          useValue: config,
+        },
+        {
+          provide: CrudService,
+          useFactory: () => new CrudService<TestEntity>(),
+        },
+      ],
+    });
+
+    service = TestBed.inject(CrudService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('create', () => {
+    it('should create an entity and return id from location header', async () => {
+      const testEntity: TestEntity = { id: '', name: 'Test Entity' };
+
+      service.create(testEntity);
+
+      const req = httpMock.expectOne(config.apiUrl);
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body).toEqual(testEntity);
+    });
+
+    it('should return null when location header is missing', async () => {
+      const testEntity: TestEntity = { id: '', name: 'Test Entity' };
+
+      const promise = service.create(testEntity);
+
+      const req = httpMock.expectOne(config.apiUrl);
+      req.flush(null, { headers: {} });
+
+      const result = await promise;
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple entities', async () => {
+      const testEntities: TestEntity[] = [
+        { id: '', name: 'Entity 1' },
+        { id: '', name: 'Entity 2' },
+      ];
+      const options: ICrudCreateManyOptions = { mode: 'default' };
+
+      const promise = service.createMany(testEntities, options);
+
+      const req = httpMock.expectOne(`${config.apiUrl}/bulk?mode=default`);
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body).toEqual(testEntities);
+
+      // req.flush(null);
+      //
+      // await promise;
+    });
+  });
+
+  describe('getById', () => {
+    it('should fetch entity by id', async () => {
+      const testId = '123';
+      const expectedEntity: TestEntity = { id: testId, name: 'Test Entity' };
+
+      const promise = service.getById(testId);
+
+      const req = httpMock.expectOne(`${config.apiUrl}/${testId}`);
+      expect(req.request.method).toBe('GET');
+
+      req.flush(expectedEntity);
+
+      const result = await promise;
+      expect(result).toEqual(expectedEntity);
+    });
+  });
+
+  describe('getList', () => {
+    it('should fetch list of entities without filter', async () => {
+      const expectedResponse = {
+        data: [{ id: '1', name: 'Entity 1' }],
+        totalCount: 1,
+        links: {},
+      };
+
+      const promise = service.getList();
+
+      const req = httpMock.expectOne(config.apiUrl);
+      expect(req.request.method).toBe('GET');
+
+      req.flush(expectedResponse);
+
+      const result = await promise;
+      expect(result).toEqual(expectedResponse);
+    });
+
+    it('should fetch list of entities with search filter', async () => {
+      const filter: ICrudFilter = { searchText: 'test' };
+      const expectedResponse = {
+        data: [{ id: '1', name: 'Test Entity' }],
+        totalCount: 1,
+        links: {},
+      };
+
+      const promise = service.getList(filter);
+
+      const req = httpMock.expectOne(`${config.apiUrl}?$search=test`);
+      expect(req.request.method).toBe('GET');
+
+      req.flush(expectedResponse);
+
+      const result = await promise;
+      expect(result).toEqual(expectedResponse);
+    });
+  });
+
+  describe('update', () => {
+    it('should update an entity', async () => {
+      const testEntity: TestEntity = { id: '123', name: 'Updated Entity' };
+
+      const promise = service.update(testEntity);
+
+      const req = httpMock.expectOne(`${config.apiUrl}/${testEntity.id}`);
+      expect(req.request.method).toBe('PUT');
+      expect(req.request.body).toEqual(testEntity);
+
+      req.flush(null);
+
+      await promise;
+    });
+  });
+
+  describe('updatePartial', () => {
+    it('should partially update an entity', async () => {
+      const partialUpdate = { id: '123', name: 'Partially Updated' };
+
+      const promise = service.updatePartial(partialUpdate);
+
+      const req = httpMock.expectOne(`${config.apiUrl}/${partialUpdate.id}`);
+      expect(req.request.method).toBe('PATCH');
+      expect(req.request.body).toEqual(partialUpdate);
+
+      req.flush(null);
+
+      await promise;
+    });
+  });
+
+  describe('updatePartialMany', () => {
+    it('should update multiple entities partially', async () => {
+      const updates = [
+        { id: '1', name: 'Update 1' },
+        { id: '2', name: 'Update 2' },
+      ];
+
+      const promise = service.updatePartialMany(updates);
+
+      updates.forEach((update) => {
+        const req = httpMock.expectOne(`${config.apiUrl}/${update.id}`);
+        expect(req.request.method).toBe('PATCH');
+        expect(req.request.body).toEqual(update);
+        req.flush(null);
+      });
+
+      await promise;
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete an entity', async () => {
+      const testId = '123';
+
+      const promise = service.delete(testId);
+
+      const req = httpMock.expectOne(`${config.apiUrl}/${testId}`);
+      expect(req.request.method).toBe('DELETE');
+
+      req.flush(null);
+
+      await promise;
+    });
+  });
+
+  describe('exportList', () => {
+    beforeEach(() => {
+      // Reset the mock before each test
+      mockCreateObjectURL.mockClear();
+    });
+
+    it('should export list as CSV', async () => {
+      const format = 'csv';
+      const csvData = 'id,name\n1,Test';
+
+      // Mock document.createElement
+      const mockLink = {
+        href: '',
+        download: '',
+        click: jest.fn(),
+      };
+      jest.spyOn(document, 'createElement').mockReturnValue(mockLink as any);
+      jest.spyOn(document.body, 'appendChild').mockImplementation();
+      jest.spyOn(document.body, 'removeChild').mockImplementation();
+
+      const promise = service.exportList(null, format);
+
+      const req = httpMock.expectOne(config.apiUrl);
+      expect(req.request.method).toBe('GET');
+      expect(req.request.headers.get('Content-Type')).toBe('text/csv');
+
+      req.flush(csvData);
+
+      await promise;
+
+      expect(mockCreateObjectURL).toHaveBeenCalled();
+      expect(mockLink.download).toBe('data.csv');
+      expect(mockLink.click).toHaveBeenCalled();
+    });
+
+    it('should export list as XLSX', async () => {
+      const format = 'xlsx';
+      const xlsxData = new Blob(['fake xlsx data']);
+
+      const mockLink = {
+        href: '',
+        download: '',
+        click: jest.fn(),
+      };
+      jest.spyOn(document, 'createElement').mockReturnValue(mockLink as any);
+      jest.spyOn(document.body, 'appendChild').mockImplementation();
+      jest.spyOn(document.body, 'removeChild').mockImplementation();
+
+      const promise = service.exportList(null, format);
+
+      const req = httpMock.expectOne(config.apiUrl);
+      expect(req.request.method).toBe('GET');
+      expect(req.request.headers.get('Content-Type')).toBe(
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      );
+
+      req.flush(xlsxData);
+
+      await promise;
+
+      expect(mockCreateObjectURL).toHaveBeenCalled();
+      expect(mockLink.download).toBe('data.xlsx');
+      expect(mockLink.click).toHaveBeenCalled();
+    });
+  });
+});

package/src/lib/services/crud/crud.service.ts

@@ -0,0 +1,178 @@
+import { HttpClient } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { IEntity } from '@smartsoft001/domain-core';
+
+import { CrudConfig } from '../../crud.config';
+import { ICrudCreateManyOptions, ICrudFilter } from '../../models';
+
+@Injectable()
+export class CrudService<T extends IEntity<string>> {
+  protected config = inject(CrudConfig<T>);
+  protected http = inject(HttpClient);
+
+  protected _formatMap = {
+    csv: 'text/csv',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  };
+
+  create(item: T): Promise<string> {
+    return firstValueFrom(
+      this.http
+        .post<void>(this.config.apiUrl, item, { observe: 'response' })
+        .pipe(
+          map((response) => {
+            const location = response.headers['Location'];
+            if (!location) return null;
+            const array = location.split('/');
+            return array[array.length - 1];
+          }),
+        ),
+    );
+  }
+
+  createMany(items: Array<T>, options: ICrudCreateManyOptions): Promise<void> {
+    return firstValueFrom(
+      this.http.post<void>(
+        this.config.apiUrl + '/bulk?mode=' + options.mode,
+        items,
+      ),
+    );
+  }
+
+  getById(id: string): Promise<T> {
+    return firstValueFrom(this.http.get<T>(this.config.apiUrl + '/' + id));
+  }
+
+  getList<T>(
+    filter: ICrudFilter = null,
+  ): Promise<{ data: T[]; totalCount: number; links }> {
+    return firstValueFrom(
+      this.http.get<{ data: T[]; totalCount: number; links }>(
+        this.config.apiUrl + this.getQuery(filter),
+      ),
+    );
+  }
+
+  exportList(
+    filter: ICrudFilter = null,
+    format: 'csv' | 'xlsx',
+  ): Promise<void> {
+    if (!format) {
+      format = 'csv';
+    }
+
+    if (format === 'xlsx') {
+      return firstValueFrom(
+        this.http
+          .get(this.config.apiUrl + this.getQuery(filter), {
+            headers: {
+              'Content-Type': this._formatMap[format],
+            },
+            observe: 'response',
+            reportProgress: false,
+            responseType: 'blob',
+          })
+          .pipe(
+            map((res) => {
+              const downloadLink = document.createElement('a');
+              const blob = res.body;
+
+              downloadLink.href = URL.createObjectURL(blob);
+              downloadLink.download = 'data.' + format;
+
+              document.body.appendChild(downloadLink);
+              downloadLink.click();
+              document.body.removeChild(downloadLink);
+            }),
+          ),
+      );
+    }
+
+    return firstValueFrom(
+      this.http
+        .get<string>(this.config.apiUrl + this.getQuery(filter), {
+          headers: {
+            'Content-Type': this._formatMap[format],
+          },
+          responseType: 'text' as 'json',
+        })
+        .pipe(
+          map((res) => {
+            const downloadLink = document.createElement('a');
+            const blob = new Blob(['\ufeff', res]);
+
+            downloadLink.href = URL.createObjectURL(blob);
+            downloadLink.download = 'data.' + format;
+
+            document.body.appendChild(downloadLink);
+            downloadLink.click();
+            document.body.removeChild(downloadLink);
+          }),
+        ),
+    );
+  }
+
+  update(item: T): Promise<void> {
+    return firstValueFrom(
+      this.http.put<void>(this.config.apiUrl + '/' + item.id, item),
+    );
+  }
+
+  updatePartial(item: Partial<T> & { id: string }): Promise<void> {
+    return firstValueFrom(
+      this.http.patch<void>(this.config.apiUrl + '/' + item.id, item),
+    );
+  }
+
+  updatePartialMany(items: (Partial<T> & { id: string })[]): Promise<any> {
+    const updatePromises = items.map((item) => {
+      return this.updatePartial(item);
+    });
+    return Promise.all(updatePromises);
+  }
+
+  delete(id: string): Promise<void> {
+    return firstValueFrom(
+      this.http.delete<void>(this.config.apiUrl + '/' + id),
+    );
+  }
+
+  protected getQuery(filter: ICrudFilter): string {
+    let query = '';
+
+    if (filter && filter.searchText) {
+      query += '&$search=' + filter.searchText;
+    }
+
+    if (filter && filter.limit) {
+      query += `&limit=${filter.limit}&offset=${
+        filter.offset ? filter.offset : 0
+      }`;
+    }
+
+    if (filter && filter.sortBy) {
+      query += `&sort=${(filter.sortDesc ? '-' : '') + filter.sortBy}`;
+    }
+
+    if (filter && filter.query) {
+      filter.query.forEach((q) => {
+        if (
+          q.value &&
+          typeof q.value === 'string' &&
+          q.value.match(/^-?\d+$/) &&
+          q.value[0] !== "'" &&
+          q.value[0] !== '"'
+        ) {
+          query += '&' + q.key + q.type + `'${q.value}'`;
+        } else {
+          query += '&' + q.key + q.type + q.value;
+        }
+      });
+    }
+
+    return query ? '?' + query.replace('&', '') : '';
+  }
+}

package/src/lib/services/list-group/list-group.service.spec.ts

@@ -0,0 +1,87 @@
+// Mock the facade before any imports
+import { ɵNoopNgZone as NoopNgZone, NgZone } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import {
+  BrowserTestingModule,
+  platformBrowserTesting,
+} from '@angular/platform-browser/testing';
+
+import { IEntity } from '@smartsoft001/domain-core';
+
+import { CrudListGroupService } from './list-group.service';
+import { CrudFacade } from '../../+state/crud.facade';
+import { ICrudFilter, ICrudListGroup } from '../../models';
+
+jest.mock('../../+state/crud.facade', () => ({
+  CrudFacade: jest.fn().mockImplementation(() => {
+    const filter: ICrudFilter = {
+      query: [],
+    };
+    return {
+      filter: jest.fn(() => filter),
+      read: jest.fn(() => []),
+    };
+  }),
+}));
+
+export class MockCrudFacade<T> {
+  filter: jest.Mock;
+  read: jest.Mock;
+
+  constructor() {
+    const filter: ICrudFilter = { query: [] };
+    this.filter = jest.fn(() => filter);
+    this.read = jest.fn(() => []);
+  }
+}
+
+TestBed.initTestEnvironment(BrowserTestingModule, platformBrowserTesting());
+
+describe('crud-shell-angular: CrudListGroupService', () => {
+  let service: CrudListGroupService<IEntity<string>>;
+  let facade: CrudFacade<IEntity<string>>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        CrudListGroupService,
+        { provide: CrudFacade, useClass: MockCrudFacade },
+        { provide: NgZone, useClass: NoopNgZone },
+      ],
+    });
+    service = TestBed.inject(CrudListGroupService);
+    facade = TestBed.inject(CrudFacade);
+  });
+
+  it('should create the service', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('change', () => {
+    it('should set item.changed to true if val is truthy', () => {
+      const item: ICrudListGroup = { key: 'test', value: 'val' } as any;
+      service.change(true, item, false);
+      expect(item.changed).toBe(true);
+    });
+
+    it('should set item.changed to true if force is true', () => {
+      const item: ICrudListGroup = { key: 'test', value: 'val' } as any;
+      service.change(false, item, true);
+      expect(item.changed).toBe(true);
+    });
+
+    it('should add a new query if not found', () => {
+      const item: ICrudListGroup = { key: 'test', value: 'val' } as any;
+      service.change(true, item, false);
+      expect(facade.filter().query.length).toBe(1);
+      expect(facade.filter().query[0].key).toBe('test');
+    });
+
+    it('should update current.value and set current.hidden to true', () => {
+      const item: ICrudListGroup = { key: 'test', value: 'val' } as any;
+      service.change(true, item, false);
+      expect(facade.filter().query[0].value).toBe('val');
+      expect(facade.filter().query[0].hidden).toBe(true);
+    });
+  });
+});

package/src/lib/services/list-group/list-group.service.ts

@@ -0,0 +1,65 @@
+import { inject, Injectable } from '@angular/core';
+import { debounce } from 'lodash-decorators';
+
+import { IEntity } from '@smartsoft001/domain-core';
+
+import { CrudFacade } from '../../+state/crud.facade';
+import { ICrudListGroup } from '../../models';
+
+@Injectable()
+export class CrudListGroupService<T extends IEntity<string>> {
+  private facade = inject(CrudFacade<T>);
+
+  private _destroyed: Array<ICrudListGroup> = [];
+
+  change(val: boolean, item: ICrudListGroup, force = false): void {
+    if (val || force) {
+      item.changed = true;
+
+      let current = this.facade
+        .filter()
+        .query.find((q) => q.key === item.key && q.type === '=');
+
+      if (!current) {
+        current = {
+          key: item.key,
+          type: '=',
+          value: null,
+        };
+        this.facade.filter().query.push(current);
+      }
+
+      current.value = item.value;
+      current.hidden = true;
+
+      this.facade.read({
+        ...this.facade.filter(),
+        offset: 0,
+      });
+    }
+  }
+
+  destroy(groups: Array<ICrudListGroup>): void {
+    this._destroyed = [
+      ...(this._destroyed ? this._destroyed : []),
+      ...groups.filter((g) => g.changed),
+    ];
+
+    this.refresh();
+  }
+
+  @debounce(250)
+  private refresh(): void {
+    const list = this._destroyed;
+    this._destroyed = [];
+
+    const newQuery = this.facade
+      .filter()
+      .query.filter((q) => !list.some((i) => q.key === i.key));
+
+    this.facade.read({
+      ...this.facade.filter(),
+      query: newQuery,
+    });
+  }
+}