@memberjunction/server 2.111.0 → 2.112.0

package/src/scheduler/LearningCycleScheduler.ts

@@ -1,4 +1,4 @@
-import { LogStatus, LogError } from '@memberjunction/core';
+import { LogStatus, LogError } from '@memberjunction/global';
 import { SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { GetReadWriteDataSource } from '../util.js';
 import { AskSkipResolver } from '../resolvers/AskSkipResolver.js';
@@ -13,22 +13,17 @@ 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
@@ -36,7 +31,6 @@ 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
@@ -44,19 +38,16 @@ 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
   //  */
@@ -67,33 +58,27 @@ 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,
@@ -105,19 +90,15 @@ 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;
@@ -125,7 +106,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;
@@ -133,9 +114,8 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //   } catch (error) {
   //     LogError(`Error executing learning cycle: ${error}`);
   //     return false;
-  //   } 
+  //   }
   // }
-  
   // /**
   //  * Get the current status of the scheduler
   //  */
@@ -151,7 +131,6 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     }))
   //   };
   // }
-  
   // /**
   //  * Checks if an organization is currently running a learning cycle
   //  * @param organizationId The organization ID to check
@@ -161,23 +140,19 @@ 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
@@ -187,20 +162,16 @@ 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
@@ -211,10 +182,8 @@ 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
@@ -225,20 +194,16 @@ 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) {
@@ -246,42 +211,36 @@ 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,
@@ -289,15 +248,12 @@ 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,
@@ -317,4 +273,4 @@ export class LearningCycleScheduler extends BaseSingleton<LearningCycleScheduler
   //     };
   //   }
   // }
-}
+}

package/src/services/ScheduledJobsService.ts

@@ -3,7 +3,7 @@
  * @module MJServer/services
  */
 
-import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
+import { LogError, LogStatus, UserInfo } from '@memberjunction/global';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { SchedulingEngine } from '@memberjunction/scheduling-engine';
 import { ScheduledJobsConfig } from '../config.js';
@@ -13,152 +13,149 @@ import { ScheduledJobsConfig } from '../config.js';
  * Handles initialization, starting/stopping polling, and graceful shutdown
  */
 export class ScheduledJobsService {
-    private engine: SchedulingEngine;
-    private systemUser: UserInfo | null = null;
-    private isRunning: boolean = false;
-    private config: ScheduledJobsConfig;
-
-    constructor(config: ScheduledJobsConfig) {
-        this.config = config;
-        this.engine = SchedulingEngine.Instance;
+  private engine: SchedulingEngine;
+  private systemUser: UserInfo | null = null;
+  private isRunning: boolean = false;
+  private config: ScheduledJobsConfig;
+
+  constructor(config: ScheduledJobsConfig) {
+    this.config = config;
+    this.engine = SchedulingEngine.Instance;
+  }
+
+  /**
+   * Initialize the scheduled jobs service
+   * Loads metadata and prepares the engine
+   */
+  public async Initialize(): Promise<void> {
+    if (!this.config.enabled) {
+      LogStatus('[ScheduledJobsService] Scheduled jobs are disabled in configuration');
+      return;
     }
 
-    /**
-     * Initialize the scheduled jobs service
-     * Loads metadata and prepares the engine
-     */
-    public async Initialize(): Promise<void> {
-        if (!this.config.enabled) {
-            LogStatus('[ScheduledJobsService] Scheduled jobs are disabled in configuration');
-            return;
-        }
-
-        try {
-            // Get system user for job execution
-            this.systemUser = await this.getSystemUser();
+    try {
+      // Get system user for job execution
+      this.systemUser = await this.getSystemUser();
 
-            if (!this.systemUser) {
-                throw new Error(`System user not found with email: ${this.config.systemUserEmail}`);
-            }
+      if (!this.systemUser) {
+        throw new Error(`System user not found with email: ${this.config.systemUserEmail}`);
+      }
 
-            // Pre-load metadata cache
-            await this.engine.Config(false, this.systemUser);
-        } catch (error) {
-            LogError('[ScheduledJobsService] Failed to initialize', undefined, error);
-            throw error;
-        }
+      // Pre-load metadata cache
+      await this.engine.Config(false, this.systemUser);
+    } catch (error) {
+      LogError('[ScheduledJobsService] Failed to initialize', undefined, error);
+      throw error;
     }
-
-    /**
-     * Start the scheduled jobs polling
-     */
-    public async Start(): Promise<void> {
-        if (!this.config.enabled) {
-            return;
-        }
-
-        if (this.isRunning) {
-            LogStatus('[ScheduledJobsService] Already running');
-            return;
-        }
-
-        if (!this.systemUser) {
-            throw new Error('Service not initialized - call Initialize() first');
-        }
-
-        try {
-            this.engine.StartPolling(this.systemUser);
-            this.isRunning = true;
-
-            // Single consolidated console message
-            const jobCount = this.engine.ScheduledJobs.length;
-            if (jobCount === 0) {
-                console.log(`📅 Scheduled Jobs: No active jobs, polling suspended (will auto-start when jobs are added)`);
-            } else {
-                const interval = this.engine.ActivePollingInterval;
-                if (interval !== null) {
-                    const intervalDisplay = interval >= 60000
-                        ? `${Math.round(interval / 60000)} minute(s)`
-                        : `${Math.round(interval / 1000)} second(s)`;
-                    console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling every ${intervalDisplay}`);
-                } else {
-                    // This shouldn't happen if jobCount > 0, but handle it gracefully
-                    console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling interval not set`);
-                }
-            }
-        } catch (error) {
-            LogError('[ScheduledJobsService] Failed to start polling', undefined, error);
-            throw error;
-        }
+  }
+
+  /**
+   * Start the scheduled jobs polling
+   */
+  public async Start(): Promise<void> {
+    if (!this.config.enabled) {
+      return;
     }
 
-    /**
-     * Stop the scheduled jobs polling gracefully
-     */
-    public async Stop(): Promise<void> {
-        if (!this.isRunning) {
-            return;
-        }
-
-        try {
-            LogStatus('[ScheduledJobsService] Stopping scheduled job polling');
-            this.engine.StopPolling();
-            this.isRunning = false;
-            LogStatus('[ScheduledJobsService] Polling stopped successfully');
-        } catch (error) {
-            LogError('[ScheduledJobsService] Error stopping polling', undefined, error);
-            throw error;
-        }
+    if (this.isRunning) {
+      LogStatus('[ScheduledJobsService] Already running');
+      return;
     }
 
-    /**
-     * Get the system user for job execution
-     * Uses the email configured in scheduledJobs.systemUserEmail
-     */
-    private async getSystemUser(): Promise<UserInfo | null> {
-        const systemUserEmail = this.config.systemUserEmail;
-
-        // Search UserCache for system user
-        const user = UserCache.Users.find(u =>
-            u.Email?.toLowerCase() === systemUserEmail.toLowerCase()
-        );
+    if (!this.systemUser) {
+      throw new Error('Service not initialized - call Initialize() first');
+    }
 
-        if (user) {
-            return user;
+    try {
+      this.engine.StartPolling(this.systemUser);
+      this.isRunning = true;
+
+      // Single consolidated console message
+      const jobCount = this.engine.ScheduledJobs.length;
+      if (jobCount === 0) {
+        console.log(`📅 Scheduled Jobs: No active jobs, polling suspended (will auto-start when jobs are added)`);
+      } else {
+        const interval = this.engine.ActivePollingInterval;
+        if (interval !== null) {
+          const intervalDisplay =
+            interval >= 60000 ? `${Math.round(interval / 60000)} minute(s)` : `${Math.round(interval / 1000)} second(s)`;
+          console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling every ${intervalDisplay}`);
+        } else {
+          // This shouldn't happen if jobCount > 0, but handle it gracefully
+          console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling interval not set`);
         }
-
-        LogError(`[ScheduledJobsService] System user not found with email: ${systemUserEmail}`);
-        return null;
+      }
+    } catch (error) {
+      LogError('[ScheduledJobsService] Failed to start polling', undefined, error);
+      throw error;
     }
-
-    /**
-     * Get current service status
-     */
-    public GetStatus(): {
-        enabled: boolean;
-        running: boolean;
-        activeJobs: number;
-        pollingInterval: number;
-    } {
-        return {
-            enabled: this.config.enabled,
-            running: this.isRunning,
-            activeJobs: this.engine?.ScheduledJobs?.length || 0,
-            pollingInterval: this.engine?.ActivePollingInterval || 0
-        };
+  }
+
+  /**
+   * Stop the scheduled jobs polling gracefully
+   */
+  public async Stop(): Promise<void> {
+    if (!this.isRunning) {
+      return;
     }
 
-    /**
-     * Check if service is enabled in configuration
-     */
-    public get IsEnabled(): boolean {
-        return this.config.enabled;
+    try {
+      LogStatus('[ScheduledJobsService] Stopping scheduled job polling');
+      this.engine.StopPolling();
+      this.isRunning = false;
+      LogStatus('[ScheduledJobsService] Polling stopped successfully');
+    } catch (error) {
+      LogError('[ScheduledJobsService] Error stopping polling', undefined, error);
+      throw error;
     }
+  }
+
+  /**
+   * Get the system user for job execution
+   * Uses the email configured in scheduledJobs.systemUserEmail
+   */
+  private async getSystemUser(): Promise<UserInfo | null> {
+    const systemUserEmail = this.config.systemUserEmail;
 
-    /**
-     * Check if service is currently running
-     */
-    public get IsRunning(): boolean {
-        return this.isRunning;
+    // Search UserCache for system user
+    const user = UserCache.Users.find((u) => u.Email?.toLowerCase() === systemUserEmail.toLowerCase());
+
+    if (user) {
+      return user;
     }
+
+    LogError(`[ScheduledJobsService] System user not found with email: ${systemUserEmail}`);
+    return null;
+  }
+
+  /**
+   * Get current service status
+   */
+  public GetStatus(): {
+    enabled: boolean;
+    running: boolean;
+    activeJobs: number;
+    pollingInterval: number;
+  } {
+    return {
+      enabled: this.config.enabled,
+      running: this.isRunning,
+      activeJobs: this.engine?.ScheduledJobs?.length || 0,
+      pollingInterval: this.engine?.ActivePollingInterval || 0,
+    };
+  }
+
+  /**
+   * Check if service is enabled in configuration
+   */
+  public get IsEnabled(): boolean {
+    return this.config.enabled;
+  }
+
+  /**
+   * Check if service is currently running
+   */
+  public get IsRunning(): boolean {
+    return this.isRunning;
+  }
 }