feat: user import action

Author: chrismclarke

src/app/shared/components/template/services/template-field.service.ts

@@ -7,25 +7,31 @@ import { booleanStringToBoolean } from "src/app/shared/utils";
 import { TemplateTranslateService } from "./template-translate.service";
 import { AsyncServiceBase } from "src/app/shared/services/asyncService.base";
 import { TemplateActionRegistry } from "./instance/template-action.registry";
+import { AppConfigService } from "src/app/shared/services/app-config/app-config.service";
 
 @Injectable({ providedIn: "root" })
 export class TemplateFieldService extends AsyncServiceBase {
   globals: { [name: string]: FlowTypes.GlobalRow } = {};
 
+  /** App config prefix used */
+  public prefix: string;
+
   constructor(
     private localStorageService: LocalStorageService,
     private dbService: DbService,
     private translateService: TemplateTranslateService,
-    private templateActionRegistry: TemplateActionRegistry
+    private templateActionRegistry: TemplateActionRegistry,
+    private appConfigService: AppConfigService
   ) {
     super("TemplateField");
     this.registerInitFunction(this.initialise);
     this.registerTemplateActionHandlers();
+    this.prefix = appConfigService.APP_CONFIG.FIELD_PREFIX;
   }
 
   private async initialise() {
     await this.ensureAsyncServicesReady([this.dbService, this.translateService]);
-    this.ensureSyncServicesReady([this.localStorageService]);
+    this.ensureSyncServicesReady([this.localStorageService, this.appConfigService]);
   }
 
   private registerTemplateActionHandlers() {
@@ -49,7 +55,7 @@ export class TemplateFieldService extends AsyncServiceBase {
    * TODO - ideally showWarnings should be linked to some sort of debug mode
    */
   public getField(key: string, showWarnings = true) {
-    let val: any = this.localStorageService.getString("rp-contact-field." + key);
+    let val: any = this.localStorageService.getString(`${this.prefix}.${key}`);
     // provide a fallback if the target variable does not exist in local storage
     if (val === null && showWarnings) {
       // console.warn("field value not found for key:", key);
@@ -80,7 +86,7 @@ export class TemplateFieldService extends AsyncServiceBase {
       }
     }
     // write to local storage - this will cast to string
-    this.localStorageService.setString("rp-contact-field." + key, value);
+    this.localStorageService.setString(`${this.prefix}.${key}`, value);
 
     // write to db - note this can handle more data formats but only string/number will be available to queries
     if (typeof value === "boolean") value = "value";

src/app/shared/services/userMeta/userMeta.service.ts

@@ -1,20 +1,31 @@
+import { HttpClient } from "@angular/common/http";
 import { Injectable } from "@angular/core";
 import { Device } from "@capacitor/device";
+import { firstValueFrom } from "rxjs";
+
 import { AsyncServiceBase } from "../asyncService.base";
 import { DbService } from "../db/db.service";
+import { TemplateActionRegistry } from "../../components/template/services/instance/template-action.registry";
+import { TemplateFieldService } from "../../components/template/services/template-field.service";
 
 @Injectable({ providedIn: "root" })
 export class UserMetaService extends AsyncServiceBase {
   /** keep an in-memory copy of user to provide synchronously */
   public userMeta: IUserMeta;
-  constructor(private dbService: DbService) {
-    super("UsesrMetaService");
+  constructor(
+    private dbService: DbService,
+    private templateActionRegistry: TemplateActionRegistry,
+    private http: HttpClient,
+    private fieldService: TemplateFieldService
+  ) {
+    super("UserMetaService");
     this.registerInitFunction(this.initialise);
   }
 
   /** When first initialising ensure a default profile created and any newer defaults are merged with older user profiles */
   private async initialise() {
-    await this.ensureAsyncServicesReady([this.dbService]);
+    await this.ensureAsyncServicesReady([this.dbService, this.fieldService]);
+    this.registerUserActions();
     const userMetaValues = await this.dbService.table<IUserMetaEntry>("user_meta").toArray();
     const userMeta: IUserMeta = USER_DEFAULTS;
     userMetaValues.forEach((v) => {
@@ -27,6 +38,8 @@ export class UserMetaService extends AsyncServiceBase {
     }
     userMeta.uuid = uuid;
     this.userMeta = userMeta;
+    // populate user id contact field
+    this.fieldService.setField("_app_user_id", uuid);
   }
 
   getUserMeta(key: keyof IUserMeta) {
@@ -38,6 +51,49 @@ export class UserMetaService extends AsyncServiceBase {
     await this.dbService.table<IUserMetaEntry>("user_meta").bulkPut(entries as any);
     this.userMeta = { ...this.userMeta, ...meta };
   }
+
+  /** Import existing user contact fields and replace current user */
+  private async importUserFields(id: string) {
+    try {
+      // TODO - get type-safe return types using openapi http client
+      const profile = await firstValueFrom(
+        this.http.get(`/app_users/${id}`, { responseType: "json" })
+      );
+      if (!profile) {
+        console.error("[User Import] not found:" + id);
+        return;
+      }
+      const { contact_fields } = profile as any;
+      for (const [key, value] of Object.entries(contact_fields)) {
+        const fieldName = key.replace(`${this.fieldService.prefix}.`, "");
+        // TODO - handle special contact fields as required (e.g. _app_skin, _app_theme)
+        if (!fieldName.startsWith("_")) {
+          await this.fieldService.setField(fieldName, value as string);
+        }
+      }
+    } catch (error) {
+      console.error("[User Import] failed", error);
+    }
+  }
+
+  private registerUserActions() {
+    const childActions = {
+      import: this.importUserFields.bind(this),
+    };
+    const childActionNames = Object.keys(childActions).join(",");
+    this.templateActionRegistry.register({
+      user: async ({ args }) => {
+        const [actionId, ...childArgs] = args;
+        if (!childActions[actionId]) {
+          console.error(
+            `[${actionId}] user action not defined. Available actions:\n${childActionNames}`
+          );
+          return;
+        }
+        return childActions[actionId](childArgs);
+      },
+    });
+  }
 }
 
 interface IUserMetaEntry {