@piserve-tech/form-submission 1.3.317 → 1.3.319

package/src/services/recaptcha.service.ts

@@ -1,179 +0,0 @@
-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

@@ -1,352 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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();
-  });
-});