@sunbird-cb/cbp-ai 0.1.119 → 0.1.120

package/fesm2022/sunbird-cb-cbp-ai.mjs

@@ -3822,6 +3822,16 @@ class GapAnalysisRecommendedCourseComponent {
             'competencySubtheme'
         ]);
     }
+    getProficiencyLevel(competency) {
+        return this.getValue(competency, [
+            'proficiency_level',
+            'proficiencyLevel',
+            'requiredProficiency',
+            'required_proficiency',
+            'currentProficiency',
+            'current_proficiency'
+        ]);
+    }
     /**
      * IMPORTANT:
      * course_level is the authoritative STO level of a course.
@@ -3915,53 +3925,76 @@ class GapAnalysisRecommendedCourseComponent {
                 const requiredArea = this.normalize(this.getCompetencyArea(requiredCompetency));
                 const requiredTheme = this.normalize(this.getCompetencyTheme(requiredCompetency));
                 const requiredSubtheme = this.normalize(this.getCompetencySubtheme(requiredCompetency));
+                const requiredProficiencyLevel = this.normalize(this.getProficiencyLevel(requiredCompetency));
                 if (!requiredTheme || !requiredSubtheme) {
                     return;
                 }
+                const courseProficiencyLevel = this.normalize(this.getProficiencyLevel(courseCompetency));
                 /*
-                 * Area:
-                 * If both course and role contain Area, they must match.
-                 * If Area is absent on either side, Theme + Subtheme remain
-                 * the matching keys.
-                 */
+                * Match:
+                * Area + Theme + Subtheme + Proficiency Level
+                */
                 const areaMatches = !courseArea ||
                     !requiredArea ||
                     courseArea === requiredArea;
                 const themeMatches = courseTheme === requiredTheme;
                 const subthemeMatches = courseSubtheme === requiredSubtheme;
-                if (!areaMatches || !themeMatches || !subthemeMatches) {
-                    return;
-                }
+                const proficiencyLevelMatches = courseProficiencyLevel === requiredProficiencyLevel;
+                /*
+                * All 4 parameters must match.
+                *
+                * If all 4 match:
+                *     NOT part of gap
+                *
+                * If any one does not match:
+                *     PART of gap
+                */
+                const allFourMatch = areaMatches &&
+                    themeMatches &&
+                    subthemeMatches &&
+                    proficiencyLevelMatches;
                 const requiredLevel = this.getRequiredLevel(requiredCompetency);
                 const currentLevel = this.getCurrentLevel(requiredCompetency);
                 const requiredRank = this.getLevelRank(requiredLevel);
                 const courseRank = this.getLevelRank(courseLevel);
                 let status;
                 let reason;
-                if (!courseLevel || !requiredLevel || !requiredRank || !courseRank) {
-                    status = 'NO_MATCH';
-                    reason =
-                        'Area, Theme and Subtheme match, but the required level or course_level is missing or invalid.';
-                }
-                else if (courseRank >= requiredRank) {
+                if (allFourMatch) {
+                    /*
+                    * All four competency attributes match.
+                    * Therefore this competency is NOT part of the gap.
+                    */
                     status = 'FULL';
                     reason =
-                        `Course covers the ${courseLevel} level, which meets or exceeds the required ${requiredLevel} level for this competency.`;
-                }
-                else if (courseRank === requiredRank - 1) {
-                    status = 'PARTIAL';
-                    reason =
-                        `Course covers the ${courseLevel} level, which is one level below the required ${requiredLevel} level.`;
+                        'Competency Area, Theme, Subtheme and Proficiency Level all match. This competency is not part of the gap.';
                 }
                 else {
+                    /*
+                    * At least one of the four attributes does not match.
+                    * Therefore this competency is part of the gap.
+                    */
+                    const mismatches = [];
+                    if (!areaMatches) {
+                        mismatches.push('Competency Area');
+                    }
+                    if (!themeMatches) {
+                        mismatches.push('Theme');
+                    }
+                    if (!subthemeMatches) {
+                        mismatches.push('Subtheme');
+                    }
+                    if (!proficiencyLevelMatches) {
+                        mismatches.push('Proficiency Level');
+                    }
                     status = 'NO_MATCH';
                     reason =
-                        `Course covers the ${courseLevel} level, which is below the required ${requiredLevel} level.`;
+                        `${mismatches.join(', ')} ${mismatches.length === 1 ? 'does' : 'do'} not match. This competency is part of the gap.`;
                 }
                 results.push({
                     area: this.getCompetencyArea(requiredCompetency),
                     theme: this.getCompetencyTheme(requiredCompetency),
                     subtheme: this.getCompetencySubtheme(requiredCompetency),
+                    proficiencyLevel: this.getProficiencyLevel(requiredCompetency),
                     currentLevel,
                     requiredLevel,
                     courseLevel,
@@ -3979,6 +4012,7 @@ class GapAnalysisRecommendedCourseComponent {
                 this.normalize(result.area),
                 this.normalize(result.theme),
                 this.normalize(result.subtheme),
+                this.normalize(result.proficiencyLevel),
                 this.normalize(result.requiredLevel),
                 this.normalize(result.courseLevel)
             ].join('|');
@@ -4123,6 +4157,7 @@ class GenerateCourseRecommendationComponent {
         // "recommendations already exist" pause, which previously caused the progress
         // display to jump to 100% and then reset back to 0%).
         this.progressTimerId = null;
+        this.immediateFailureHandled = false;
         this.searchText = '';
         this.filterdCourses = [];
         this.originalData = [];
@@ -5877,6 +5912,7 @@ class GenerateCourseRecommendationComponent {
             this.progressPercentage = 30;
             this.startProgressiveLoading();
             this.firstApiResponse = null;
+            this.immediateFailureHandled = false;
             concat(of(null), // immediate call
             interval(5000) // poll every 5 sec
             )
@@ -5887,18 +5923,42 @@ class GenerateCourseRecommendationComponent {
                         this.existingRecommendationFound = true;
                     }
                     console.log('First recommendation response:', this.firstApiResponse);
+                    if (response?.status === 'FAILED') {
+                        // takeWhile still forwards this same value to the subscriber below; tell it to skip
+                        this.immediateFailureHandled = true;
+                        this.stopProgressiveLoading();
+                        this.sharedService.deleteCourseRecommendations(role_mapping_id).pipe(catchError((error) => {
+                            // A 404 just means there were no course recommendations to delete yet;
+                            // either way, don't let this block the automatic retry below.
+                            if (error?.status !== 404) {
+                                console.error(`Failed to delete course recommendations for role mapping ${role_mapping_id}`, error);
+                            }
+                            return of(null);
+                        })).subscribe(() => {
+                            this.loading = false;
+                            this.firstApiResponse = null;
+                            // regenerate
+                            this.getRecommendedCourseWithProgress(role_mapping_id)
+                                .then(resolve)
+                                .catch(reject);
+                        });
+                    }
                 }
             }), takeWhile((response) => {
                 // stop polling if existing recommendations found
                 if (this.firstApiResponse?.is_existing) {
                     return false;
                 }
-                return response?.status !== 'COMPLETED';
+                return response?.status !== 'COMPLETED' && response?.status !== 'FAILED';
             }, true), finalize(() => {
                 this.loading = false;
             }))
                 .subscribe({
                 next: (response) => {
+                    if (this.immediateFailureHandled) {
+                        this.immediateFailureHandled = false; // already handled in tap() above; avoid double-handling this same emission
+                        return;
+                    }
                     // ===========================
                     // EXISTING RECOMMENDATIONS
                     // ===========================
@@ -5966,6 +6026,21 @@ class GenerateCourseRecommendationComponent {
                         });
                         resolve(response);
                     }
+                    // ===========================
+                    // FAILED (after being in progress)
+                    // ===========================
+                    else if (response?.status === 'FAILED') {
+                        this.stopProgressiveLoading();
+                        this.loading = false;
+                        this.currentProcessingStage = '';
+                        this.progressPercentage = 0;
+                        this.firstApiResponse = null;
+                        this.snackBar.open('Generation failed please try again later', 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-error']
+                        });
+                        reject(response);
+                    }
                 },
                 error: (error) => {
                     this.stopProgressiveLoading();
@@ -11680,6 +11755,7 @@ class RoleMappingGenerationComponent {
         this.workAllocationOrderDocumentMissing = false;
         this.showWorkAllocationOrderDocumentMissing = false;
         this.destroy$ = new Subject();
+        this.immediateFailureHandled = false;
         this.onDepartmentScroll = (event) => {
             const panel = event.target;
             if (panel.scrollTop + panel.clientHeight >= panel.scrollHeight - 60) {
@@ -12206,6 +12282,7 @@ class RoleMappingGenerationComponent {
     }
     generateFinalRoleMapping() {
         this.apiLoading = true;
+        this.immediateFailureHandled = false;
         if (!this.roleMappingForm.valid) {
             this.roleMappingForm.markAllAsTouched();
             return;
@@ -12270,6 +12347,7 @@ class RoleMappingGenerationComponent {
                 if (data && data?.status === 'FAILED') {
                     this.apiLoading = false;
                     this.loading = false;
+                    this.immediateFailureHandled = true; // takeWhile still forwards this same value to subscribe(); tell it to skip
                     this.destroy$.next(); // 🛑 stop polling
                     this.regenerateRoleMappingAfterFailedAndDelete();
                     return;
@@ -12282,6 +12360,10 @@ class RoleMappingGenerationComponent {
             data?.status !== 'FAILED', true // emit the final COMPLETED/FAILED response
         ))
             .subscribe(data => {
+            if (this.immediateFailureHandled) {
+                this.immediateFailureHandled = false; // already handled in tap() above; avoid double-handling this same emission
+                return;
+            }
             console.log('role mapping data--', data);
             if (this.firstApiResponse?.is_existing) {
                 this.showWorkAllocationOrderDocumentMissing = false;
@@ -12369,7 +12451,10 @@ class RoleMappingGenerationComponent {
                 this.loading = false;
                 this.apiLoading = false;
                 this.destroy$.next(); // 🛑 stop polling
-                this.showRoleMappingFailedPopup();
+                this.snackBar.open('Generation failed please try again later', 'X', {
+                    duration: 3000,
+                    panelClass: ['snackbar-error']
+                });
                 return;
             }
         });
@@ -12626,45 +12711,41 @@ class RoleMappingGenerationComponent {
     goToUploadDocument() {
         this.router.navigate(['/ai/upload-documents']);
     }
-    showRoleMappingFailedPopup() {
-        console.log('role mapping failed, try to regenerate role mapping?');
-        // alert('role mapping failed, try to regenerate role mapping?')
-        const dialogRef = this.dialog.open(DeleteRoleMappingPopupComponent, {
-            width: '400px',
-            data: { documents: this.documents, from: 'roleMappingFailed', },
-            panelClass: 'view-cbp-plan-popup',
-            minHeight: '300px',
-            maxHeight: '80vh',
-            disableClose: true // Optional: prevent closing with outside click
-        });
-        dialogRef.afterClosed().subscribe(result => {
-            if (result === 'saved') {
-                console.log('Changes saved!');
-                this.regenerateRoleMappingAfterFailedAndDelete();
-                this.loading = true;
-            }
-            else {
-                this.loading = false;
-            }
-        });
-    }
     regenerateRoleMappingAfterFailedAndDelete() {
-        this.sharedService.deleteRoleMappingByStateAndDepartment(this.roleMappingForm.value.ministry, this.roleMappingForm.value.departments).subscribe({
-            next: (res) => {
-                // Success handling
-                console.log('Success:', res);
-                this.loading = false;
-                this.firstApiResponse = [];
-                this.generateFinalRoleMapping();
+        const stateCenterId = this.roleMappingForm.value.ministry;
+        const departmentId = this.roleMappingForm.value.departments;
+        this.sharedService.getRoleMappingByStateCenterAndDepartment(stateCenterId, departmentId).subscribe({
+            next: (existingRoleMappings) => {
+                const roleMappingIds = (Array.isArray(existingRoleMappings) ? existingRoleMappings : [])
+                    .map((roleMapping) => roleMapping?.id)
+                    .filter(Boolean);
+                if (!roleMappingIds.length) {
+                    this.loading = false;
+                    this.firstApiResponse = null;
+                    this.generateFinalRoleMapping();
+                    return;
+                }
+                forkJoin(roleMappingIds.map((id) => this.sharedService.deleteCourseRecommendations(id).pipe(catchError((error) => {
+                    // A 404 just means this designation had no course recommendations yet.
+                    // Either way, one designation's delete failing shouldn't block the
+                    // regenerate retry for the rest.
+                    if (error?.status !== 404) {
+                        console.error(`Failed to delete course recommendations for role mapping ${id}`, error);
+                    }
+                    return of(null);
+                })))).subscribe(() => {
+                    this.loading = false;
+                    this.firstApiResponse = null;
+                    this.generateFinalRoleMapping();
+                });
             },
             error: (error) => {
                 this.snackBar.open(error?.error?.detail, 'X', {
                     duration: 3000,
                     panelClass: ['snackbar-error']
                 });
-                this.firstApiResponse = [];
                 this.loading = false;
-                // this.generateFinalRoleMapping()
+                this.firstApiResponse = null;
             }
         });
     }