@piserve-tech/form-submission 1.3.317 → 1.3.319

package/esm2022/services/recaptcha.service.mjs

@@ -0,0 +1,136 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-toastr";
+import * as i2 from "@angular/common/http";
+import * as i3 from "./data.service";
+export class RecaptchaService {
+    constructor(toastr, http, dataService) {
+        this.toastr = toastr;
+        this.http = http;
+        this.dataService = dataService;
+        this.siteKey = '';
+        this.apiUrl = '';
+        this.widgetId = null;
+        this.initialized = false;
+        this.resolved = false;
+        this.dataService.apiUrl$.subscribe((data) => {
+            this.apiUrl = data;
+        });
+    }
+    ngOnInit() {
+        this.fetchSiteKeyFromApi().subscribe({
+            next: (key) => (this.siteKey = key),
+            error: () => this.toastr.error('Failed to load CAPTCHA config')
+        });
+    }
+    fetchSiteKeyFromApi() {
+        return this.http.get(`${this.apiUrl}/api/application-settings/recaptcha/siteKey`).pipe(map((response) => {
+            const siteKey = response.message;
+            return siteKey;
+        }));
+    }
+    initialize() {
+        if (!this.siteKey || this.siteKey === '') {
+            this.fetchSiteKeyFromApi().subscribe({
+                next: (key) => (this.siteKey = key),
+                error: () => this.toastr.error('Failed to load CAPTCHA config')
+            });
+        }
+        return new Promise((resolve, reject) => {
+            if (this.widgetId !== null) {
+                resolve();
+                return;
+            }
+            if (this.initialized && typeof grecaptcha !== 'undefined' && typeof grecaptcha.render === 'function') {
+                resolve();
+                return;
+            }
+            const existingScript = document.querySelector('script[src*="recaptcha/api.js"]');
+            if (existingScript) {
+                existingScript.addEventListener('load', () => resolve());
+                resolve();
+                return;
+            }
+            const script = document.createElement('script');
+            script.src = 'https://www.google.com/recaptcha/api.js?onload=onRecaptchaLoadCallback&render=explicit';
+            script.async = true;
+            script.defer = true;
+            window.onRecaptchaLoadCallback = () => {
+                this.initialized = true;
+                resolve();
+            };
+            script.onerror = () => {
+                reject('Failed to load reCAPTCHA script');
+            };
+            document.head.appendChild(script);
+        });
+    }
+    render(containerId, callback) {
+        if (typeof grecaptcha === 'undefined') {
+            throw new Error('reCAPTCHA is not loaded');
+        }
+        // ✅ Prevent rendering more than once
+        if (this.widgetId !== null) {
+            console.warn('reCAPTCHA already rendered, skipping render.');
+            return;
+        }
+        this.widgetId = grecaptcha.render(containerId, {
+            sitekey: this.siteKey,
+            callback: (token) => {
+                this.resolved = true;
+                callback(token);
+            },
+            'expired-callback': () => {
+                this.resolved = false;
+                this.toastr.warning('reCAPTCHA expired, please verify again');
+            },
+            'error-callback': () => {
+                this.resolved = false;
+                this.toastr.error('reCAPTCHA error occurred');
+            },
+            size: 'normal',
+            theme: 'light',
+        });
+    }
+    reset() {
+        if (typeof grecaptcha !== 'undefined' && this.widgetId !== null) {
+            grecaptcha.reset(this.widgetId);
+            this.resolved = false;
+        }
+    }
+    getResponse() {
+        if (typeof grecaptcha === 'undefined' || this.widgetId === null) {
+            return '';
+        }
+        return grecaptcha.getResponse(this.widgetId);
+    }
+    isRendered() {
+        return this.widgetId !== null;
+    }
+    isResolved() {
+        return this.resolved && !!this.getResponse();
+    }
+    removeRecaptchaScript() {
+        const script = document.querySelector('script[src*="recaptcha/api.js"]');
+        if (script) {
+            script.remove();
+        }
+        const badge = document.querySelector('.grecaptcha-badge');
+        if (badge) {
+            badge.remove();
+        }
+        this.widgetId = null;
+        this.initialized = false;
+        this.resolved = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RecaptchaService, deps: [{ token: i1.ToastrService }, { token: i2.HttpClient }, { token: i3.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RecaptchaService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RecaptchaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ToastrService }, { type: i2.HttpClient }, { type: i3.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recaptcha.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/recaptcha.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { ToastrService } from 'ngx-toastr';\r\nimport { map, Observable } from 'rxjs';\r\nimport { DataService } from './data.service';\r\n\r\ndeclare global {\r\n  interface Window {\r\n    onRecaptchaLoadCallback: () => void;\r\n  }\r\n\r\n  var grecaptcha: {\r\n    ready: (callback: () => void) => void;\r\n    render: (\r\n      container: string | HTMLElement,\r\n      parameters: {\r\n        sitekey: string;\r\n        callback?: (token: string) => void;\r\n        'expired-callback'?: () => void;\r\n        'error-callback'?: () => void;\r\n        size?: 'normal' | 'compact' | 'invisible';\r\n        theme?: 'light' | 'dark';\r\n      }\r\n    ) => number;\r\n    execute: (widgetId?: number) => void;\r\n    getResponse: (widgetId?: number) => string;\r\n    reset: (widgetId?: number) => void;\r\n  };\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RecaptchaService {\r\n  private siteKey = '';\r\n   private apiUrl: string = '';\r\n  private widgetId: number | null = null;\r\n  private initialized = false;\r\n  private resolved = false;\r\n\r\n  constructor(private toastr: ToastrService,private http: HttpClient, private dataService: DataService) {\r\n     this.dataService.apiUrl$.subscribe((data) => {\r\n       this.apiUrl = data;\r\n     });\r\n\r\n  }\r\n\r\n  ngOnInit() {\r\nthis.fetchSiteKeyFromApi().subscribe({\r\n    next: (key) => (this.siteKey = key),\r\n    error: () => this.toastr.error('Failed to load CAPTCHA config')\r\n  });\r\n  }\r\n\r\n\r\n\r\n  fetchSiteKeyFromApi(): Observable<string> {\r\n\r\n    return this.http.get<{ message: string }>(`${this.apiUrl}/api/application-settings/recaptcha/siteKey`).pipe(\r\n      map((response: { message: string }) => {\r\n        const siteKey = response.message;\r\n        return siteKey;\r\n      })\r\n    );\r\n  }\r\n\r\n  initialize(): Promise<void> {\r\n    if(!this.siteKey || this.siteKey === '') {\r\n       this.fetchSiteKeyFromApi().subscribe({\r\n    next: (key) => (this.siteKey = key),\r\n    error: () => this.toastr.error('Failed to load CAPTCHA config')\r\n  });\r\n    }\r\n\r\n\r\n    return new Promise((resolve, reject) => {\r\n         if (this.widgetId !== null) {\r\n          resolve();\r\n          return;\r\n    }\r\n      if (this.initialized && typeof grecaptcha !== 'undefined' && typeof grecaptcha.render === 'function') {\r\n        resolve();\r\n        return;\r\n      }\r\n\r\n      const existingScript = document.querySelector('script[src*=\"recaptcha/api.js\"]');\r\n      if (existingScript) {\r\n        existingScript.addEventListener('load', () => resolve());\r\n        resolve();\r\n        return;\r\n      }\r\n\r\n      const script = document.createElement('script');\r\n      script.src = 'https://www.google.com/recaptcha/api.js?onload=onRecaptchaLoadCallback&render=explicit';\r\n      script.async = true;\r\n      script.defer = true;\r\n\r\n      window.onRecaptchaLoadCallback = () => {\r\n        this.initialized = true;\r\n        resolve();\r\n      };\r\n\r\n      script.onerror = () => {\r\n        reject('Failed to load reCAPTCHA script');\r\n      };\r\n\r\n      document.head.appendChild(script);\r\n    });\r\n  }\r\n\r\nrender(containerId: string, callback: (token: string) => void): void {\r\n  if (typeof grecaptcha === 'undefined') {\r\n    throw new Error('reCAPTCHA is not loaded');\r\n  }\r\n\r\n  // ✅ Prevent rendering more than once\r\n  if (this.widgetId !== null) {\r\n    console.warn('reCAPTCHA already rendered, skipping render.');\r\n    return;\r\n  }\r\n\r\n  this.widgetId = grecaptcha.render(containerId, {\r\n    sitekey: this.siteKey,\r\n    callback: (token: string) => {\r\n      this.resolved = true;\r\n      callback(token);\r\n    },\r\n    'expired-callback': () => {\r\n      this.resolved = false;\r\n      this.toastr.warning('reCAPTCHA expired, please verify again');\r\n    },\r\n    'error-callback': () => {\r\n      this.resolved = false;\r\n      this.toastr.error('reCAPTCHA error occurred');\r\n    },\r\n    size: 'normal',\r\n    theme: 'light',\r\n  });\r\n}\r\n\r\n\r\n  reset(): void {\r\n    if (typeof grecaptcha !== 'undefined' && this.widgetId !== null) {\r\n      grecaptcha.reset(this.widgetId);\r\n      this.resolved = false;\r\n    }\r\n  }\r\n\r\n  getResponse(): string {\r\n    if (typeof grecaptcha === 'undefined' || this.widgetId === null) {\r\n      return '';\r\n    }\r\n    return grecaptcha.getResponse(this.widgetId);\r\n  }\r\n\r\n  isRendered(): boolean {\r\n    return this.widgetId !== null;\r\n  }\r\n\r\n  isResolved(): boolean {\r\n    return this.resolved && !!this.getResponse();\r\n  }\r\n\r\n  removeRecaptchaScript(): void {\r\n    const script = document.querySelector('script[src*=\"recaptcha/api.js\"]');\r\n    if (script) {\r\n      script.remove();\r\n    }\r\n\r\n    const badge = document.querySelector('.grecaptcha-badge');\r\n    if (badge) {\r\n      badge.remove();\r\n    }\r\n\r\n    this.widgetId = null;\r\n    this.initialized = false;\r\n    this.resolved = false;\r\n  }\r\n}\r\n"]}

package/esm2022/services/score.service.mjs

@@ -0,0 +1,268 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ScoreCalculationService {
+    constructor() {
+        this.calculateSubmissionScore = (answers, enableScoringType = true) => {
+            let submissionScoreType = null;
+            let totalScore = 1;
+            for (const ans of answers) {
+                if (!ans.scores)
+                    continue;
+                for (const s of ans.scores) {
+                    // ✅ Always add scores (ignore type during summation)
+                    totalScore *= s.score ?? 1;
+                    // ✅ Decide submission-level scoreType
+                    if (enableScoringType) {
+                        if (s.scoreType === "GOOD_SCORE") {
+                            submissionScoreType = "GOOD_SCORE";
+                        }
+                        else if (s.scoreType === "BAD_SCORE") {
+                            submissionScoreType = "BAD_SCORE";
+                        }
+                    }
+                    else if (s.scoreType === "NOT_APPLICABLE") {
+                        submissionScoreType = "NOT_APPLICABLE";
+                    }
+                }
+            }
+            // ✅ Default type if none found
+            if (!submissionScoreType) {
+                submissionScoreType = enableScoringType ? "GOOD_SCORE" : "NOT_APPLICABLE";
+            }
+            return [
+                {
+                    scoreType: submissionScoreType,
+                    score: totalScore,
+                },
+            ];
+        };
+    }
+    calculateScoreFromAnswer(newAnswer, question) {
+        const scoring = question?.formElement?.scoring;
+        if (!scoring || !scoring.enableScoring || !newAnswer || (Array.isArray(newAnswer) && newAnswer.length === 0)) {
+            return null;
+        }
+        const defaultScore = scoring.defaultScore ?? 0;
+        const scoreRules = scoring.score || [];
+        const answers = Array.isArray(newAnswer) ? newAnswer : [newAnswer];
+        // If scoringType is NOT enabled, behave like the old logic
+        if (!scoring.enableScoringType) {
+            let totalScore = 0;
+            const scoreByOption = {};
+            for (const answer of answers) {
+                const value = answer.split('|')[1]; // Extract actual value
+                const matchingScore = scoreRules.find((rule) => rule.label.includes(value));
+                if (matchingScore && typeof matchingScore.score === 'number') {
+                    scoreByOption[answer] = matchingScore.score;
+                    totalScore += matchingScore.score;
+                }
+                else {
+                    scoreByOption[answer] = defaultScore;
+                    totalScore += defaultScore;
+                }
+            }
+            return { scores: [{ scoreType: 'NOT_APPLICABLE', score: totalScore }] };
+        }
+        // ✅ Scoring Type ENABLED → separate Good/Bad scoring
+        const groupedScores = {};
+        for (const answer of answers) {
+            const value = answer.split('|')[1];
+            const matchingScore = scoreRules.find((rule) => rule.label.includes(value));
+            if (matchingScore && typeof matchingScore.score === 'number') {
+                const type = matchingScore.scoreType || 'NOT_APPLICABLE';
+                groupedScores[type] = (groupedScores[type] || 0) + matchingScore.score;
+            }
+            else {
+                // if no matching score, add default under NOT_APPLICABLE
+                groupedScores['NOT_APPLICABLE'] = (groupedScores['NOT_APPLICABLE'] || 0) + defaultScore;
+            }
+        }
+        // Convert grouped results into required array format
+        const resultScores = Object.keys(groupedScores).map((type) => ({
+            scoreType: type,
+            score: groupedScores[type],
+        }));
+        return { scores: resultScores };
+    }
+    getMaxPossibleScore(subform) {
+        let goodMaxProduct = 1;
+        let badMaxProduct = 1;
+        subform.rows.forEach((row) => {
+            row.grid.forEach((gridItem) => {
+                if (gridItem.entityType === "QUESTION") {
+                    const element = gridItem.element;
+                    const formElement = element?.formElement;
+                    if (formElement?.elementType === "DROP_DOWN" &&
+                        formElement?.scoring?.enableScoring &&
+                        Array.isArray(formElement.scoring.score)) {
+                        // ---- GOOD SCORE CALC ----
+                        let maxGoodForQuestion = 0;
+                        const goodScores = formElement.scoring.score.filter((s) => s.scoreType === "GOOD_SCORE");
+                        if (formElement.appearance?.selectionType === "SINGLE") {
+                            if (goodScores.length > 0) {
+                                // Pick max abs, but return real value
+                                const maxAbs = goodScores.reduce((max, s) => Math.abs(s.score ?? 0) > Math.abs(max.score ?? 0) ? s : max, { score: 0 });
+                                maxGoodForQuestion = maxAbs.score ?? 0;
+                            }
+                            else {
+                                maxGoodForQuestion = Math.max(...formElement.scoring.score.map((s) => s.score ?? 0));
+                            }
+                        }
+                        else if (formElement.appearance?.selectionType === "MULTIPLE") {
+                            const maxSelection = formElement.validation?.maximumSelection;
+                            if (maxSelection && maxSelection > 0) {
+                                const labelScores = [];
+                                const src = goodScores.length > 0 ? goodScores : formElement.scoring.score;
+                                src.forEach((s) => {
+                                    const scoreValue = s.score ?? 0;
+                                    const count = s.label?.length ?? 0;
+                                    for (let i = 0; i < count; i++) {
+                                        labelScores.push(scoreValue);
+                                    }
+                                });
+                                labelScores.sort((a, b) => Math.abs(b) - Math.abs(a));
+                                maxGoodForQuestion = labelScores
+                                    .slice(0, maxSelection)
+                                    .reduce((sum, score) => sum + score, 0);
+                            }
+                            else {
+                                maxGoodForQuestion = formElement.scoring.score.reduce((sum, s) => sum + (s.score ?? 0) * (s.label?.length ?? 0), 0);
+                            }
+                        }
+                        // ---- BAD SCORE CALC ----
+                        let maxBadForQuestion = 0;
+                        const badScores = formElement.scoring.score.filter((s) => s.scoreType === "BAD_SCORE");
+                        if (formElement.appearance?.selectionType === "SINGLE") {
+                            if (badScores.length > 0) {
+                                maxBadForQuestion = Math.max(...badScores.map((s) => s.score ?? 0));
+                            }
+                            else {
+                                maxBadForQuestion = Math.max(...formElement.scoring.score.map((s) => s.score ?? 0));
+                            }
+                        }
+                        else if (formElement.appearance?.selectionType === "MULTIPLE") {
+                            const maxSelection = formElement.validation?.maximumSelection;
+                            if (maxSelection && maxSelection > 0) {
+                                const labelScores = [];
+                                const src = badScores.length > 0 ? badScores : formElement.scoring.score;
+                                src.forEach((s) => {
+                                    const scoreValue = s.score ?? 0;
+                                    const count = s.label?.length ?? 0;
+                                    for (let i = 0; i < count; i++) {
+                                        labelScores.push(scoreValue);
+                                    }
+                                });
+                                labelScores.sort((a, b) => b - a);
+                                maxBadForQuestion = labelScores
+                                    .slice(0, maxSelection)
+                                    .reduce((sum, score) => sum + score, 0);
+                            }
+                            else {
+                                maxBadForQuestion = formElement.scoring.score.reduce((sum, s) => sum + (s.score ?? 0) * (s.label?.length ?? 0), 0);
+                            }
+                        }
+                        goodMaxProduct *= maxGoodForQuestion;
+                        badMaxProduct *= maxBadForQuestion;
+                    }
+                }
+            });
+        });
+        return { goodMax: goodMaxProduct, badMax: badMaxProduct };
+    }
+    calculateFinalScore(submissions, maxPossibleGoodScore, maxPossibleBadScore) {
+        let totalGood = 0;
+        let totalBad = 0;
+        const hasGood = (s) => s.scores?.some(x => x.scoreType === 'GOOD_SCORE');
+        const hasBad = (s) => s.scores?.some(x => x.scoreType === 'BAD_SCORE');
+        const goodCount = submissions.filter(hasGood).length;
+        const badCount = submissions.filter(hasBad).length;
+        for (const sub of submissions) {
+            if (!sub.scores)
+                continue;
+            for (const s of sub.scores) {
+                if (s.scoreType === 'GOOD_SCORE')
+                    totalGood += s.score ?? 0;
+                if (s.scoreType === 'BAD_SCORE')
+                    totalBad += s.score ?? 0;
+            }
+        }
+        const totalSubmissions = submissions.length;
+        const maxGood = totalSubmissions * maxPossibleGoodScore;
+        const maxBad = totalSubmissions * maxPossibleBadScore;
+        const result = [];
+        // use !== 0 (not > 0) because maxGood may be negative by design
+        if (goodCount > 0 && maxGood !== 0) {
+            result.push({
+                scoreType: 'GOOD_SCORE',
+                score: Math.round(100 - (totalGood / maxGood) * 100)
+            });
+        }
+        if (badCount > 0 && maxBad !== 0) {
+            result.push({
+                scoreType: 'BAD_SCORE',
+                score: Math.round(100 - (totalBad / maxBad) * 100)
+            });
+        }
+        return result;
+    }
+    getMaxPossibleScoreForQuestion(question) {
+        const formElement = question?.formElement;
+        if (!formElement?.scoring?.enableScoring ||
+            !Array.isArray(formElement.scoring.score)) {
+            return 0; // No scoring or invalid config      
+        }
+        let maxScoreForQuestion = 0;
+        if (formElement.appearance?.selectionType === "SINGLE") {
+            // For single selection: take the highest score
+            maxScoreForQuestion = Math.max(...formElement.scoring.score.map((s) => s.score ?? 0));
+        }
+        else if (formElement.appearance?.selectionType === "MULTIPLE") {
+            const maxSelection = formElement.validation?.maximumSelection;
+            if (maxSelection && maxSelection > 0) {
+                // Flatten scores per label
+                const labelScores = [];
+                formElement.scoring.score.forEach((s) => {
+                    const scoreValue = s.score ?? 0;
+                    const count = s.label?.length ?? 0;
+                    for (let i = 0; i < count; i++) {
+                        labelScores.push(scoreValue);
+                    }
+                });
+                // Sort descending & take top N
+                labelScores.sort((a, b) => b - a);
+                maxScoreForQuestion = labelScores
+                    .slice(0, maxSelection)
+                    .reduce((sum, score) => sum + score, 0);
+            }
+            else {
+                // Sum all scores × label count
+                maxScoreForQuestion = formElement.scoring.score.reduce((sum, s) => sum + (s.score ?? 0) * (s.label?.length ?? 0), 0);
+            }
+        }
+        return maxScoreForQuestion;
+    }
+    shouldCalculateScore(subForm, submission) {
+        // Get all dropdown-like questions in subform that have scoring enabled
+        const scoringQuestions = subForm.rows
+            .flatMap((row) => row.grid)
+            .filter((g) => g.entityType === 'QUESTION')
+            .map((g) => g.element)
+            .filter((q) => q.formElement &&
+            ['DROP_DOWN', 'RADIO_BUTTON', 'CHECK_BOX'].includes(q.formElement.elementType) &&
+            q.formElement.scoring?.enableScoring);
+        // Check if all scoring-enabled dropdown questions are answered in submission
+        return scoringQuestions.every((q) => {
+            const ans = submission.answers.find((a) => a.questionId === q.id);
+            return ans && ans.answer !== '' && !(Array.isArray(ans.answer) && ans.answer.length === 0);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ScoreCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ScoreCalculationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ScoreCalculationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"score.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/score.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Answer } from '../models/answer.model';\r\nimport { Submission } from '../models/submission.model';\r\n\r\ninterface SubmissionScore {\r\n  scoreType: string;\r\n  score: number;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ScoreCalculationService {\r\n  constructor() {}\r\n\r\n  calculateScoreFromAnswer(\r\n    newAnswer: string[] | string,\r\n    question: any\r\n  ): { scores: { scoreType: string; score: number }[] } | null {\r\n  \r\n    const scoring = question?.formElement?.scoring;\r\n    if (!scoring || !scoring.enableScoring || !newAnswer || (Array.isArray(newAnswer) && newAnswer.length === 0)) {\r\n      return null;\r\n    }\r\n  \r\n    const defaultScore = scoring.defaultScore ?? 0;\r\n    const scoreRules = scoring.score || [];\r\n  \r\n    const answers = Array.isArray(newAnswer) ? newAnswer : [newAnswer];\r\n  \r\n    // If scoringType is NOT enabled, behave like the old logic\r\n    if (!scoring.enableScoringType) {\r\n      let totalScore = 0;\r\n      const scoreByOption: Record<string, number> = {};\r\n  \r\n      for (const answer of answers) {\r\n        const value = answer.split('|')[1]; // Extract actual value\r\n        const matchingScore = scoreRules.find((rule: any) => rule.label.includes(value));\r\n  \r\n        if (matchingScore && typeof matchingScore.score === 'number') {\r\n          scoreByOption[answer] = matchingScore.score;\r\n          totalScore += matchingScore.score;\r\n        } else {\r\n          scoreByOption[answer] = defaultScore;\r\n          totalScore += defaultScore;\r\n        }\r\n      }\r\n  \r\n      return { scores: [{ scoreType: 'NOT_APPLICABLE', score:totalScore }] };\r\n    }\r\n  \r\n    // ✅ Scoring Type ENABLED → separate Good/Bad scoring\r\n    const groupedScores: Record<string, number> = {};\r\n  \r\n    for (const answer of answers) {\r\n      const value = answer.split('|')[1];\r\n      const matchingScore = scoreRules.find((rule: any) => rule.label.includes(value));\r\n  \r\n      if (matchingScore && typeof matchingScore.score === 'number') {\r\n        const type = matchingScore.scoreType || 'NOT_APPLICABLE';\r\n        groupedScores[type] = (groupedScores[type] || 0) + matchingScore.score;\r\n      } else {\r\n        // if no matching score, add default under NOT_APPLICABLE\r\n        groupedScores['NOT_APPLICABLE'] = (groupedScores['NOT_APPLICABLE'] || 0) + defaultScore;\r\n      }\r\n    }\r\n  \r\n    // Convert grouped results into required array format\r\n    const resultScores = Object.keys(groupedScores).map((type) => ({\r\n      scoreType:type,\r\n      score: groupedScores[type],\r\n    }));\r\n  \r\n    return { scores: resultScores };\r\n  }\r\n\r\n\r\n  getMaxPossibleScore(subform: any): { goodMax: number; badMax: number } {\r\n    let goodMaxProduct = 1;\r\n    let badMaxProduct = 1;\r\n  \r\n    subform.rows.forEach((row: any) => {\r\n      row.grid.forEach((gridItem: any) => {\r\n        if (gridItem.entityType === \"QUESTION\") {\r\n          const element = gridItem.element;\r\n          const formElement = element?.formElement;\r\n  \r\n          if (\r\n            formElement?.elementType === \"DROP_DOWN\" &&\r\n            formElement?.scoring?.enableScoring &&\r\n            Array.isArray(formElement.scoring.score)\r\n          ) {\r\n            // ---- GOOD SCORE CALC ----\r\n            let maxGoodForQuestion = 0;\r\n            const goodScores = formElement.scoring.score.filter(\r\n              (s: any) => s.scoreType === \"GOOD_SCORE\"\r\n            );\r\n  \r\n            if (formElement.appearance?.selectionType === \"SINGLE\") {\r\n              if (goodScores.length > 0) {\r\n                // Pick max abs, but return real value\r\n                const maxAbs = goodScores.reduce(\r\n                  (max: any, s: any) =>\r\n                    Math.abs(s.score ?? 0) > Math.abs(max.score ?? 0) ? s : max,\r\n                  { score: 0 }\r\n                );\r\n                maxGoodForQuestion = maxAbs.score ?? 0;\r\n              } else {\r\n                maxGoodForQuestion = Math.max(\r\n                  ...formElement.scoring.score.map((s: any) => s.score ?? 0)\r\n                );\r\n              }\r\n            } else if (formElement.appearance?.selectionType === \"MULTIPLE\") {\r\n              const maxSelection = formElement.validation?.maximumSelection;\r\n  \r\n              if (maxSelection && maxSelection > 0) {\r\n                const labelScores: number[] = [];\r\n                const src = goodScores.length > 0 ? goodScores : formElement.scoring.score;\r\n  \r\n                src.forEach((s: any) => {\r\n                  const scoreValue = s.score ?? 0;\r\n                  const count = s.label?.length ?? 0;\r\n                  for (let i = 0; i < count; i++) {\r\n                    labelScores.push(scoreValue);\r\n                  }\r\n                });\r\n  \r\n                labelScores.sort((a, b) => Math.abs(b) - Math.abs(a));\r\n                maxGoodForQuestion = labelScores\r\n                  .slice(0, maxSelection)\r\n                  .reduce((sum, score) => sum + score, 0);\r\n              } else {\r\n                maxGoodForQuestion = formElement.scoring.score.reduce(\r\n                  (sum: number, s: any) =>\r\n                    sum + (s.score ?? 0) * (s.label?.length ?? 0),\r\n                  0\r\n                );\r\n              }\r\n            }\r\n  \r\n            // ---- BAD SCORE CALC ----\r\n            let maxBadForQuestion = 0;\r\n            const badScores = formElement.scoring.score.filter(\r\n              (s: any) => s.scoreType === \"BAD_SCORE\"\r\n            );\r\n  \r\n            if (formElement.appearance?.selectionType === \"SINGLE\") {\r\n              if (badScores.length > 0) {\r\n                maxBadForQuestion = Math.max(\r\n                  ...badScores.map((s: any) => s.score ?? 0)\r\n                );\r\n              } else {\r\n                maxBadForQuestion = Math.max(\r\n                  ...formElement.scoring.score.map((s: any) => s.score ?? 0)\r\n                );\r\n              }\r\n            } else if (formElement.appearance?.selectionType === \"MULTIPLE\") {\r\n              const maxSelection = formElement.validation?.maximumSelection;\r\n  \r\n              if (maxSelection && maxSelection > 0) {\r\n                const labelScores: number[] = [];\r\n                const src = badScores.length > 0 ? badScores : formElement.scoring.score;\r\n  \r\n                src.forEach((s: any) => {\r\n                  const scoreValue = s.score ?? 0;\r\n                  const count = s.label?.length ?? 0;\r\n                  for (let i = 0; i < count; i++) {\r\n                    labelScores.push(scoreValue);\r\n                  }\r\n                });\r\n  \r\n                labelScores.sort((a, b) => b - a);\r\n                maxBadForQuestion = labelScores\r\n                  .slice(0, maxSelection)\r\n                  .reduce((sum, score) => sum + score, 0);\r\n              } else {\r\n                maxBadForQuestion = formElement.scoring.score.reduce(\r\n                  (sum: number, s: any) =>\r\n                    sum + (s.score ?? 0) * (s.label?.length ?? 0),\r\n                  0\r\n                );\r\n              }\r\n            }\r\n  \r\n            goodMaxProduct *= maxGoodForQuestion;\r\n            badMaxProduct *= maxBadForQuestion;\r\n          }\r\n        }\r\n      });\r\n    });\r\n  \r\n    return { goodMax: goodMaxProduct, badMax: badMaxProduct };\r\n  }\r\n  \r\n  \r\n  \r\n\r\n  calculateSubmissionScore = (answers: Answer[], enableScoringType = true): SubmissionScore[] => {\r\n    let submissionScoreType: string | null = null;\r\n    let totalScore = 1;\r\n    for (const ans of answers) {\r\n      if (!ans.scores) continue;\r\n  \r\n      for (const s of ans.scores) {\r\n        // ✅ Always add scores (ignore type during summation)\r\n        totalScore *= s.score ?? 1;\r\n  \r\n        // ✅ Decide submission-level scoreType\r\n        if (enableScoringType) {\r\n          if (s.scoreType === \"GOOD_SCORE\") {\r\n            submissionScoreType = \"GOOD_SCORE\";\r\n          } else if (s.scoreType === \"BAD_SCORE\") {\r\n            submissionScoreType = \"BAD_SCORE\";\r\n          }\r\n        } else if (s.scoreType === \"NOT_APPLICABLE\") {\r\n          submissionScoreType = \"NOT_APPLICABLE\";\r\n        }\r\n      }\r\n    }\r\n  \r\n    // ✅ Default type if none found\r\n    if (!submissionScoreType) {\r\n      submissionScoreType = enableScoringType ? \"GOOD_SCORE\" : \"NOT_APPLICABLE\";\r\n    }\r\n  \r\n    return [\r\n      {\r\n        scoreType: submissionScoreType,\r\n        score: totalScore,\r\n      },\r\n    ];\r\n  };\r\n\r\n  calculateFinalScore(\r\n    submissions: Submission[],\r\n    maxPossibleGoodScore: number,\r\n    maxPossibleBadScore: number\r\n  ): SubmissionScore[] {\r\n    let totalGood = 0;\r\n    let totalBad = 0;\r\n  \r\n    const hasGood = (s: Submission) => s.scores?.some(x => x.scoreType === 'GOOD_SCORE');\r\n    const hasBad  = (s: Submission) => s.scores?.some(x => x.scoreType === 'BAD_SCORE');\r\n  \r\n    const goodCount = submissions.filter(hasGood).length;\r\n    const badCount  = submissions.filter(hasBad).length;\r\n  \r\n    for (const sub of submissions) {\r\n      if (!sub.scores) continue;\r\n      for (const s of sub.scores) {\r\n        if (s.scoreType === 'GOOD_SCORE') totalGood += s.score ?? 0;\r\n        if (s.scoreType === 'BAD_SCORE')  totalBad  += s.score ?? 0;\r\n      }\r\n    }\r\n  \r\n    const totalSubmissions = submissions.length;\r\n  \r\n    const maxGood = totalSubmissions * maxPossibleGoodScore;\r\n    const maxBad = totalSubmissions * maxPossibleBadScore;\r\n  \r\n    const result: SubmissionScore[] = [];\r\n  \r\n    // use !== 0 (not > 0) because maxGood may be negative by design\r\n    if (goodCount > 0 && maxGood !== 0) {\r\n      result.push({\r\n        scoreType: 'GOOD_SCORE',\r\n        score: Math.round(100 - (totalGood / maxGood) * 100)\r\n      });\r\n    }\r\n  \r\n    if (badCount > 0 && maxBad !== 0) {\r\n      result.push({\r\n        scoreType: 'BAD_SCORE',\r\n        score: Math.round(100 - (totalBad / maxBad) * 100)\r\n      });\r\n    }\r\n  \r\n    return result;\r\n  }\r\n  \r\n  \r\n\r\n  getMaxPossibleScoreForQuestion(question: any): number {\r\n    const formElement = question?.formElement;\r\n  \r\n    if (\r\n      !formElement?.scoring?.enableScoring ||\r\n      !Array.isArray(formElement.scoring.score)\r\n    ) {\r\n      return 0; // No scoring or invalid config      \r\n    }\r\n  \r\n    let maxScoreForQuestion = 0;\r\n  \r\n    if (formElement.appearance?.selectionType === \"SINGLE\") {\r\n      // For single selection: take the highest score\r\n      maxScoreForQuestion = Math.max(\r\n        ...formElement.scoring.score.map((s: any) => s.score ?? 0)\r\n      );\r\n    } \r\n    else if (formElement.appearance?.selectionType === \"MULTIPLE\") {\r\n      const maxSelection = formElement.validation?.maximumSelection;\r\n  \r\n      if (maxSelection && maxSelection > 0) {\r\n        // Flatten scores per label\r\n        const labelScores: number[] = [];\r\n        formElement.scoring.score.forEach((s: any) => {\r\n          const scoreValue = s.score ?? 0;\r\n          const count = s.label?.length ?? 0;\r\n          for (let i = 0; i < count; i++) {\r\n            labelScores.push(scoreValue);\r\n          }\r\n        });\r\n  \r\n        // Sort descending & take top N\r\n        labelScores.sort((a, b) => b - a);\r\n        maxScoreForQuestion = labelScores\r\n          .slice(0, maxSelection)\r\n          .reduce((sum, score) => sum + score, 0);\r\n      } else {\r\n        // Sum all scores × label count\r\n        maxScoreForQuestion = formElement.scoring.score.reduce(\r\n          (sum: number, s: any) =>\r\n            sum + (s.score ?? 0) * (s.label?.length ?? 0),\r\n          0\r\n        );\r\n      }\r\n    }\r\n    return maxScoreForQuestion;\r\n  }\r\n\r\n\r\n  shouldCalculateScore(subForm: any, submission: any): boolean {\r\n    // Get all dropdown-like questions in subform that have scoring enabled\r\n    const scoringQuestions = subForm.rows\r\n      .flatMap((row: any) => row.grid)\r\n      .filter((g: any) => g.entityType === 'QUESTION')\r\n      .map((g: any) => g.element)\r\n      .filter((q: any) =>\r\n        q.formElement &&\r\n        ['DROP_DOWN', 'RADIO_BUTTON', 'CHECK_BOX'].includes(q.formElement.elementType) &&\r\n        q.formElement.scoring?.enableScoring\r\n      );\r\n  \r\n    // Check if all scoring-enabled dropdown questions are answered in submission\r\n    return scoringQuestions.every((q: any) => {\r\n      const ans = submission.answers.find((a: any) => a.questionId === q.id);\r\n      return ans && ans.answer !== '' && !(Array.isArray(ans.answer) && ans.answer.length === 0);\r\n    });\r\n  }\r\n  \r\n}\r\n"]}

package/esm2022/services/subform-copy.service.mjs

@@ -0,0 +1,122 @@
+import { Injectable } from '@angular/core';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+export class SubformCopyService {
+    copySubform(subForm, pages) {
+        const questionRelation = {};
+        const copiedSubform = this.deepCopyWithNewIds(subForm, questionRelation);
+        // Attach copy metadata directly inside the copied subform
+        copiedSubform.copySubformMeta = {
+            id: copiedSubform.id,
+            title: '',
+            description: '',
+            parentSubform: subForm.id,
+            questionRelation,
+        };
+        if (!subForm.copiedForms) {
+            subForm.copiedForms = [];
+        }
+        subForm.copiedForms.push(copiedSubform.id);
+        const page = this.findPageContainingSubform(subForm.id, pages);
+        if (page) {
+            const rowIndex = page.rows.findIndex((row) => row.grid.some((grid) => grid.entityType === 'SUBFORM' && grid.element.id === subForm.id));
+            copiedSubform.submissions = [];
+            copiedSubform.score = null;
+            if (rowIndex !== -1) {
+                const newSubformGrid = {
+                    entityType: 'SUBFORM',
+                    element: copiedSubform,
+                    show: true
+                };
+                page.rows.splice(rowIndex + 1, 0, {
+                    grid: [newSubformGrid],
+                });
+            }
+        }
+        return {
+            updatedPages: pages
+        };
+    }
+    deepCopyWithNewIds(subform, questionRelation) {
+        const idMap = new Map();
+        const replaceIds = (obj) => {
+            if (Array.isArray(obj)) {
+                return obj.map(replaceIds);
+            }
+            else if (obj !== null && typeof obj === 'object') {
+                const newObj = {};
+                for (const key of Object.keys(obj)) {
+                    const value = obj[key];
+                    if (key === 'id' && typeof value === 'string') {
+                        if (!idMap.has(value)) {
+                            idMap.set(value, uuidv4());
+                        }
+                        newObj[key] = idMap.get(value);
+                    }
+                    else {
+                        newObj[key] = replaceIds(value);
+                    }
+                }
+                // ✅ Now handle answer reset and questionRelation mapping
+                if (obj.entityType === 'QUESTION' &&
+                    obj.element &&
+                    typeof obj.element.id === 'string') {
+                    const originalQuestionId = obj.element.id;
+                    const newQuestionId = newObj.element?.id;
+                    if (originalQuestionId && newQuestionId) {
+                        questionRelation[newQuestionId] = originalQuestionId;
+                    }
+                    // ✅ Reset answer here
+                    if (newObj.element) {
+                        newObj.element.answer = '';
+                        newObj.element.files = '';
+                    }
+                }
+                return newObj;
+            }
+            return obj;
+        };
+        const getCircularReplacer = () => {
+            const seen = new WeakSet();
+            return (_key, value) => {
+                if (typeof value === "object" && value !== null) {
+                    if (seen.has(value)) {
+                        return undefined;
+                    }
+                    seen.add(value);
+                }
+                return value;
+            };
+        };
+        const copied = replaceIds(JSON.parse(JSON.stringify(subform, getCircularReplacer())));
+        if (copied.defaultAnswers &&
+            Array.isArray(copied.defaultAnswers.answers)) {
+            copied.defaultAnswers.answers.forEach((answerBlock) => {
+                if (Array.isArray(answerBlock.defaultQuestionsAnswers)) {
+                    answerBlock.defaultQuestionsAnswers.forEach((dqAnswer) => {
+                        const oldQId = dqAnswer.questionId;
+                        if (idMap.has(oldQId)) {
+                            dqAnswer.questionId = idMap.get(oldQId);
+                        }
+                    });
+                }
+            });
+        }
+        copied.copied = true;
+        return copied;
+    }
+    findPageContainingSubform(subformId, pages) {
+        return pages.find((page) => page.rows.some((row) => row.grid.some((grid) => grid.entityType === 'SUBFORM' &&
+            grid.element &&
+            grid.element.id === subformId)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubformCopyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubformCopyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubformCopyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subform-copy.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/subform-copy.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { v4 as uuidv4 } from 'uuid';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SubformCopyService {\r\n  copySubform(subForm: any, pages: any[]): { updatedPages: any[] } {\r\n    const questionRelation: Record<string, string> = {};\r\n    const copiedSubform = this.deepCopyWithNewIds(subForm, questionRelation);\r\n\r\n    // Attach copy metadata directly inside the copied subform\r\n    copiedSubform.copySubformMeta = {\r\n      id: copiedSubform.id,\r\n      title: '',\r\n      description: '',\r\n      parentSubform: subForm.id,\r\n      questionRelation,\r\n    };\r\n\r\n    if (!subForm.copiedForms) {\r\n        subForm.copiedForms = [];\r\n      }\r\n      subForm.copiedForms.push(copiedSubform.id);\r\n\r\n    const page = this.findPageContainingSubform(subForm.id, pages);\r\n\r\n    if (page) {\r\n      const rowIndex = page.rows.findIndex((row: any) =>\r\n        row.grid.some((grid: any) =>\r\n          grid.entityType === 'SUBFORM' && grid.element.id === subForm.id\r\n        )\r\n      );\r\n      copiedSubform.submissions = [];\r\n      copiedSubform.score = null;\r\n      if (rowIndex !== -1) {\r\n        const newSubformGrid = {\r\n          entityType: 'SUBFORM',\r\n          element: copiedSubform,\r\n          show: true\r\n        };\r\n\r\n        page.rows.splice(rowIndex + 1, 0, {\r\n          grid: [newSubformGrid],\r\n        });\r\n      }\r\n    }\r\n\r\n    return {\r\n      updatedPages: pages\r\n    };\r\n  }\r\n\r\n  private deepCopyWithNewIds(subform: any, questionRelation: Record<string, string>): any {\r\n    const idMap: Map<string, string> = new Map();\r\n\r\n    const replaceIds = (obj: any): any => {\r\n        if (Array.isArray(obj)) {\r\n          return obj.map(replaceIds);\r\n        } else if (obj !== null && typeof obj === 'object') {\r\n          const newObj: any = {};\r\n          for (const key of Object.keys(obj)) {\r\n            const value = obj[key];\r\n      \r\n            if (key === 'id' && typeof value === 'string') {\r\n              if (!idMap.has(value)) {\r\n                idMap.set(value, uuidv4());\r\n              }\r\n              newObj[key] = idMap.get(value);\r\n            } else {\r\n              newObj[key] = replaceIds(value);\r\n            }\r\n          }\r\n      \r\n          // ✅ Now handle answer reset and questionRelation mapping\r\n          if (\r\n            obj.entityType === 'QUESTION' &&\r\n            obj.element &&\r\n            typeof obj.element.id === 'string'\r\n          ) {\r\n            const originalQuestionId = obj.element.id;\r\n            const newQuestionId = newObj.element?.id;\r\n      \r\n            if (originalQuestionId && newQuestionId) {\r\n              questionRelation[newQuestionId] = originalQuestionId;\r\n            }\r\n      \r\n            // ✅ Reset answer here\r\n            if (newObj.element) {\r\n              newObj.element.answer = '';\r\n              newObj.element.files = '';\r\n            }\r\n          }\r\n      \r\n          return newObj;\r\n        }\r\n      \r\n        return obj;\r\n      };\r\n      \r\n\r\n      const getCircularReplacer = () => {\r\n        const seen = new WeakSet();\r\n        return (_key: string, value: any) => {\r\n          if (typeof value === \"object\" && value !== null) {\r\n            if (seen.has(value)) {\r\n              return undefined;\r\n            }\r\n            seen.add(value);\r\n          }\r\n          return value;\r\n        };\r\n      };\r\n\r\n    const copied = replaceIds(JSON.parse(JSON.stringify(subform, getCircularReplacer())));\r\n    if (\r\n      copied.defaultAnswers &&\r\n      Array.isArray(copied.defaultAnswers.answers)\r\n    ) {\r\n      copied.defaultAnswers.answers.forEach((answerBlock: any) => {\r\n        if (Array.isArray(answerBlock.defaultQuestionsAnswers)) {\r\n          answerBlock.defaultQuestionsAnswers.forEach((dqAnswer: any) => {\r\n            const oldQId = dqAnswer.questionId;            \r\n            if (idMap.has(oldQId)) {\r\n              dqAnswer.questionId = idMap.get(oldQId);\r\n            }\r\n          });\r\n        }\r\n      });\r\n    }\r\n    \r\n    copied.copied = true;\r\n    return copied;\r\n  }\r\n\r\n  private findPageContainingSubform(subformId: string, pages: any[]): any {\r\n    return pages.find((page: any) =>\r\n      page.rows.some((row: any) =>\r\n        row.grid.some(\r\n          (grid: any) =>\r\n            grid.entityType === 'SUBFORM' &&\r\n            grid.element &&\r\n            grid.element.id === subformId\r\n        )\r\n      )\r\n    );\r\n  }\r\n}\r\n"]}