@sumaris-net/ngx-components 2.6.4-alpha3 → 2.6.4-alpha5

package/scripts/release.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+# Get to the root project
+if [[ "_" == "_${PROJECT_DIR}" ]]; then
+  SCRIPT_DIR=$(dirname "$0")
+  PROJECT_DIR=$(cd "${SCRIPT_DIR}/.." && pwd)
+  export PROJECT_DIR
+fi;
+
+cd "${PROJECT_DIR}" || exit 1
+
+# Preparing environment
+# TODO check if env-global can be run with JDK17
+#. "${PROJECT_DIR}"/scripts/env-global.sh
+#[[ $? -ne 0 ]] && exit 1
+
+# Read parameters
+version=$1
+release_description=$2
+
+# Check parameters
+if [[ ! $version =~ ^[0-9]+.[0-9]+.[0-9]+(-(alpha|beta|rc)[0-9]+)?$ ]]; then
+  echo "Wrong version format"
+  echo "Usage:"
+  echo " > $0 <version> <release_description>"
+  echo "with:"
+  echo " - version: x.y.z"
+  echo " - release_description: a optional comment on release"
+  exit 1
+fi
+
+if [[ "_$release_description" == "_" ]]; then
+  release_description="Release $version"
+fi
+
+# Control if there is no uncommitted files
+if [[ -n $(git status -s) ]]
+then
+  echo "Please commit changes before running release"
+#  exit 1
+fi
+
+# Control that the script is run on `dev` branch
+resumeRelease=0
+branch=$(git rev-parse --abbrev-ref HEAD)
+if [[ ! "$branch" == "develop" ]]; then
+  if [[ "$branch" == "release/$version" ]]; then
+    echo "Resuming release ..."
+    resumeRelease=1
+  else
+    echo ">> This script must be run under \`develop\` or \`release/$version\` branch"
+  # exit 1
+  fi
+fi
+
+### Get current version (package.json)
+package=$(node -p "require('./package.json').name")
+current=$(grep -oP "version\": \"\d+.\d+.\d+(-(alpha|beta|rc)[0-9]+)?" package.json | grep -m 1 -oP "\d+.\d+.\d+(-(alpha|beta|rc)[0-9]+)?")
+if [[ "_$current" == "_" ]]; then
+  echo ">> Unable to read the current version in 'package.json'. Please check version format is: x.y.z (x and y should be an integer)."
+  exit 1;
+fi
+
+echo "----------------------------------"
+if [[ $resumeRelease = 0 ]]
+then
+  echo "- Starting release..."
+else
+  echo "- Resuming release..."
+fi
+echo "----------------------------------"
+if [[ $resumeRelease = 0 ]]
+then
+  echo "- Current version: $current"
+fi
+echo "- Release version: $version"
+echo "----------------------------------"
+
+# Check version already published
+if [[ "$(npm view "$package"@"$version" version 2>/dev/null)" == "$version" ]]; then
+  echo "Version $version already published"
+  exit 1
+fi
+
+if [[ $resumeRelease == 0 ]]; then
+  read -r -p "Is these new versions correct ? [y/N] " response
+  response=${response,,} # tolower
+  [[ ! "$response" =~ ^(yes|y)$ ]] && exit 1
+  # Create release branch
+  git checkout -b release/"$version"
+fi
+
+# Change the version in files: 'package.json' and 'config.xml'
+sed -i "s/version\": \"$current\"/version\": \"$version\"/g" package.json
+# Change version in file: 'src/assets/manifest.json'
+currentManifestJsonVersion=$(grep -oP "version\": \"\d+.\d+.\d+(-(alpha|beta|rc)[0-9]*)?\"" src/assets/manifest.json | grep -oP "\d+.\d+.\d+(-(alpha|beta|rc)[0-9]*)?")
+sed -i "s/version\": \"$currentManifestJsonVersion\"/version\": \"$version\"/g" src/assets/manifest.json
+
+echo "----------------------------------"
+echo "- Build..."
+echo "----------------------------------"
+npm run packagr
+[[ $? -ne 0 ]] && exit 1
+
+echo "----------------------------------"
+echo "- Publish..."
+echo "----------------------------------"
+cd dist || exit 1
+npm publish
+[[ $? -ne 0 ]] && exit 1
+
+echo "----------------------------------"
+echo "- Finish release..."
+echo "----------------------------------"
+# Git process for release (ISO gitflow)
+cd..
+git commit -a -m "Prepare release $version"
+git checkout master
+git merge --no-ff --no-edit -m "Release $version" "release/$version"
+git tag -a "$version" -m "$release_description"
+git checkout develop
+git merge --no-ff --no-edit -m "[skip ci] Release $version" "release/$version"
+git push origin develop
+git push origin master
+git push --tags
+git branch -D "release/$version"
+
+echo "----------------------------------"
+echo "- Release OK"
+echo "----------------------------------"
+
+#echo "----------------------------------"
+#echo "- Creating web artifact..."
+#echo "----------------------------------"
+#mkdir -p "${PROJECT_DIR}/dist"
+#ZIP_FILE=${PROJECT_DIR}/dist/${PROJECT_NAME}.zip
+#if [[ -f "$ZIP_FILE" ]]; then
+#  rm $ZIP_FILE
+#fi
+#cd $PROJECT_DIR/www
+#zip -q -r $ZIP_FILE .
+#if [[ $? -ne 0 ]]; then
+#  echo "Cannot create the archive for the web artifact"
+#  exit 1
+#fi
+
+#echo "-------------------------------------------"
+#echo "- Compiling sources for Android platform..."
+#echo "-------------------------------------------"
+

package/scripts/run-android.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+BUILD_CONFIGURATION=development
+
+# Get to the root project
+if [[ "_" == "_${PROJECT_DIR}" ]]; then
+  SCRIPT_DIR=$(dirname $0)
+  PROJECT_DIR=$(cd ${SCRIPT_DIR}/.. && pwd)
+  export PROJECT_DIR
+fi;
+
+# Preparing Android environment
+. ${PROJECT_DIR}/scripts/env-android.sh
+[[ $? -ne 0 ]] && exit 1
+
+# Ask user, before cleaning old APK
+if [[ -f ${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release.apk ]] ||
+   [[ -f "${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release-unsigned.apk" ]] ||
+   [[ -f "${ANDROID_OUTPUT_APK_DEBUG}/${ANDROID_OUTPUT_APK_PREFIX}-debug.apk" ]]; then
+
+  echo "-------------------------------------------"
+  echo "--- There is existing APK files!"
+  read -r -p "> Would you like to recompile ? [y/N] " response
+  response=${response,,}    # tolower
+
+  # Use confirm: Clean old APK files
+  if [[ "$response" =~ ^(yes|y)$ ]]; then
+
+    if [[ -d "${ANDROID_OUTPUT_APK_RELEASE}" ]]; then
+      rm -f ${ANDROID_OUTPUT_APK_RELEASE}/*.apk
+    fi
+    if [[ -d "${ANDROID_OUTPUT_APK_DEBUG}" ]]; then
+      rm -f ${ANDROID_OUTPUT_APK_DEBUG}/*.apk
+    fi
+  fi
+fi
+
+# Building APK file
+if [[ ! -f ${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release.apk ]] &&
+   [[ ! -f "${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release-unsigned.apk" ]] &&
+   [[ ! -f "${ANDROID_OUTPUT_APK_DEBUG}/${ANDROID_OUTPUT_APK_PREFIX}-debug.apk" ]]; then
+  echo "-------------------------------------------"
+  echo "--- Building Android APK..."
+  cd ${PROJECT_DIR}
+
+  ionic capacitor run android -l --external
+  [[ $? -ne 0 ]] && exit 1
+fi
+
+echo "-------------------------------------------"
+echo "--- Running Android application..."
+if [[ -f "${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release.apk" ]]; then
+  native-run android --app ${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release.apk
+elif [[ -f "${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release-unsigned.apk" ]]; then
+  native-run android --app ${ANDROID_OUTPUT_APK_RELEASE}/${ANDROID_OUTPUT_APK_PREFIX}-release-unsigned.apk
+else
+  native-run android --app ${ANDROID_OUTPUT_APK_DEBUG}/${ANDROID_OUTPUT_APK_PREFIX}-debug.apk
+fi
+

package/scripts/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# Get to the root project
+if [[ "_" == "_${PROJECT_DIR}" ]]; then
+  SCRIPT_DIR=$(dirname $0)
+  PROJECT_DIR=$(cd ${SCRIPT_DIR}/.. && pwd)
+  export PROJECT_DIR
+fi;
+
+# Override with a local file, if any
+if [[ -f "${PROJECT_DIR}/.local/env.sh" ]]; then
+  echo "Loading environment variables from: '.local/env.sh'"
+  source ${PROJECT_DIR}/.local/env.sh
+  [[ $? -ne 0 ]] && exit 1
+else
+  echo "No file '${PROJECT_DIR}/.local/env.sh' found. Will use defaults"
+fi
+
+# launch tests
+ng test --browsers=ChromeHeadless --watch=false

package/src/app/admin/admin-routing.module.ts

@@ -0,0 +1,30 @@
+import {RouterModule, Routes} from '@angular/router';
+import {UsersPage} from './users/users';
+import {AuthGuardService} from '../core/services/auth-guard.service';
+import {NgModule} from '@angular/core';
+import {SharedRoutingModule} from '../shared/shared-routing.module';
+import {AdminModule} from './admin.module';
+import {ComponentDirtyGuard} from '../shared/guard/component-dirty.guard';
+
+const routes: Routes = [
+  {
+    path: 'users',
+    pathMatch: 'full',
+    component: UsersPage,
+    canActivate: [AuthGuardService],
+    canDeactivate: [ComponentDirtyGuard],
+    data: {
+      profile: 'ADMIN'
+    }
+  }
+];
+
+@NgModule({
+  imports: [
+    SharedRoutingModule,
+    AdminModule,
+    RouterModule.forChild(routes)
+  ],
+  exports: [RouterModule]
+})
+export class AdminRoutingModule { }

package/src/app/admin/admin.module.ts

@@ -0,0 +1,23 @@
+import {NgModule} from '@angular/core';
+import {CommonModule} from '@angular/common';
+import {CoreModule} from '../core/core.module';
+import {AdminUsersModule} from './users/users.module';
+
+@NgModule({
+  imports: [
+    CommonModule,
+    CoreModule,
+
+    // Sub modules
+    AdminUsersModule
+  ],
+  exports: [
+    AdminUsersModule
+  ]
+})
+export class AdminModule {
+
+  constructor() {
+    console.debug('[admin] Creating module');
+  }
+}

package/src/app/admin/services/filter/person.filter.ts

@@ -0,0 +1,77 @@
+import { EntityClass } from '../../../core/services/model/entity.decorators';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+import { Person } from '../../../core/services/model/person.model';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { EntityAsObjectOptions, EntityUtils } from '../../../core/services/model/entity.model';
+import { StoreObject } from '@apollo/client/core';
+import { isNil, isNotEmptyArray, isNotNil } from '../../../shared/functions';
+
+// @dynamic
+@EntityClass({ typename: 'PersonFilterVO' })
+export class PersonFilter extends EntityFilter<PersonFilter, Person> {
+
+  static fromObject: (source, opts?: any) => PersonFilter;
+
+  static searchFilter(source: any): FilterFn<Person> {
+    return source && PersonFilter.fromObject(source).asFilterFn();
+  }
+
+  email: string;
+  pubkey: string;
+  searchText: string;
+  statusIds: number[];
+  userProfiles: string[];
+  excludedIds: number[];
+  searchAttribute: string;
+  searchAttributes: string[];
+
+  constructor() {
+    super(PersonFilter.TYPENAME);
+  }
+
+  fromObject(source: any, opts?: EntityAsObjectOptions) {
+    super.fromObject(source, opts);
+    this.email = source.email;
+    this.pubkey = source.pubkey;
+    this.searchText = source.searchText;
+    this.statusIds = source.statusIds || (isNotNil(source.statusId) ? [source.statusId] : undefined);
+    this.userProfiles = source.userProfiles;
+    this.excludedIds = source.excludedIds;
+    this.searchAttribute = source.searchAttribute;
+    this.searchAttributes = source.searchAttributes;
+  }
+
+  asObject(opts?: EntityAsObjectOptions): StoreObject {
+    const target = super.asObject(opts);
+    target.email = this.email;
+    target.pubkey = this.pubkey;
+    target.searchText = this.searchText;
+    target.statusIds = this.statusIds;
+    target.userProfiles = this.userProfiles;
+    target.excludedIds = this.excludedIds;
+    target.searchAttribute = this.searchAttribute;
+    target.searchAttributes = this.searchAttributes;
+    return target;
+  }
+
+  protected buildFilter(): FilterFn<Person>[] {
+
+    const filterFns = super.buildFilter();
+
+    // Filter by status
+    if (isNotEmptyArray(this.statusIds)) {
+      filterFns.push(e => this.statusIds.includes(e.statusId));
+    }
+
+    // Filter excluded ids
+    if (isNotEmptyArray(this.excludedIds)) {
+      filterFns.push(e => isNil(e.id) || !this.excludedIds.includes(e.id));
+    }
+
+    // Search text
+    const searchTextFilter = EntityUtils.searchTextFilter(this.searchAttribute || this.searchAttributes || ['lastName', 'firstName', 'department.name'], this.searchText);
+    if (searchTextFilter) filterFns.push(searchTextFilter);
+
+    return filterFns;
+  }
+}

package/src/app/admin/services/person.service.ts

@@ -0,0 +1,212 @@
+import {Injectable} from '@angular/core';
+import {FetchPolicy, gql} from '@apollo/client/core';
+import {BehaviorSubject} from 'rxjs';
+import {GraphqlService} from '../../core/graphql/graphql.service';
+import {NetworkService} from '../../core/services/network.service';
+import {EntitiesStorage} from '../../core/services/storage/entities-storage.service';
+import {Person, UserProfileLabel} from '../../core/services/model/person.model';
+import {StatusIds} from '../../core/services/model/model.enum';
+import {SortDirection} from '@angular/material/sort';
+import {JobUtils} from '../../shared/services/job.utils';
+import {LoadResult, SuggestService} from '../../shared/services/entity-service.class';
+import {PlatformService} from '../../core/services/platform.service';
+import {PersonFilter} from './filter/person.filter';
+import {EntityUtils} from '../../core/services/model/entity.model';
+import {BaseEntityGraphqlMutations, BaseEntityService} from '../../core/services/base-entity-service.class';
+import {environment} from '../../../environments/environment';
+
+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: BaseEntityGraphqlMutations = {
+  saveAll: gql`
+    mutation savePersons($data:[PersonVOInput]){
+      data: savePersons(persons: $data){
+        ...PersonFragment
+      }
+    }
+    ${PersonFragments.person}`,
+  deleteAll: gql`
+    mutation deletePersons($ids:[Int]){
+      deletePersons(ids: $ids)
+    }`
+};
+
+@Injectable({providedIn: 'root'})
+export class PersonService extends BaseEntityService<Person, PersonFilter>
+  implements SuggestService<Person, PersonFilter> {
+
+  constructor(
+    protected graphql: GraphqlService,
+    protected platform: PlatformService,
+    protected network: NetworkService,
+    protected entities: EntitiesStorage
+  ) {
+    super(graphql, platform, Person, PersonFilter, {
+      queries: PersonQueries,
+      mutations: PersonMutations,
+      defaultSortBy: 'lastName',
+      defaultSortDirection: 'asc'
+    });
+
+    // for DEV only -----
+    this._debug = !environment.production;
+  }
+
+  async loadAll(offset: number, size: number, sortBy?: string,
+                sortDirection?: SortDirection,
+                filter?: Partial<PersonFilter>, opts?: {
+        [key: string]: any;
+        fetchPolicy?: FetchPolicy;
+        debug?: boolean;
+        withTotal?: boolean;
+        toEntity?: boolean;
+      }): Promise<LoadResult<Person>> {
+
+    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: number, size: number, sortBy?: string, sortDirection?: SortDirection,
+                       filter?: Partial<PersonFilter>,
+                       opts?: {
+                         [key: string]: any;
+                         fetchPolicy?: FetchPolicy;
+                         debug?: boolean;
+                         withTotal?: boolean;
+                         toEntity?: boolean;
+                       }): Promise<LoadResult<Person>> {
+
+    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<Person>('PersonVO', variables);
+
+    const entities = (!opts || opts.toEntity !== false) ?
+      (data || []).map(Person.fromObject) :
+      (data || []) as Person[];
+    return {
+      data: entities,
+      total
+    };
+  }
+
+  async suggest(value: any, filter?: PersonFilter, sortBy?: string, sortDirection?: SortDirection): Promise<LoadResult<Person>> {
+    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 as string,
+        statusIds: filter && filter.statusIds || [StatusIds.ENABLE],
+        userProfiles: filter && filter.userProfiles
+      },
+      { withTotal: true /* need by autocomplete */ }
+      );
+  }
+
+  async executeImport(filter: Partial<PersonFilter>,
+                      opts: {
+                        progression?: BehaviorSubject<number>;
+                        maxProgression?: number;
+                      }): Promise<void> {
+
+    const maxProgression = opts && opts.maxProgression || 100;
+    filter = {
+      ...filter,
+      statusIds: [StatusIds.ENABLE, StatusIds.TEMPORARY],
+      userProfiles: <UserProfileLabel[]>['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), // Compute total only once
+          toEntity: false
+        }),
+      {progression: opts?.progression, maxProgression: maxProgression * 0.9}
+    );
+
+    // Save result locally
+    await this.entities.saveAll(res.data, {entityName: 'PersonVO', reset: true});
+  }
+
+  /* -- protected methods -- */
+
+  protected asObject(source: Person | any): any {
+    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;
+  }
+
+}

package/src/app/admin/services/validator/person.validator.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { ValidatorService } from '@e-is/ngx-material-table';
+import {UntypedFormGroup, UntypedFormBuilder, Validators} from '@angular/forms';
+import { Person } from '../../../core/services/model/person.model';
+import { Account } from '../../../core/services/model/account.model';
+import { SharedValidators } from '../../../shared/validator/validators';
+import {AccountValidatorService} from '../../../core/services/validator/account.validator';
+
+@Injectable({providedIn: 'root'})
+export class PersonValidatorService implements ValidatorService {
+
+  constructor(
+    protected formBuilder: UntypedFormBuilder,
+    protected accountValidatorService: AccountValidatorService
+  ) {
+  }
+
+  getRowValidator(): UntypedFormGroup {
+    return this.getFormGroup();
+  }
+
+  getFormGroup(data?: Person): UntypedFormGroup {
+
+    // 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);
+  }
+
+
+}