Merge pull request #725 from Tusharmahajan12/new_aspmar25

Pass courseId in array for shortlisting users

Author: Tusharmahajan12

src/adapters/postgres/cohortMembers-adapter.ts

@@ -6162,70 +6162,38 @@ export class PostgresCohortMembersService {
   }
 
   /**
-   * Enrolls a user to multiple courses
-   * Uses for...of loop for proper async handling
+   * Enrolls a user to multiple courses in bulk
+   * Makes API call to LMS service to create enrollments
    *
    * @param userId - The user ID to enroll
    * @param courses - Array of courses to enroll the user in
-   * @returns Promise with enrollment results for each course
+   * @returns Promise with enrollment results
    */
   private async enrollUserToCourses(
     userId: string,
     courses: any[],
     cohortId: string
-  ) {
-    const enrollmentResults = [];
-
-    // Use for...of loop for proper async handling
-    for (let i = 0; i < courses.length; i++) {
-      const course = courses[i];
-
-      try {
-        const enrollmentResult = await this.enrollUserToSingleCourse(
-          userId,
-          course.courseId,
-          cohortId
-        );
-
-        enrollmentResults.push({
-          courseId: course.courseId,
-          status: 'success',
-          result: enrollmentResult,
-        });
-      } catch (error) {
-        enrollmentResults.push({
-          courseId: course.courseId,
-          status: 'failed',
-          error: error.message,
-        });
-      }
-    }
-
-    return enrollmentResults;
-  }
-
-  /**
-   * Enrolls a user to a single course
-   * Makes API call to LMS service to create enrollment
-   *
-   * @param userId - The user ID to enroll
-   * @param courseId - The course ID to enroll in
-   * @returns Promise with enrollment result
-   */
-  private async enrollUserToSingleCourse(
-    userId: string,
-    courseId: string,
-    cohortId: string
-  ) {
+  ): Promise<
+    Array<{
+      courseId: string;
+      status: 'success' | 'failed';
+      result?: any;
+      error?: any;
+    }>
+  > {
     const lmsBaseUrl = process.env.LMS_SERVICE_URL;
     const tenantId = process.env.DEFAULT_TENANT_ID;
     const organisationId = process.env.DEFAULT_ORGANISATION_ID;
 
+    const courseIds = courses
+      .map((c) => c.courseId || c.id || c.course_id)
+      .filter((id) => !!id);
+
     try {
       const requestUrl = `${lmsBaseUrl}/lms-service/v1/enrollments`;
 
       const requestBody = {
-        courseId: courseId,
+        courseId: courseIds,
         learnerId: userId,
         status: 'published',
       };
@@ -6242,28 +6210,62 @@ export class PostgresCohortMembersService {
         },
       });
 
-      // Log successful enrollment
+      // Log successful enrollment for all courses in bulk
       ShortlistingLogger.logLMSEnrollmentSuccess({
         dateTime: new Date().toISOString(),
         userId: userId,
         cohortId: cohortId,
-        courseId: courseId,
-        enrollmentId: response.data?.enrollmentId || response.data?.id,
+        courseId: courseIds.join(','),
+        enrollmentId: 'bulk', // response.data is an array now
       });
 
-      return response.data;
+      // Map to the expected return format extracting individual course results
+      const successfullyEnrolled = response.data?.successfullyEnrolled || [];
+      const alreadyEnrolledCourseIds = response.data?.alreadyEnrolledCourseIds || [];
+      const failedCourseIds = response.data?.failedCourseIds || [];
+
+      return courseIds.map((id) => {
+        if (failedCourseIds.includes(id)) {
+          return {
+            courseId: id,
+            status: 'failed',
+            error: 'LMS API reported failure for this course',
+          };
+        }
+        if (alreadyEnrolledCourseIds.includes(id)) {
+          // Previously, a 409 threw an error and was recorded as 'failed' in the loop
+          return {
+            courseId: id,
+            status: 'failed',
+            error: 'User already enrolled (409 Conflict)',
+          };
+        }
+
+        const successMatch = successfullyEnrolled.find(
+          (e: any) => e.courseId === id
+        );
+        return {
+          courseId: id,
+          status: 'success',
+          result: successMatch || { status: 'PUBLISHED' },
+        };
+      });
     } catch (error) {
       // Log failed enrollment
       ShortlistingLogger.logLMSEnrollmentFailure({
         dateTime: new Date().toISOString(),
         userId: userId,
         cohortId: cohortId,
-        courseId: courseId,
+        courseId: courseIds.join(','),
         failureReason: error.message,
         errorCode: error.response?.status?.toString() || 'UNKNOWN',
       });
 
-      throw error;
+      return courseIds.map(id => ({
+        courseId: id,
+        status: 'failed',
+        error: error.message,
+      }));
     }
   }
 
@@ -6351,22 +6353,25 @@ export class PostgresCohortMembersService {
     // Use for...of loop for proper async handling
     for (let i = 0; i < courses.length; i++) {
       const course = courses[i];
+      const courseId = course.courseId || course.id || course.course_id;
+
+      if (!courseId) continue;
 
       try {
         const deenrollmentResult = await this.deenrollUserFromSingleCourse(
           userId,
-          course.courseId,
+          courseId,
           cohortId
         );
 
         deenrollmentResults.push({
-          courseId: course.courseId,
+          courseId: courseId,
           status: 'success',
           result: deenrollmentResult,
         });
       } catch (error) {
         deenrollmentResults.push({
-          courseId: course.courseId,
+          courseId: courseId,
           status: 'error',
           error: error.message,
         });

src/pathways/common/services/lms-client.service.ts

@@ -485,60 +485,54 @@ export class LmsClientService {
       'Content-Type': 'application/json',
     };
 
-    const failedCourseIds: string[] = [];
-    let alreadyEnrolledCount = 0;
-
-    const runChunk = async (chunk: string[]) => {
-      const results = await Promise.all(
-        chunk.map(async (courseId) => {
-          try {
-            const res = await axios.post(
-              enrollUrl,
-              { learnerId: userId, courseId, status: 'published' },
-              { headers, params: { userId }, timeout: 15000, validateStatus: () => true }
-            );
-            if (res.status >= 200 && res.status < 300) return { courseId, ok: true, alreadyEnrolled: false };
-            // 409 Conflict = already enrolled; treat as success so assignment can proceed
-            if (res.status === 409) {
-              this.logger.debug(
-                `User ${userId} already enrolled in course ${courseId} (409); treating as success`
-              );
-              return { courseId, ok: true, alreadyEnrolled: true };
-            }
-            failedCourseIds.push(courseId);
-            this.logger.warn(
-              `LMS enrollment failed for user ${userId} course ${courseId}: status ${res.status}`
-            );
-            return { courseId, ok: false, alreadyEnrolled: false };
-          } catch (err) {
-            failedCourseIds.push(courseId);
-            const msg = err instanceof Error ? err.message : 'Unknown error';
-            this.logger.warn(
-              `LMS enrollment error for user ${userId} course ${courseId}: ${msg}`
-            );
-            return { courseId, ok: false, alreadyEnrolled: false };
-          }
-        })
+    try {
+      this.logger.debug(
+        `Enrolling user ${userId} to ${courseIds.length} courses in bulk`
+      );
+      const res = await axios.post(
+        enrollUrl,
+        { learnerId: userId, courseId: courseIds, status: 'published' },
+        {
+          headers,
+          params: { userId },
+          timeout: 30000,
+          validateStatus: () => true,
+        }
       );
-      return results;
-    };
 
-    const concurrency = LmsClientService.ENROLL_CONCURRENCY;
-    for (let i = 0; i < courseIds.length; i += concurrency) {
-      const chunk = courseIds.slice(i, i + concurrency);
-      const chunkResults = await runChunk(chunk);
-      alreadyEnrolledCount += chunkResults.filter((r) => r.alreadyEnrolled).length;
-    }
+      if (res.status >= 200 && res.status < 300) {
+        const alreadyEnrolledCount =
+          res.data?.alreadyEnrolledCourseIds?.length || 0;
+        return { success: true, alreadyEnrolledCount };
+      }
+
+      // 409 Conflict = already enrolled; treat as success so assignment can proceed
+      if (res.status === 409) {
+        this.logger.debug(
+          `User ${userId} already enrolled in courses (409); treating as success`
+        );
+        const alreadyEnrolledCount = courseIds.length;
+        return { success: true, alreadyEnrolledCount };
+      }
 
-    if (failedCourseIds.length > 0) {
+      this.logger.warn(
+        `LMS bulk enrollment failed for user ${userId}: status ${res.status}`
+      );
+      return {
+        success: false,
+        failedCourseIds: courseIds,
+        message: `LMS bulk enrollment failed with status ${res.status}`,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      this.logger.error(
+        `LMS bulk enrollment error for user ${userId}: ${msg}`
+      );
       return {
         success: false,
-        failedCourseIds,
-        message: `Enrollment failed for ${failedCourseIds.length} course(s)`,
+        failedCourseIds: courseIds,
+        message: `LMS bulk enrollment error: ${msg}`,
       };
     }
-    return alreadyEnrolledCount > 0
-      ? { success: true, alreadyEnrolledCount }
-      : { success: true };
   }
 }