@sunbird-cb/toc 0.0.1-mauritius

package/esm2022/lib/services/viewer-util.service.mjs

@@ -0,0 +1,627 @@
+import { NsContent } from '../_services/widget-content.model';
+import { Inject, Injectable } from '@angular/core';
+import { noop, Subject } from 'rxjs';
+import dayjs from 'dayjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@sunbird-cb/utils-v2";
+import * as i3 from "../_collection-api";
+import * as i4 from "./app-toc.service";
+import * as i5 from "@sunbird-cb/consumption";
+export class ViewerUtilService {
+    constructor(http, configservice, contentSvc, tocSvc, userSvc, contentLangSvc, domainConfSvc, environment) {
+        this.http = http;
+        this.configservice = configservice;
+        this.contentSvc = contentSvc;
+        this.tocSvc = tocSvc;
+        this.userSvc = userSvc;
+        this.contentLangSvc = contentLangSvc;
+        this.domainConfSvc = domainConfSvc;
+        this.environment = environment;
+        this.API_ENDPOINTS = {
+            setS3Cookie: `/apis/v8/protected/content/setCookie`,
+            // PROGRESS_UPDATE: `/apis/protected/v8/user/realTimeProgress/update`,
+            PROGRESS_UPDATE: `/apis/proxies/v8/content-progres`,
+            ASSESSMENT_SECTION: `/apis/proxies/v8/assessment/v5/read`,
+            GET_FORM_BYID: (formId) => `apis/proxies/v8/forms/v2/getFormById?formId=${formId}`,
+            SUBMIT_FORM: `/apis/proxies/v8/forms/v2/saveFormSubmit`,
+            // GET_FORM_BYID: (formId: string) => `apis/proxies/v8/forms/getFormById?id=${formId}`,
+            // SUBMIT_FORM: `/apis/proxies/v8/forms/v1/saveFormSubmit`,
+            PRE_ASSESSMENT_STATE_UPDATE: `/apis/proxies/v8/content/v2/state/update`
+        };
+        this.downloadRegex = new RegExp(`(/content-store/.*?)(\\\)?\\\\?['"])`, 'gm');
+        this.authoringBase = '/apis/authContent/';
+        this.markAsCompleteSubject = new Subject();
+        this.autoPlayNextVideo = new Subject();
+        this.autoPlayNextAudio = new Subject();
+        this.forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true');
+        this.publicUserDetails = {};
+        this.regexDownloadReplace = (_str = '', group1, group2) => {
+            return `${this.authoringBase}${encodeURIComponent(group1)}${group2}`;
+        };
+    }
+    async fetchManifestFile(url) {
+        this.setS3Cookie(url);
+        const manifestFile = await this.http
+            .get(url)
+            .toPromise()
+            .catch((_err) => { });
+        return manifestFile;
+    }
+    async setS3Cookie(_contentId) {
+        // await this.http
+        //   .post(this.API_ENDPOINTS.setS3Cookie, { contentId })
+        //   .toPromise()
+        //   .catch((_err: any) => { })
+        return;
+    }
+    calculatePercent(current, max, mimeType) {
+        try {
+            const temp = [...current];
+            if (temp && temp.length && max) {
+                const latest = parseFloat(temp.pop() || '0');
+                const percentMilis = (latest / max) * 100;
+                let percent = parseFloat(percentMilis.toFixed(2));
+                if (mimeType === NsContent.EMimeTypes.MP4 ||
+                    mimeType === NsContent.EMimeTypes.M3U8 ||
+                    mimeType === NsContent.EMimeTypes.MP3 ||
+                    mimeType === NsContent.EMimeTypes.M4A ||
+                    mimeType === NsContent.EMimeTypes.YOUTUBE ||
+                    mimeType === NsContent.EMimeTypes.SURVEY) {
+                    if (percent <= 5) {
+                        // if percentage is less than 5% make it 0
+                        percent = 0;
+                    }
+                    else if (percent >= 95) {
+                        // if percentage is greater than 95% make it 100
+                        percent = 100;
+                    }
+                }
+                return percent;
+            }
+            return 0;
+        }
+        catch (e) {
+            // tslint:disable-next-line: no-console
+            console.log('Error in calculating percentage', e);
+            return 0;
+        }
+    }
+    getStatus(current, max, mimeType) {
+        try {
+            const percentage = this.calculatePercent(current, max, mimeType);
+            // for videos and audios
+            if (mimeType === NsContent.EMimeTypes.MP4 ||
+                mimeType === NsContent.EMimeTypes.M3U8 ||
+                mimeType === NsContent.EMimeTypes.MP3 ||
+                mimeType === NsContent.EMimeTypes.M4A ||
+                mimeType === NsContent.EMimeTypes.SURVEY ||
+                mimeType === NsContent.EMimeTypes.PDF) {
+                // if percentage is less than 5% then make status started
+                if (Math.ceil(percentage) <= 5) {
+                    return 1;
+                }
+                // if percentage is greater than 95% then make status complete
+                if (Math.ceil(percentage) >= 95) {
+                    return 2;
+                }
+            }
+            else {
+                if (Math.ceil(percentage) >= 100) {
+                    return 2;
+                }
+            }
+            return 1;
+        }
+        catch (e) {
+            // tslint:disable-next-line: no-console
+            console.log('Error in getting completion status', e);
+            return 1;
+        }
+    }
+    realTimeProgressUpdate(contentId, request, collectionId, batchId) {
+        let req;
+        if (this.configservice.userProfile) {
+            const language = this.getResourceContentLanguage(contentId);
+            req = {
+                request: {
+                    userId: this.configservice.userProfile.userId || '',
+                    contents: [
+                        {
+                            contentId,
+                            batchId,
+                            language,
+                            status: this.getStatus(request.current, request.max_size, request.mime_type),
+                            courseId: collectionId,
+                            lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),
+                            progressdetails: {
+                                max_size: request.max_size,
+                                current: request.current,
+                                mimeType: request.mime_type,
+                            },
+                            completionPercentage: this.calculatePercent(request.current, request.max_size, request.mime_type),
+                        },
+                    ],
+                },
+            };
+            // if (this.configservice.cstoken !== '') {
+            //   const headers = new HttpHeaders()
+            //   .set('cstoken', this.configservice.cstoken)
+            //   this.http
+            //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, { headers } , req)
+            //   .subscribe(noop, noop)
+            // } else {
+            //   this.http
+            //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)
+            //   .subscribe(noop, noop)
+            // }
+            this.http
+                .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)
+                .subscribe(noop, noop);
+            if (this.tocSvc.hashmap[contentId]) {
+                const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus'];
+                if (!currentStatus || currentStatus < 2) {
+                    this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage;
+                    this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0;
+                    this.tocSvc.hashmap = { ...this.tocSvc.hashmap };
+                    // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes
+                    this.tocSvc.triggerMilestoneLockUpdate();
+                    // Emit to trigger viewer component refresh for Learning Pathways
+                    this.markAsCompleteSubject.next(true);
+                }
+            }
+        }
+        else {
+            req = {};
+            // do nothing
+        }
+    }
+    getBatchIdAndCourseId(courseId, batchId, resourceId) {
+        const tempData = {
+            courseId,
+            batchId,
+        };
+        const tempContentData = this.contentSvc.currentMetaData;
+        const tempContentReadData = this.contentSvc.currentContentReadMetaData;
+        const enrollmentList = this.contentSvc.currentBatchEnrollmentList;
+        if (!this.forPreview) {
+            if (tempContentData.courseCategory === 'Learning Pathway') {
+                // Find the course that contains the given resource ID
+                const foundCourse = this.findCourseContainingResource(tempContentData, resourceId);
+                if (foundCourse) {
+                    // Always update courseId if course is found
+                    tempData.courseId = foundCourse.identifier;
+                    // Try to find batch ID from enrollment data for the found course
+                    if (foundCourse.identifier) {
+                        const enrollment = enrollmentList.find((course) => course.collectionId === foundCourse.identifier);
+                        if (enrollment && enrollment.batchId) {
+                            tempData.batchId = enrollment.batchId;
+                        }
+                    }
+                }
+            }
+            else if (tempContentData && tempContentReadData.cumulativeTracking &&
+                (tempContentData.primaryCategory === NsContent.EPrimaryCategory.PROGRAM ||
+                    tempContentData.primaryCategory === NsContent.EPrimaryCategory.CURATED_PROGRAM
+                    || tempContentData.primaryCategory === NsContent.EPrimaryCategory.BLENDED_PROGRAM)) {
+                tempContentData.children.forEach(async (childList) => {
+                    if (childList.primaryCategory === NsContent.EPrimaryCategory.COURSE) {
+                        // tslint:disable-next-line: max-line-length
+                        const courseEnrollmentList = enrollmentList && enrollmentList.filter((v) => v.contentId === childList.identifier);
+                        if (childList.childNodes && childList.childNodes.indexOf(resourceId) !== -1) {
+                            if (courseEnrollmentList && courseEnrollmentList.length > 0) {
+                                tempData.batchId = courseEnrollmentList[courseEnrollmentList.length - 1].batch.batchId;
+                                tempData.courseId = childList.identifier;
+                            }
+                            else {
+                                const data = await this.checkForCourseEnrollment(childList, resourceId, enrollmentList, tempData);
+                                tempData.courseId = data.courseId;
+                                tempData.batchId = data.batchId;
+                            }
+                        }
+                    }
+                    else if (tempContentData.primaryCategory === NsContent.EPrimaryCategory.BLENDED_PROGRAM) {
+                        if (tempData.courseId === courseId) {
+                            const bPEnrollmentList = enrollmentList.filter((v) => v.contentId === tempContentData.identifier);
+                            if (tempContentData.childNodes && tempContentData.childNodes.indexOf(resourceId) !== -1) {
+                                if (bPEnrollmentList.length > 0) {
+                                    tempData.batchId = bPEnrollmentList[bPEnrollmentList.length - 1].batch.batchId;
+                                    tempData.courseId = tempContentData.identifier;
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+        }
+        return tempData;
+    }
+    /**
+     * Recursively searches for a resource ID in a content's children hierarchy
+     * @param content The content object to search in
+     * @param resourceId The resource ID to find
+     * @returns true if resource is found, false otherwise
+     */
+    findResourceInContent(content, resourceId) {
+        // Check if this content has the resource in its leafNodes
+        if (content.leafNodes && Array.isArray(content.leafNodes)) {
+            if (content.leafNodes.indexOf(resourceId) !== -1) {
+                return true;
+            }
+        }
+        // Check if this content's identifier matches the resource ID
+        if (content.identifier === resourceId) {
+            return true;
+        }
+        // Recursively search in children
+        if (content.children && Array.isArray(content.children)) {
+            for (const child of content.children) {
+                if (this.findResourceInContent(child, resourceId)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Finds the course that contains a given resource ID in a Learning Pathway
+     * @param learningPathwayContent The Learning Pathway content data
+     * @param resourceId The resource ID to find
+     * @returns The course object containing the resource, or null if not found
+     */
+    findCourseContainingResource(learningPathwayContent, resourceId) {
+        // Check if milestones_v1 exists
+        if (!learningPathwayContent.milestones_v1 || !Array.isArray(learningPathwayContent.milestones_v1)) {
+            return null;
+        }
+        // Loop through each milestone
+        for (const milestone of learningPathwayContent.milestones_v1) {
+            // Check if milestone has courses
+            if (milestone.courses && Array.isArray(milestone.courses)) {
+                // Loop through each course in the milestone
+                for (const course of milestone.courses) {
+                    // Check if this course contains the resource
+                    if (this.findResourceInContent(course, resourceId)) {
+                        return course;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    getResourceContentLanguage(resourceId) {
+        let tempLanguage = 'english';
+        let languageFound = false;
+        const tempContentData = this.contentSvc.currentMetaData;
+        if (!this.forPreview) {
+            tempContentData.children?.forEach(async (childList) => {
+                if (childList.primaryCategory === NsContent.EPrimaryCategory.COURSE) {
+                    // tslint:disable-next-line: max-line-length
+                    if (childList.leafNodes && childList.leafNodes.indexOf(resourceId) !== -1) {
+                        tempLanguage = this.contentLangSvc.getContentLanguage(childList);
+                        languageFound = true;
+                    }
+                }
+                else if (childList?.primaryCategory === 'Milestone') {
+                    childList.children?.forEach(async (child) => {
+                        if (child.primaryCategory === NsContent.EPrimaryCategory.COURSE) {
+                            // tslint:disable-next-line: max-line-length
+                            if (child.leafNodes && child.leafNodes.indexOf(resourceId) !== -1) {
+                                tempLanguage = this.contentLangSvc.getContentLanguage(child);
+                                languageFound = true;
+                            }
+                        }
+                    });
+                }
+            });
+            if (!languageFound) {
+                if (tempContentData.leafNodes && tempContentData.leafNodes.indexOf(resourceId) !== -1) {
+                    tempLanguage = this.contentLangSvc.getContentLanguage(tempContentData);
+                }
+            }
+        }
+        return tempLanguage;
+    }
+    async checkForCourseEnrollment(childList, _resourceId, _enrollmentList, _tempData) {
+        // tslint:disable-next-line: max-line-length
+        const courseData = await this.contentSvc.autoAssignBatchApi(childList.identifier).toPromise().then(async (data) => {
+            if (data) {
+                // tslint:disable-next-line: max-line-length
+                const responseData = await this.userSvc.fetchEnrollmentDataByContentId(this.configservice.userProfile?.userId, childList.identifier).toPromise().then(async (res) => {
+                    if (res && res.courses && res.courses.length) {
+                        return res.courses;
+                    }
+                    return [{ courseId: childList.identifier, batchId: '' }];
+                }).catch((_err) => {
+                    return [{ courseId: childList.identifier, batchId: '' }];
+                });
+                this.contentSvc.currentBatchEnrollmentList = [...this.contentSvc.currentBatchEnrollmentList, ...responseData];
+                return { courseId: childList.identifier, batchId: responseData[0].batchId };
+            }
+        }).catch((_err) => {
+            return [{ courseId: childList.identifier, batchId: '' }];
+        });
+        return courseData;
+    }
+    realTimeProgressUpdateQuiz(contentId, collectionId, batchId, status) {
+        let req;
+        if (this.configservice.userProfile) {
+            const language = this.getResourceContentLanguage(contentId);
+            req = {
+                request: {
+                    userId: this.configservice.userProfile.userId || '',
+                    contents: [
+                        {
+                            contentId,
+                            batchId,
+                            language,
+                            status: status || 2,
+                            courseId: collectionId,
+                            lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),
+                            completionPercentage: status === 2 ? 100 : 0,
+                        },
+                    ],
+                },
+            };
+            this.http
+                .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)
+                .subscribe(noop, noop);
+            if (this.tocSvc.hashmap && this.tocSvc.hashmap[contentId] && req.request.contents[0]) {
+                const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus'];
+                if (!currentStatus || currentStatus < 2) {
+                    this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage;
+                    this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0;
+                    this.tocSvc.hashmap = { ...this.tocSvc.hashmap };
+                    // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes
+                    if (this.tocSvc.triggerMilestoneLockUpdate) {
+                        this.tocSvc.triggerMilestoneLockUpdate();
+                    }
+                    // Emit to trigger viewer component refresh for Learning Pathways
+                    this.markAsCompleteSubject.next(true);
+                }
+            }
+        }
+        else {
+            req = {};
+            // do nothing
+        }
+    }
+    getContent(contentId) {
+        const forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true');
+        let url = `/apis/proxies/v8/action/content/v3/read/${contentId}`;
+        if (!forPreview) {
+            url = `/apis/proxies/v8/action/content/v3/read/${contentId}`;
+        }
+        else {
+            if (window.location.href.includes('editMode=true') && window.location.href.includes('_rc')) {
+                url = `/apis/proxies/v8/action/content/v3/read/${contentId}`;
+            }
+            else {
+                url = `/api/content/v1/read/${contentId}`;
+            }
+        }
+        return this.http.get(
+        // tslint:disable-next-line:max-line-length
+        // `/apis/authApi/action/content/hierarchy/${contentId}?rootOrg=${this.configservice.rootOrg || 'igot'}&org=${this.configservice.activeOrg || 'dopt'}`,
+        url);
+    }
+    getAuthoringUrl(url) {
+        return url
+            // tslint:disable-next-line:max-line-length
+            ? `/apis/authContent/${url.includes('/content-store/') ? new URL(url).pathname.slice(1) : encodeURIComponent(url)}`
+            : '';
+    }
+    replaceToAuthUrl(data) {
+        return JSON.parse(JSON.stringify(data).replace(this.downloadRegex, this.regexDownloadReplace));
+    }
+    readSections(assessmentId) {
+        return `${this.API_ENDPOINTS}/${assessmentId}`;
+    }
+    getPublicUrl(url) {
+        const mainUrl = url.split('/content').pop() || '';
+        return `${this.environment.contentHost}/${this.environment.contentBucket}/content${mainUrl}`;
+    }
+    getCdnUrl(url) {
+        const mainUrl = url.split('/content').pop() || '';
+        return `${this.domainConfSvc.getDomainCDNHost()}/${this.environment.cdnContentBucket}/content${mainUrl}`;
+    }
+    //  fetchContent(
+    //   contentId: string,
+    //   hierarchyType: 'all' | 'minimal' | 'detail' = 'detail'
+    //   ): Observable<NsContent.IContent> {
+    //     let url = ''
+    //     const forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true')
+    //       if (!forPreview) {
+    //         url = `/apis/proxies/v8/action/content/v3/hierarchy/${contentId}?hierarchyType=${hierarchyType}`
+    //       } else {
+    //         url = `/api/course/v1/hierarchy/${contentId}?hierarchyType=${hierarchyType}`
+    //       }
+    //       return this.http.get<NsContent.IContent>(url)
+    //   }
+    fetchContent(id, type) {
+        return this.http.get(`/apis/proxies/v8/action/content/v3/hierarchy/${id}?mode=${type}`);
+    }
+    updateContentHashMapForAssesstent(contentId, contentProgress) {
+        if (this.tocSvc.hashmap[contentId]) {
+            const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus'] || 0;
+            const newStatus = Number(contentProgress.status) || 0;
+            // Update if not complete or if new status is higher
+            if (currentStatus < 2 || newStatus >= currentStatus) {
+                this.tocSvc.hashmap[contentId]['completionPercentage'] = contentProgress.completionPercentage;
+                this.tocSvc.hashmap[contentId]['completionStatus'] = newStatus;
+                this.tocSvc.hashmap[contentId]['status'] = newStatus;
+                // Create new hashmap reference for Angular change detection
+                this.tocSvc.hashmap = { ...this.tocSvc.hashmap };
+                // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes
+                if (this.tocSvc.triggerMilestoneLockUpdate) {
+                    this.tocSvc.triggerMilestoneLockUpdate();
+                }
+                // Emit to trigger viewer component refresh for Learning Pathways
+                this.markAsCompleteSubject.next(true);
+            }
+        }
+    }
+    getFormById(formId) {
+        return this.http.get(this.API_ENDPOINTS.GET_FORM_BYID(formId));
+    }
+    submitForm(formData) {
+        return this.http.post(this.API_ENDPOINTS.SUBMIT_FORM, formData);
+    }
+    realTimeProgressUpdateForPreAssessment(contentId, request) {
+        let req;
+        if (this.configservice.userProfile) {
+            req = {
+                request: {
+                    userId: this.configservice.userProfile.userId || '',
+                    contents: [
+                        {
+                            contentId,
+                            // batchId,
+                            status: this.getStatus(request.current, request.max_size, request.mime_type),
+                            // courseId: collectionId,
+                            lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),
+                            progressdetails: {
+                                max_size: request.max_size,
+                                current: request.current,
+                                mimeType: request.mime_type,
+                            },
+                            completionPercentage: this.calculatePercent(request.current, request.max_size, request.mime_type),
+                        },
+                    ],
+                },
+            };
+            // if (this.configservice.cstoken !== '') {
+            //   const headers = new HttpHeaders()
+            //   .set('cstoken', this.configservice.cstoken)
+            //   this.http
+            //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, { headers } , req)
+            //   .subscribe(noop, noop)
+            // } else {
+            //   this.http
+            //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)
+            //   .subscribe(noop, noop)
+            // }
+            // this.http
+            //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)
+            //   .subscribe(noop, noop)
+            //const contentIdNew= req.request.contents[0].contentId
+            // const updatedCompletionPercentage = req.request.contents[0].completionPercentage
+            // const updatedStatus = req.request.contents[0].status
+            // // Clone the inner object and update
+            // const existingContent = this.tocSvc.hashmap[contentIdNew] || {}
+            // this.tocSvc.hashmap = {
+            //   ...this.tocSvc.hashmap,
+            //   [contentIdNew]: {
+            //     ...existingContent,
+            //     completionPercentage: updatedCompletionPercentage,
+            //     completionStatus: updatedStatus
+            //   }
+            // }
+            // console.log('req', JSON.stringify(req))
+            // console.log('req', req)
+            const resourceStatus = this.getPreAssessmentResourceStatus(contentId);
+            if (resourceStatus < 2) {
+                this.http
+                    .patch(`${this.API_ENDPOINTS.PRE_ASSESSMENT_STATE_UPDATE}`, req)
+                    .subscribe(noop, noop);
+            }
+            if (this.tocSvc.hashmap[contentId] &&
+                (!this.tocSvc.hashmap[contentId]['completionStatus'] || this.tocSvc.hashmap[contentId]['completionStatus'] < 2)) {
+                this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage;
+                this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0;
+                this.tocSvc.hashmap[contentId]['parent'] = req.request.contents[0].courseId;
+                this.tocSvc.hashmap[contentId]['progress'] = req.request.contents[0].progressdetails;
+                this.tocSvc.hashmap = { ...this.tocSvc.hashmap };
+                // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes
+                if (this.tocSvc.triggerMilestoneLockUpdate) {
+                    this.tocSvc.triggerMilestoneLockUpdate();
+                }
+                // Emit to trigger viewer component refresh for Learning Pathways
+                this.markAsCompleteSubject.next(true);
+            }
+        }
+        else {
+            req = {};
+            // do nothing
+        }
+    }
+    realTimeProgressUpdateForPreAssessmentQuiz(contentId, status, mimeType) {
+        let req;
+        if (this.configservice.userProfile) {
+            req = {
+                request: {
+                    //userId: this.configservice.userProfile.userId || '',
+                    contents: [
+                        {
+                            contentId,
+                            // batchId,
+                            status: status || 2,
+                            // courseId: collectionId,
+                            lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),
+                            completionPercentage: status === 2 ? 100.0 : 0,
+                            progressdetails: {
+                                "mimeType": mimeType || "application/vnd.sunbird.questionset"
+                            },
+                        },
+                    ],
+                },
+            };
+            const resourceStatus = this.getPreAssessmentResourceStatus(contentId);
+            if (resourceStatus < 2) {
+                this.http
+                    .patch(`${this.API_ENDPOINTS.PRE_ASSESSMENT_STATE_UPDATE}`, req)
+                    .subscribe(noop, noop);
+            }
+            // Update hashmap - create entry if it doesn't exist
+            if (this.tocSvc.hashmap) {
+                if (!this.tocSvc.hashmap[contentId]) {
+                    // Create new entry for pre-assessment if it doesn't exist
+                    this.tocSvc.hashmap[contentId] = {
+                        identifier: contentId,
+                        completionPercentage: req.request.contents[0].completionPercentage,
+                        completionStatus: Number(req.request.contents[0].status) || 0,
+                        status: Number(req.request.contents[0].status) || 0,
+                        isPreAssessment: true
+                    };
+                }
+                else {
+                    // Update existing entry
+                    this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage;
+                    this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0;
+                    this.tocSvc.hashmap[contentId]['status'] = Number(req.request.contents[0].status) || 0;
+                }
+                this.tocSvc.hashmap = { ...this.tocSvc.hashmap };
+                // ALWAYS trigger milestone lock recomputation when pre-assessment completes
+                // This ensures milestone 1 unlocks immediately after pre-assessment completion
+                if (this.tocSvc.triggerMilestoneLockUpdate) {
+                    this.tocSvc.triggerMilestoneLockUpdate();
+                }
+                // Emit markAsCompleteSubject to trigger viewer component to refresh enrollment and progress
+                // This is critical for Learning Pathways to unlock milestones immediately
+                this.markAsCompleteSubject.next(true);
+            }
+        }
+        else {
+            req = {};
+            // do nothing
+        }
+    }
+    getPreAssessmentResourceStatus(resourceId) {
+        if (this.tocSvc && this.tocSvc.hashmap && this.tocSvc.hashmap[resourceId]) {
+            return this.tocSvc.hashmap[resourceId]['completionStatus'] || 1;
+        }
+        return 1;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ViewerUtilService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigurationsService }, { token: i3.WidgetContentService }, { token: i4.AppTocService }, { token: i5.WidgetUserServiceLib }, { token: i5.ContentLanguageService }, { token: i2.DomainConfService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ViewerUtilService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ViewerUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigurationsService }, { type: i3.WidgetContentService }, { type: i4.AppTocService }, { type: i5.WidgetUserServiceLib }, { type: i5.ContentLanguageService }, { type: i2.DomainConfService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewer-util.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/toc/src/lib/services/viewer-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConfigurationsService, DomainConfService } from '@sunbird-cb/utils-v2'\nimport { NsContent } from '../_services/widget-content.model'\nimport { Inject, Injectable } from '@angular/core'\nimport { HttpClient } from '@angular/common/http'\nimport { noop, Observable, Subject } from 'rxjs'\nimport dayjs from 'dayjs'\nimport { AppTocService } from './app-toc.service'\nimport { ContentLanguageService, WidgetUserServiceLib } from '@sunbird-cb/consumption'\nimport { WidgetContentService } from '../_collection-api'\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ViewerUtilService {\n  API_ENDPOINTS = {\n    setS3Cookie: `/apis/v8/protected/content/setCookie`,\n    // PROGRESS_UPDATE: `/apis/protected/v8/user/realTimeProgress/update`,\n    PROGRESS_UPDATE: `/apis/proxies/v8/content-progres`,\n    ASSESSMENT_SECTION: `/apis/proxies/v8/assessment/v5/read`,\n    GET_FORM_BYID: (formId: string) => `apis/proxies/v8/forms/v2/getFormById?formId=${formId}`,\n    SUBMIT_FORM: `/apis/proxies/v8/forms/v2/saveFormSubmit`,\n    // GET_FORM_BYID: (formId: string) => `apis/proxies/v8/forms/getFormById?id=${formId}`,\n    // SUBMIT_FORM: `/apis/proxies/v8/forms/v1/saveFormSubmit`,\n    PRE_ASSESSMENT_STATE_UPDATE: `/apis/proxies/v8/content/v2/state/update`\n\n  }\n  downloadRegex = new RegExp(`(/content-store/.*?)(\\\\\\)?\\\\\\\\?['\"])`, 'gm')\n  authoringBase = '/apis/authContent/'\n  markAsCompleteSubject = new Subject()\n  autoPlayNextVideo = new Subject()\n  autoPlayNextAudio = new Subject()\n  forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true')\n  publicUserDetails: any = {}\n  constructor(\n    private http: HttpClient,\n    private configservice: ConfigurationsService,\n    private contentSvc: WidgetContentService,\n    private tocSvc: AppTocService,\n    private userSvc: WidgetUserServiceLib,\n    private contentLangSvc: ContentLanguageService,\n    private domainConfSvc: DomainConfService,\n    @Inject('environment') private environment: any\n  ) { }\n\n  async fetchManifestFile(url: string) {\n    this.setS3Cookie(url)\n    const manifestFile = await this.http\n      .get<any>(url)\n      .toPromise()\n      .catch((_err: any) => { })\n    return manifestFile\n  }\n\n  private async setS3Cookie(_contentId: string) {\n    // await this.http\n    //   .post(this.API_ENDPOINTS.setS3Cookie, { contentId })\n    //   .toPromise()\n    //   .catch((_err: any) => { })\n    return\n  }\n\n  calculatePercent(current: string[], max: number, mimeType?: string): number {\n    try {\n      const temp = [...current]\n      if (temp && temp.length && max) {\n        const latest = parseFloat(temp.pop() || '0')\n        const percentMilis = (latest / max) * 100\n        let percent = parseFloat(percentMilis.toFixed(2))\n        if (\n          mimeType === NsContent.EMimeTypes.MP4 ||\n          mimeType === NsContent.EMimeTypes.M3U8 ||\n          mimeType === NsContent.EMimeTypes.MP3 ||\n          mimeType === NsContent.EMimeTypes.M4A ||\n          mimeType === NsContent.EMimeTypes.YOUTUBE ||\n          mimeType === NsContent.EMimeTypes.SURVEY\n        ) {\n          if (percent <= 5) {\n            // if percentage is less than 5% make it 0\n            percent = 0\n          } else if (percent >= 95) {\n            // if percentage is greater than 95% make it 100\n            percent = 100\n          }\n        }\n        return percent\n      }\n      return 0\n    } catch (e) {\n      // tslint:disable-next-line: no-console\n      console.log('Error in calculating percentage', e)\n      return 0\n    }\n  }\n\n  getStatus(current: string[], max: number, mimeType?: string) {\n    try {\n      const percentage = this.calculatePercent(current, max, mimeType)\n      // for videos and audios\n      if (\n        mimeType === NsContent.EMimeTypes.MP4 ||\n        mimeType === NsContent.EMimeTypes.M3U8 ||\n        mimeType === NsContent.EMimeTypes.MP3 ||\n        mimeType === NsContent.EMimeTypes.M4A ||\n        mimeType === NsContent.EMimeTypes.SURVEY ||\n        mimeType === NsContent.EMimeTypes.PDF\n      ) {\n        // if percentage is less than 5% then make status started\n        if (Math.ceil(percentage) <= 5) {\n          return 1\n        }\n        // if percentage is greater than 95% then make status complete\n        if (Math.ceil(percentage) >= 95) {\n          return 2\n        }\n      } else {\n        if (Math.ceil(percentage) >= 100) {\n          return 2\n        }\n      }\n      return 1\n    } catch (e) {\n      // tslint:disable-next-line: no-console\n      console.log('Error in getting completion status', e)\n      return 1\n    }\n  }\n\n  realTimeProgressUpdate(contentId: string, request: any, collectionId?: string, batchId?: string) {\n    let req: any\n    if (this.configservice.userProfile) {\n      const language = this.getResourceContentLanguage(contentId)\n      req = {\n        request: {\n          userId: this.configservice.userProfile.userId || '',\n          contents: [\n            {\n              contentId,\n              batchId,\n              language,\n              status: this.getStatus(request.current, request.max_size, request.mime_type),\n              courseId: collectionId,\n              lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),\n              progressdetails: {\n                max_size: request.max_size,\n                current: request.current,\n                mimeType: request.mime_type,\n              },\n              completionPercentage: this.calculatePercent(request.current, request.max_size, request.mime_type),\n            },\n          ],\n        },\n      }\n      // if (this.configservice.cstoken !== '') {\n      //   const headers = new HttpHeaders()\n      //   .set('cstoken', this.configservice.cstoken)\n\n      //   this.http\n      //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, { headers } , req)\n      //   .subscribe(noop, noop)\n      // } else {\n      //   this.http\n      //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)\n      //   .subscribe(noop, noop)\n      // }\n      this.http\n        .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)\n        .subscribe(noop, noop)\n      if (this.tocSvc.hashmap[contentId]) {\n        const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus']\n        \n        if (!currentStatus || currentStatus < 2) {\n          this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage\n          this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0\n          this.tocSvc.hashmap = { ...this.tocSvc.hashmap }\n          \n          // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes\n          this.tocSvc.triggerMilestoneLockUpdate()\n          // Emit to trigger viewer component refresh for Learning Pathways\n          this.markAsCompleteSubject.next(true)\n        }\n      }\n    } else {\n      req = {}\n      // do nothing\n    }\n  }\n\n  getBatchIdAndCourseId(courseId: string, batchId: string, resourceId: string) {\n    const tempData = {\n      courseId,\n      batchId,\n    }\n    \n    const tempContentData = this.contentSvc.currentMetaData\n    const tempContentReadData = this.contentSvc.currentContentReadMetaData\n    const enrollmentList = this.contentSvc.currentBatchEnrollmentList\n    if (!this.forPreview) {\n      if (tempContentData.courseCategory === 'Learning Pathway') {\n        // Find the course that contains the given resource ID\n        const foundCourse = this.findCourseContainingResource(tempContentData, resourceId)\n\n        if (foundCourse) {\n          // Always update courseId if course is found\n          tempData.courseId = foundCourse.identifier\n\n          // Try to find batch ID from enrollment data for the found course\n          if (foundCourse.identifier) {\n            const enrollment = enrollmentList.find(\n              (course: any) => course.collectionId === foundCourse.identifier\n            )\n\n            if (enrollment && enrollment.batchId) {\n              tempData.batchId = enrollment.batchId\n            }\n          }\n        }\n      } else if (tempContentData && tempContentReadData.cumulativeTracking &&\n        (tempContentData.primaryCategory === NsContent.EPrimaryCategory.PROGRAM ||\n          tempContentData.primaryCategory === NsContent.EPrimaryCategory.CURATED_PROGRAM\n          || tempContentData.primaryCategory === NsContent.EPrimaryCategory.BLENDED_PROGRAM\n        )\n      ) {\n        tempContentData.children.forEach(async (childList: NsContent.IContent) => {\n          if (childList.primaryCategory === NsContent.EPrimaryCategory.COURSE) {\n            // tslint:disable-next-line: max-line-length\n            const courseEnrollmentList = enrollmentList && enrollmentList.filter((v: NsContent.ICourse) => v.contentId === childList.identifier)\n            if (childList.childNodes && childList.childNodes.indexOf(resourceId) !== -1) {\n              if (courseEnrollmentList && courseEnrollmentList.length > 0) {\n                tempData.batchId = courseEnrollmentList[courseEnrollmentList.length - 1].batch.batchId\n                tempData.courseId = childList.identifier\n              } else {\n                const data: any = await this.checkForCourseEnrollment(childList, resourceId, enrollmentList, tempData)\n                tempData.courseId = data.courseId\n                tempData.batchId = data.batchId\n              }\n            }\n          } else if (tempContentData.primaryCategory === NsContent.EPrimaryCategory.BLENDED_PROGRAM) {\n            if (tempData.courseId === courseId) {\n              const bPEnrollmentList = enrollmentList.filter((v: NsContent.ICourse) => v.contentId === tempContentData.identifier)\n              if (tempContentData.childNodes && tempContentData.childNodes.indexOf(resourceId) !== -1) {\n                if (bPEnrollmentList.length > 0) {\n                  tempData.batchId = bPEnrollmentList[bPEnrollmentList.length - 1].batch.batchId\n                  tempData.courseId = tempContentData.identifier\n                }\n              }\n            }\n          }\n        })\n      }\n    }\n    return tempData\n  }\n\n  /**\n   * Recursively searches for a resource ID in a content's children hierarchy\n   * @param content The content object to search in\n   * @param resourceId The resource ID to find\n   * @returns true if resource is found, false otherwise\n   */\n  private findResourceInContent(content: any, resourceId: string): boolean {\n    // Check if this content has the resource in its leafNodes\n    if (content.leafNodes && Array.isArray(content.leafNodes)) {\n      if (content.leafNodes.indexOf(resourceId) !== -1) {\n        return true\n      }\n    }\n\n    // Check if this content's identifier matches the resource ID\n    if (content.identifier === resourceId) {\n      return true\n    }\n\n    // Recursively search in children\n    if (content.children && Array.isArray(content.children)) {\n      for (const child of content.children) {\n        if (this.findResourceInContent(child, resourceId)) {\n          return true\n        }\n      }\n    }\n\n    return false\n  }\n\n  /**\n   * Finds the course that contains a given resource ID in a Learning Pathway\n   * @param learningPathwayContent The Learning Pathway content data\n   * @param resourceId The resource ID to find\n   * @returns The course object containing the resource, or null if not found\n   */\n  findCourseContainingResource(learningPathwayContent: any, resourceId: string): any {\n    // Check if milestones_v1 exists\n    if (!learningPathwayContent.milestones_v1 || !Array.isArray(learningPathwayContent.milestones_v1)) {\n      return null\n    }\n\n    // Loop through each milestone\n    for (const milestone of learningPathwayContent.milestones_v1) {\n      // Check if milestone has courses\n      if (milestone.courses && Array.isArray(milestone.courses)) {\n        // Loop through each course in the milestone\n        for (const course of milestone.courses) {\n          // Check if this course contains the resource\n          if (this.findResourceInContent(course, resourceId)) {\n            return course\n          }\n        }\n      }\n    }\n\n    return null\n  }\n\n  getResourceContentLanguage(resourceId: string) {\n\n    let tempLanguage: any = 'english'\n    let languageFound = false\n    const tempContentData = this.contentSvc.currentMetaData\n    if (!this.forPreview) {\n      tempContentData.children?.forEach(async (childList:any) => {\n        if (childList.primaryCategory === NsContent.EPrimaryCategory.COURSE) {\n          // tslint:disable-next-line: max-line-length\n          if (childList.leafNodes && childList.leafNodes.indexOf(resourceId) !== -1) {\n            tempLanguage = this.contentLangSvc.getContentLanguage(childList)\n            languageFound = true\n          }\n        } else if (childList?.primaryCategory === 'Milestone') {\n          childList.children?.forEach(async (child:any) => {\n            if (child.primaryCategory === NsContent.EPrimaryCategory.COURSE) {\n              // tslint:disable-next-line: max-line-length\n              if (child.leafNodes && child.leafNodes.indexOf(resourceId) !== -1) {\n                tempLanguage = this.contentLangSvc.getContentLanguage(child)\n                languageFound = true\n              }\n            } \n          })\n        }\n      }\n      )\n      if (!languageFound) {\n        if (tempContentData.leafNodes && tempContentData.leafNodes.indexOf(resourceId) !== -1) {\n          tempLanguage = this.contentLangSvc.getContentLanguage(tempContentData)\n        }\n      }\n    }\n    return tempLanguage\n  }\n\n  async checkForCourseEnrollment(childList: NsContent.IContent, _resourceId: string, _enrollmentList: any, _tempData: any) {\n    // tslint:disable-next-line: max-line-length\n    const courseData: any = await this.contentSvc.autoAssignBatchApi(childList.identifier).toPromise().then(async (data: NsContent.IBatchListResponse) => {\n      if (data) {\n        // tslint:disable-next-line: max-line-length\n        const responseData = await this.userSvc.fetchEnrollmentDataByContentId(this.configservice.userProfile?.userId, childList.identifier).toPromise().then(async (res: any) => {\n          if (res && res.courses && res.courses.length) {\n            return res.courses\n          }\n          return [{ courseId: childList.identifier, batchId: '' }]\n\n        }).catch((_err: any) => {\n          return [{ courseId: childList.identifier, batchId: '' }]\n        })\n        this.contentSvc.currentBatchEnrollmentList = [...this.contentSvc.currentBatchEnrollmentList, ...responseData]\n        return { courseId: childList.identifier, batchId: responseData[0].batchId }\n      }\n    }).catch((_err: any) => {\n      return [{ courseId: childList.identifier, batchId: '' }]\n    })\n    return courseData\n  }\n\n  realTimeProgressUpdateQuiz(contentId: string, collectionId?: string, batchId?: string, status?: number) {\n    let req: any\n    if (this.configservice.userProfile) {\n      const language = this.getResourceContentLanguage(contentId)\n      req = {\n        request: {\n          userId: this.configservice.userProfile.userId || '',\n          contents: [\n            {\n              contentId,\n              batchId,\n              language,\n              status: status || 2,\n              courseId: collectionId,\n              lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),\n              completionPercentage: status === 2 ? 100 : 0,\n            },\n          ],\n        },\n      }\n\n      this.http\n        .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)\n        .subscribe(noop, noop)\n      if (this.tocSvc.hashmap && this.tocSvc.hashmap[contentId] && req.request.contents[0]) {\n        const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus']\n        \n        if (!currentStatus || currentStatus < 2) {\n          this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage\n          this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0\n          this.tocSvc.hashmap = { ...this.tocSvc.hashmap }\n          \n          // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes\n          if (this.tocSvc.triggerMilestoneLockUpdate) {\n            this.tocSvc.triggerMilestoneLockUpdate()\n          }\n          \n          // Emit to trigger viewer component refresh for Learning Pathways\n          this.markAsCompleteSubject.next(true)\n        }\n      }\n    } else {\n      req = {}\n      // do nothing\n    }\n  }\n\n  getContent(contentId: string): Observable<NsContent.IContent> {\n    const forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true')\n    let url = `/apis/proxies/v8/action/content/v3/read/${contentId}`\n    if (!forPreview) {\n      url = `/apis/proxies/v8/action/content/v3/read/${contentId}`\n    } else {\n      if (window.location.href.includes('editMode=true') && window.location.href.includes('_rc')) {\n        url = `/apis/proxies/v8/action/content/v3/read/${contentId}`\n      } else {\n        url = `/api/content/v1/read/${contentId}`\n      }\n    }\n    return this.http.get<NsContent.IContent>(\n      // tslint:disable-next-line:max-line-length\n      // `/apis/authApi/action/content/hierarchy/${contentId}?rootOrg=${this.configservice.rootOrg || 'igot'}&org=${this.configservice.activeOrg || 'dopt'}`,\n      url\n    )\n  }\n\n  getAuthoringUrl(url: string): string {\n    return url\n      // tslint:disable-next-line:max-line-length\n      ? `/apis/authContent/${url.includes('/content-store/') ? new URL(url).pathname.slice(1) : encodeURIComponent(url)}`\n      : ''\n  }\n\n  regexDownloadReplace = (_str = '', group1: string, group2: string): string => {\n    return `${this.authoringBase}${encodeURIComponent(group1)}${group2}`\n  }\n\n  replaceToAuthUrl(data: any): any {\n    return JSON.parse(\n      JSON.stringify(data).replace(\n        this.downloadRegex,\n        this.regexDownloadReplace,\n      ),\n    )\n  }\n  readSections(assessmentId: string) {\n    return `${this.API_ENDPOINTS}/${assessmentId}`\n  }\n\n  getPublicUrl(url: string): string {\n    const mainUrl = url.split('/content').pop() || ''\n    return `${this.environment.contentHost}/${this.environment.contentBucket}/content${mainUrl}`\n  }\n\n  getCdnUrl(url: string): string {\n    const mainUrl = url.split('/content').pop() || ''\n    return `${this.domainConfSvc.getDomainCDNHost()}/${this.environment.cdnContentBucket}/content${mainUrl}`\n  }\n\n  //  fetchContent(\n  //   contentId: string,\n  //   hierarchyType: 'all' | 'minimal' | 'detail' = 'detail'\n  //   ): Observable<NsContent.IContent> {\n  //     let url = ''\n  //     const forPreview = window.location.href.includes('/public/') || window.location.href.includes('&preview=true')\n  //       if (!forPreview) {\n  //         url = `/apis/proxies/v8/action/content/v3/hierarchy/${contentId}?hierarchyType=${hierarchyType}`\n  //       } else {\n  //         url = `/api/course/v1/hierarchy/${contentId}?hierarchyType=${hierarchyType}`\n  //       }\n  //       return this.http.get<NsContent.IContent>(url)\n  //   }\n\n  fetchContent(id: string, type: string) {\n    return this.http.get<NsContent.IContent>(`/apis/proxies/v8/action/content/v3/hierarchy/${id}?mode=${type}`)\n  }\n\n  updateContentHashMapForAssesstent(contentId: string, contentProgress: any) {\n    \n    \n    if (this.tocSvc.hashmap[contentId]) {\n      const currentStatus = this.tocSvc.hashmap[contentId]['completionStatus'] || 0\n      const newStatus = Number(contentProgress.status) || 0\n      \n      // Update if not complete or if new status is higher\n      if (currentStatus < 2 || newStatus >= currentStatus) {\n        this.tocSvc.hashmap[contentId]['completionPercentage'] = contentProgress.completionPercentage\n        this.tocSvc.hashmap[contentId]['completionStatus'] = newStatus\n        this.tocSvc.hashmap[contentId]['status'] = newStatus\n        \n        \n        // Create new hashmap reference for Angular change detection\n        this.tocSvc.hashmap = { ...this.tocSvc.hashmap }\n        \n        // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes\n        if (this.tocSvc.triggerMilestoneLockUpdate) {\n          this.tocSvc.triggerMilestoneLockUpdate()\n        }\n        \n        // Emit to trigger viewer component refresh for Learning Pathways\n        this.markAsCompleteSubject.next(true)\n      }\n    }\n  }\n\n  getFormById(formId: string) {\n    return this.http.get(this.API_ENDPOINTS.GET_FORM_BYID(formId))\n  }\n\n  submitForm(formData: any) {\n    return this.http.post<any>(this.API_ENDPOINTS.SUBMIT_FORM, formData)\n  }\n\n  realTimeProgressUpdateForPreAssessment(contentId: string, request: any) {\n    let req: any\n    if (this.configservice.userProfile) {\n      req = {\n        request: {\n          userId: this.configservice.userProfile.userId || '',\n          contents: [\n            {\n              contentId,\n              // batchId,\n              status: this.getStatus(request.current, request.max_size, request.mime_type),\n              // courseId: collectionId,\n              lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),\n              progressdetails: {\n                max_size: request.max_size,\n                current: request.current,\n                mimeType: request.mime_type,\n              },\n              completionPercentage: this.calculatePercent(request.current, request.max_size, request.mime_type),\n            },\n          ],\n        },\n      }\n      // if (this.configservice.cstoken !== '') {\n      //   const headers = new HttpHeaders()\n      //   .set('cstoken', this.configservice.cstoken)\n\n      //   this.http\n      //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, { headers } , req)\n      //   .subscribe(noop, noop)\n      // } else {\n      //   this.http\n      //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)\n      //   .subscribe(noop, noop)\n      // }\n      // this.http\n      //   .patch(`${this.API_ENDPOINTS.PROGRESS_UPDATE}/${contentId}`, req)\n      //   .subscribe(noop, noop)\n      //const contentIdNew= req.request.contents[0].contentId\n      // const updatedCompletionPercentage = req.request.contents[0].completionPercentage\n      // const updatedStatus = req.request.contents[0].status\n\n      // // Clone the inner object and update\n      // const existingContent = this.tocSvc.hashmap[contentIdNew] || {}\n\n      // this.tocSvc.hashmap = {\n      //   ...this.tocSvc.hashmap,\n      //   [contentIdNew]: {\n      //     ...existingContent,\n      //     completionPercentage: updatedCompletionPercentage,\n      //     completionStatus: updatedStatus\n      //   }\n      // }\n      // console.log('req', JSON.stringify(req))\n      // console.log('req', req)\n\n      const resourceStatus = this.getPreAssessmentResourceStatus(contentId)\n      if (resourceStatus < 2) {\n        this.http\n          .patch(`${this.API_ENDPOINTS.PRE_ASSESSMENT_STATE_UPDATE}`, req)\n          .subscribe(noop, noop)\n      }\n      \n      if (this.tocSvc.hashmap[contentId] &&\n        (!this.tocSvc.hashmap[contentId]['completionStatus'] || this.tocSvc.hashmap[contentId]['completionStatus'] < 2)) {\n        this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage\n        this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0\n        this.tocSvc.hashmap[contentId]['parent'] = req.request.contents[0].courseId\n        this.tocSvc.hashmap[contentId]['progress'] = req.request.contents[0].progressdetails\n        this.tocSvc.hashmap = { ...this.tocSvc.hashmap }\n        \n        // Trigger milestone lock recomputation - it will emit hashmapUpdated with both progress and lock changes\n        if (this.tocSvc.triggerMilestoneLockUpdate) {\n          this.tocSvc.triggerMilestoneLockUpdate()\n        }\n          // Emit to trigger viewer component refresh for Learning Pathways\n          this.markAsCompleteSubject.next(true)\n      }\n    } else {\n      req = {}\n      // do nothing\n    }\n  }\n\n  realTimeProgressUpdateForPreAssessmentQuiz(contentId: string, status?: number, mimeType?: string) {\n    let req: any\n    if (this.configservice.userProfile) {\n      req = {\n        request: {\n          //userId: this.configservice.userProfile.userId || '',\n          contents: [\n            {\n              contentId,\n              // batchId,\n              status: status || 2,\n              // courseId: collectionId,\n              lastAccessTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss:SSSZZ'),\n              completionPercentage: status === 2 ? 100.0 : 0,\n              progressdetails: {\n                \"mimeType\": mimeType || \"application/vnd.sunbird.questionset\"\n              },\n            },\n          ],\n        },\n      }\n      const resourceStatus = this.getPreAssessmentResourceStatus(contentId)\n      if (resourceStatus < 2) {\n        this.http\n          .patch(`${this.API_ENDPOINTS.PRE_ASSESSMENT_STATE_UPDATE}`, req)\n          .subscribe(noop, noop)\n      }\n      \n      // Update hashmap - create entry if it doesn't exist\n      if (this.tocSvc.hashmap) {\n        if (!this.tocSvc.hashmap[contentId]) {\n          // Create new entry for pre-assessment if it doesn't exist\n          this.tocSvc.hashmap[contentId] = {\n            identifier: contentId,\n            completionPercentage: req.request.contents[0].completionPercentage,\n            completionStatus: Number(req.request.contents[0].status) || 0,\n            status: Number(req.request.contents[0].status) || 0,\n            isPreAssessment: true\n          }\n        } else {\n          // Update existing entry\n          this.tocSvc.hashmap[contentId]['completionPercentage'] = req.request.contents[0].completionPercentage\n          this.tocSvc.hashmap[contentId]['completionStatus'] = Number(req.request.contents[0].status) || 0\n          this.tocSvc.hashmap[contentId]['status'] = Number(req.request.contents[0].status) || 0\n        }\n        \n        this.tocSvc.hashmap = { ...this.tocSvc.hashmap }\n        \n        // ALWAYS trigger milestone lock recomputation when pre-assessment completes\n        // This ensures milestone 1 unlocks immediately after pre-assessment completion\n        if (this.tocSvc.triggerMilestoneLockUpdate) {\n          this.tocSvc.triggerMilestoneLockUpdate()\n        }\n        \n        // Emit markAsCompleteSubject to trigger viewer component to refresh enrollment and progress\n        // This is critical for Learning Pathways to unlock milestones immediately\n        this.markAsCompleteSubject.next(true)\n      }\n    } else {\n      req = {}\n      // do nothing\n    }\n  }\n\n  getPreAssessmentResourceStatus(resourceId: string) {\n    if (this.tocSvc && this.tocSvc.hashmap && this.tocSvc.hashmap[resourceId]) {\n      return this.tocSvc.hashmap[resourceId]['completionStatus'] || 1\n    }\n    return 1\n  }\n\n\n}\n"]}