refact normalizers, denormalizer, entityManager

models/ApiModel.ts

@@ -5,7 +5,15 @@ export class ApiModel extends Model {
     @Uid()
     id!: number | string
 
-    isNew: boolean = false
+    /**
+     * Does the entity exists in the data source
+     */
+    persisted: boolean = false
+
+    /**
+     * The entity as it was when it was fetched from the data source
+     */
+    initialState: object | null = null
 }
 
 export default ApiModel

services/data/entityManager.ts

@@ -1,9 +1,9 @@
 import ApiRequestService from "./apiRequestService";
-import {AssociativeArray, FORMAT} from "./data";
-import {Model, useRepo} from "pinia-orm";
+import {AssociativeArray} from "./data";
+import {useRepo} from "pinia-orm";
 import UrlBuilder from "~/services/utils/urlBuilder";
-import ModelNormalizer from "~/services/data/serializer/normalizer/modelNormalizer";
-import HydraDenormalizer from "~/services/data/serializer/denormalizer/hydraDenormalizer";
+import ModelNormalizer from "./serializer/normalizer/modelNormalizer";
+import HydraDenormalizer from "./serializer/denormalizer/hydraDenormalizer";
 import ApiModel from "~/models/ApiModel";
 
 /**
@@ -18,37 +18,57 @@ class EntityManager  {
         this.apiRequestService = apiRequestService
     }
 
-    public getRepository(model: typeof Model) {
+    public getRepository(model: typeof ApiModel) {
         return useRepo(model)
     }
 
+    private static getEntityModel(entity: ApiModel): typeof ApiModel{
+        return Object.getPrototypeOf(entity)
+    }
+
     /**
      * Fetch one entity by its id, save it to the store and returns it
-     * @param model
-     * @param id
+     *
+     * @param model  Model of the object to fetch
+     * @param id   Id of the object to fetch
+     * @param forceRefresh  Force a new get request to the api ;
+     *                      current object in store will be overwritten if it exists
      */
-    public async fetch(model: typeof ApiModel, id: number) {
+    public async fetch(model: typeof ApiModel, id: number, forceRefresh: boolean = false) {
+
+        const repository = this.getRepository(model)
 
+        // If the entity is already in the store and forceRefresh is false, return the object in store
+        if (!forceRefresh) {
+            const item = repository.find(id)
+            if (item && typeof item !== 'undefined') {
+                return item
+            }
+        }
+
+        // Else, get the object from the API
         const url = UrlBuilder.concat('api', model.entity, String(id))
 
         const response = await this.apiRequestService.get(url)
 
         // deserialize the response
         const entity = await HydraDenormalizer.denormalize(response)
+        entity.persisted = true
+
+        entity.initialState = structuredClone(entity)
 
         // Save data into the store
-        const repository = this.getRepository(model)
         repository.save(entity)
 
         return entity
     }
 
     public findBy(model: typeof ApiModel, query: AssociativeArray) {
-
+        // TODO: implement
     }
 
     public fetchAll(model: typeof ApiModel) {
-
+        // TODO: implement
     }
 
     public async persist(model: typeof ApiModel, entity: ApiModel) {
@@ -56,15 +76,15 @@ class EntityManager  {
         let url = UrlBuilder.concat('api', model.entity)
         let response = null
 
-        if (entity.isNew) {
-            response = await this.apiRequestService.post(url, data)
-
-        } else {
+        if (entity.persisted) {
             url = UrlBuilder.concat(url, String(entity.id))
             response = await this.apiRequestService.put(url, data)
+        } else {
+            response = await this.apiRequestService.post(url, data)
         }
 
         const fetchedEntity = await HydraDenormalizer.denormalize(response)
+        fetchedEntity.persisted = true
 
         // Save data into the store
         const repository = this.getRepository(model)
@@ -73,23 +93,47 @@ class EntityManager  {
         return fetchedEntity
     }
 
-    public delete() {
+    public async delete(model: typeof ApiModel, id: number) {
+        const repository = this.getRepository(model)
+        const entity = repository.find(id) as ApiModel
+
+        if (!entity || typeof entity === 'undefined') {
+            throw new Error(model + ' ' + id + ' does not exists in store')
+        }
+
+        // If object has been persisted to the datasource, send a delete request
+        if (entity.persisted) {
+            const url = UrlBuilder.concat('api', model.entity, String(id))
+            await this.apiRequestService.delete(url)
+        }
 
+        // update the store
+        repository.destroy(id)
     }
 
     public new(model: typeof ApiModel) {
-        const entity = new model()
-        entity.isNew = true
+        const repository = this.getRepository(model)
+
+        const entity = repository.make()
+        entity.persisted = false
 
         // Save data into the store
-        const repository = this.getRepository(model)
         repository.save(entity)
 
         return entity
     }
 
-    public reset() {
+    public reset(entity: ApiModel) {
+        if (entity.initialState === null) {
+            console.log('object has no initial state - abort')
+            return
+        }
+
+        entity = entity.initialState as ApiModel
+        entity.initialState = structuredClone(entity)
 
+        const repository = this.getRepository(this.getEntityModel(entity))
+        repository.save(entity)
     }
 }
 

services/data/serializer/denormalizer/_import.ts

@@ -1,7 +0,0 @@
-import Hydra from '~/services/serializer/denormalizer/hydra'
-import Yaml from '~/services/serializer/denormalizer/yaml'
-
-export const denormalizers = [
-  Yaml,
-  Hydra
-]

services/data/serializer/denormalizer/baseDenormalizer.ts

@@ -1,8 +0,0 @@
-
-abstract class BaseDenormalizer {
-  static support (subject: object): boolean {
-    throw new Error('Not implemented')
-  }
-}
-
-export default BaseDenormalizer

services/data/serializer/denormalizer/hydraDenormalizer.ts

@@ -1,27 +1,22 @@
 import {AnyJson, ApiResponse, HydraMetadata} from '~/types/interfaces'
-import BaseDenormalizer from '~/services/serializer/denormalizer/baseDenormalizer'
-import {DENORMALIZER_TYPE, METADATA_TYPE} from '~/types/enums'
+import {METADATA_TYPE} from '~/types/enums'
 
 /**
  * Classe permettant d'assurer la dénormalization d'un objet Hydra en JSON
  */
-class HydraDenormalizer extends BaseDenormalizer {
-  static support (type: DENORMALIZER_TYPE): boolean {
-    return type === DENORMALIZER_TYPE.HYDRA
-  }
-
+class HydraDenormalizer {
   /**
    * Parcourt une réponse Hydra pour retourner son équivalent en Json
    *
-   * @param {AnyJson} hydraData
+   * @param {AnyJson} data
    * @return {AnyJson} réponse parsée
    */
-  public static denormalize (hydraData: AnyJson): AnyJson {
-    if (hydraData['hydra:member']) {
-      hydraData.totalCount = hydraData['hydra:totalItems']
-      return HydraDenormalizer.parseCollection(hydraData)
+  public static denormalize (data: AnyJson): AnyJson {
+    if (data['hydra:member']) {
+      data.totalCount = data['hydra:totalItems']
+      return HydraDenormalizer.parseCollection(data)
     } else {
-      return HydraDenormalizer.parseItem(hydraData)
+      return HydraDenormalizer.parseItem(data)
     }
   }
 
@@ -116,7 +111,7 @@ class HydraDenormalizer extends BaseDenormalizer {
   private static  getPageNumber(uri:string):number {
     if(uri){
       const number = uri.split('page=').pop()
-      return number ? useParseInt(number) : 0
+      return number ? parseInt(number) : 0
     }
     return 0
   }

services/data/serializer/denormalizer/yaml.ts → services/data/serializer/denormalizer/yamlDenormalizer.ts

@@ -1,18 +1,12 @@
 import { read } from 'yaml-import'
 import { AnyJson } from '~/types/interfaces'
-import BaseDenormalizer from '~/services/serializer/denormalizer/baseDenormalizer'
-import { DENORMALIZER_TYPE } from '~/types/enums'
 import {dump, load} from 'js-yaml';
 
 
 /**
  * Classe permettant d'assurer la dénormalization d'un fichier JSON en JSON
  */
-class Yaml extends BaseDenormalizer {
-  static support (type: DENORMALIZER_TYPE): boolean {
-    return type === DENORMALIZER_TYPE.YAML
-  }
-
+class YamlDenormalizer {
   /**
    * Parse un fichier Yaml pour en retourner son équivalent en Json
    *
@@ -20,12 +14,8 @@ class Yaml extends BaseDenormalizer {
    * @return {AnyJson}
    */
   public static denormalize (data: AnyJson): AnyJson {
-    try {
       return load(dump(read(data.path))) as AnyJson
-    } catch (e) {
-      throw new Error(e.message)
-    }
   }
 }
 
-export default Yaml
+export default YamlDenormalizer

services/data/serializer/normalizer/_import.ts

@@ -1,9 +0,0 @@
-import Default from '~/services/serializer/normalizer/default'
-import Model from '~/services/serializer/normalizer/model'
-import File from '~/services/serializer/normalizer/file'
-
-export const normalizers = [
-  Default,
-  Model,
-  File
-]

services/data/serializer/normalizer/baseNormalizer.ts

@@ -1,9 +0,0 @@
-import { QUERY_TYPE } from '~/types/enums'
-
-abstract class BaseNormalizer {
-  static support (subject: object): boolean {
-    throw new Error('Not implemented')
-  }
-}
-
-export default BaseNormalizer

services/data/serializer/normalizer/default.ts

@@ -1,28 +0,0 @@
-import BaseNormalizer from '~/services/serializer/normalizer/baseNormalizer'
-import {DataPersisterArgs} from '~/types/interfaces'
-import { QUERY_TYPE } from '~/types/enums'
-
-/**
- * @category Services/serializer/normalizer
- * @class Default
- * Classe assurant la normalization par défaut
- */
-class Default extends BaseNormalizer {
-  static support (type: QUERY_TYPE): boolean {
-    return type === QUERY_TYPE.DEFAULT
-  }
-
-  /**
-   * On renvoi les datas a persister
-   * @param {DataPersisterArgs} args
-   * @return {any} réponse
-   */
-  public static normalize (args: DataPersisterArgs): any {
-    if (!args.data) {
-      throw new Error('*args* has no data attribute')
-    }
-
-    return args.data
-  }
-}
-export default Default

services/data/serializer/normalizer/file.ts

@@ -1,34 +0,0 @@
-import BaseNormalizer from '~/services/serializer/normalizer/baseNormalizer'
-import {DataPersisterArgs} from '~/types/interfaces'
-import { QUERY_TYPE } from '~/types/enums'
-
-/**
- * @category Services/serializer/normalizer
- * @class Default
- * Classe assurant la normalization par défaut
- */
-class File extends BaseNormalizer {
-  static support (type: QUERY_TYPE): boolean {
-    return type === QUERY_TYPE.FILE
-  }
-
-  /**
-   * On transforme les data en FormData et on les renvois
-   * @param {DataPersisterArgs} args
-   * @return {any} réponse
-   */
-  public static normalize (args: DataPersisterArgs): any {
-    if (!args.data) {
-      throw new Error('*args* has no data attribute')
-    }
-
-    const fileData = new FormData();
-    for(const key in args.data){
-      fileData.set(key, args.data[key])
-    }
-
-    fileData.set('file', args.file as string)
-    return fileData
-  }
-}
-export default File

services/data/serializer/normalizer/fileNormalizer.ts

@@ -0,0 +1,23 @@
+/**
+ * @category Services/serializer/normalizer
+ * @class Default
+ * Classe assurant la normalization par défaut
+ */
+class FileNormalizer {
+  /**
+   * On transforme les data en FormData et on les renvois
+   * @return {any} réponse
+   * @param data
+   * @param file
+   */
+  public static normalize (data: any, file: string): any {
+    const fileData = new FormData();
+    for(const key in data){
+      fileData.set(key, data[key])
+    }
+
+    fileData.set('file', file as string)
+    return fileData
+  }
+}
+export default FileNormalizer

services/data/serializer/normalizer/modelNormalizer.ts

@@ -1,14 +1,9 @@
-import BaseNormalizer from './baseNormalizer'
 import ApiModel from "~/models/ApiModel";
 
 /**
  * Classe assurant la normalization d'un Model vers un fichier JSON
  */
-class ModelNormalizer extends BaseNormalizer {
-  static support (subject: object): boolean {
-    return subject instanceof ApiModel
-  }
-
+class ModelNormalizer {
   /**
    * Récupération de l'Item souhaité puis transformation en JSON
    *

services/data/serializer/serializer.ts

@@ -1,23 +0,0 @@
-import { denormalizers } from './denormalizer/_import'
-import { normalizers } from './normalizer/_import'
-import {FORMAT} from "../data";
-
-class Serializer {
-  public static normalize (subject: object) {
-    for (const Normalizer of normalizers) {
-      if (Normalizer.support(subject)) {
-        return Normalizer.normalize(subject)
-      }
-    }
-  }
-
-  public static denormalize (data: object, format: FORMAT): any {
-    for (const Denormalizer of denormalizers) {
-      if (Denormalizer.support(format)) {
-        return Denormalizer.denormalize(data)
-      }
-    }
-  }
-}
-
-export default Serializer

services/data_old/__mocks__/__dataProvider.ts

@@ -1,13 +0,0 @@
-
-/**
- * ATTENTION : dans ce cas cette déclaration sera prioritaire sur les autres façon de moker l'implémentation et on ne peut pas avoir 2 type de mokes différents pour
- cette classe dans l'application...
- */
-const mock = jest.fn().mockImplementation(() => {
-  return {
-    invoke: () => {
-      return true
-    }
-  }
-})
-export default mock

services/data_old/baseDataManager.ts

@@ -1,71 +0,0 @@
-import {NuxtApp} from "#app";
-import {DataManager, DataPersisterArgs, DataProviderArgs, UrlArgs} from '~/types/interfaces'
-import Connection from '~/services/connection/connection'
-import Hookable from '~/services/data/hookable'
-import { HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
-
-/**
- * @todo : le context (ctx) on devrait pouvoir s'en passer grace aux différent composable... a voir..
- * Base class for data providers, persisters or deleters
- */
-abstract class BaseDataManager extends Hookable implements DataManager {
-  protected ctx!: NuxtApp
-  protected defaultArguments: object = {
-    type: QUERY_TYPE.MODEL,
-    showProgress: true
-  }
-
-  /**
-   * Initialise le contexte (la connection en particulier)
-   * @param {NuxtApp} ctx
-   */
-  public initCtx (ctx: NuxtApp) {
-    this.ctx = ctx
-  }
-
-  /**
-   * Exécute la requête et retourne la réponse désérialisée
-   * @param {UrlArgs} _args
-   */
-  // eslint-disable-next-line require-await
-  protected async _invoke (_args: UrlArgs): Promise<any> {
-    throw new Error('Not implemented')
-  }
-
-  /**
-   * Exécute la requête
-   * @param {DataProviderArgs|DataPersisterArgs} args
-   */
-  public async invoke (args: DataProviderArgs|DataPersisterArgs): Promise<any> {
-    const queryArguments = { ...this.defaultArguments, ...args }
-    BaseDataManager.startLoading(queryArguments)
-
-    const response = await this._invoke(queryArguments)
-
-    await this.triggerHooks(queryArguments)
-    return response
-  }
-
-  /**
-   * Signale le début du chargement à nuxt (si showProgress est true)
-   * @param {UrlArgs} args
-   */
-  private static startLoading (args: UrlArgs) {
-    if (args.showProgress) {
-      // const $nuxt = window.$nuxt
-      // $nuxt.$loading.start()
-    }
-  }
-
-  /**
-   * Send the request trough the Connection
-   * @param {string} url
-   * @param {HTTP_METHOD} method
-   * @param {UrlArgs} args
-   */
-  public static request (url: string, method: HTTP_METHOD, args: UrlArgs): Promise<any> {
-    return Connection.invoke(method, url, args)
-  }
-}
-
-export default BaseDataManager

services/data_old/dataDeleter.ts

@@ -1,33 +0,0 @@
-import { DataDeleterArgs } from '~/types/interfaces'
-import BaseDataManager from '~/services/data/baseDataManager'
-import { repositoryHelper } from '~/services/store/repository'
-import { hooksDeleter } from '~/services/data/hooks/hookDeleter/_import'
-import UrlBuilder from '~/services/connection/urlBuilder'
-import { HTTP_METHOD } from '~/types/enums'
-import Connection from '~/services/connection/connection'
-
-/**
- * Le DataDeleter a pour rôle de supprimer des enregistrements via l'API
- */
-class DataDeleter extends BaseDataManager {
-  protected hooks = hooksDeleter;
-
-  /**
-   * Exécute la requête
-   * @param {DataDeleterArgs} queryArguments
-   */
-  protected async _invoke (queryArguments: DataDeleterArgs): Promise<any> {
-    // build the url according to the url args
-    const url = UrlBuilder.build(queryArguments)
-
-    // send the DELETE request to the api
-    await Connection.invoke(HTTP_METHOD.DELETE, url, queryArguments)
-
-    // update the store
-    if (queryArguments.model) {
-      await repositoryHelper.deleteItem(queryArguments.model, queryArguments.id)
-    }
-  }
-}
-
-export default DataDeleter

services/data_old/dataPersister.ts

@@ -1,71 +0,0 @@
-import { AnyJson, DataPersisterArgs, DataProviderArgs } from '~/types/interfaces'
-import UrlBuilder from '~/services/connection/urlBuilder'
-import { DENORMALIZER_TYPE, HTTP_METHOD } from '~/types/enums'
-import Serializer from '~/services/serializer/serializer'
-import DataProvider from '~/services/data/dataProvider'
-import BaseDataManager from '~/services/data/baseDataManager'
-import { hooksPersister } from '~/services/data/hooks/hookPersister/_import'
-
-/**
- * Le DataPersister a pour rôle de mettre à jour les données via de l'API
- *
- * Il sérialise les données et les envoie à l'API sous la forme d'une requête
- * PUT ou POST, selon les cas. Il fait ensuite appel au DataProvider pour traiter la
- * réponse de l'API et la retourner.
- */
-class DataPersister extends BaseDataManager {
-  protected hooks = hooksPersister;
-
-  /**
-   * Exécute la requête et retourne la réponse désérialisée
-   * @param {DataDeleterArgs} queryArguments
-   */
-  protected async _invoke (queryArguments: DataPersisterArgs): Promise<any> {
-    // serialize the data to persist and attach it to the request arguments
-    queryArguments.data = Serializer.normalize(queryArguments)
-
-    // build the url according to the url args
-    const url = UrlBuilder.build(queryArguments)
-
-    // send the POST / PUT request to the api and retrieve the response
-    const response = await DataPersister.request(
-      url,
-      queryArguments.id ? HTTP_METHOD.PUT : HTTP_METHOD.POST,
-      queryArguments
-    )
-
-    // Deserialize, post-process and return the response
-    return await this.provideResponse(response, queryArguments)
-  }
-
-  /**
-   * Use a data provider to deserialize, post-process and return the response
-   *
-   * @param {AnyJson} response
-   * @param {DataPersisterArgs} args
-   */
-  private async provideResponse (response: AnyJson, args: DataPersisterArgs) {
-
-    const deserializedResponse = Serializer.denormalize(response, DENORMALIZER_TYPE.HYDRA)
-
-    const dataProvider = new DataProvider()
-    dataProvider.initCtx(this.ctx)
-    const dataProviderArgs: DataProviderArgs = {
-      type: args.type,
-      url: args.url,
-      enumType: args.enumType,
-      model: args.model,
-      rootModel: args.rootModel,
-      id: args.id,
-      rootId: args.rootId
-    }
-    return await dataProvider.process(deserializedResponse, dataProviderArgs)
-  }
-
-  public async fetchProfile() {
-    console.log('refresh the current profile with updated data')
-    await this.ctx.store.dispatch('refreshUserProfile')
-  }
-}
-
-export default DataPersister

services/data_old/dataProvider.ts

@@ -1,70 +0,0 @@
-import { AnyJson, DataProviderArgs } from '~/types/interfaces'
-import { DENORMALIZER_TYPE, HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
-import { processors } from '~/services/data/processor/_import'
-import UrlBuilder from '~/services/connection/urlBuilder'
-import Serializer from '~/services/serializer/serializer'
-import BaseDataManager from '~/services/data/baseDataManager'
-import { hooksProvider } from '~/services/data/hooks/hookProvider/_import'
-
-/**
- * Le DataProvider a pour rôle de fournir des données issues de l'API
- *
- * Pour cela, le DataProvider envoie une requête GET, récupérer la réponse de l'API,
- * puis la désérialiser.
- * Enfin, il va itérer sur les différents Processor disponibles, jusqu'à trouver
- * un processeur adapté à la requête. Ce processeur va mettre en forme la réponse qui est enfin
- * retournée par le DataProvider.
- */
-class DataProvider extends BaseDataManager {
-  protected progress: boolean = false
-  protected hooks = hooksProvider;
-  protected defaultArguments: object = {
-    type: QUERY_TYPE.MODEL,
-    showProgress: false
-  }
-
-  /**
-   * Exécute la requête et retourne la réponse désérialisée
-   * @param {DataDeleterArgs} queryArguments
-   */
-  protected async _invoke (queryArguments:DataProviderArgs): Promise<any> {
-    // build the url according to the url args
-    const url = UrlBuilder.build(queryArguments)
-
-    // send the GET request to the api and retrieve the response
-    const response = await DataProvider.request(url, HTTP_METHOD.GET, queryArguments)
-
-    // deserialize the response
-    const data = await Serializer.denormalize(response, DENORMALIZER_TYPE.HYDRA)
-
-    // post-process the data with the first supported processor
-    return await this.process(data, queryArguments)
-  }
-
-  /**
-   * Find the first supported post data processor, and process the data with it
-   * @param {AnyJson} data
-   * @param {DataProviderArgs} args
-   */
-  public async process (data: AnyJson, args: DataProviderArgs) {
-    const postProcessor = this.getProcessor(args)
-    if(!postProcessor) throw new Error('A processor need to be defined')
-    return await postProcessor.process(data)
-  }
-
-  /**
-   * Iterate over the available data processors and return an instance of
-   * the first one that support the given args
-   * @param {DataProviderArgs} args
-   */
-  private getProcessor (args: DataProviderArgs): any {
-    for (const processor of processors) {
-      if (processor.support(args)) {
-        // eslint-disable-next-line new-cap
-        return new processor(this.ctx, args)
-      }
-    }
-  }
-}
-
-export default DataProvider

services/data_old/hookable.ts

@@ -1,35 +0,0 @@
-import { UrlArgs } from '~/types/interfaces'
-import BaseHook from '~/services/data/hooks/baseHook'
-
-/**
- * Base class for an object which support hooks
- */
-abstract class Hookable {
-  protected hooks: Array<typeof BaseHook> = [];
-
-  /**
-   * Iterate over the available hooks and invoke the ones
-   * that support the given args
-   */
-  protected async triggerHooks (args: UrlArgs) {
-    for (const Hook of this.sortedHooks()) {
-      if (Hook.support(args)) {
-        await new Hook(this).invoke(args)  // TODO: trouver une alternative au passage du this dans le constructeur, je trouve pas pour le moment :(
-      }
-    }
-  }
-
-  /**
-   * Sort the available hooks by priority
-   * @private
-   */
-  private sortedHooks (): Iterable<any> {
-    return this.hooks.sort(function (a, b) {
-      if (a.priority > b.priority) { return 1 }
-      if (a.priority < b.priority) { return -1 }
-      return 0
-    })
-  }
-}
-
-export default Hookable

services/data_old/hooks/baseHook.ts

@@ -1,22 +0,0 @@
-import { DataProviderArgs } from '~/types/interfaces'
-import Hookable from "~/services/data/hookable";
-
-abstract class BaseHook {
-  public static priority = 255
-  protected parent: Hookable;
-
-  constructor(parent: Hookable) {
-    this.parent = parent
-  }
-
-  // eslint-disable-next-line require-await
-  async invoke (_args: DataProviderArgs): Promise<any> {
-    throw new Error('Not implemented')
-  }
-
-  static support (_args: DataProviderArgs): boolean {
-    throw new Error('Not implemented')
-  }
-}
-
-export default BaseHook

services/data_old/hooks/hookDeleter/_import.ts

@@ -1,5 +0,0 @@
-import HookDeleterExample from '~/services/data/hooks/hookDeleter/hookDeleterExample'
-
-export const hooksDeleter = [
-  HookDeleterExample
-]

services/data_old/hooks/hookDeleter/hookDeleterExample.ts

@@ -1,19 +0,0 @@
-import BaseHook from '~/services/data/hooks/baseHook'
-import { DataDeleterArgs, HookDeleter } from '~/types/interfaces'
-
-class HookDeleterExample extends BaseHook implements HookDeleter {
-  public static priority = 10
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async invoke (args: DataDeleterArgs): Promise<any> {
-    // eslint-disable-next-line no-console
-    await console.log('This is a deleter hook')
-    // don't forget to include this class ins the _import.ts file
-  }
-
-  static support (_args: DataDeleterArgs): boolean {
-    return false
-  }
-}
-
-export default HookDeleterExample

services/data_old/hooks/hookPersister/_import.ts

@@ -1,7 +0,0 @@
-import HookPersisterExample from '~/services/data/hooks/hookPersister/hookPersisterExample'
-import PostPersistProfileRefresh from "~/services/data/hooks/hookPersister/postPersistProfileRefresh";
-
-export const hooksPersister = [
-  HookPersisterExample,
-  PostPersistProfileRefresh
-]

services/data_old/hooks/hookPersister/hookPersisterExample.ts

@@ -1,18 +0,0 @@
-import { DataPersisterArgs, HookPersister } from '~/types/interfaces'
-import BaseHook from '~/services/data/hooks/baseHook'
-
-class HookPersisterExample extends BaseHook implements HookPersister {
-  public static  priority = 10
-
-  async invoke (_args: DataPersisterArgs): Promise<any> {
-    // eslint-disable-next-line no-console
-    await console.log('This is a persister hook')
-    // don't forget to include this class ins the _import.ts file
-  }
-
-  static support (_args: DataPersisterArgs): boolean {
-    return false
-  }
-}
-
-export default HookPersisterExample

services/data_old/hooks/hookPersister/postPersistProfileRefresh.ts

@@ -1,22 +0,0 @@
-import { DataPersisterArgs, HookPersister } from '~/types/interfaces'
-import BaseHook from '~/services/data/hooks/baseHook'
-import DataPersister from "~/services/data/dataPersister";
-
-/**
- * Access profile (and its embed organization profile) shall be re-fetched after some
- * data updates
- */
-class PostPersistProfileRefresh extends BaseHook implements HookPersister {
-  public static  priority = 10
-
-  async invoke (_args: DataPersisterArgs): Promise<any> {
-    await (this.parent as DataPersister).fetchProfile()
-  }
-
-  static support (_args: DataPersisterArgs): boolean {
-    return (typeof _args.model !== 'undefined') &&
-      ['accesses', 'organizations', 'parameters', 'subdomains'].includes(_args.model.entity)
-  }
-}
-
-export default PostPersistProfileRefresh

services/data_old/hooks/hookProvider/_import.ts

@@ -1,5 +0,0 @@
-import HookProviderExample from '~/services/data/hooks/hookProvider/hookProviderExample'
-
-export const hooksProvider = [
-  HookProviderExample
-]

services/data_old/hooks/hookProvider/hookProviderExample.ts

@@ -1,18 +0,0 @@
-import BaseHook from '~/services/data/hooks/baseHook'
-import { DataProviderArgs, HookProvider } from '~/types/interfaces'
-
-class HookProviderExample extends BaseHook implements HookProvider {
-  public static  priority = 10
-
-  async invoke (_args: DataProviderArgs): Promise<any> {
-    // eslint-disable-next-line no-console
-    await console.log('This is a provider hook')
-    // don't forget to include this class ins the _import.ts file
-  }
-
-  static support (_args: DataProviderArgs): boolean {
-    return false
-  }
-}
-
-export default HookProviderExample

services/data_old/processor/_import.ts

@@ -1,13 +0,0 @@
-import ModelProcessor from '~/services/data/processor/modelProcessor'
-import EnumProcessor from '~/services/data/processor/enumProcessor'
-import DefaultProcessor from '~/services/data/processor/defaultProcessor'
-import ImageProcessor from "~/services/data/processor/imageProcessor";
-import FileProcessor from "~/services/data/processor/fileProcessor";
-
-export const processors = [
-  DefaultProcessor,
-  ModelProcessor,
-  EnumProcessor,
-  FileProcessor,
-  ImageProcessor
-]

services/data_old/processor/baseProcessor.ts

@@ -1,32 +0,0 @@
-import {NuxtApp} from "#app";
-import { AnyJson, DataProviderArgs } from '~/types/interfaces'
-
-class BaseProcessor {
-  protected arguments!: DataProviderArgs;
-  protected ctx!: NuxtApp;
-
-  constructor (ctx: NuxtApp, args: DataProviderArgs) {
-    this.arguments = args
-    this.ctx = ctx
-  }
-
-  /**
-   * Is the given argument a supported model
-   * @param _args
-   */
-  public static support (_args: DataProviderArgs): boolean {
-    throw new Error('Not implemented')
-  }
-
-  /**
-   * Process and return the given data to the Provider
-   *
-   * @param _data
-   */
-  // eslint-disable-next-line require-await
-  public async process (_data: AnyJson): Promise<any> {
-    throw new Error('Not implemented')
-  }
-}
-
-export default BaseProcessor

services/data_old/processor/defaultProcessor.ts

@@ -1,24 +0,0 @@
-import { AnyJson, DataProviderArgs, Processor } from '~/types/interfaces'
-import BaseProcessor from '~/services/data/processor/baseProcessor'
-import { QUERY_TYPE } from '~/types/enums'
-
-class DefaultProcessor extends BaseProcessor implements Processor {
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  public static support (args: DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.DEFAULT
-  }
-
-  /**
-   *
-   * @param data
-   */
-  // eslint-disable-next-line require-await
-  async process (data: AnyJson): Promise<any> {
-    return data
-  }
-}
-
-export default DefaultProcessor

services/data_old/processor/enumProcessor.ts

@@ -1,47 +0,0 @@
-import {ApiResponse, DataProviderArgs, EnumChoice, EnumChoices, Processor} from '~/types/interfaces'
-import BaseProcessor from '~/services/data/processor/baseProcessor'
-import { QUERY_TYPE } from '~/types/enums'
-
-class EnumProcessor extends BaseProcessor implements Processor {
-
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  public static support (args:DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.ENUM
-  }
-
-  /**
-   *
-   * @param data
-   */
-  // eslint-disable-next-line require-await
-  async process (payload: ApiResponse): Promise<any> {
-    const enums: EnumChoices = []
-
-    useEach(payload.data.items, (item, key) => {
-      const entry:EnumChoice = {
-        value: key,
-        label: this.ctx.app.i18n.t(item) as string
-      }
-      enums.push(entry)
-    })
-    return EnumProcessor.sortEnum(enums)
-  }
-
-  /**
-   * Sort the given enum by its elements labels
-   * @param enums
-   * @private
-   */
-  private static sortEnum (enums: EnumChoices) {
-    return enums.sort((a, b) => {
-      if (a.label > b.label) { return 1 }
-      if (a.label < b.label) { return -1 }
-      return 0
-    })
-  }
-}
-
-export default EnumProcessor

services/data_old/processor/fileProcessor.ts

@@ -1,24 +0,0 @@
-import { AnyJson, DataProviderArgs, Processor } from '~/types/interfaces'
-import BaseProcessor from '~/services/data/processor/baseProcessor'
-import { QUERY_TYPE } from '~/types/enums'
-
-class FileProcessor extends BaseProcessor implements Processor {
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  public static support (args: DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.FILE
-  }
-
-  /**
-   *
-   * @param data
-   */
-  // eslint-disable-next-line require-await
-  async process (data: AnyJson): Promise<any> {
-    return data
-  }
-}
-
-export default FileProcessor

services/data_old/processor/imageProcessor.ts

@@ -1,38 +0,0 @@
-import {ApiResponse, DataProviderArgs, Processor} from '~/types/interfaces'
-import BaseProcessor from '~/services/data/processor/baseProcessor'
-import {QUERY_TYPE} from '~/types/enums'
-
-class ImageProcessor extends BaseProcessor implements Processor {
-  /**
-   * @param {DataProviderArgs} args
-   */
-  public static support(args: DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.IMAGE
-  }
-
-  /**
-   * proccessing des data
-   * @param {BlobPart[]} data
-   */
-  // eslint-disable-next-line require-await
-  async process(payload: ApiResponse): Promise<any> {
-    if(payload.data.size === 0) throw new Error('image not found')
-
-    let blob = new Blob([payload.data as BlobPart], {type: 'image/jpeg'});
-    return await this.blobToBase64(blob);
-  }
-
-  /**
-   * Transforme un Blob en Base64
-   * @param {Blob} blob
-   */
-  async blobToBase64(blob: Blob) {
-    return new Promise((resolve, _) => {
-      const reader = new FileReader();
-      reader.onloadend = () => resolve(reader.result);
-      reader.readAsDataURL(blob);
-    });
-  }
-}
-
-export default ImageProcessor

services/data_old/processor/modelProcessor.ts

@@ -1,33 +0,0 @@
-import {ApiResponse, DataProviderArgs, Processor} from '~/types/interfaces'
-import BaseProcessor from '~/services/data/processor/baseProcessor'
-import {METADATA_TYPE, QUERY_TYPE} from '~/types/enums'
-import { repositoryHelper } from '~/services/store/repository'
-
-class ModelProcessor extends BaseProcessor implements Processor {
-  /**
-   * Is the given argument a supported model
-   * @param args
-   */
-  public static support (args: DataProviderArgs): boolean {
-    return args.type === QUERY_TYPE.MODEL
-  }
-
-  /**
-   * Exécute la requête et retourne la réponse désérialisée
-   * @param payload
-   */
-  async process (payload: ApiResponse): Promise<any> {
-    if (typeof this.arguments.model === 'undefined') {
-      throw new TypeError('model must be defined')
-    }
-
-    if(payload.metadata.type !== METADATA_TYPE.COLLECTION){
-      payload.data.originalState = useCloneDeep(payload)
-    }
-    await repositoryHelper.persist(this.arguments.model, payload.data)
-
-    return payload
-  }
-}
-
-export default ModelProcessor