@piserve-tech/form-submission 1.3.314 → 1.3.316

package/src/services/recaptcha.service.ts

@@ -0,0 +1,179 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ToastrService } from 'ngx-toastr';
+import { map, Observable } from 'rxjs';
+import { DataService } from './data.service';
+
+declare global {
+  interface Window {
+    onRecaptchaLoadCallback: () => void;
+  }
+
+  var grecaptcha: {
+    ready: (callback: () => void) => void;
+    render: (
+      container: string | HTMLElement,
+      parameters: {
+        sitekey: string;
+        callback?: (token: string) => void;
+        'expired-callback'?: () => void;
+        'error-callback'?: () => void;
+        size?: 'normal' | 'compact' | 'invisible';
+        theme?: 'light' | 'dark';
+      }
+    ) => number;
+    execute: (widgetId?: number) => void;
+    getResponse: (widgetId?: number) => string;
+    reset: (widgetId?: number) => void;
+  };
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class RecaptchaService {
+  private siteKey = '';
+   private apiUrl: string = '';
+  private widgetId: number | null = null;
+  private initialized = false;
+  private resolved = false;
+
+  constructor(private toastr: ToastrService,private http: HttpClient, private dataService: DataService) {
+     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(): Observable<string> {
+
+    return this.http.get<{ message: string }>(`${this.apiUrl}/api/application-settings/recaptcha/siteKey`).pipe(
+      map((response: { message: string }) => {
+        const siteKey = response.message;
+        return siteKey;
+      })
+    );
+  }
+
+  initialize(): Promise<void> {
+    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: string, callback: (token: string) => void): void {
+  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: string) => {
+      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(): void {
+    if (typeof grecaptcha !== 'undefined' && this.widgetId !== null) {
+      grecaptcha.reset(this.widgetId);
+      this.resolved = false;
+    }
+  }
+
+  getResponse(): string {
+    if (typeof grecaptcha === 'undefined' || this.widgetId === null) {
+      return '';
+    }
+    return grecaptcha.getResponse(this.widgetId);
+  }
+
+  isRendered(): boolean {
+    return this.widgetId !== null;
+  }
+
+  isResolved(): boolean {
+    return this.resolved && !!this.getResponse();
+  }
+
+  removeRecaptchaScript(): void {
+    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;
+  }
+}

package/src/services/score.service.ts

@@ -0,0 +1,352 @@
+import { Injectable } from '@angular/core';
+import { Answer } from '../models/answer.model';
+import { Submission } from '../models/submission.model';
+
+interface SubmissionScore {
+  scoreType: string;
+  score: number;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ScoreCalculationService {
+  constructor() {}
+
+  calculateScoreFromAnswer(
+    newAnswer: string[] | string,
+    question: any
+  ): { scores: { scoreType: string; score: number }[] } | null {
+  
+    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: Record<string, number> = {};
+  
+      for (const answer of answers) {
+        const value = answer.split('|')[1]; // Extract actual value
+        const matchingScore = scoreRules.find((rule: any) => 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: Record<string, number> = {};
+  
+    for (const answer of answers) {
+      const value = answer.split('|')[1];
+      const matchingScore = scoreRules.find((rule: any) => 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: any): { goodMax: number; badMax: number } {
+    let goodMaxProduct = 1;
+    let badMaxProduct = 1;
+  
+    subform.rows.forEach((row: any) => {
+      row.grid.forEach((gridItem: any) => {
+        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: any) => 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: any, s: any) =>
+                    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: any) => s.score ?? 0)
+                );
+              }
+            } else if (formElement.appearance?.selectionType === "MULTIPLE") {
+              const maxSelection = formElement.validation?.maximumSelection;
+  
+              if (maxSelection && maxSelection > 0) {
+                const labelScores: number[] = [];
+                const src = goodScores.length > 0 ? goodScores : formElement.scoring.score;
+  
+                src.forEach((s: any) => {
+                  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: number, s: any) =>
+                    sum + (s.score ?? 0) * (s.label?.length ?? 0),
+                  0
+                );
+              }
+            }
+  
+            // ---- BAD SCORE CALC ----
+            let maxBadForQuestion = 0;
+            const badScores = formElement.scoring.score.filter(
+              (s: any) => s.scoreType === "BAD_SCORE"
+            );
+  
+            if (formElement.appearance?.selectionType === "SINGLE") {
+              if (badScores.length > 0) {
+                maxBadForQuestion = Math.max(
+                  ...badScores.map((s: any) => s.score ?? 0)
+                );
+              } else {
+                maxBadForQuestion = Math.max(
+                  ...formElement.scoring.score.map((s: any) => s.score ?? 0)
+                );
+              }
+            } else if (formElement.appearance?.selectionType === "MULTIPLE") {
+              const maxSelection = formElement.validation?.maximumSelection;
+  
+              if (maxSelection && maxSelection > 0) {
+                const labelScores: number[] = [];
+                const src = badScores.length > 0 ? badScores : formElement.scoring.score;
+  
+                src.forEach((s: any) => {
+                  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: number, s: any) =>
+                    sum + (s.score ?? 0) * (s.label?.length ?? 0),
+                  0
+                );
+              }
+            }
+  
+            goodMaxProduct *= maxGoodForQuestion;
+            badMaxProduct *= maxBadForQuestion;
+          }
+        }
+      });
+    });
+  
+    return { goodMax: goodMaxProduct, badMax: badMaxProduct };
+  }
+  
+  
+  
+
+  calculateSubmissionScore = (answers: Answer[], enableScoringType = true): SubmissionScore[] => {
+    let submissionScoreType: string | null = 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,
+      },
+    ];
+  };
+
+  calculateFinalScore(
+    submissions: Submission[],
+    maxPossibleGoodScore: number,
+    maxPossibleBadScore: number
+  ): SubmissionScore[] {
+    let totalGood = 0;
+    let totalBad = 0;
+  
+    const hasGood = (s: Submission) => s.scores?.some(x => x.scoreType === 'GOOD_SCORE');
+    const hasBad  = (s: Submission) => 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: SubmissionScore[] = [];
+  
+    // 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: any): number {
+    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: any) => s.score ?? 0)
+      );
+    } 
+    else if (formElement.appearance?.selectionType === "MULTIPLE") {
+      const maxSelection = formElement.validation?.maximumSelection;
+  
+      if (maxSelection && maxSelection > 0) {
+        // Flatten scores per label
+        const labelScores: number[] = [];
+        formElement.scoring.score.forEach((s: any) => {
+          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: number, s: any) =>
+            sum + (s.score ?? 0) * (s.label?.length ?? 0),
+          0
+        );
+      }
+    }
+    return maxScoreForQuestion;
+  }
+
+
+  shouldCalculateScore(subForm: any, submission: any): boolean {
+    // Get all dropdown-like questions in subform that have scoring enabled
+    const scoringQuestions = subForm.rows
+      .flatMap((row: any) => row.grid)
+      .filter((g: any) => g.entityType === 'QUESTION')
+      .map((g: any) => g.element)
+      .filter((q: any) =>
+        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: any) => {
+      const ans = submission.answers.find((a: any) => a.questionId === q.id);
+      return ans && ans.answer !== '' && !(Array.isArray(ans.answer) && ans.answer.length === 0);
+    });
+  }
+  
+}

package/src/services/subform-copy.service.ts

@@ -0,0 +1,148 @@
+import { Injectable } from '@angular/core';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SubformCopyService {
+  copySubform(subForm: any, pages: any[]): { updatedPages: any[] } {
+    const questionRelation: Record<string, string> = {};
+    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: any) =>
+        row.grid.some((grid: any) =>
+          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
+    };
+  }
+
+  private deepCopyWithNewIds(subform: any, questionRelation: Record<string, string>): any {
+    const idMap: Map<string, string> = new Map();
+
+    const replaceIds = (obj: any): any => {
+        if (Array.isArray(obj)) {
+          return obj.map(replaceIds);
+        } else if (obj !== null && typeof obj === 'object') {
+          const newObj: any = {};
+          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: string, value: any) => {
+          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: any) => {
+        if (Array.isArray(answerBlock.defaultQuestionsAnswers)) {
+          answerBlock.defaultQuestionsAnswers.forEach((dqAnswer: any) => {
+            const oldQId = dqAnswer.questionId;            
+            if (idMap.has(oldQId)) {
+              dqAnswer.questionId = idMap.get(oldQId);
+            }
+          });
+        }
+      });
+    }
+    
+    copied.copied = true;
+    return copied;
+  }
+
+  private findPageContainingSubform(subformId: string, pages: any[]): any {
+    return pages.find((page: any) =>
+      page.rows.some((row: any) =>
+        row.grid.some(
+          (grid: any) =>
+            grid.entityType === 'SUBFORM' &&
+            grid.element &&
+            grid.element.id === subformId
+        )
+      )
+    );
+  }
+}

package/src/services/validation.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ValidationService } from './validation.service';
+
+describe('ValidationService', () => {
+  let service: ValidationService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ValidationService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});