@memberjunction/server 5.24.0 → 5.25.0

package/src/index.ts

@@ -108,6 +108,7 @@ export * from './generic/DeleteOptionsInput.js';
 export * from './agents/skip-agent.js';
 export * from './agents/skip-sdk.js';
 
+export * from './resolvers/GeoResolver.js';
 export * from './resolvers/ColorResolver.js';
 export * from './resolvers/ComponentRegistryResolver.js';
 export * from './resolvers/DatasetResolver.js';
@@ -130,6 +131,7 @@ export * from './resolvers/ActionResolver.js';
 export * from './resolvers/EntityCommunicationsResolver.js';
 export * from './resolvers/EntityResolver.js';
 export * from './resolvers/ISAEntityResolver.js';
+export * from './resolvers/ArtifactFileResolver.js';
 export * from './resolvers/FileCategoryResolver.js';
 export * from './resolvers/FileResolver.js';
 export * from './resolvers/InfoResolver.js';

package/src/resolvers/ArtifactFileResolver.ts

@@ -0,0 +1,71 @@
+import { Resolver, Query, Arg, Ctx } from 'type-graphql';
+import { Metadata, IMetadataProvider } from '@memberjunction/core';
+import { MJArtifactVersionEntity, MJFileEntity } from '@memberjunction/core-entities';
+import { FileStorageEngine } from '@memberjunction/storage';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { AppContext } from '../types.js';
+import { GetReadWriteProvider } from '../util.js';
+
+/**
+ * GraphQL resolver that produces a short-lived download URL for an artifact version
+ * stored as a binary file (ContentMode = 'File').
+ *
+ * Separating this from the generated FileResolver keeps the artifact-specific
+ * logic in one place and avoids mixing concerns in the large FileResolver class.
+ */
+@Resolver()
+export class ArtifactFileResolver extends ResolverBase {
+
+    @Query(() => String, { description: 'Returns a pre-authenticated download URL for an artifact version whose ContentMode is "File".' })
+    async ArtifactFileDownloadUrl(
+        @Arg('artifactVersionId', () => String) artifactVersionId: string,
+        @Ctx() context: AppContext,
+    ): Promise<string> {
+        const user = this.GetUserFromPayload(context.userPayload);
+        if (!user) {
+            throw new Error('Unauthorized');
+        }
+
+        const p = GetReadWriteProvider(context.providers);
+
+        // Load the artifact version
+        const artifactVersion = await p.GetEntityObject<MJArtifactVersionEntity>('MJ: Artifact Versions', user);
+        const loaded = await artifactVersion.Load(artifactVersionId);
+        if (!loaded) {
+            throw new Error(`Artifact version ${artifactVersionId} not found`);
+        }
+
+        if (artifactVersion.ContentMode !== 'File') {
+            throw new Error(`Artifact version ${artifactVersionId} is not a file artifact (ContentMode=${artifactVersion.ContentMode})`);
+        }
+
+        if (!artifactVersion.FileID) {
+            throw new Error(`Artifact version ${artifactVersionId} has no associated file`);
+        }
+
+        return this.buildDownloadUrl(artifactVersion.FileID, user, p);
+    }
+
+    /** Load the File + its storage account/provider and generate a signed URL. */
+    private async buildDownloadUrl(
+        fileId: string,
+        user: ReturnType<ResolverBase['GetUserFromPayload']>,
+        provider: IMetadataProvider,
+    ): Promise<string> {
+        const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
+        const fileLoaded = await fileEntity.Load(fileId);
+        if (!fileLoaded) {
+            throw new Error(`File record ${fileId} not found`);
+        }
+
+        // Find the storage account for this file's provider using cached metadata
+        await FileStorageEngine.Instance.Config(false, user!);
+        const matchingAccounts = FileStorageEngine.Instance.GetAccountsByProviderID(fileEntity.ProviderID);
+        if (matchingAccounts.length === 0) {
+            throw new Error(`No FileStorageAccount found for ProviderID ${fileEntity.ProviderID}. Cannot generate download URL.`);
+        }
+
+        const driver = await FileStorageEngine.Instance.GetDriver(matchingAccounts[0].ID, user!);
+        return driver.CreatePreAuthDownloadUrl(fileEntity.ProviderKey ?? fileEntity.Name);
+    }
+}

package/src/resolvers/AutotagPipelineResolver.ts

@@ -1,6 +1,6 @@
 import { Resolver, Mutation, Ctx, Arg, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { MJContentProcessRunEntity } from '@memberjunction/core-entities';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { ActionEngineServer } from '@memberjunction/actions';
@@ -67,11 +67,13 @@ export class AutotagPipelineResolver extends ResolverBase {
      */
     private async runPipelineInBackground(
         pipelineRunID: string,
-        currentUser: import('@memberjunction/core').UserInfo,
+        currentUser: UserInfo,
         contentSourceIDs?: string[],
         forceReprocess?: boolean
     ): Promise<void> {
         const startTime = Date.now();
+        const processRun = await this.createProcessRun(pipelineRunID, currentUser, contentSourceIDs);
+
         try {
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Initializing pipeline...');
 
@@ -83,22 +85,26 @@ export class AutotagPipelineResolver extends ResolverBase {
             if (!action) {
                 LogError(`RunAutotagPipeline: Action 'Autotag and Vectorize Content' not found`);
                 this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, 'Autotag action not found');
+                await this.completeProcessRun(processRun, 'Failed', 'Autotag action not found', currentUser);
                 return;
             }
 
             // Stage: autotagging — provide a progress callback that publishes per-item updates
+            // and keeps the process run record in sync
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Running autotaggers...');
 
             const progressCallback = (processed: number, total: number, currentItem?: string) => {
                 const pct = total > 0 ? Math.round((processed / total) * 80) : 0; // 0-80% for tagging
                 this.publishProgress(pipelineRunID, 'autotag', total, pct, startTime, currentItem || `${processed}/${total} items`);
+                this.updateProcessRunProgress(processRun, processed, total);
             };
 
-            // Build action params
+            // Build action params — include the process run ID so the action can create detail records
             const actionParams: Array<{ Name: string; Value: unknown; Type: 'Input' | 'Output' | 'Both' }> = [
                 { Name: 'Autotag', Value: 1, Type: 'Input' },
                 { Name: 'Vectorize', Value: 1, Type: 'Input' },
-                { Name: '__progressCallback', Value: progressCallback, Type: 'Input' }
+                { Name: '__progressCallback', Value: progressCallback, Type: 'Input' },
+                { Name: 'ContentProcessRunID', Value: pipelineRunID, Type: 'Input' }
             ];
             if (contentSourceIDs && contentSourceIDs.length > 0) {
                 actionParams.push({ Name: 'ContentSourceIDs', Value: contentSourceIDs, Type: 'Input' });
@@ -120,14 +126,122 @@ export class AutotagPipelineResolver extends ResolverBase {
             if (result.Success) {
                 LogStatus(`RunAutotagPipeline: pipeline ${pipelineRunID} completed successfully`);
                 this.publishProgress(pipelineRunID, 'complete', 100, 100, startTime);
+                await this.completeProcessRun(processRun, 'Completed', undefined, currentUser);
             } else {
                 LogError(`RunAutotagPipeline: pipeline ${pipelineRunID} failed: ${result.Message}`);
                 this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, String(result.Message));
+                await this.completeProcessRun(processRun, 'Failed', String(result.Message), currentUser);
             }
         } catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             LogError(`RunAutotagPipeline pipeline ${pipelineRunID} failed: ${msg}`);
             this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, msg);
+            await this.completeProcessRun(processRun, 'Failed', msg, currentUser);
+        }
+    }
+
+    /**
+     * Create a ContentProcessRun record to track this pipeline execution.
+     * Returns the entity so it can be updated during and after the run.
+     */
+    private async createProcessRun(
+        pipelineRunID: string,
+        currentUser: UserInfo,
+        contentSourceIDs?: string[]
+    ): Promise<MJContentProcessRunEntity | null> {
+        try {
+            // Resolve the source ID — use the specified source or the first available
+            let sourceID: string | undefined;
+            if (contentSourceIDs && contentSourceIDs.length > 0) {
+                sourceID = contentSourceIDs[0];
+            } else {
+                // Load content sources to get any available source ID (SourceID is NOT NULL)
+                const rv = new RunView();
+                const result = await rv.RunView<{ ID: string }>({
+                    EntityName: 'MJ: Content Sources',
+                    Fields: ['ID'],
+                    ResultType: 'simple',
+                    MaxRows: 1
+                }, currentUser);
+                if (result.Success && result.Results.length > 0) {
+                    sourceID = result.Results[0].ID;
+                }
+            }
+
+            if (!sourceID) {
+                LogError('RunAutotagPipeline: no content sources available, cannot create process run');
+                return null;
+            }
+
+            const md = new Metadata();
+            const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
+            run.NewRecord();
+            run.ID = pipelineRunID;
+            run.SourceID = sourceID;
+            run.StartTime = new Date();
+            run.Status = 'Running';
+            run.StartedByUserID = currentUser.ID;
+            run.ProcessedItems = 0;
+            run.TotalItemCount = 0;
+            run.LastProcessedOffset = 0;
+            run.ErrorCount = 0;
+            run.BatchSize = 20;
+            run.CancellationRequested = false;
+            const saved = await run.Save();
+            if (!saved) {
+                LogError(`RunAutotagPipeline: failed to create ContentProcessRun: ${run.LatestResult?.CompleteMessage}`);
+                return null;
+            }
+            LogStatus(`RunAutotagPipeline: created ContentProcessRun ${pipelineRunID}`);
+            return run;
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`RunAutotagPipeline: error creating ContentProcessRun: ${msg}`);
+            return null;
+        }
+    }
+
+    /**
+     * Update the process run record with current progress (fire-and-forget, non-blocking).
+     */
+    private updateProcessRunProgress(
+        processRun: MJContentProcessRunEntity | null,
+        processedItems: number,
+        totalItems: number
+    ): void {
+        if (!processRun) return;
+        processRun.ProcessedItems = processedItems;
+        processRun.TotalItemCount = totalItems;
+        processRun.LastProcessedOffset = processedItems;
+        // Fire-and-forget save — don't await to avoid slowing down the pipeline
+        processRun.Save().catch(e => {
+            LogError(`RunAutotagPipeline: error updating process run progress: ${e instanceof Error ? e.message : String(e)}`);
+        });
+    }
+
+    /**
+     * Mark the process run as completed, failed, or cancelled.
+     */
+    private async completeProcessRun(
+        processRun: MJContentProcessRunEntity | null,
+        status: string,
+        errorMessage: string | undefined,
+        currentUser: import('@memberjunction/core').UserInfo
+    ): Promise<void> {
+        if (!processRun) return;
+        try {
+            processRun.Status = status;
+            processRun.EndTime = new Date();
+            if (errorMessage) {
+                processRun.ErrorMessage = errorMessage;
+                processRun.ErrorCount = (processRun.ErrorCount ?? 0) + 1;
+            }
+            const saved = await processRun.Save();
+            if (!saved) {
+                LogError(`RunAutotagPipeline: failed to complete ContentProcessRun: ${processRun.LatestResult?.CompleteMessage}`);
+            }
+        } catch (error) {
+            LogError(`RunAutotagPipeline: error completing ContentProcessRun: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions, RunView } from '@memberjunction/core';
+import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
 import { NormalizeUUID } from '@memberjunction/global';
 import { MJFileEntity, MJFileStorageProviderEntity, MJFileStorageAccountEntity } from '@memberjunction/core-entities';
 import {
@@ -32,7 +32,7 @@ import {
   FileSearchResult,
   UserContextOptions,
   ExtendedUserContextOptions,
-  initializeDriverWithAccountCredentials,
+  FileStorageEngine,
 } from '@memberjunction/storage';
 import { CreateMJFileInput, MJFileResolver as FileResolverBase, MJFile_, UpdateMJFileInput } from '../generated/generated.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
@@ -648,12 +648,9 @@ export class FileResolver extends FileResolverBase {
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Create, true);
 
-    // Initialize driver with account-based credentials from Credential Engine
-    const driver = await initializeDriverWithAccountCredentials({
-      accountEntity,
-      providerEntity,
-      contextUser: user,
-    });
+    // Initialize driver via FileStorageEngine (handles credential decryption + token refresh)
+    await FileStorageEngine.Instance.Config(false, user);
+    const driver = await FileStorageEngine.Instance.GetDriver(accountEntity.ID, user);
 
     const success = await driver.CreateDirectory(input.Path);
     return success;
@@ -726,23 +723,12 @@ export class FileResolver extends FileResolverBase {
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Read, true);
 
-    // Load all requested account entities in a single query
-    const rv = new RunView();
-    const quotedIDs = input.AccountIDs.map((id) => `'${id}'`).join(', ');
-    const accountResult = await rv.RunView<MJFileStorageAccountEntity>(
-      {
-        EntityName: 'MJ: File Storage Accounts',
-        ExtraFilter: `ID IN (${quotedIDs})`,
-        ResultType: 'entity_object',
-      },
-      user,
-    );
+    // Use cached accounts from the engine — no RunView needed
+    await FileStorageEngine.Instance.Config(false, user);
+    const normalizedIDs = new Set(input.AccountIDs.map((id: string) => NormalizeUUID(id)));
+    const accountEntities = FileStorageEngine.Instance.Accounts
+      .filter(a => normalizedIDs.has(NormalizeUUID(a.ID)));
 
-    if (!accountResult.Success) {
-      throw new Error(`Failed to load storage accounts: ${accountResult.ErrorMessage}`);
-    }
-
-    const accountEntities = accountResult.Results;
     if (accountEntities.length === 0) {
       throw new Error('No valid storage accounts found for the provided IDs');
     }
@@ -754,24 +740,9 @@ export class FileResolver extends FileResolverBase {
       console.warn(`[FileResolver] Accounts not found: ${missingIDs.join(', ')}`);
     }
 
-    // Load providers for all accounts
-    const providerIDs = [...new Set(accountEntities.map((a) => a.ProviderID))];
-    const quotedProviderIDs = providerIDs.map((id) => `'${id}'`).join(', ');
-    const providerResult = await rv.RunView<MJFileStorageProviderEntity>(
-      {
-        EntityName: 'MJ: File Storage Providers',
-        ExtraFilter: `ID IN (${quotedProviderIDs})`,
-        ResultType: 'entity_object',
-      },
-      user,
-    );
-
-    if (!providerResult.Success) {
-      throw new Error(`Failed to load storage providers: ${providerResult.ErrorMessage}`);
-    }
-
+    // Load providers from cached metadata
     const providerMap = new Map<string, MJFileStorageProviderEntity>();
-    for (const provider of providerResult.Results) {
+    for (const provider of FileStorageEngine.Instance.Providers) {
       providerMap.set(provider.ID, provider);
     }
 

package/src/resolvers/GeoResolver.ts

@@ -0,0 +1,258 @@
+import { Resolver, Query, Arg, Ctx, ObjectType, Field, InputType, Float, Int } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { RunView, LogError, Metadata, UserInfo } from '@memberjunction/core';
+import { MJCountryEntity, MJStateProvinceEntity } from '@memberjunction/core-entities';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+@ObjectType()
+export class GeoCountryResult {
+    @Field()
+    ID!: string;
+
+    @Field()
+    Name!: string;
+
+    @Field()
+    ISO2!: string;
+
+    @Field()
+    ISO3!: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude!: number | null;
+
+    @Field(() => Float, { nullable: true })
+    Longitude!: number | null;
+}
+
+@ObjectType()
+export class GeoStateProvinceResult {
+    @Field()
+    ID!: string;
+
+    @Field()
+    CountryID!: string;
+
+    @Field()
+    Name!: string;
+
+    @Field()
+    Code!: string;
+
+    @Field()
+    ISO3166_2!: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude!: number | null;
+
+    @Field(() => Float, { nullable: true })
+    Longitude!: number | null;
+}
+
+@ObjectType()
+export class GeoResolveResult {
+    @Field()
+    Success!: boolean;
+
+    @Field({ nullable: true })
+    CountryID?: string;
+
+    @Field({ nullable: true })
+    CountryName?: string;
+
+    @Field({ nullable: true })
+    StateProvinceID?: string;
+
+    @Field({ nullable: true })
+    StateProvinceName?: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude?: number;
+
+    @Field(() => Float, { nullable: true })
+    Longitude?: number;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Resolver
+// ---------------------------------------------------------------------------
+
+/**
+ * GraphQL resolver for geographic reference data resolution.
+ * Provides country/state text-to-reference matching via the GeoResolver service.
+ * Used by clients that need to resolve free-text location strings to structured
+ * reference data (Country/StateProvince IDs, centroids) without a full geocoding API call.
+ */
+@Resolver()
+export class GeoResolver extends ResolverBase {
+    private _countries: MJCountryEntity[] | null = null;
+    private _states: MJStateProvinceEntity[] | null = null;
+
+    /**
+     * Lazily load all countries into memory (~250 records).
+     */
+    private async GetCountries(contextUser: UserInfo | undefined): Promise<MJCountryEntity[]> {
+        if (this._countries) return this._countries;
+        const rv = new RunView();
+        const result = await rv.RunView<MJCountryEntity>({
+            EntityName: 'MJ: Countries',
+            ResultType: 'entity_object'
+        }, contextUser);
+        if (result.Success) {
+            this._countries = result.Results;
+        }
+        return this._countries ?? [];
+    }
+
+    /**
+     * Lazily load all state/provinces into memory (~5000 records).
+     */
+    private async GetStates(contextUser: UserInfo | undefined): Promise<MJStateProvinceEntity[]> {
+        if (this._states) return this._states;
+        const rv = new RunView();
+        const result = await rv.RunView<MJStateProvinceEntity>({
+            EntityName: 'MJ: State Provinces',
+            ResultType: 'entity_object'
+        }, contextUser);
+        if (result.Success) {
+            this._states = result.Results;
+        }
+        return this._states ?? [];
+    }
+
+    /**
+     * Resolve a free-text country string to a Country reference record.
+     * Matches by Name, ISO2, ISO3, or CommonAliases.
+     */
+    @Query(() => GeoResolveResult)
+    async ResolveCountry(
+        @Arg('input', () => String) input: string,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<GeoResolveResult> {
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+            const countries = await this.GetCountries(user);
+            const normalized = input.trim().toLowerCase();
+
+            // 1. Exact match on Name, ISO2, ISO3
+            const exact = countries.find(c =>
+                c.Name.toLowerCase() === normalized ||
+                c.ISO2.toLowerCase() === normalized ||
+                c.ISO3.toLowerCase() === normalized
+            );
+            if (exact) {
+                return {
+                    Success: true,
+                    CountryID: exact.ID,
+                    CountryName: exact.Name,
+                    Latitude: exact.Latitude ?? undefined,
+                    Longitude: exact.Longitude ?? undefined
+                };
+            }
+
+            // 2. CommonAliases search
+            const aliasMatch = countries.find(c => {
+                if (!c.CommonAliases) return false;
+                try {
+                    const aliases: string[] = JSON.parse(c.CommonAliases);
+                    return aliases.some(a => a.toLowerCase() === normalized);
+                } catch {
+                    return false;
+                }
+            });
+            if (aliasMatch) {
+                return {
+                    Success: true,
+                    CountryID: aliasMatch.ID,
+                    CountryName: aliasMatch.Name,
+                    Latitude: aliasMatch.Latitude ?? undefined,
+                    Longitude: aliasMatch.Longitude ?? undefined
+                };
+            }
+
+            return { Success: false, ErrorMessage: `No country match for "${input}"` };
+        } catch (e: unknown) {
+            const msg = e instanceof Error ? e.message : String(e);
+            LogError(`GeoResolver.ResolveCountry error: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+
+    /**
+     * Resolve a free-text state/province string with country context.
+     * Country context is critical: "CA" = California (US) vs Canada (ISO2).
+     */
+    @Query(() => GeoResolveResult)
+    async ResolveStateProvince(
+        @Arg('stateInput', () => String) stateInput: string,
+        @Arg('countryInput', () => String) countryInput: string,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<GeoResolveResult> {
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+
+            // First resolve country
+            const countryResult = await this.ResolveCountry(countryInput, { userPayload } as AppContext);
+            if (!countryResult.Success || !countryResult.CountryID) {
+                return { Success: false, ErrorMessage: `Could not resolve country "${countryInput}"` };
+            }
+
+            const states = await this.GetStates(user);
+            const countryStates = states.filter(s => s.CountryID === countryResult.CountryID);
+            const normalized = stateInput.trim().toLowerCase();
+
+            // 1. Exact match on Name, Code, ISO3166_2
+            const exact = countryStates.find(s =>
+                s.Name.toLowerCase() === normalized ||
+                s.Code.toLowerCase() === normalized ||
+                s.ISO3166_2.toLowerCase() === normalized
+            );
+            if (exact) {
+                return {
+                    Success: true,
+                    CountryID: countryResult.CountryID,
+                    CountryName: countryResult.CountryName,
+                    StateProvinceID: exact.ID,
+                    StateProvinceName: exact.Name,
+                    Latitude: exact.Latitude ?? undefined,
+                    Longitude: exact.Longitude ?? undefined
+                };
+            }
+
+            // 2. CommonAliases search
+            const aliasMatch = countryStates.find(s => {
+                if (!s.CommonAliases) return false;
+                try {
+                    const aliases: string[] = JSON.parse(s.CommonAliases);
+                    return aliases.some(a => a.toLowerCase() === normalized);
+                } catch {
+                    return false;
+                }
+            });
+            if (aliasMatch) {
+                return {
+                    Success: true,
+                    CountryID: countryResult.CountryID,
+                    CountryName: countryResult.CountryName,
+                    StateProvinceID: aliasMatch.ID,
+                    StateProvinceName: aliasMatch.Name,
+                    Latitude: aliasMatch.Latitude ?? undefined,
+                    Longitude: aliasMatch.Longitude ?? undefined
+                };
+            }
+
+            return { Success: false, ErrorMessage: `No state/province match for "${stateInput}" in ${countryResult.CountryName}` };
+        } catch (e: unknown) {
+            const msg = e instanceof Error ? e.message : String(e);
+            LogError(`GeoResolver.ResolveStateProvince error: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+}