@smartsoft001/crud-shell-angular 1.1.732 → 1.1.736

package/esm2020/lib/+state/crud.effects.mjs

@@ -0,0 +1,182 @@
+import "reflect-metadata";
+import { Injectable } from "@angular/core";
+import { catchError, first, tap } from "rxjs/operators";
+import { of } from "rxjs";
+import { ActionsSubject, select, State, Store } from "@ngrx/store";
+import { CrudService } from "../services/crud/crud.service";
+import * as CrudActions from "./crud.actions";
+import { CrudConfig } from "../crud.config";
+import { getCrudFilter } from "./crud.selectors";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "../services/crud/crud.service";
+import * as i3 from "../crud.config";
+export class CrudEffects {
+    constructor(actions$, service, config, store, state) {
+        this.actions$ = actions$;
+        this.service = service;
+        this.config = config;
+        this.store = store;
+        this.state = state;
+    }
+    init() {
+        const metadata = Reflect.getMetadata(this.config.entity, CrudEffects);
+        if (metadata)
+            return;
+        Reflect.defineMetadata(this.config.entity, true, CrudEffects);
+        this.actions$.subscribe((action) => {
+            switch (action.type) {
+                case `[${this.config.entity}] Create`:
+                    this.service
+                        .create(action.item)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.createSuccess(this.config.entity, action.item))), catchError((error) => {
+                        this.store.dispatch(CrudActions.createFailure(this.config.entity, action.item, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Create Success`:
+                    const createState = this.state.getValue()[this.config.entity];
+                    this.store.dispatch(CrudActions.read(this.config.entity, createState.filter ? { ...createState.filter, offset: 0 } : null));
+                    break;
+                case `[${this.config.entity}] Create Many`:
+                    this.service
+                        .createMany(action.data.items, action.data.options)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.createManySuccess(this.config.entity, {
+                        items: action.data.items,
+                        options: action.data.options,
+                    }))), catchError((error) => {
+                        this.store.dispatch(CrudActions.createManyFailure(this.config.entity, {
+                            items: action.data.items,
+                            options: action.data.options,
+                        }, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Create Many Success`:
+                    const createManyState = this.state.getValue()[this.config.entity];
+                    this.store.dispatch(CrudActions.read(this.config.entity, createManyState.filter
+                        ? { ...createManyState.filter, offset: 0 }
+                        : null));
+                    break;
+                case `[${this.config.entity}] Read`:
+                    this.service
+                        .getList(action.filter)
+                        .pipe(tap((result) => this.store.dispatch(CrudActions.readSuccess(this.config.entity, action.filter, result))), catchError((error) => {
+                        this.store.dispatch(CrudActions.readFailure(this.config.entity, action.filter, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Export`:
+                    this.service
+                        .exportList(action.filter, action.format)
+                        .pipe(tap((result) => this.store.dispatch(CrudActions.exportListSuccess(this.config.entity, action.filter))), catchError((error) => {
+                        this.store.dispatch(CrudActions.exportListFailure(this.config.entity, action.filter, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Select`:
+                    this.service
+                        .getById(action.id)
+                        .pipe(tap((result) => this.store.dispatch(CrudActions.selectSuccess(this.config.entity, action.id, result))), catchError((error) => {
+                        this.store.dispatch(CrudActions.selectFailure(this.config.entity, action.id, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Update`:
+                    this.service
+                        .updatePartial(action.item)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.updateSuccess(this.config.entity, action.item))), catchError((error) => {
+                        this.store.dispatch(CrudActions.updateFailure(this.config.entity, action.item, error));
+                        this.store.dispatch(CrudActions.read(this.config.entity));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Update Success`:
+                    this.store
+                        .pipe(select(getCrudFilter(this.config.entity)), first())
+                        .subscribe((filter) => {
+                        this.store.dispatch(CrudActions.read(this.config.entity, {
+                            ...filter,
+                            offset: 0,
+                        }));
+                        this.store.dispatch(CrudActions.select(this.config.entity, action.item.id));
+                    });
+                    break;
+                case `[${this.config.entity}] Update partial`:
+                    this.service
+                        .updatePartial(action.item)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.updatePartialSuccess(this.config.entity, action.item))), catchError((error) => {
+                        this.store.dispatch(CrudActions.updatePartialFailure(this.config.entity, action.item, error));
+                        this.store.dispatch(CrudActions.read(this.config.entity));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Update partial Success`:
+                    this.store
+                        .pipe(select(getCrudFilter(this.config.entity)), first())
+                        .subscribe((filter) => {
+                        this.store.dispatch(CrudActions.read(this.config.entity, {
+                            ...filter,
+                            offset: 0,
+                        }));
+                        this.store.dispatch(CrudActions.select(this.config.entity, action.item.id));
+                    });
+                    break;
+                case `[${this.config.entity}] Update partial many`:
+                    this.service
+                        .updatePartialMany(action.items)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.updatePartialManySuccess(this.config.entity, action.items))), catchError((error) => {
+                        this.store.dispatch(CrudActions.updatePartialManyFailure(this.config.entity, action.items, error));
+                        this.store.dispatch(CrudActions.read(this.config.entity));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Update partial many Success`:
+                    this.store
+                        .pipe(select(getCrudFilter(this.config.entity)), first())
+                        .subscribe((filter) => {
+                        this.store.dispatch(CrudActions.read(this.config.entity, {
+                            ...filter,
+                            offset: 0,
+                        }));
+                    });
+                    break;
+                case `[${this.config.entity}] Delete`:
+                    this.service
+                        .delete(action.id)
+                        .pipe(tap(() => this.store.dispatch(CrudActions.deleteSuccess(this.config.entity, action.id))), catchError((error) => {
+                        this.store.dispatch(CrudActions.deleteFailure(this.config.entity, action.id, error));
+                        return of();
+                    }))
+                        .subscribe();
+                    break;
+                case `[${this.config.entity}] Delete Success`:
+                    this.store
+                        .pipe(select(getCrudFilter(this.config.entity)), first())
+                        .subscribe((filter) => {
+                        this.store.dispatch(CrudActions.read(this.config.entity, {
+                            ...filter,
+                            offset: 0,
+                        }));
+                    });
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CrudEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudEffects, deps: [{ token: i1.ActionsSubject }, { token: i2.CrudService }, { token: i3.CrudConfig }, { token: i1.Store }, { token: i1.State }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CrudEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ActionsSubject }, { type: i2.CrudService }, { type: i3.CrudConfig }, { type: i1.Store }, { type: i1.State }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud.effects.js","sourceRoot":"","sources":["../../../../../../../../libs/crud/shell/angular/src/lib/+state/crud.effects.ts"],"names":[],"mappings":"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","sourcesContent":["import \"reflect-metadata\";\n\nimport { Injectable } from \"@angular/core\";\nimport { catchError, first, tap } from \"rxjs/operators\";\nimport { of } from \"rxjs\";\nimport { Action, ActionsSubject, select, State, Store } from \"@ngrx/store\";\n\nimport { CrudService } from \"../services/crud/crud.service\";\nimport { IEntity } from \"@smartsoft001/domain-core\";\nimport * as CrudActions from \"./crud.actions\";\nimport { CrudConfig } from \"../crud.config\";\nimport { getCrudFilter } from \"./crud.selectors\";\n\n@Injectable()\nexport class CrudEffects<T extends IEntity<string>> {\n  constructor(\n    private actions$: ActionsSubject,\n    private service: CrudService<T>,\n    private config: CrudConfig<T>,\n    private store: Store<any>,\n    private state: State<any>\n  ) {}\n\n  init(): void {\n    const metadata = Reflect.getMetadata(this.config.entity, CrudEffects);\n\n    if (metadata) return;\n\n    Reflect.defineMetadata(this.config.entity, true, CrudEffects);\n\n    this.actions$.subscribe((action: Action & any) => {\n      switch (action.type) {\n        case `[${this.config.entity}] Create`:\n          this.service\n            .create(action.item)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.createSuccess(this.config.entity, action.item)\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.createFailure(\n                    this.config.entity,\n                    action.item,\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Create Success`:\n          const createState = this.state.getValue()[this.config.entity];\n          this.store.dispatch(\n            CrudActions.read(\n              this.config.entity,\n              createState.filter ? { ...createState.filter, offset: 0 } : null\n            )\n          );\n          break;\n\n        case `[${this.config.entity}] Create Many`:\n          this.service\n            .createMany(action.data.items, action.data.options)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.createManySuccess(this.config.entity, {\n                    items: action.data.items,\n                    options: action.data.options,\n                  })\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.createManyFailure(\n                    this.config.entity,\n                    {\n                      items: action.data.items,\n                      options: action.data.options,\n                    },\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Create Many Success`:\n          const createManyState = this.state.getValue()[this.config.entity];\n          this.store.dispatch(\n            CrudActions.read(\n              this.config.entity,\n              createManyState.filter\n                ? { ...createManyState.filter, offset: 0 }\n                : null\n            )\n          );\n          break;\n\n        case `[${this.config.entity}] Read`:\n          this.service\n            .getList(action.filter)\n            .pipe(\n              tap((result) =>\n                this.store.dispatch(\n                  CrudActions.readSuccess(\n                    this.config.entity,\n                    action.filter,\n                    result\n                  )\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.readFailure(\n                    this.config.entity,\n                    action.filter,\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Export`:\n          this.service\n            .exportList(action.filter, action.format)\n            .pipe(\n              tap((result) =>\n                this.store.dispatch(\n                  CrudActions.exportListSuccess(\n                    this.config.entity,\n                    action.filter\n                  )\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.exportListFailure(\n                    this.config.entity,\n                    action.filter,\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Select`:\n          this.service\n            .getById(action.id)\n            .pipe(\n              tap((result) =>\n                this.store.dispatch(\n                  CrudActions.selectSuccess(\n                    this.config.entity,\n                    action.id,\n                    result\n                  )\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.selectFailure(\n                    this.config.entity,\n                    action.id,\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Update`:\n          this.service\n            .updatePartial(action.item)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.updateSuccess(this.config.entity, action.item)\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.updateFailure(\n                    this.config.entity,\n                    action.item,\n                    error\n                  )\n                );\n                this.store.dispatch(CrudActions.read(this.config.entity));\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Update Success`:\n          this.store\n            .pipe(select(getCrudFilter(this.config.entity)), first())\n            .subscribe((filter) => {\n              this.store.dispatch(\n                CrudActions.read(this.config.entity, {\n                  ...filter,\n                  offset: 0,\n                })\n              );\n\n              this.store.dispatch(CrudActions.select(this.config.entity, action.item.id));\n            });\n          break;\n\n        case `[${this.config.entity}] Update partial`:\n          this.service\n            .updatePartial(action.item)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.updatePartialSuccess(\n                    this.config.entity,\n                    action.item\n                  )\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.updatePartialFailure(\n                    this.config.entity,\n                    action.item,\n                    error\n                  )\n                );\n                this.store.dispatch(CrudActions.read(this.config.entity));\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Update partial Success`:\n          this.store\n            .pipe(select(getCrudFilter(this.config.entity)), first())\n            .subscribe((filter) => {\n              this.store.dispatch(\n                CrudActions.read(this.config.entity, {\n                  ...filter,\n                  offset: 0,\n                })\n              );\n\n              this.store.dispatch(CrudActions.select(this.config.entity, action.item.id));\n            });\n          break;\n\n        case `[${this.config.entity}] Update partial many`:\n          this.service\n            .updatePartialMany(action.items)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.updatePartialManySuccess(\n                    this.config.entity,\n                    action.items\n                  )\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.updatePartialManyFailure(\n                    this.config.entity,\n                    action.items,\n                    error\n                  )\n                );\n                this.store.dispatch(CrudActions.read(this.config.entity));\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Update partial many Success`:\n          this.store\n            .pipe(select(getCrudFilter(this.config.entity)), first())\n            .subscribe((filter) => {\n              this.store.dispatch(\n                CrudActions.read(this.config.entity, {\n                  ...filter,\n                  offset: 0,\n                })\n              );\n            });\n          break;\n\n        case `[${this.config.entity}] Delete`:\n          this.service\n            .delete(action.id)\n            .pipe(\n              tap(() =>\n                this.store.dispatch(\n                  CrudActions.deleteSuccess(this.config.entity, action.id)\n                )\n              ),\n              catchError((error) => {\n                this.store.dispatch(\n                  CrudActions.deleteFailure(\n                    this.config.entity,\n                    action.id,\n                    error\n                  )\n                );\n                return of();\n              })\n            )\n            .subscribe();\n          break;\n\n        case `[${this.config.entity}] Delete Success`:\n            this.store\n                .pipe(select(getCrudFilter(this.config.entity)), first())\n                .subscribe((filter) => {\n                    this.store.dispatch(\n                        CrudActions.read(this.config.entity, {\n                            ...filter,\n                            offset: 0,\n                        })\n                    );\n                });\n          break;\n\n        default:\n          break;\n      }\n    });\n  }\n}\n"]}

package/esm2020/lib/+state/crud.facade.mjs

@@ -0,0 +1,88 @@
+import { select, Store } from "@ngrx/store";
+import { Injectable } from "@angular/core";
+import { map, tap } from "rxjs/operators";
+import { CrudConfig } from "../crud.config";
+import * as CrudActions from "./crud.actions";
+import * as CrudSelectors from "./crud.selectors";
+import { NgrxStoreService } from "@smartsoft001/angular";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "../crud.config";
+export class CrudFacade {
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+        this.loaded$ = this.store.pipe(select(CrudSelectors.getCrudLoaded(this.config.entity)));
+        this.loading$ = this.store.pipe(select(CrudSelectors.getCrudLoaded(this.config.entity)), map(l => !l));
+        this.selected$ = this.store.pipe(select(CrudSelectors.getCrudSelected(this.config.entity)), tap(s => {
+            this.selected = s;
+        }));
+        this.multiSelected$ = this.store.pipe(select(CrudSelectors.getCrudMultiSelected(this.config.entity)), tap(s => {
+            this.multiSelected = s;
+        }));
+        this.list$ = this.store.pipe(select(CrudSelectors.getCrudList(this.config.entity)), tap(l => {
+            this.list = l;
+        }));
+        this.filter$ = this.store.pipe(select(CrudSelectors.getCrudFilter(this.config.entity)), tap(f => {
+            this.filter = f;
+        }));
+        this.totalCount$ = this.store.pipe(select(CrudSelectors.getCrudTotalCount(this.config.entity)));
+        this.links$ = this.store.pipe(select(CrudSelectors.getCrudLinks(this.config.entity)));
+        this.error$ = this.store.pipe(select(CrudSelectors.getCrudError(this.config.entity)));
+        if (NgrxStoreService.store) {
+            this.store = NgrxStoreService.store;
+        }
+    }
+    create(item) {
+        this.store.dispatch(CrudActions.create(this.config.entity, item));
+    }
+    createMany(items, options) {
+        this.store.dispatch(CrudActions.createMany(this.config.entity, { items, options }));
+    }
+    read(filter = null) {
+        let baseQuery = [];
+        if (this.config.baseQuery) {
+            baseQuery = this.config.baseQuery;
+        }
+        const fullFilter = {
+            ...(filter ? filter : {}),
+            query: filter && filter.query ? filter.query : baseQuery
+        };
+        this.store.dispatch(CrudActions.read(this.config.entity, fullFilter));
+    }
+    select(id) {
+        this.store.dispatch(CrudActions.select(this.config.entity, id));
+    }
+    unselect() {
+        this.store.dispatch(CrudActions.unselect(this.config.entity));
+    }
+    multiSelect(items) {
+        this.store.dispatch(CrudActions.multiSelect(this.config.entity, items));
+    }
+    update(item) {
+        this.getStore().dispatch(CrudActions.update(this.config.entity, item));
+    }
+    export(filter = null, format = null) {
+        this.getStore().dispatch(CrudActions.exportList(this.config.entity, filter, format));
+    }
+    updatePartial(item) {
+        this.getStore().dispatch(CrudActions.updatePartial(this.config.entity, item));
+    }
+    updatePartialMany(items) {
+        this.getStore().dispatch(CrudActions.updatePartialMany(this.config.entity, items));
+    }
+    delete(id) {
+        this.getStore().dispatch(CrudActions.deleteItem(this.config.entity, id));
+    }
+    getStore() {
+        if (NgrxStoreService.store)
+            return NgrxStoreService.store;
+        return this.store;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CrudFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudFacade, deps: [{ token: i1.Store }, { token: i2.CrudConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CrudFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudFacade });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CrudFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.CrudConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud.facade.js","sourceRoot":"","sources":["../../../../../../../../libs/crud/shell/angular/src/lib/+state/crud.facade.ts"],"names":[],"mappings":"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","sourcesContent":["import { select, Store } from \"@ngrx/store\";\nimport { Observable } from \"rxjs\";\nimport { Injectable } from \"@angular/core\";\nimport { map, tap } from \"rxjs/operators\";\nimport * as _ from \"lodash\";\n\nimport { IEntity } from \"@smartsoft001/domain-core\";\n\nimport { CrudConfig } from \"../crud.config\";\nimport * as CrudActions from \"./crud.actions\";\nimport * as CrudSelectors from \"./crud.selectors\";\nimport {ICrudCreateManyOptions, ICrudFilter} from \"../models/interfaces\";\nimport {NgrxStoreService} from \"@smartsoft001/angular\";\n\n\n@Injectable()\nexport class CrudFacade<T extends IEntity<string>> {\n  selected: T;\n  multiSelected: T;\n  list: Array<T>;\n  filter: ICrudFilter;\n\n  loaded$: Observable<boolean> = this.store.pipe(\n    select(CrudSelectors.getCrudLoaded(this.config.entity))\n  );\n  loading$: Observable<boolean> = this.store.pipe(\n    select(CrudSelectors.getCrudLoaded(this.config.entity)),\n    map(l => !l)\n  );\n  selected$: Observable<T> = this.store.pipe(\n    select(CrudSelectors.getCrudSelected(this.config.entity)),\n    tap(s => {\n      this.selected = s;\n    })\n  );\n  multiSelected$: Observable<T[]> = this.store.pipe(\n      select(CrudSelectors.getCrudMultiSelected(this.config.entity)),\n      tap(s => {\n        this.multiSelected = s;\n      })\n  );\n  list$: Observable<T[]> = this.store.pipe(\n    select(CrudSelectors.getCrudList(this.config.entity)),\n    tap(l => {\n      this.list = l;\n    })\n  );\n  filter$: Observable<ICrudFilter> = this.store.pipe(\n    select(CrudSelectors.getCrudFilter(this.config.entity)),\n    tap(f => {\n      this.filter = f;\n    })\n  );\n  totalCount$: Observable<number> = this.store.pipe(\n    select(CrudSelectors.getCrudTotalCount(this.config.entity))\n  );\n  links$: Observable<any> = this.store.pipe(\n    select(CrudSelectors.getCrudLinks(this.config.entity))\n  );\n\n  error$: Observable<any> = this.store.pipe(\n      select(CrudSelectors.getCrudError(this.config.entity))\n  );\n\n  constructor(private store: Store<any>, private config: CrudConfig<T>) {\n    if (NgrxStoreService.store) {\n      this.store = NgrxStoreService.store;\n    }\n  }\n\n  create(item: T): void {\n    this.store.dispatch(CrudActions.create(this.config.entity, item));\n  }\n\n  createMany(items: Array<T>, options: ICrudCreateManyOptions): void {\n    this.store.dispatch(CrudActions.createMany(this.config.entity, { items, options }));\n  }\n\n  read(filter: ICrudFilter = null): void {\n    let baseQuery = [];\n    if (this.config.baseQuery) {\n      baseQuery = this.config.baseQuery;\n    }\n\n    const fullFilter = {\n      ...(filter ? filter : {}),\n      query: filter && filter.query ? filter.query : baseQuery\n    };\n\n    this.store.dispatch(CrudActions.read(this.config.entity, fullFilter));\n  }\n\n  select(id: string): void {\n    this.store.dispatch(CrudActions.select(this.config.entity, id));\n  }\n\n  unselect(): void {\n    this.store.dispatch(CrudActions.unselect(this.config.entity));\n  }\n\n  multiSelect(items: Array<T>): void {\n    this.store.dispatch(CrudActions.multiSelect(this.config.entity, items));\n  }\n\n  update(item: T): void {\n    this.getStore().dispatch(CrudActions.update(this.config.entity, item));\n  }\n\n  export(filter: ICrudFilter = null, format = null): void {\n    this.getStore().dispatch(CrudActions.exportList(this.config.entity, filter, format));\n  }\n\n  updatePartial(item: Partial<T> & { id: string }): void {\n    this.getStore().dispatch(CrudActions.updatePartial(this.config.entity, item));\n  }\n\n  updatePartialMany(items: (Partial<T> & {id: string})[]) {\n    this.getStore().dispatch(CrudActions.updatePartialMany(this.config.entity, items));\n  }\n\n  delete(id: string): void {\n    this.getStore().dispatch(CrudActions.deleteItem(this.config.entity, id));\n  }\n\n  private getStore(): Store {\n    if (NgrxStoreService.store) return NgrxStoreService.store;\n\n    return this.store;\n  }\n}\n"]}

package/esm2020/lib/+state/crud.reducer.mjs

@@ -0,0 +1,212 @@
+import { PaginationMode } from "@smartsoft001/angular";
+export const initialState = {
+    loaded: false
+};
+const crudReducer = (state = initialState, action, entity) => {
+    switch (action.type) {
+        case `[${entity}] Create`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Create Success`:
+            return {
+                ...state,
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Create Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Create Many`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Create Many Success`:
+            return {
+                ...state,
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Create Many Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Export`:
+            return {
+                ...state,
+                loaded: false
+            };
+        case `[${entity}] Export Success`:
+            return {
+                ...state,
+                loaded: true
+            };
+        case `[${entity}] Export Failure`:
+            return {
+                ...state,
+                loaded: true
+            };
+        case `[${entity}] Read`:
+            return {
+                ...state,
+                loaded: false,
+                filter: action.filter,
+                error: null,
+                totalCount: null,
+                links: null,
+            };
+        case `[${entity}] Read Success`:
+            let list = [];
+            if (action.filter
+                && action.filter.offset
+                && state.list
+                && action.filter.paginationMode !== PaginationMode.singlePage) {
+                state.list.forEach(i => {
+                    list.push(i);
+                });
+                list = [
+                    ...list,
+                    ...action.result.data
+                ];
+            }
+            else {
+                list = action.result.data;
+            }
+            return {
+                ...state,
+                loaded: true,
+                list,
+                totalCount: action.result.totalCount,
+                links: action.result.links,
+                error: null
+            };
+        case `[${entity}] Read Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Select`:
+            return {
+                ...state,
+                loaded: false,
+                selected: null,
+                error: null
+            };
+        case `[${entity}] Select Success`:
+            return {
+                ...state,
+                loaded: true,
+                selected: action.item,
+                error: null
+            };
+        case `[${entity}] Select Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] MultiSelect`:
+            return {
+                ...state,
+                multiSelected: [...action.items]
+            };
+        case `[${entity}] Unselect`:
+            return {
+                ...state,
+                loaded: true,
+                selected: null,
+                error: null
+            };
+        case `[${entity}] Update`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Update Success`:
+            return {
+                ...state,
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Update Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Update partial`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Update partial Success`:
+            return {
+                ...state,
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Update partial Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Update partial many`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Update partial many Success`:
+            return {
+                ...state,
+                multiSelected: [],
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Update partial many Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        case `[${entity}] Delete`:
+            return {
+                ...state,
+                loaded: false,
+                error: null
+            };
+        case `[${entity}] Delete Success`:
+            return {
+                ...state,
+                loaded: true,
+                error: null
+            };
+        case `[${entity}] Delete Failure`:
+            return {
+                ...state,
+                loaded: true,
+                error: action.error
+            };
+        default:
+            return state;
+    }
+};
+export function getReducer(entity) {
+    return (state, action) => {
+        return crudReducer(state, action, entity);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud.reducer.js","sourceRoot":"","sources":["../../../../../../../../libs/crud/shell/angular/src/lib/+state/crud.reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import {IEntity} from \"@smartsoft001/domain-core\";\nimport {Action} from \"@ngrx/store\";\nimport {PaginationMode} from \"@smartsoft001/angular\";\n\nimport {ICrudFilter} from \"../models/interfaces\";\n\nexport interface State<T extends IEntity<string>> {\n    selected?: T;\n    multiSelected?: Array<T>;\n    list?: T[];\n    totalCount?: number;\n    filter?: ICrudFilter;\n    links?: any;\n    loaded: boolean; // has the Auth list been loaded\n    error?: string | null; // last none error (if any)\n}\n\nexport const initialState: State<any> = {\n    loaded: false\n};\n\nconst crudReducer = (state = initialState, action, entity) => {\n    switch (action.type) {\n        case `[${entity}] Create`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Create Success`:\n            return {\n                ...state,\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Create Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Create Many`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Create Many Success`:\n            return {\n                ...state,\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Create Many Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Export`:\n            return {\n                ...state,\n                loaded: false\n            };\n\n        case `[${entity}] Export Success`:\n            return {\n                ...state,\n                loaded: true\n            };\n\n        case `[${entity}] Export Failure`:\n            return {\n                ...state,\n                loaded: true\n            };\n\n        case `[${entity}] Read`:\n            return {\n                ...state,\n                loaded: false,\n                filter: action.filter,\n                error: null,\n                totalCount: null,\n                links: null,\n            };\n\n        case `[${entity}] Read Success`:\n\n            let list = [];\n\n            if (\n                action.filter\n                && action.filter.offset\n                && state.list\n                && action.filter.paginationMode !== PaginationMode.singlePage\n            ) {\n                state.list.forEach(i => {\n                   list.push(i);\n                });\n\n                list = [\n                    ...list,\n                    ...action.result.data\n                ];\n            } else {\n                list = action.result.data;\n            }\n\n            return {\n                ...state,\n                loaded: true,\n                list,\n                totalCount: action.result.totalCount,\n                links: action.result.links,\n                error: null\n            };\n\n        case `[${entity}] Read Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Select`:\n            return {\n                ...state,\n                loaded: false,\n                selected: null,\n                error: null\n            };\n\n        case `[${entity}] Select Success`:\n            return {\n                ...state,\n                loaded: true,\n                selected: action.item,\n                error: null\n            };\n\n        case `[${entity}] Select Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] MultiSelect`:\n            return {\n                ...state,\n                multiSelected: [...action.items]\n            };\n\n        case `[${entity}] Unselect`:\n            return {\n                ...state,\n                loaded: true,\n                selected: null,\n                error: null\n            };\n\n        case `[${entity}] Update`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Update Success`:\n            return {\n                ...state,\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Update Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Update partial`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Update partial Success`:\n            return {\n                ...state,\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Update partial Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Update partial many`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Update partial many Success`:\n            return {\n                ...state,\n                multiSelected: [],\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Update partial many Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        case `[${entity}] Delete`:\n            return {\n                ...state,\n                loaded: false,\n                error: null\n            };\n\n        case `[${entity}] Delete Success`:\n            return {\n                ...state,\n                loaded: true,\n                error: null\n            };\n\n        case `[${entity}] Delete Failure`:\n            return {\n                ...state,\n                loaded: true,\n                error: action.error\n            };\n\n        default:\n            return state;\n    }\n};\n\nexport function getReducer(entity) {\n    return (state, action: Action) => {\n        return crudReducer(state, action, entity);\n    }\n}\n"]}