@sumaris-net/ngx-components 1.23.9 → 2.0.0-rc1

package/esm2020/src/app/admin/services/person.service.mjs

@@ -0,0 +1,161 @@
+import { Injectable } from '@angular/core';
+import { gql } from '@apollo/client/core';
+import { Person } from '../../core/services/model/person.model';
+import { StatusIds } from '../../core/services/model/model.enum';
+import { JobUtils } from '../../shared/services/job.utils';
+import { PersonFilter } from './filter/person.filter';
+import { EntityUtils } from '../../core/services/model/entity.model';
+import { BaseEntityService } from '../../core/services/base-entity-service.class';
+import { environment } from '../../../environments/environment';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/graphql/graphql.service";
+import * as i2 from "../../core/services/platform.service";
+import * as i3 from "../../core/services/network.service";
+import * as i4 from "../../core/services/storage/entities-storage.service";
+export const PersonFragments = {
+    person: gql `fragment PersonFragment on PersonVO {
+    id
+    firstName
+    lastName
+    email
+    pubkey
+    avatar
+    statusId
+    updateDate
+    creationDate
+    profiles
+    username
+    usernameExtranet
+    department {
+      id
+      label
+      name
+      logo
+      __typename
+    }
+    __typename
+  }`
+};
+// Load persons query
+const PersonQueries = {
+    loadAll: gql `
+    query Persons($offset: Int, $size: Int, $sortBy: String, $sortDirection: String, $filter: PersonFilterVOInput){
+      data: persons(filter: $filter, offset: $offset, size: $size, sortBy: $sortBy, sortDirection: $sortDirection){
+        ...PersonFragment
+      }
+    }
+    ${PersonFragments.person}`,
+    loadAllWithTotal: gql `
+    query PersonsWithTotal($offset: Int, $size: Int, $sortBy: String, $sortDirection: String, $filter: PersonFilterVOInput){
+      data: persons(filter: $filter, offset: $offset, size: $size, sortBy: $sortBy, sortDirection: $sortDirection){
+        ...PersonFragment
+      }
+      total: personsCount(filter: $filter)
+    }
+    ${PersonFragments.person}`
+};
+const PersonMutations = {
+    saveAll: gql `
+    mutation savePersons($data:[PersonVOInput]){
+      data: savePersons(persons: $data){
+        ...PersonFragment
+      }
+    }
+    ${PersonFragments.person}`,
+    deleteAll: gql `
+    mutation deletePersons($ids:[Int]){
+      deletePersons(ids: $ids)
+    }`
+};
+export class PersonService extends BaseEntityService {
+    constructor(graphql, platform, network, entities) {
+        super(graphql, platform, Person, PersonFilter, {
+            queries: PersonQueries,
+            mutations: PersonMutations,
+            defaultSortBy: 'lastName',
+            defaultSortDirection: 'asc'
+        });
+        this.graphql = graphql;
+        this.platform = platform;
+        this.network = network;
+        this.entities = entities;
+        // for DEV only -----
+        this._debug = !environment.production;
+    }
+    async loadAll(offset, size, sortBy, sortDirection, filter, opts) {
+        const offline = this.network.offline && (!opts || opts.fetchPolicy !== 'network-only');
+        if (offline) {
+            return this.loadAllLocally(offset, size, sortBy, sortDirection, filter, opts);
+        }
+        return super.loadAll(offset, size, sortBy, sortDirection, filter, opts);
+    }
+    async loadAllLocally(offset, size, sortBy, sortDirection, filter, opts) {
+        filter = this.asFilter(filter);
+        const variables = {
+            offset: offset || 0,
+            size: size || 100,
+            sortBy: sortBy || this.defaultSortBy,
+            sortDirection: sortDirection || this.defaultSortDirection,
+            filter: filter && filter.asFilterFn()
+        };
+        const { data, total } = await this.entities.loadAll('PersonVO', variables);
+        const entities = (!opts || opts.toEntity !== false) ?
+            (data || []).map(Person.fromObject) :
+            (data || []);
+        return {
+            data: entities,
+            total
+        };
+    }
+    async suggest(value, filter, sortBy, sortDirection) {
+        if (EntityUtils.isNotEmpty(value, 'id'))
+            return { data: [value] };
+        value = (typeof value === 'string' && value !== '*') && value || undefined;
+        sortBy = sortBy || filter.searchAttribute || (filter.searchAttributes && filter.searchAttributes[0]);
+        return this.loadAll(0, !value ? 30 : 10, sortBy, sortDirection, {
+            ...filter,
+            searchText: value,
+            statusIds: filter && filter.statusIds || [StatusIds.ENABLE],
+            userProfiles: filter && filter.userProfiles
+        }, { withTotal: true /* need by autocomplete */ });
+    }
+    async executeImport(filter, opts) {
+        const maxProgression = opts && opts.maxProgression || 100;
+        filter = {
+            ...filter,
+            statusIds: [StatusIds.ENABLE, StatusIds.TEMPORARY],
+            userProfiles: ['SUPERVISOR', 'USER', 'GUEST']
+        };
+        console.info('[person-service] Importing persons...');
+        const res = await JobUtils.fetchAllPages((offset, size) => this.loadAll(offset, size, 'id', null, filter, {
+            debug: false,
+            fetchPolicy: 'network-only',
+            withTotal: (offset === 0),
+            toEntity: false
+        }), { progression: opts?.progression, maxProgression: maxProgression * 0.9 });
+        // Save result locally
+        await this.entities.saveAll(res.data, { entityName: 'PersonVO', reset: true });
+    }
+    /* -- protected methods -- */
+    asObject(source) {
+        if (!source)
+            return undefined;
+        console.debug('TODO check isInstanceOf');
+        if (!(source instanceof Person)) {
+            source = Person.fromObject(source);
+        }
+        const target = source.asObject();
+        // Not known in server GraphQL schema
+        delete target.mainProfile;
+        // Minify the department object
+        target.department = source.department && source.department.asObject(true);
+        return target;
+    }
+}
+PersonService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonService, deps: [{ token: i1.GraphqlService }, { token: i2.PlatformService }, { token: i3.NetworkService }, { token: i4.EntitiesStorage }], target: i0.ɵɵFactoryTarget.Injectable });
+PersonService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.GraphqlService }, { type: i2.PlatformService }, { type: i3.NetworkService }, { type: i4.EntitiesStorage }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"person.service.js","sourceRoot":"","sources":["../../../../../../src/app/admin/services/person.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAc,GAAG,EAAC,MAAM,qBAAqB,CAAC;AAKrD,OAAO,EAAC,MAAM,EAAmB,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAC,SAAS,EAAC,MAAM,sCAAsC,CAAC;AAE/D,OAAO,EAAC,QAAQ,EAAC,MAAM,iCAAiC,CAAC;AAGzD,OAAO,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,wCAAwC,CAAC;AACnE,OAAO,EAA6B,iBAAiB,EAAC,MAAM,+CAA+C,CAAC;AAC5G,OAAO,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;;;;;;AAE9D,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,MAAM,EAAE,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;IAqBT;CACH,CAAC;AAEF,qBAAqB;AACrB,MAAM,aAAa,GAAG;IACpB,OAAO,EAAE,GAAG,CAAA;;;;;;MAMR,eAAe,CAAC,MAAM,EAAE;IAE5B,gBAAgB,EAAE,GAAG,CAAA;;;;;;;MAOjB,eAAe,CAAC,MAAM,EAAE;CAC7B,CAAC;AAGF,MAAM,eAAe,GAA+B;IAClD,OAAO,EAAE,GAAG,CAAA;;;;;;MAMR,eAAe,CAAC,MAAM,EAAE;IAC5B,SAAS,EAAE,GAAG,CAAA;;;MAGV;CACL,CAAC;AAGF,MAAM,OAAO,aAAc,SAAQ,iBAAuC;IAGxE,YACY,OAAuB,EACvB,QAAyB,EACzB,OAAuB,EACvB,QAAyB;QAEnC,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE;YAC7C,OAAO,EAAE,aAAa;YACtB,SAAS,EAAE,eAAe;YAC1B,aAAa,EAAE,UAAU;YACzB,oBAAoB,EAAE,KAAK;SAC5B,CAAC,CAAC;QAVO,YAAO,GAAP,OAAO,CAAgB;QACvB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,YAAO,GAAP,OAAO,CAAgB;QACvB,aAAQ,GAAR,QAAQ,CAAiB;QASnC,qBAAqB;QACrB,IAAI,CAAC,MAAM,GAAG,CAAC,WAAW,CAAC,UAAU,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,MAAc,EAAE,IAAY,EAAE,MAAe,EAC7C,aAA6B,EAC7B,MAA8B,EAAE,IAMzC;QAEH,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,cAAc,CAAC,CAAC;QACvF,IAAI,OAAO,EAAE;YACX,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;SAC/E;QAED,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1E,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,MAAc,EAAE,IAAY,EAAE,MAAe,EAAE,aAA6B,EAC5E,MAA8B,EAC9B,IAMC;QAEpB,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/B,MAAM,SAAS,GAAG;YAChB,MAAM,EAAE,MAAM,IAAI,CAAC;YACnB,IAAI,EAAE,IAAI,IAAI,GAAG;YACjB,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC,aAAa;YACpC,aAAa,EAAE,aAAa,IAAI,IAAI,CAAC,oBAAoB;YACzD,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,UAAU,EAAE;SACtC,CAAC;QAEF,MAAM,EAAC,IAAI,EAAE,KAAK,EAAC,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAS,UAAU,EAAE,SAAS,CAAC,CAAC;QAEjF,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC;YACnD,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YACrC,CAAC,IAAI,IAAI,EAAE,CAAa,CAAC;QAC3B,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,KAAK;SACN,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAU,EAAE,MAAqB,EAAE,MAAe,EAAE,aAA6B;QAC7F,IAAI,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC;YAAE,OAAO,EAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAC,CAAC;QAChE,KAAK,GAAG,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,SAAS,CAAC;QAC3E,MAAM,GAAG,MAAM,IAAI,MAAM,CAAC,eAAe,IAAI,CAAC,MAAM,CAAC,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;QACrG,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,aAAa,EAC5D;YACE,GAAG,MAAM;YACT,UAAU,EAAE,KAAe;YAC3B,SAAS,EAAE,MAAM,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YAC3D,YAAY,EAAE,MAAM,IAAI,MAAM,CAAC,YAAY;SAC5C,EACD,EAAE,SAAS,EAAE,IAAI,CAAC,0BAA0B,EAAE,CAC7C,CAAC;IACN,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,MAA6B,EAC7B,IAGC;QAEnB,MAAM,cAAc,GAAG,IAAI,IAAI,IAAI,CAAC,cAAc,IAAI,GAAG,CAAC;QAC1D,MAAM,GAAG;YACP,GAAG,MAAM;YACT,SAAS,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC;YAClD,YAAY,EAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC;SAClE,CAAC;QAEF,OAAO,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;QAEtD,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CACtD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE;YAC7C,KAAK,EAAE,KAAK;YACZ,WAAW,EAAE,cAAc;YAC3B,SAAS,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;YACzB,QAAQ,EAAE,KAAK;SAChB,CAAC,EACJ,EAAC,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,GAAG,GAAG,EAAC,CACvE,CAAC;QAEF,sBAAsB;QACtB,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;IAC/E,CAAC;IAED,6BAA6B;IAEnB,QAAQ,CAAC,MAAoB;QACrC,IAAI,CAAC,MAAM;YAAE,OAAO,SAAS,CAAC;QAE9B,OAAO,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC;QACzC,IAAI,CAAC,CAAC,MAAM,YAAY,MAAM,CAAC,EAAE;YAC/B,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;SACpC;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAEjC,qCAAqC;QACrC,OAAO,MAAM,CAAC,WAAW,CAAC;QAE1B,+BAA+B;QAC/B,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAE1E,OAAO,MAAM,CAAC;IAChB,CAAC;;0GAnIU,aAAa;8GAAb,aAAa,cADD,MAAM;2FAClB,aAAa;kBADzB,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC","sourcesContent":["import {Injectable} from '@angular/core';\nimport {FetchPolicy, gql} from '@apollo/client/core';\nimport {BehaviorSubject} from 'rxjs';\nimport {GraphqlService} from '../../core/graphql/graphql.service';\nimport {NetworkService} from '../../core/services/network.service';\nimport {EntitiesStorage} from '../../core/services/storage/entities-storage.service';\nimport {Person, UserProfileLabel} from '../../core/services/model/person.model';\nimport {StatusIds} from '../../core/services/model/model.enum';\nimport {SortDirection} from '@angular/material/sort';\nimport {JobUtils} from '../../shared/services/job.utils';\nimport {LoadResult, SuggestService} from '../../shared/services/entity-service.class';\nimport {PlatformService} from '../../core/services/platform.service';\nimport {PersonFilter} from './filter/person.filter';\nimport {EntityUtils} from '../../core/services/model/entity.model';\nimport {BaseEntityGraphqlMutations, BaseEntityService} from '../../core/services/base-entity-service.class';\nimport {environment} from '../../../environments/environment';\n\nexport const PersonFragments = {\n  person: gql`fragment PersonFragment on PersonVO {\n    id\n    firstName\n    lastName\n    email\n    pubkey\n    avatar\n    statusId\n    updateDate\n    creationDate\n    profiles\n    username\n    usernameExtranet\n    department {\n      id\n      label\n      name\n      logo\n      __typename\n    }\n    __typename\n  }`\n};\n\n// Load persons query\nconst PersonQueries = {\n  loadAll: gql`\n    query Persons($offset: Int, $size: Int, $sortBy: String, $sortDirection: String, $filter: PersonFilterVOInput){\n      data: persons(filter: $filter, offset: $offset, size: $size, sortBy: $sortBy, sortDirection: $sortDirection){\n        ...PersonFragment\n      }\n    }\n    ${PersonFragments.person}`,\n\n  loadAllWithTotal: gql`\n    query PersonsWithTotal($offset: Int, $size: Int, $sortBy: String, $sortDirection: String, $filter: PersonFilterVOInput){\n      data: persons(filter: $filter, offset: $offset, size: $size, sortBy: $sortBy, sortDirection: $sortDirection){\n        ...PersonFragment\n      }\n      total: personsCount(filter: $filter)\n    }\n    ${PersonFragments.person}`\n};\n\n\nconst PersonMutations: BaseEntityGraphqlMutations = {\n  saveAll: gql`\n    mutation savePersons($data:[PersonVOInput]){\n      data: savePersons(persons: $data){\n        ...PersonFragment\n      }\n    }\n    ${PersonFragments.person}`,\n  deleteAll: gql`\n    mutation deletePersons($ids:[Int]){\n      deletePersons(ids: $ids)\n    }`\n};\n\n@Injectable({providedIn: 'root'})\nexport class PersonService extends BaseEntityService<Person, PersonFilter>\n  implements SuggestService<Person, PersonFilter> {\n\n  constructor(\n    protected graphql: GraphqlService,\n    protected platform: PlatformService,\n    protected network: NetworkService,\n    protected entities: EntitiesStorage\n  ) {\n    super(graphql, platform, Person, PersonFilter, {\n      queries: PersonQueries,\n      mutations: PersonMutations,\n      defaultSortBy: 'lastName',\n      defaultSortDirection: 'asc'\n    });\n\n    // for DEV only -----\n    this._debug = !environment.production;\n  }\n\n  async loadAll(offset: number, size: number, sortBy?: string,\n                sortDirection?: SortDirection,\n                filter?: Partial<PersonFilter>, opts?: {\n        [key: string]: any;\n        fetchPolicy?: FetchPolicy;\n        debug?: boolean;\n        withTotal?: boolean;\n        toEntity?: boolean;\n      }): Promise<LoadResult<Person>> {\n\n    const offline = this.network.offline && (!opts || opts.fetchPolicy !== 'network-only');\n    if (offline) {\n      return this.loadAllLocally(offset, size, sortBy, sortDirection, filter, opts);\n    }\n\n    return super.loadAll(offset, size, sortBy, sortDirection, filter, opts);\n  }\n\n  async loadAllLocally(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection,\n                       filter?: Partial<PersonFilter>,\n                       opts?: {\n                         [key: string]: any;\n                         fetchPolicy?: FetchPolicy;\n                         debug?: boolean;\n                         withTotal?: boolean;\n                         toEntity?: boolean;\n                       }): Promise<LoadResult<Person>> {\n\n    filter = this.asFilter(filter);\n\n    const variables = {\n      offset: offset || 0,\n      size: size || 100,\n      sortBy: sortBy || this.defaultSortBy,\n      sortDirection: sortDirection || this.defaultSortDirection,\n      filter: filter && filter.asFilterFn()\n    };\n\n    const {data, total} = await this.entities.loadAll<Person>('PersonVO', variables);\n\n    const entities = (!opts || opts.toEntity !== false) ?\n      (data || []).map(Person.fromObject) :\n      (data || []) as Person[];\n    return {\n      data: entities,\n      total\n    };\n  }\n\n  async suggest(value: any, filter?: PersonFilter, sortBy?: string, sortDirection?: SortDirection): Promise<LoadResult<Person>> {\n    if (EntityUtils.isNotEmpty(value, 'id')) return {data: [value]};\n    value = (typeof value === 'string' && value !== '*') && value || undefined;\n    sortBy = sortBy || filter.searchAttribute || (filter.searchAttributes && filter.searchAttributes[0]);\n    return this.loadAll(0, !value ? 30 : 10, sortBy, sortDirection,\n      {\n        ...filter,\n        searchText: value as string,\n        statusIds: filter && filter.statusIds || [StatusIds.ENABLE],\n        userProfiles: filter && filter.userProfiles\n      },\n      { withTotal: true /* need by autocomplete */ }\n      );\n  }\n\n  async executeImport(filter: Partial<PersonFilter>,\n                      opts: {\n                        progression?: BehaviorSubject<number>;\n                        maxProgression?: number;\n                      }): Promise<void> {\n\n    const maxProgression = opts && opts.maxProgression || 100;\n    filter = {\n      ...filter,\n      statusIds: [StatusIds.ENABLE, StatusIds.TEMPORARY],\n      userProfiles: <UserProfileLabel[]>['SUPERVISOR', 'USER', 'GUEST']\n    };\n\n    console.info('[person-service] Importing persons...');\n\n    const res = await JobUtils.fetchAllPages((offset, size) =>\n        this.loadAll(offset, size, 'id', null, filter, {\n          debug: false,\n          fetchPolicy: 'network-only',\n          withTotal: (offset === 0), // Compute total only once\n          toEntity: false\n        }),\n      {progression: opts?.progression, maxProgression: maxProgression * 0.9}\n    );\n\n    // Save result locally\n    await this.entities.saveAll(res.data, {entityName: 'PersonVO', reset: true});\n  }\n\n  /* -- protected methods -- */\n\n  protected asObject(source: Person | any): any {\n    if (!source) return undefined;\n\n    console.debug('TODO check isInstanceOf');\n    if (!(source instanceof Person)) {\n      source = Person.fromObject(source);\n    }\n    const target = source.asObject();\n\n    // Not known in server GraphQL schema\n    delete target.mainProfile;\n\n    // Minify the department object\n    target.department = source.department && source.department.asObject(true);\n\n    return target;\n  }\n\n}\n"]}

package/esm2020/src/app/admin/services/validator/person.validator.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { Account } from '../../../core/services/model/account.model';
+import { SharedValidators } from '../../../shared/validator/validators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../../core/services/validator/account.validator";
+export class PersonValidatorService {
+    constructor(formBuilder, accountValidatorService) {
+        this.formBuilder = formBuilder;
+        this.accountValidatorService = accountValidatorService;
+    }
+    getRowValidator() {
+        return this.getFormGroup();
+    }
+    getFormGroup(data) {
+        // Use account validator as base form group definition
+        // BUT add more flexibility (e.g. 'pubkey' become optional)
+        // This is need to be able to store person that are not using SUMARiS tools (e.g. onboard observers)
+        const formConfig = this.accountValidatorService.getFormGroupConfig(data && Account.fromObject(data.asObject()));
+        formConfig.pubkey = [data && data.pubkey || null, SharedValidators.pubkey];
+        formConfig.username = [data && data.username || null, Validators.minLength(2)];
+        formConfig.usernameExtranet = [data && data.usernameExtranet || null, Validators.minLength(2)];
+        formConfig.avatar = [data && data.avatar || null];
+        return this.formBuilder.group(formConfig);
+    }
+}
+PersonValidatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonValidatorService, deps: [{ token: i1.UntypedFormBuilder }, { token: i2.AccountValidatorService }], target: i0.ɵɵFactoryTarget.Injectable });
+PersonValidatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonValidatorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: PersonValidatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.UntypedFormBuilder }, { type: i2.AccountValidatorService }]; } });
+//# sourceMappingURL=data:application/json;base64,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