@memberjunction/server 2.112.0 → 2.113.1

package/src/rest/ViewOperationsHandler.ts

@@ -1,203 +1,207 @@
-import { LogError, Metadata, RunView, RunViewParams, RunViewResult, UserInfo } from '@memberjunction/global';
+import { 
+    LogError, Metadata, RunView, RunViewParams, 
+    RunViewResult, UserInfo 
+} from '@memberjunction/core';
 
 /**
  * View Operations Implementation for REST endpoints
  * These functions handle running views through the REST API
  */
 export class ViewOperationsHandler {
-  /**
-   * Run a view and return results
-   */
-  static async runView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean; result?: RunViewResult; error?: string }> {
-    try {
-      // Validate entity exists
-      const md = new Metadata();
-      const entity = md.Entities.find((e) => e.Name === params.EntityName);
-      if (!entity) {
-        return {
-          success: false,
-          error: `Entity '${params.EntityName}' not found`,
-        };
-      }
-
-      // Check read permission
-      const permissions = entity.GetUserPermisions(user);
-      if (!permissions.CanRead) {
-        return {
-          success: false,
-          error: `User ${user.Name} does not have permission to read ${params.EntityName} records`,
-        };
-      }
-
-      // Sanitize and validate parameters
-      this.sanitizeRunViewParams(params);
-
-      // Execute the view
-      const runView = new RunView();
-      const result = await runView.RunView(params, user);
-
-      return { success: true, result };
-    } catch (error) {
-      LogError(error);
-      return { success: false, error: (error as Error)?.message || 'Unknown error' };
-    }
-  }
-
-  /**
-   * Run multiple views in batch
-   */
-  static async runViews(
-    paramsArray: RunViewParams[],
-    user: UserInfo
-  ): Promise<{ success: boolean; results?: RunViewResult[]; error?: string }> {
-    try {
-      // Validate and sanitize each set of parameters
-      const md = new Metadata();
-      for (const params of paramsArray) {
-        // Validate entity exists
-        const entity = md.Entities.find((e) => e.Name === params.EntityName);
-        if (!entity) {
-          return {
-            success: false,
-            error: `Entity '${params.EntityName}' not found`,
-          };
-        }
-
-        // Check read permission
-        const permissions = entity.GetUserPermisions(user);
-        if (!permissions.CanRead) {
-          return {
-            success: false,
-            error: `User ${user.Name} does not have permission to read ${params.EntityName} records`,
-          };
+    /**
+     * Run a view and return results
+     */
+    static async runView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean, result?: RunViewResult, error?: string }> {
+        try {
+            // Validate entity exists
+            const md = new Metadata();
+            const entity = md.Entities.find(e => e.Name === params.EntityName);
+            if (!entity) {
+                return { 
+                    success: false, 
+                    error: `Entity '${params.EntityName}' not found` 
+                };
+            }
+            
+            // Check read permission
+            const permissions = entity.GetUserPermisions(user);
+            if (!permissions.CanRead) {
+                return { 
+                    success: false, 
+                    error: `User ${user.Name} does not have permission to read ${params.EntityName} records` 
+                };
+            }
+            
+            // Sanitize and validate parameters
+            this.sanitizeRunViewParams(params);
+            
+            // Execute the view
+            const runView = new RunView();
+            const result = await runView.RunView(params, user);
+            
+            return { success: true, result };
+        } catch (error) {
+            LogError(error);
+            return { success: false, error: (error as Error)?.message || 'Unknown error' };
         }
-
-        // Sanitize parameters
-        this.sanitizeRunViewParams(params);
-      }
-
-      // Execute the views
-      const runView = new RunView();
-      const results = await runView.RunViews(paramsArray, user);
-
-      return { success: true, results };
-    } catch (error) {
-      LogError(error);
-      return { success: false, error: (error as Error)?.message || 'Unknown error' };
-    }
-  }
-
-  /**
-   * List entities with optional filtering
-   */
-  static async listEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
-    try {
-      // Check entity exists and user has permission
-      const md = new Metadata();
-      const entity = md.Entities.find((e) => e.Name === params.EntityName);
-      if (!entity) {
-        throw new Error(`Entity '${params.EntityName}' not found`);
-      }
-
-      const permissions = entity.GetUserPermisions(user);
-      if (!permissions.CanRead) {
-        throw new Error(`User ${user.Name} does not have permission to read ${params.EntityName} records`);
-      }
-
-      // Sanitize and validate parameters
-      this.sanitizeRunViewParams(params);
-
-      // Execute the view
-      const runView = new RunView();
-      return await runView.RunView(params, user);
-    } catch (error) {
-      LogError(error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get available views for an entity
-   */
-  static async getEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean; views?: any[]; error?: string }> {
-    try {
-      // Validate entity exists
-      const md = new Metadata();
-      const entity = md.Entities.find((e) => e.Name === entityName);
-      if (!entity) {
-        return {
-          success: false,
-          error: `Entity '${entityName}' not found`,
-        };
-      }
-
-      // Check read permission
-      const permissions = entity.GetUserPermisions(user);
-      if (!permissions.CanRead) {
-        return {
-          success: false,
-          error: `User ${user.Name} does not have permission to read ${entityName} records`,
-        };
-      }
-
-      // Run a view to get the available views
-      const params: RunViewParams = {
-        EntityName: 'User Views',
-        ExtraFilter: `Entity = '${entityName}'`,
-      };
-
-      const runView = new RunView();
-      const result = await runView.RunView(params, user);
-
-      if (!result.Success) {
-        return {
-          success: false,
-          error: result.ErrorMessage || 'Failed to retrieve views',
-        };
-      }
-
-      // Format the view data
-      const views = result.Results.map((view) => ({
-        ID: view.ID,
-        Name: view.Name,
-        Description: view.Description,
-        IsShared: view.IsShared,
-        CreatedAt: view.CreatedAt,
-      }));
-
-      return { success: true, views };
-    } catch (error) {
-      LogError(error);
-      return { success: false, error: (error as Error)?.message || 'Unknown error' };
     }
-  }
-
-  /**
-   * Sanitize and validate RunViewParams
-   */
-  private static sanitizeRunViewParams(params: RunViewParams): void {
-    // Ensure EntityName is provided
-    if (!params.EntityName) {
-      throw new Error('EntityName is required');
-    }
-
-    // Convert string arrays if they came in as comma-separated strings
-    if (params.Fields && typeof params.Fields === 'string') {
-      params.Fields = (params.Fields as string).split(',');
+    
+    /**
+     * Run multiple views in batch
+     */
+    static async runViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
+        try {
+            // Validate and sanitize each set of parameters
+            const md = new Metadata();
+            for (const params of paramsArray) {
+                // Validate entity exists
+                const entity = md.Entities.find(e => e.Name === params.EntityName);
+                if (!entity) {
+                    return { 
+                        success: false, 
+                        error: `Entity '${params.EntityName}' not found` 
+                    };
+                }
+                
+                // Check read permission
+                const permissions = entity.GetUserPermisions(user);
+                if (!permissions.CanRead) {
+                    return { 
+                        success: false, 
+                        error: `User ${user.Name} does not have permission to read ${params.EntityName} records` 
+                    };
+                }
+                
+                // Sanitize parameters
+                this.sanitizeRunViewParams(params);
+            }
+            
+            // Execute the views
+            const runView = new RunView();
+            const results = await runView.RunViews(paramsArray, user);
+            
+            return { success: true, results };
+        } catch (error) {
+            LogError(error);
+            return { success: false, error: (error as Error)?.message || 'Unknown error' };
+        }
     }
-
-    // Sanitize numeric values
-    if (params.MaxRows !== undefined) {
-      params.MaxRows = typeof params.MaxRows === 'string' ? parseInt(params.MaxRows as string) : params.MaxRows;
+    
+    /**
+     * List entities with optional filtering
+     */
+    static async listEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
+        try {
+            // Check entity exists and user has permission
+            const md = new Metadata();
+            const entity = md.Entities.find(e => e.Name === params.EntityName);
+            if (!entity) {
+                throw new Error(`Entity '${params.EntityName}' not found`);
+            }
+            
+            const permissions = entity.GetUserPermisions(user);
+            if (!permissions.CanRead) {
+                throw new Error(`User ${user.Name} does not have permission to read ${params.EntityName} records`);
+            }
+            
+            // Sanitize and validate parameters
+            this.sanitizeRunViewParams(params);
+            
+            // Execute the view
+            const runView = new RunView();
+            return await runView.RunView(params, user);
+        } catch (error) {
+            LogError(error);
+            throw error;
+        }
     }
-
-    if (params.StartRow !== undefined) {
-      params.StartRow = typeof params.StartRow === 'string' ? parseInt(params.StartRow as string) : params.StartRow;
+    
+    /**
+     * Get available views for an entity
+     */
+    static async getEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean, views?: any[], error?: string }> {
+        try {
+            // Validate entity exists
+            const md = new Metadata();
+            const entity = md.Entities.find(e => e.Name === entityName);
+            if (!entity) {
+                return { 
+                    success: false, 
+                    error: `Entity '${entityName}' not found` 
+                };
+            }
+            
+            // Check read permission
+            const permissions = entity.GetUserPermisions(user);
+            if (!permissions.CanRead) {
+                return { 
+                    success: false, 
+                    error: `User ${user.Name} does not have permission to read ${entityName} records` 
+                };
+            }
+            
+            // Run a view to get the available views
+            const params: RunViewParams = {
+                EntityName: 'User Views',
+                ExtraFilter: `Entity = '${entityName}'`
+            };
+            
+            const runView = new RunView();
+            const result = await runView.RunView(params, user);
+            
+            if (!result.Success) {
+                return { 
+                    success: false, 
+                    error: result.ErrorMessage || 'Failed to retrieve views' 
+                };
+            }
+            
+            // Format the view data
+            const views = result.Results.map(view => ({
+                ID: view.ID,
+                Name: view.Name,
+                Description: view.Description,
+                IsShared: view.IsShared,
+                CreatedAt: view.CreatedAt
+            }));
+            
+            return { success: true, views };
+        } catch (error) {
+            LogError(error);
+            return { success: false, error: (error as Error)?.message || 'Unknown error' };
+        }
     }
-
-    // Default ResultType if not provided
-    if (!params.ResultType) {
-      params.ResultType = 'simple';
+    
+    /**
+     * Sanitize and validate RunViewParams
+     */
+    private static sanitizeRunViewParams(params: RunViewParams): void {
+        // Ensure EntityName is provided
+        if (!params.EntityName) {
+            throw new Error('EntityName is required');
+        }
+        
+        // Convert string arrays if they came in as comma-separated strings
+        if (params.Fields && typeof params.Fields === 'string') {
+            params.Fields = (params.Fields as string).split(',');
+        }
+        
+        // Sanitize numeric values
+        if (params.MaxRows !== undefined) {
+            params.MaxRows = typeof params.MaxRows === 'string' 
+                ? parseInt(params.MaxRows as string) 
+                : params.MaxRows;
+        }
+        
+        if (params.StartRow !== undefined) {
+            params.StartRow = typeof params.StartRow === 'string' 
+                ? parseInt(params.StartRow as string) 
+                : params.StartRow;
+        }
+        
+        // Default ResultType if not provided
+        if (!params.ResultType) {
+            params.ResultType = 'simple';
+        }
     }
-  }
-}
+}

package/src/scheduler/LearningCycleScheduler.ts

@@ -1,4 +1,4 @@
-import { LogStatus, LogError } from '@memberjunction/global';
+import { LogStatus, LogError } from '@memberjunction/core';
 import { SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { GetReadWriteDataSource } from '../util.js';
 import { AskSkipResolver } from '../resolvers/AskSkipResolver.js';
@@ -13,17 +13,22 @@ import { mj_core_schema } from '../config.js';
  */
 export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler> {
   // private intervalId: NodeJS.Timeout | null = null;
+  
   // // Track executions by organization ID instead of a global flag
   // private runningOrganizations: Map<string, { startTime: Date, learningCycleId: string }> = new Map();
+  
   // private lastRunTime: Date | null = null;
   // private dataSources: DataSourceInfo[] = [];
+  
   // // Protected constructor to enforce singleton pattern via BaseSingleton
   // protected constructor() {
   //   super();
   // }
+  
   // public static get Instance(): LearningCycleScheduler {
   //   return super.getInstance<LearningCycleScheduler>();
   // }
+  
   // /**
   //  * Set the data sources for the scheduler
   //  * @param dataSources Array of data sources
@@ -31,6 +36,7 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   // public setDataSources(dataSources: DataSourceInfo[]): void {
   //   this.dataSources = dataSources;
   // }
+  
   // /**
   //  * Start the scheduler with the specified interval in minutes
   //  * @param intervalMinutes The interval in minutes between runs
@@ -38,16 +44,19 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //  */
   // public start(intervalMinutes: number = 60): void {
   //   LogStatus(`Starting learning cycle scheduler with interval of ${intervalMinutes} minutes`);
+    
   //   // Set up the interval for recurring calls
   //   const intervalMs = intervalMinutes * 60 * 1000;
   //   this.intervalId = setInterval(() => {
   //     this.runLearningCycle()
   //       .catch(error => LogError(`Error in scheduled learning cycle: ${error}`));
   //   }, intervalMs);
+    
   //   // Start learning cycle immediately upon the server start
   //   this.runLearningCycle()
   //     .catch(error => LogError(`Error in initial learning cycle: ${error}`));
   // }
+  
   // /**
   //  * Stop the scheduler
   //  */
@@ -58,27 +67,33 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     LogStatus('Learning cycle scheduler stopped');
   //   }
   // }
+  
   // /**
   //  * Run the learning cycle if it's not already running
   //  * @returns A promise that resolves when the learning cycle completes
   //  */
   // public async runLearningCycle(): Promise<boolean> {
   //   const startTime = new Date();
+    
   //   try {
   //     // Make sure we have data sources
   //     if (!this.dataSources || this.dataSources.length === 0) {
   //       throw new Error('No data sources available for the learning cycle');
   //     }
+
   //     const dataSource = GetReadWriteDataSource(this.dataSources);
+      
   //     // Get system user for operation
   //     const systemUser = await getSystemUser(dataSource);
   //     if (!systemUser) {
   //       throw new Error('System user not found');
   //     }
+      
   //     // Create context for the resolver
   //     const config = new SQLServerProviderConfigData(dataSource, mj_core_schema, 0, undefined, undefined, false);
   //     const p = new SQLServerDataProvider();
   //     await p.Config(config);
+
   //     const context: AppContext = {
   //       dataSource: dataSource,
   //       dataSources: this.dataSources,
@@ -90,15 +105,19 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //       },
   //       providers: [{provider: p, type: 'Read-Write'}]
   //     };
+      
   //     // Execute the learning cycle
   //     const skipResolver = new AskSkipResolver();
   //     const result = await skipResolver.ExecuteAskSkipLearningCycle(
   //       context,
   //       false // forceEntityRefresh
   //     );
+      
   //     const endTime = new Date();
   //     const elapsedMs = endTime.getTime() - startTime.getTime();
+      
   //     this.lastRunTime = startTime;
+      
   //     if (result.learningCycleSkipped) {
   //       // skipped the learning cycle - no messages to process, already logged..
   //       return true;
@@ -106,7 +125,7 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     else if (result.success) {
   //       LogStatus(`Learning cycle completed successfully in ${elapsedMs}ms`);
   //       return true;
-  //     }
+  //     } 
   //     else {
   //       LogError(`Learning cycle failed after ${elapsedMs}ms: ${result.error}`);
   //       return false;
@@ -114,8 +133,9 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //   } catch (error) {
   //     LogError(`Error executing learning cycle: ${error}`);
   //     return false;
-  //   }
+  //   } 
   // }
+  
   // /**
   //  * Get the current status of the scheduler
   //  */
@@ -131,6 +151,7 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     }))
   //   };
   // }
+  
   // /**
   //  * Checks if an organization is currently running a learning cycle
   //  * @param organizationId The organization ID to check
@@ -140,19 +161,23 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //   organizationId: string
   // ): { isRunning: boolean, startTime?: Date, learningCycleId?: string, runningForMinutes?: number } {
   //   const runningInfo = this.runningOrganizations.get(organizationId);
+    
   //   if (runningInfo) {
   //     // Check if it's been running too long and should be considered stalled
   //     const now = new Date();
   //     const elapsedMinutes = (now.getTime() - runningInfo.startTime.getTime()) / (1000 * 60);
-  //     return {
-  //       isRunning: true,
+      
+  //     return { 
+  //       isRunning: true, 
   //       startTime: runningInfo.startTime,
   //       learningCycleId: runningInfo.learningCycleId,
   //       runningForMinutes: elapsedMinutes
   //     };
   //   }
+    
   //   return { isRunning: false };
   // }
+
   // /**
   //  * Registers an organization as running a learning cycle
   //  * @param organizationId The organization ID to register
@@ -162,16 +187,20 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   // public registerRunningCycle(organizationId: string, learningCycleId: string): boolean {
   //   // First check if already running
   //   const { isRunning } = this.isOrganizationRunningCycle(organizationId);
+    
   //   if (isRunning) {
   //     return false;
   //   }
+    
   //   // Register the organization as running a cycle
   //   this.runningOrganizations.set(organizationId, {
   //     startTime: new Date(),
   //     learningCycleId
   //   });
+    
   //   return true;
   // }
+
   // /**
   //  * Unregisters an organization after its learning cycle completes
   //  * @param organizationId The organization ID to unregister
@@ -182,8 +211,10 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     this.runningOrganizations.delete(organizationId);
   //     return true;
   //   }
+    
   //   return false;
   // }
+  
   // /**
   //  * Manually execute a learning cycle run for testing purposes
   //  * This is intended for debugging/testing only and will force a run
@@ -194,16 +225,20 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   // public async manuallyExecuteLearningCycle(organizationId?: string): Promise<boolean> {
   //   try {
   //     LogStatus('🧪 Manually executing learning cycle for testing...');
+      
   //     // If an organization ID is provided, register it as running
   //     const learningCycleId = `manual_${Date.now()}`;
   //     let orgRegistered = false;
+      
   //     if (organizationId) {
   //       // Check if already running
   //       const runningStatus = this.isOrganizationRunningCycle(organizationId);
+        
   //       if (runningStatus.isRunning) {
   //         LogError(`Organization ${organizationId} is already running a learning cycle. Cannot start a new one.`);
   //         return false;
   //       }
+        
   //       // Register this organization
   //       orgRegistered = this.registerRunningCycle(organizationId, learningCycleId);
   //       if (!orgRegistered) {
@@ -211,36 +246,42 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //         return false;
   //       }
   //     }
+      
   //     // Run the learning cycle
   //     const result = await this.runLearningCycle();
   //     LogStatus(`🧪 Manual learning cycle execution completed with result: ${result ? 'Success' : 'Failed'}`);
+      
   //     // Unregister the organization if it was registered
   //     if (organizationId && orgRegistered) {
   //       this.unregisterRunningCycle(organizationId);
   //     }
+      
   //     return result;
   //   } catch (error) {
   //     // Make sure to unregister on error
   //     if (organizationId && this.runningOrganizations.has(organizationId)) {
   //       this.unregisterRunningCycle(organizationId);
   //     }
+      
   //     LogError(`Error in manual learning cycle execution: ${error}`);
   //     return false;
   //   }
   // }
+  
   // /**
   //  * Force stop a running learning cycle for an organization
   //  * @param organizationId The organization ID to stop the cycle for
   //  * @returns Information about the stopped cycle
   //  */
-  // public stopLearningCycleForOrganization(organizationId: string): {
-  //   success: boolean,
+  // public stopLearningCycleForOrganization(organizationId: string): { 
+  //   success: boolean, 
   //   message: string,
   //   wasRunning: boolean,
   //   cycleDetails?: { learningCycleId: string, startTime: Date, runningForMinutes: number }
   // } {
   //   // Check if this organization has a running cycle
   //   const runningStatus = this.isOrganizationRunningCycle(organizationId);
+    
   //   if (!runningStatus.isRunning) {
   //     return {
   //       success: false,
@@ -248,12 +289,15 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //       wasRunning: false
   //     };
   //   }
+    
   //   // Capture details before unregistering
   //   const startTime = runningStatus.startTime!;
   //   const learningCycleId = runningStatus.learningCycleId!;
   //   const runningForMinutes = runningStatus.runningForMinutes!;
+    
   //   // Unregister the organization
   //   const unregistered = this.unregisterRunningCycle(organizationId);
+    
   //   if (unregistered) {
   //     return {
   //       success: true,
@@ -273,4 +317,4 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     };
   //   }
   // }
-}
+}