@one-paragon/angular-utilities 0.1.19 → 0.1.21

package/src/table-builder/classes/TableState.ts

@@ -0,0 +1,63 @@
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+import { Sort } from '@angular/material/sort';
+import { MetaData, Target } from '../interfaces/report-def';
+import { NotPersisitedTableSettings, PesrsistedTableSettings } from './table-builder-general-settings';
+
+export interface Group {
+  groupName?: string;
+  parentGroupName?: string;
+  isExpanded?: boolean;
+}
+
+export interface PersistedTableState {
+  hiddenKeys?: string [];
+  pageSize?: number;
+  filters: Dictionary<FilterInfo | CustomFilter>;
+  sorted : Sort [];
+  userDefined : {order:Dictionary<number>,widths:Dictionary<number>,table:{width?:number}};
+  persistedTableSettings : PesrsistedTableSettings;
+  groupByKeys: string[];
+  groups: Group[];
+}
+
+export interface TableState extends Required<PersistedTableState> {
+  initializationState: InitializationState;
+  metaData: Dictionary<MetaData>;
+  notPersisitedTableSettings : NotPersisitedTableSettings;
+  linkMaps:{[key:string]:{
+    link: (t:any)=>string,
+    useRouterLink: boolean,
+    target: Target
+  }};
+}
+type RequireNull<T> = { [K in keyof T]: null };
+class KeysToDelete implements  RequireNull<Omit<TableState, keyof PersistedTableState>> {
+  initializationState = null;
+  metaData = null;
+  notPersisitedTableSettings = null;
+  linkMaps = null;
+}
+export const keysToDelete = Object.keys(new KeysToDelete());
+
+export enum InitializationState {
+  Created,
+  MetaDataLoaded,
+  LoadedFromStore,
+  Ready,
+}
+
+export const defaultTableState: TableState = {
+  initializationState: InitializationState.Created,
+  metaData: {},
+  filters: {},
+  hiddenKeys: [],
+  sorted: [],
+  userDefined:{order:{},widths:{},table:{}},
+  persistedTableSettings : new PesrsistedTableSettings(),
+  notPersisitedTableSettings : new NotPersisitedTableSettings(),
+  pageSize: 10,
+  linkMaps:{},
+  groupByKeys: [],
+  groups: []
+};

package/src/table-builder/classes/data-filter.spec.ts

@@ -0,0 +1,72 @@
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { DataFilter } from './data-filter';
+
+
+const data = [{
+  name: 'bob',
+  age: 10
+},
+{
+  name: 'john',
+  age: 11
+},
+{
+  name: 'sally',
+  age: 12
+}
+];
+
+// Straight Jasmine testing without Angular's testing support
+
+class ValueService {
+  getValue = () => 'real value';
+
+  getObservableValue() {
+    return of(data);
+  }
+
+  getPromiseValue() {
+    return this.getObservableValue().pipe(map(() => 'promise value')).toPromise();
+  }
+}
+
+describe('Filter', () => {
+  let service: ValueService;
+  beforeEach(() => {
+    service = new ValueService();
+  });
+
+
+  it('filter should return all when no filters',
+    (done: DoneFn) => {
+      const filter = new DataFilter(of([])).filterData(service.getObservableValue());
+      filter.subscribe(d => {
+        expect(d.length).toBe(3);
+        done();
+      });
+    });
+
+  it('single filter should work',
+    (done: DoneFn) => {
+      const filter = new DataFilter(of([
+        d => d.name.includes('o')
+      ])).filterData( service.getObservableValue());
+      filter.subscribe(d => {
+        expect(d.length).toBe(2);
+        done();
+      });
+    });
+
+  it('multiple filters should work',
+    (done: DoneFn) => {
+      const filter = new DataFilter(of([
+        d => d.name.includes('o'),
+        d => d.age > 10
+      ])).filterData( service.getObservableValue());
+      filter.subscribe(d => {
+        expect(d.length).toBe(1);
+        done();
+      });
+    });
+});

package/src/table-builder/classes/data-filter.ts

@@ -0,0 +1,32 @@
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, shareReplay } from 'rxjs/operators';
+import { combineArrays } from '../../rxjs/rxjs-operators';
+import { createFilterFunc, CustomFilter, FilterInfo } from './filter-info';
+
+export class DataFilter<T = any> {
+
+  constructor(private filters$: Observable< Array< (val: any) => boolean>> ) {
+  }
+
+  filter(data: any[], filters: Array<(val: any) => boolean> ): any[] {
+    return data.filter( r => filters.every( fltr => fltr(r)) );
+  }
+
+  filterData(data$: Observable<T[]>) {
+    return combineLatest([data$, this.filters$]).pipe(
+      map(([data, filters]) => this.filter(data, filters)),
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+  }
+
+  appendFilters(filters$: Observable<(FilterInfo | CustomFilter )[]>) : DataFilter {
+    return new DataFilter(combineArrays([
+      this.filters$ ?? of([]),
+      filters$.pipe(map(fltrs => fltrs
+          // we only want to remove it if it was specifically set to false
+          // as apposed to falsy
+          .filter( f => f.active !== false )
+          .map(filter => createFilterFunc(filter))))
+    ]));
+  }
+}

package/{table-builder/classes/display-col.d.ts → src/table-builder/classes/display-col.ts}

@@ -1,5 +1,5 @@
-export interface DisplayCol {
-    key: string;
-    displayName?: string;
-    isVisible: boolean;
-}
+export interface DisplayCol {
+    key: string;
+    displayName?: string;
+    isVisible: boolean;
+}

package/src/table-builder/classes/filter-info.ts

@@ -0,0 +1,132 @@
+import { StringFilterMap, DateFilterMap, NumberFilterMap, BooleanFilterMap, FilterType, FilterToFiltersMap, EnumFilterMap } from '../enums/filterTypes';
+import { EnumFilterFuncs, StringFilterFuncs } from '../functions/string-filter-function';
+import { NumberFilterFuncs } from '../functions/number-filter-function';
+import { DateFilterFuncs } from '../functions/date-filter-function';
+import { BooleanFilterFuncs } from '../functions/boolean-filter-function';
+import { FieldType } from '../interfaces/report-def';
+import { Dictionary } from '../interfaces/dictionary';
+import { Predicate } from '@angular/core';
+import { get } from 'lodash';
+
+type FilterTypeMapType = { [key in FieldType]: FilterToFiltersMap};
+export type UnmappedTypes = FieldType.Expression |
+  FieldType.Hidden |
+  FieldType.ImageUrl;
+
+
+export type mappedFieldTypes =
+  FieldType.Unknown |
+  FieldType.Date |
+  FieldType.Currency |
+  FieldType.Array |
+  FieldType.Number |
+  FieldType.String |
+  FieldType.Boolean |
+  FieldType.PhoneNumber |
+  FieldType.Link |
+  FieldType.Enum;
+
+export const filterTypeMap: Omit<FilterTypeMapType, UnmappedTypes> = {
+  [FieldType.Unknown] : StringFilterMap,
+  [FieldType.Date] : DateFilterMap,
+  [FieldType.Currency] : NumberFilterMap,
+  [FieldType.Array] : StringFilterMap,
+  [FieldType.Number] : NumberFilterMap,
+  [FieldType.String] : StringFilterMap,
+  [FieldType.Boolean] : BooleanFilterMap,
+  [FieldType.PhoneNumber] : StringFilterMap,
+  [FieldType.Link] : StringFilterMap,
+  [FieldType.Enum] : EnumFilterMap,
+};
+
+const filterFactoryMap: Dictionary<FilterFunc<any,any>> = {
+  [FilterType.And] : (filter: FilterInfo ): ((obj: any) => boolean) =>  {
+    const filters = (filter.filterValue as FilterInfo[]).map(createFilterFunc);
+    return (obj: any) : boolean => filters.every( f => f(obj));
+  },
+  [FilterType.In] : (filter: FilterInfo ): (obj: any) => boolean =>  {
+    const filters = (filter.filterValue as FilterInfo[]).map(createFilterFunc);
+    return (obj: any) : boolean => filters.some( f => f(obj));
+  },
+};
+
+const filterTypeFuncMap : Dictionary<Dictionary<FilterFunc<any,any>>> = {
+  [FieldType.String] : StringFilterFuncs,
+  [FieldType.Array] : StringFilterFuncs,
+  [FieldType.Currency] : NumberFilterFuncs,
+  [FieldType.PhoneNumber] : StringFilterFuncs,
+  [FieldType.Date] : DateFilterFuncs,
+  [FieldType.Number] : NumberFilterFuncs,
+  [FieldType.Boolean] : BooleanFilterFuncs,
+  [FieldType.Unknown] : StringFilterFuncs,
+  [FieldType.Enum] : EnumFilterFuncs ,
+  [FieldType.Link] : StringFilterFuncs,
+};
+
+export interface FilterState {
+  filterId: string;
+  filterType: FilterType;
+  filterValue?: any;
+  active?: boolean;
+
+}
+
+export interface FilterInfo<T extends FieldType = any> extends FilterState {
+    key: string;
+    fieldType: T;
+    _isExternalyManaged?: boolean;
+}
+
+export interface PartialFilter<T extends FieldType = any> {
+  filterId?: string;
+  key: string;
+  fieldType: T;
+  filterType?: FilterType;
+  filterValue?: any;
+}
+
+
+
+export interface CustomFilter<T extends FieldType = any>  extends FilterState {
+  predicate: Predicate<T>;
+  filterType: FilterType.Custom;
+}
+
+export function isCustomFilter(filter : FilterInfo | CustomFilter) :  filter is CustomFilter {
+  return filter && filter.filterType === FilterType.Custom;
+}
+
+export function isFilterInfo(filter : FilterInfo | CustomFilter) :  filter is FilterInfo {
+  return  filter && typeof (filter as FilterInfo).key === 'string' && filter.filterType !== FilterType.Custom;
+}
+
+const defaultPredicate: Predicate<any> = () => true;
+
+export function createFilterFunc(filter: FilterInfo | CustomFilter): Predicate<any>  {
+  if(isCustomFilter(filter)) {
+    return filter.active ? filter.predicate : defaultPredicate;
+  }
+  if (filter.filterValue === undefined) {
+    return defaultPredicate;
+  }
+
+  const func = filterTypeFuncMap[filter.fieldType][filter.filterType](filter);
+  if(!func) {
+    if(filterFactoryMap[filter.filterType]){
+      return filterFactoryMap[filter.filterType!](filter);
+    }
+  }
+
+  const cannotBeTrueForNull = !FalseyValueCanBeIncludedFilterTypes.includes(filter.filterType!);
+  return (rowObj) => {
+    const value = get(rowObj, filter.key);
+    return ((value == undefined) && cannotBeTrueForNull)
+      ? false
+      : func( value);
+  };
+}
+
+export type FilterFunc<T,V = T> = (filterInfo:FilterInfo) => (val:V) => boolean;
+export type Range<T> = {Start:T,End:T};
+
+const FalseyValueCanBeIncludedFilterTypes = [FilterType.IsNull,FilterType.NumberNotEqual,FilterType.DateIsNotOn,FilterType.StringDoesNotContain];

package/src/table-builder/classes/table-builder-general-settings.ts

@@ -0,0 +1,73 @@
+import { merge } from "lodash";
+
+export class GeneralTableSettings {
+  constructor(settings? : TableBuilderSettings){
+    if(settings){
+      merge(this.headerSettings, settings.headerSettings);
+      merge(this.footerSettings, settings.footerSettings);
+      merge(this.columnHeaderSettings, settings.columnHeaderSettings);
+    }
+  }
+  headerSettings = new TableWrapperHeaderSettings();
+  footerSettings = new TableWrapperFooterSettings();
+  columnHeaderSettings = new TableColumnHeaderSettings();
+}
+
+export interface TableBuilderSettings {
+  headerSettings? : Partial<TableWrapperHeaderSettings>;
+  footerSettings? : Partial<TableWrapperFooterSettings>;
+  columnHeaderSettings? : Partial<TableColumnHeaderSettings>;
+}
+
+export class TableWrapperHeaderSettings {
+  hideExport = false
+  hideFilter = false
+  hideColumnSettings = false
+  hideHeader = false
+  hideSort = false
+  collapse = false
+  showTitleWhenCollapsed = true;
+}
+
+export class TableWrapperFooterSettings {
+  collapse = false
+}
+
+export class TableColumnHeaderSettings {
+  noFilters = false;
+  noHeader = false;
+}
+
+export class PesrsistedTableSettings {
+  constructor(tableSettings? :GeneralTableSettings | PesrsistedTableSettings){
+    if (tableSettings){
+      this.collapseHeader = (tableSettings as GeneralTableSettings).headerSettings?.collapse ?? (tableSettings as PesrsistedTableSettings).collapseHeader;
+      this.collapseFooter = (tableSettings as GeneralTableSettings).footerSettings?.collapse ?? (tableSettings as PesrsistedTableSettings).collapseFooter;
+    }
+  }
+  collapseHeader = false;
+  collapseFooter = false;
+}
+
+export class NotPersisitedTableSettings {
+  constructor(tableSettings? :GeneralTableSettings){
+    if(tableSettings){
+      this.hideExport = tableSettings.headerSettings.hideExport;
+      this.hideColumnSettings = tableSettings.headerSettings.hideColumnSettings;
+      this.hideFilter = tableSettings.headerSettings.hideFilter;
+      this.hideSort = tableSettings.headerSettings.hideSort;
+      this.showTitleWhenHeaderCollapsed = tableSettings.headerSettings.showTitleWhenCollapsed;
+      this.hideHeader = tableSettings.headerSettings.hideHeader;
+      this.hideColumnHeaderFilters = tableSettings.columnHeaderSettings.noFilters;
+      this.hideColumnHeader = tableSettings.columnHeaderSettings.noHeader;
+    }
+  }
+  hideExport = true
+  hideFilter = true
+  hideColumnSettings = true
+  hideSort = true
+  showTitleWhenHeaderCollapsed = true;
+  hideHeader = true
+  hideColumnHeaderFilters = true;
+  hideColumnHeader = true;
+}

package/src/table-builder/classes/table-builder.ts

@@ -0,0 +1,71 @@
+import { isObservable, Observable, of } from 'rxjs';
+import { MetaData, FieldType, ReportDef } from '../interfaces/report-def';
+import { first, map, switchMap } from 'rxjs/operators';
+import { mapArray } from '../../rxjs/rxjs-operators';
+import { GeneralTableSettings, TableBuilderSettings } from './table-builder-general-settings';
+import { defaultShareReplay } from '../../rxjs';
+import { get, set } from 'lodash';
+
+export class TableBuilder<T = any> {
+
+  metaData$: Observable<MetaData<T>[]>;
+  constructor(private data$: Observable<T[]>,  metaData$?: Observable<MetaData<T,any>[]>, settings: TableBuilderSettings | Observable<TableBuilderSettings> = new GeneralTableSettings() ) {
+    this.data$ = this.data$.pipe(defaultShareReplay());
+    this.metaData$ = metaData$ ?
+      metaData$.pipe(defaultShareReplay()) :
+      data$.pipe(first(), map( data => this.createMetaData(data[0]) ),defaultShareReplay());
+    const s = isObservable(settings) ? settings : of(settings);
+    this.settings = s.pipe(map(sett => new GeneralTableSettings(sett)),defaultShareReplay());
+  }
+  settings : Observable<GeneralTableSettings>;
+  getData$(): Observable<any[]> {
+    return this.metaData$.pipe(
+      switchMap( metaData => this.data$.pipe(
+        mapArray( data => this.cleanRecord(data, metaData ) )
+      ))
+    );
+  }
+
+  createMetaData(obj: any): MetaData [] {
+    return Object.keys(obj ?? {})
+    .map( key => ({
+      key,
+      fieldType: FieldType.Unknown,
+      order: -1
+    }));
+  }
+
+  cleanVal(val: any, metaData: MetaData): any {
+    switch ( metaData.fieldType ) {
+      case FieldType.Currency:
+      case FieldType.Number:
+        const num = Number( val );
+        return isNaN(num) || val == null ? null : num;
+      case FieldType.Date:
+        const date = Date.parse(val);
+        if(isNaN(date)){
+          return null;
+        }
+        const d = new Date(date);
+        d.setHours(0,0,0,0);
+        return d;
+    }
+    return val;
+  }
+
+  cleanRecord( record: T, metadata: MetaData []): T  {
+    const cleaned = metadata.reduce( (prev: T, curr: MetaData<T>) => {
+      const val = this.cleanVal(get(record, curr.key), curr);
+      if(val !== undefined) {
+        set(prev as {}, curr.key, val);
+      }
+      return prev;
+    }, {...record} as T )
+    return {...record, ...cleaned};
+  }
+}
+
+export const CreateTableBuilder = (reportDef$: Observable<ReportDef> ): TableBuilder => {
+  reportDef$ = reportDef$.pipe(defaultShareReplay());
+  return new TableBuilder(reportDef$.pipe(map( r => r.data) ), reportDef$.pipe( map ( r => r.metaData) ));
+};