@sumaris-net/ngx-components 18.23.13 → 18.23.15

package/doc/changelog.md

@@ -2079,3 +2079,9 @@ enh: Environment: add useHash property to configure Angular router to use hash U
 
 # 18.23.12
 - enh(account) Add avatar edition (enable by a config option)
+
+# 18.23.14
+- enh(account-service) Add service options (new injection token), to be able to change graphql default queries 
+
+# 18.23.15
+- enh(entity-metadata-component) Fix avatar background color

package/esm2022/src/app/admin/users/person.service.mjs

@@ -1,14 +1,18 @@
-import { Directive, inject, InjectionToken } from '@angular/core';
+import { Directive, Injectable, inject, Inject, InjectionToken, Optional } from '@angular/core';
+import { Person } from '../../core/services/model/person.model';
 import { StatusIds } from '../../core/services/model/model.enum';
+import { PersonFilter } from './person.filter';
 import { BaseEntityService, } from '../../core/services/base-entity-service.class';
 import { isNotEmptyArray } from '../../shared/functions';
 import { NetworkService } from '../../core/services/network.service';
 import { EntitiesStorage } from '../../core/services/storage/entities-storage.service';
 import { ENVIRONMENT } from '../../../environments/environment.class';
+import { gql } from 'apollo-angular';
 import * as i0 from "@angular/core";
 import * as i1 from "../../core/graphql/graphql.service";
 import * as i2 from "../../core/services/platform.service";
 export const APP_PERSON_SERVICE = new InjectionToken('PersonService');
+export const APP_PERSON_SERVICE_OPTIONS = new InjectionToken('PersonServiceOptions');
 // This class is under GPLv3 license
 export class AbstractPersonService extends BaseEntityService {
     dataType;
@@ -86,4 +90,137 @@ export class AbstractPersonService extends BaseEntityService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractPersonService, decorators: [{
             type: Directive
         }], ctorParameters: () => [{ type: i1.GraphqlService }, { type: i2.PlatformService }, { type: undefined }, { type: undefined }, { type: undefined }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"person.service.js","sourceRoot":"","sources":["../../../../../../src/app/admin/users/person.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, InjectionToken } from '@angular/core';\nimport { GraphqlService } from '../../core/graphql/graphql.service';\nimport { Person } from '../../core/services/model/person.model';\nimport { StatusIds } from '../../core/services/model/model.enum';\nimport { SortDirection } from '@angular/material/sort';\nimport {\n  EntitiesServiceLoadOptions,\n  EntitiesServiceWatchOptions,\n  EntityServiceLoadOptions,\n  IEntitiesService,\n  LoadResult,\n  SuggestService,\n} from '../../shared/services/entity-service.class';\nimport { PlatformService } from '../../core/services/platform.service';\nimport { PersonFilter } from './person.filter';\nimport {\n  BaseEntityGraphqlMutations,\n  BaseEntityGraphqlQueries,\n  BaseEntityGraphqlSubscriptions,\n  BaseEntityService,\n  BaseEntityServiceOptions,\n} from '../../core/services/base-entity-service.class';\nimport { IStartableService } from '../../shared/services/startable-service.class';\nimport { isNotEmptyArray } from '../../shared/functions';\nimport { NetworkService } from '../../core/services/network.service';\nimport { EntitiesStorage } from '../../core/services/storage/entities-storage.service';\nimport { ENVIRONMENT } from '../../../environments/environment.class';\n\nexport const APP_PERSON_SERVICE = new InjectionToken<IPersonService<any, any>>('PersonService');\n\nexport interface IPersonService<\n  E extends Person<E> = Person<any>,\n  F extends PersonFilter = PersonFilter,\n  ID = number,\n  WO extends EntitiesServiceWatchOptions<E> = EntitiesServiceWatchOptions<E>,\n  LO extends EntitiesServiceLoadOptions<E> = EntitiesServiceLoadOptions<E>,\n> extends IEntitiesService<E, F, WO>,\n    SuggestService<E, F>,\n    IStartableService {\n  loadAll(\n    offset: number,\n    size: number,\n    sortBy?: keyof Person | string,\n    sortDirection?: SortDirection,\n    filter?: Partial<PersonFilter>,\n    opts?: LO & {\n      debug?: boolean;\n    }\n  ): Promise<LoadResult<Person>>;\n\n  loadById(id: number, opts?: EntityServiceLoadOptions): Promise<Person>;\n\n  loadByPubkey(pubkey: string, opts?: EntityServiceLoadOptions): Promise<Person>;\n\n  countAll(filter?: Partial<F>, opts?: LO): Promise<number>;\n}\n\nexport interface AbstractPersonServiceOptions<\n  T extends Person<any>,\n  Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,\n  M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,\n  S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions,\n> extends BaseEntityServiceOptions<T, number, Q, M, S> {}\n\n// This class is under GPLv3 license\n@Directive()\nexport abstract class AbstractPersonService<\n    E extends Person<E> = Person<any>,\n    F extends PersonFilter<F, E> = PersonFilter<any, E>,\n    Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,\n    M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,\n    S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions,\n    WO extends EntitiesServiceWatchOptions<E> = EntitiesServiceWatchOptions<E>,\n    LO extends EntitiesServiceLoadOptions<E> = EntitiesServiceLoadOptions<E>,\n    O extends AbstractPersonServiceOptions<E, Q, M, S> = AbstractPersonServiceOptions<E, Q, M, S>,\n  >\n  extends BaseEntityService<E, F, number, WO, LO>\n  implements IPersonService<E, F>\n{\n  protected network = inject(NetworkService);\n  protected entities = inject(EntitiesStorage);\n\n  protected constructor(\n    graphql: GraphqlService,\n    platform: PlatformService,\n    protected dataType: new () => E,\n    protected filterType: new () => F,\n    protected options: O\n  ) {\n    super(graphql, platform, dataType, filterType, options);\n\n    // for DEV only -----\n    this._debug = !inject(ENVIRONMENT).production;\n  }\n\n  async loadAll(\n    offset: number,\n    size: number,\n    sortBy?: keyof E | string,\n    sortDirection?: SortDirection,\n    filter?: Partial<F>,\n    opts?: EntitiesServiceLoadOptions & { debug?: boolean }\n  ): Promise<LoadResult<E>> {\n    const offline = this.network.offline && (!opts || opts.fetchPolicy !== 'network-only');\n    if (offline) {\n      return this.loadAllLocally(offset, size, sortBy as string, sortDirection, filter, opts);\n    }\n    return super.loadAll(offset, size, sortBy as any, sortDirection, filter, opts as any);\n  }\n\n  protected async loadAllLocally(\n    offset: number,\n    size: number,\n    sortBy?: string,\n    sortDirection?: SortDirection,\n    filter?: Partial<F>,\n    opts?: EntitiesServiceLoadOptions & { debug?: boolean }\n  ): Promise<LoadResult<E>> {\n    filter = this.asFilter(filter);\n\n    const variables = {\n      offset: offset || 0,\n      size: size || 100,\n      sortBy: sortBy || (this.defaultSortBy as string),\n      sortDirection: sortDirection || this.defaultSortDirection,\n      filter: (filter as any) && (filter as any).asFilterFn ? (filter as any).asFilterFn() : filter,\n    };\n\n    const typename = (this.dataType as any).TYPENAME || new this.dataType().__typename || 'PersonVO';\n    const { data, total } = await this.entities.loadAll<E>(typename, variables);\n\n    const entities = this.fromObjects(data, opts as any);\n    const res: LoadResult<E> = { data: entities, total } as any;\n\n    // Add fetch more function\n    const nextOffset = (offset || 0) + entities.length;\n    if (nextOffset < total) {\n      res.fetchMore = () => this.loadAllLocally(nextOffset, size, sortBy, sortDirection, filter, opts);\n    }\n\n    return res;\n  }\n\n  async suggest(\n    value: any,\n    filter?: Partial<F>,\n    sortBy?: keyof E | string,\n    sortDirection?: SortDirection,\n    opts?: EntitiesServiceLoadOptions\n  ): Promise<LoadResult<E>> {\n    if ((value as any)?.id != null) return { data: [value] } as any;\n    value = (typeof value === 'string' && value !== '*' && value) || undefined;\n    const f = (filter as any) || {};\n    sortBy = (sortBy as any) || f.searchAttribute || (f.searchAttributes && f.searchAttributes[0]);\n    return this.loadAll(\n      0,\n      !value ? 30 : 10,\n      sortBy,\n      sortDirection,\n      {\n        ...(filter as any),\n        searchText: value as string,\n        statusIds: (f && f.statusIds) || [StatusIds.ENABLE, StatusIds.TEMPORARY],\n        userProfiles: f && f.userProfiles,\n      },\n      {\n        withTotal: true /* need by autocomplete */,\n        ...(opts as any),\n      } as any\n    );\n  }\n\n  async loadById(id: number, opts?: EntityServiceLoadOptions): Promise<E> {\n    const { data } = await this.loadAll(0, 1, null as any, null as any, { includedIds: [id] } as any, { withTotal: false, ...(opts as any) });\n    const source = isNotEmptyArray(data) ? (data[0] as any) : ({ id } as any);\n    return this.fromObject(source, opts as any);\n  }\n\n  async loadByPubkey(pubkey: string, opts?: EntityServiceLoadOptions): Promise<E> {\n    const { data } = await this.loadAll(0, 1, null as any, null as any, { pubkey } as any, { withTotal: false, ...(opts as any) });\n    const source = isNotEmptyArray(data) ? (data[0] as any) : ({ pubkey } as any);\n    return this.fromObject(source, opts as any);\n  }\n\n  protected asObject(source: E | any): any {\n    return super.asObject(source);\n  }\n}\n"]}
+/* ------------------------------------
+ * Default GraphQL (from former testing service)
+ * ------------------------------------*/
+export const PersonFragments = {
+    lightPerson: gql `
+    fragment LightPersonFragment on PersonVO {
+      id
+      firstName
+      lastName
+      avatar
+      department {
+        id
+        label
+        name
+        __typename
+      }
+      __typename
+    }
+  `,
+    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
+    }
+  `,
+    personFilter: gql `
+    fragment PersonFilterFragment on PersonFilterVO {
+      email
+      pubkey
+      searchText
+      statusIds
+      userProfiles
+      includedIds
+      excludedIds
+      searchAttribute
+      searchAttributes
+    }
+  `,
+};
+const DefaultPersonQueries = {
+    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 DefaultPersonMutations = {
+    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 AbstractPersonService {
+    constructor(graphql, platform, options) {
+        super(graphql, platform, Person, PersonFilter, {
+            queries: { ...DefaultPersonQueries, ...(options?.queries || {}) },
+            mutations: { ...DefaultPersonMutations, ...(options?.mutations || {}) },
+            subscriptions: options?.subscriptions,
+            defaultSortBy: 'lastName',
+            defaultSortDirection: 'asc',
+            watchQueriesDeletePolicy: 'refetch-queries',
+        });
+    }
+    /* -- protected methods -- */
+    asObject(source) {
+        if (!source)
+            return undefined;
+        if (!(source instanceof Person)) {
+            source = Person.fromObject(source);
+        }
+        const target = source.asObject();
+        // Not known in server GraphQL schema
+        delete target.mainProfile;
+        target.department = source.department?.asObject();
+        return target;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PersonService, deps: [{ token: i1.GraphqlService }, { token: i2.PlatformService }, { token: APP_PERSON_SERVICE_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PersonService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PersonService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.GraphqlService }, { type: i2.PlatformService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_PERSON_SERVICE_OPTIONS]
+                }] }] });
+export function providePersonService() {
+    return {
+        provide: APP_PERSON_SERVICE,
+        useExisting: PersonService,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"person.service.js","sourceRoot":"","sources":["../../../../../../src/app/admin/users/person.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Injectable, inject, Inject, InjectionToken, Optional, Provider } from '@angular/core';\nimport { GraphqlService } from '../../core/graphql/graphql.service';\nimport { Person } from '../../core/services/model/person.model';\nimport { StatusIds } from '../../core/services/model/model.enum';\nimport { SortDirection } from '@angular/material/sort';\nimport {\n  EntitiesServiceLoadOptions,\n  EntitiesServiceWatchOptions,\n  EntityServiceLoadOptions,\n  IEntitiesService,\n  LoadResult,\n  SuggestService,\n} from '../../shared/services/entity-service.class';\nimport { PlatformService } from '../../core/services/platform.service';\nimport { PersonFilter } from './person.filter';\nimport {\n  BaseEntityGraphqlMutations,\n  BaseEntityGraphqlQueries,\n  BaseEntityGraphqlSubscriptions,\n  BaseEntityService,\n  BaseEntityServiceOptions,\n} from '../../core/services/base-entity-service.class';\nimport { IStartableService } from '../../shared/services/startable-service.class';\nimport { isNotEmptyArray } from '../../shared/functions';\nimport { NetworkService } from '../../core/services/network.service';\nimport { EntitiesStorage } from '../../core/services/storage/entities-storage.service';\nimport { ENVIRONMENT } from '../../../environments/environment.class';\nimport { gql } from 'apollo-angular';\n\nexport const APP_PERSON_SERVICE = new InjectionToken<IPersonService<any, any>>('PersonService');\n\nexport interface IPersonService<\n  E extends Person<E> = Person<any>,\n  F extends PersonFilter = PersonFilter,\n  ID = number,\n  WO extends EntitiesServiceWatchOptions<E> = EntitiesServiceWatchOptions<E>,\n  LO extends EntitiesServiceLoadOptions<E> = EntitiesServiceLoadOptions<E>,\n> extends IEntitiesService<E, F, WO>,\n    SuggestService<E, F>,\n    IStartableService {\n  loadAll(\n    offset: number,\n    size: number,\n    sortBy?: keyof Person | string,\n    sortDirection?: SortDirection,\n    filter?: Partial<PersonFilter>,\n    opts?: LO & {\n      debug?: boolean;\n    }\n  ): Promise<LoadResult<Person>>;\n\n  loadById(id: number, opts?: EntityServiceLoadOptions): Promise<Person>;\n\n  loadByPubkey(pubkey: string, opts?: EntityServiceLoadOptions): Promise<Person>;\n\n  countAll(filter?: Partial<F>, opts?: LO): Promise<number>;\n}\n\nexport interface AbstractPersonServiceOptions<\n  T extends Person<any>,\n  Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,\n  M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,\n  S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions,\n> extends BaseEntityServiceOptions<T, number, Q, M, S> {}\n\n// Allow apps to override GraphQL operations used by PersonService\nexport interface PersonServiceOptions {\n  queries?: Partial<BaseEntityGraphqlQueries>;\n  mutations?: Partial<BaseEntityGraphqlMutations>;\n  subscriptions?: Partial<BaseEntityGraphqlSubscriptions>;\n}\nexport const APP_PERSON_SERVICE_OPTIONS = new InjectionToken<PersonServiceOptions>('PersonServiceOptions');\n\n// This class is under GPLv3 license\n@Directive()\nexport abstract class AbstractPersonService<\n    E extends Person<E> = Person<any>,\n    F extends PersonFilter<F, E> = PersonFilter<any, E>,\n    Q extends BaseEntityGraphqlQueries = BaseEntityGraphqlQueries,\n    M extends BaseEntityGraphqlMutations = BaseEntityGraphqlMutations,\n    S extends BaseEntityGraphqlSubscriptions = BaseEntityGraphqlSubscriptions,\n    WO extends EntitiesServiceWatchOptions<E> = EntitiesServiceWatchOptions<E>,\n    LO extends EntitiesServiceLoadOptions<E> = EntitiesServiceLoadOptions<E>,\n    O extends AbstractPersonServiceOptions<E, Q, M, S> = AbstractPersonServiceOptions<E, Q, M, S>,\n  >\n  extends BaseEntityService<E, F, number, WO, LO>\n  implements IPersonService<E, F>\n{\n  protected network = inject(NetworkService);\n  protected entities = inject(EntitiesStorage);\n\n  protected constructor(\n    graphql: GraphqlService,\n    platform: PlatformService,\n    protected dataType: new () => E,\n    protected filterType: new () => F,\n    protected options: O\n  ) {\n    super(graphql, platform, dataType, filterType, options);\n\n    // for DEV only -----\n    this._debug = !inject(ENVIRONMENT).production;\n  }\n\n  async loadAll(\n    offset: number,\n    size: number,\n    sortBy?: keyof E | string,\n    sortDirection?: SortDirection,\n    filter?: Partial<F>,\n    opts?: EntitiesServiceLoadOptions & { debug?: boolean }\n  ): Promise<LoadResult<E>> {\n    const offline = this.network.offline && (!opts || opts.fetchPolicy !== 'network-only');\n    if (offline) {\n      return this.loadAllLocally(offset, size, sortBy as string, sortDirection, filter, opts);\n    }\n    return super.loadAll(offset, size, sortBy as any, sortDirection, filter, opts as any);\n  }\n\n  protected async loadAllLocally(\n    offset: number,\n    size: number,\n    sortBy?: string,\n    sortDirection?: SortDirection,\n    filter?: Partial<F>,\n    opts?: EntitiesServiceLoadOptions & { debug?: boolean }\n  ): Promise<LoadResult<E>> {\n    filter = this.asFilter(filter);\n\n    const variables = {\n      offset: offset || 0,\n      size: size || 100,\n      sortBy: sortBy || (this.defaultSortBy as string),\n      sortDirection: sortDirection || this.defaultSortDirection,\n      filter: (filter as any) && (filter as any).asFilterFn ? (filter as any).asFilterFn() : filter,\n    };\n\n    const typename = (this.dataType as any).TYPENAME || new this.dataType().__typename || 'PersonVO';\n    const { data, total } = await this.entities.loadAll<E>(typename, variables);\n\n    const entities = this.fromObjects(data, opts as any);\n    const res: LoadResult<E> = { data: entities, total } as any;\n\n    // Add fetch more function\n    const nextOffset = (offset || 0) + entities.length;\n    if (nextOffset < total) {\n      res.fetchMore = () => this.loadAllLocally(nextOffset, size, sortBy, sortDirection, filter, opts);\n    }\n\n    return res;\n  }\n\n  async suggest(\n    value: any,\n    filter?: Partial<F>,\n    sortBy?: keyof E | string,\n    sortDirection?: SortDirection,\n    opts?: EntitiesServiceLoadOptions\n  ): Promise<LoadResult<E>> {\n    if ((value as any)?.id != null) return { data: [value] } as any;\n    value = (typeof value === 'string' && value !== '*' && value) || undefined;\n    const f = (filter as any) || {};\n    sortBy = (sortBy as any) || f.searchAttribute || (f.searchAttributes && f.searchAttributes[0]);\n    return this.loadAll(\n      0,\n      !value ? 30 : 10,\n      sortBy,\n      sortDirection,\n      {\n        ...(filter as any),\n        searchText: value as string,\n        statusIds: (f && f.statusIds) || [StatusIds.ENABLE, StatusIds.TEMPORARY],\n        userProfiles: f && f.userProfiles,\n      },\n      {\n        withTotal: true /* need by autocomplete */,\n        ...(opts as any),\n      } as any\n    );\n  }\n\n  async loadById(id: number, opts?: EntityServiceLoadOptions): Promise<E> {\n    const { data } = await this.loadAll(0, 1, null as any, null as any, { includedIds: [id] } as any, { withTotal: false, ...(opts as any) });\n    const source = isNotEmptyArray(data) ? (data[0] as any) : ({ id } as any);\n    return this.fromObject(source, opts as any);\n  }\n\n  async loadByPubkey(pubkey: string, opts?: EntityServiceLoadOptions): Promise<E> {\n    const { data } = await this.loadAll(0, 1, null as any, null as any, { pubkey } as any, { withTotal: false, ...(opts as any) });\n    const source = isNotEmptyArray(data) ? (data[0] as any) : ({ pubkey } as any);\n    return this.fromObject(source, opts as any);\n  }\n\n  protected asObject(source: E | any): any {\n    return super.asObject(source);\n  }\n}\n\n/* ------------------------------------\n * Default GraphQL (from former testing service)\n * ------------------------------------*/\nexport const PersonFragments = {\n  lightPerson: gql`\n    fragment LightPersonFragment on PersonVO {\n      id\n      firstName\n      lastName\n      avatar\n      department {\n        id\n        label\n        name\n        __typename\n      }\n      __typename\n    }\n  `,\n\n  person: gql`\n    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  personFilter: gql`\n    fragment PersonFilterFragment on PersonFilterVO {\n      email\n      pubkey\n      searchText\n      statusIds\n      userProfiles\n      includedIds\n      excludedIds\n      searchAttribute\n      searchAttributes\n    }\n  `,\n};\n\nconst DefaultPersonQueries: BaseEntityGraphqlQueries = {\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\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 DefaultPersonMutations: BaseEntityGraphqlMutations = {\n  saveAll: gql`\n    mutation savePersons($data: [PersonVOInput]) {\n      data: savePersons(persons: $data) {\n        ...PersonFragment\n      }\n    }\n    ${PersonFragments.person}\n  `,\n  deleteAll: gql`\n    mutation deletePersons($ids: [Int]) {\n      deletePersons(ids: $ids)\n    }\n  `,\n};\n\n@Injectable({ providedIn: 'root' })\nexport class PersonService extends AbstractPersonService<Person, PersonFilter> implements IPersonService {\n  constructor(\n    graphql: GraphqlService,\n    platform: PlatformService,\n    @Optional() @Inject(APP_PERSON_SERVICE_OPTIONS) options?: PersonServiceOptions\n  ) {\n    super(graphql, platform, Person, PersonFilter, {\n      queries: { ...DefaultPersonQueries, ...(options?.queries || {}) },\n      mutations: { ...DefaultPersonMutations, ...(options?.mutations || {}) },\n      subscriptions: options?.subscriptions as any,\n      defaultSortBy: 'lastName',\n      defaultSortDirection: 'asc',\n      watchQueriesDeletePolicy: 'refetch-queries',\n    });\n  }\n\n  /* -- protected methods -- */\n  protected asObject(source: Person | any): any {\n    if (!source) return undefined;\n\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 as any).mainProfile;\n\n    (target as any).department = source.department?.asObject();\n\n    return target;\n  }\n}\n\nexport function providePersonService() {\n  return <Provider>{\n    provide: APP_PERSON_SERVICE,\n    useExisting: PersonService,\n  }\n}\n"]}