@piserve-tech/form-submission 1.3.317 → 1.3.319

package/src/services/mapper.service.ts

@@ -1,625 +0,0 @@
-import { Appearance } from '../models/appearance.model';
-import { ElementOptionAPI } from '../models/elementOptionAPI.model';
-import { elementOptionAPIData } from '../models/elementOptionAPIData.model';
-import { ElementOptionDB } from '../models/elementOptionDB.model';
-import { ElementOptionDBCriteria } from '../models/elementOptionDBCriteria.model';
-import { FormElement } from '../models/formElement.model';
-import { Grid } from '../models/grid.model';
-import { Page } from '../models/page.model';
-import { PublicForm } from '../models/publicForm.model';
-import { Question } from '../models/question.model';
-import { Row } from '../models/row.model';
-import { Validation } from '../models/validation.model';
-import { Option } from '../models/option.model';
-import { Section } from '../models/section.model';
-import { SubForm } from '../models/subForm.model';
-import { FormElementType } from '../models/formElementType.model';
-import { Logic } from '../models/logic.model';
-import { Attachment } from '../models/attachment.model';
-import { Submission } from '../models/submission.model';
-import { Answer } from '../models/answer.model';
-import { termsAndConditionType } from '../models/terms&condition.model';
-import { FormConfiguration } from '../models/formConfiguration.model';
-import { QuestionGroup } from '../models/questionGroup.model';
-import { SubformProperty } from '../models/subformPropery.model';
-import { Multifields } from '../models/multifields.model';
-import { AggregateFunction } from '../models/aggregate.model';
-import { DefaultAnswersModel } from '../models/defaultAnswersModel.model';
-import { DefaultAnswerEntry } from '../models/defaultAnswerEntry.model';
-import { DefaultQuestionAnswer } from '../models/defaultQuestionAnswer.model';
-import { SubformConfiguration } from '../models/subformConfiguration.model';
-import { EmitterDTO } from '../models/emitters.model';
-import { add } from 'ngx-bootstrap/chronos';
-import { Scoring } from '../models/scoring.model';
-import { HiddenField } from '../models/hiddenField.model';
-import { IFrameProperties } from '../models/iFrameProperties.model';
-import { SubmissionCopyConfig } from '../models/submissionCopyConfig.mopdel';
-
-export function mapPublicFormToModel(apiPublicForm: any): PublicForm {
-  return {
-    name: apiPublicForm.result.name,
-    formConfiguration: mapFormConfigurationToModel(
-      apiPublicForm.result.moduleConfiguration
-    ),
-    currency:apiPublicForm?.result?.currency,
-    defautlCurrency:apiPublicForm?.result?.defaultCurrency,
-    pages: apiPublicForm.result.pages.map((apiPage: any) =>
-      mapPageToModel(apiPage,apiPublicForm?.result?.currency,apiPublicForm?.result?.defaultCurrency)
-    ),
-    questionAnswers:apiPublicForm.result.questionAnswers,
-    parentId:apiPublicForm.result.parentId,
-    emitters: apiPublicForm.result.emittersDTOS
-      ? apiPublicForm.result.emittersDTOS.map((emitter: any) => mapEmitterToModel(emitter))
-      : [],
-    score:apiPublicForm.score,
-    maximumPossibleScore:apiPublicForm.maximumPossibleScore,
-  };
-}
-
-
-export function mapEmitterToModel(apiEmitter: any): EmitterDTO {
-  return {
-    id: apiEmitter.id,
-    keyName: apiEmitter.keyName,
-    valueSource: apiEmitter.valueSource,
-    questionId: apiEmitter.questionId,
-    inputValue: apiEmitter.inputValue,
-    isConflict: apiEmitter.isConflict ?? false
-  };
-}
-
-
-function mapFormConfigurationToModel(
-  apiFormConfiguration: any
-): FormConfiguration {
-  return {
-    saveAutomatically: apiFormConfiguration?.saveAutomatically,
-    saveInterval: apiFormConfiguration?.saveInterval,
-    customizeFont: apiFormConfiguration?.customizeFont,
-    fontFamily: apiFormConfiguration?.fontFamily,
-    fontSize: apiFormConfiguration?.fontSize,
-    enableDataExport: apiFormConfiguration?.enableDataExport,
-    fileFormats: apiFormConfiguration?.fileFormats,
-    enableQuestionNumbering: apiFormConfiguration?.enableQuestionNumbering,
-    questionNumbering: apiFormConfiguration?.questionNumbering,
-    enableGoogleRecaptcha: apiFormConfiguration?.enableGoogleRecaptcha,
-    googleRecaptchaKey: apiFormConfiguration?.googleRecaptchaKey,
-    googleRecaptchaSecret: apiFormConfiguration?.googleRecaptchaSecret,
-    navigation: apiFormConfiguration?.navigation,
-    markAllQuestionsAsRequired: apiFormConfiguration?.markAllQuestionsAsRequired,
-  };
-}
-
-
-
-export function mapPageToModel(apiPage: any, currency:any, defaultCurrency:any): Page {
-  return {
-    title: apiPage.title,
-    testElementName: apiPage.testElementName,
-    rows: apiPage?.rows?.map((apiRow: any) => mapRowToModel(apiRow,currency,defaultCurrency)),
-  };
-}
-
-function mapRowToModel(apiRow: any, currency:any,defaultCurrency:any): Row {
-  return {
-    grid: apiRow.grid.map((apiGrid: any) => mapGridToModel(apiGrid,currency,defaultCurrency)),
-  };
-}
-
-function mapGridToModel(apiGrid: any, currency:any,defaultCurrency:any): Grid {
-  let entity: Section | Question | SubForm | QuestionGroup | Multifields | undefined;
-
-  switch (apiGrid.entityType) {
-    case 'QUESTION':
-      entity = mapQuestionToModel(apiGrid.element,currency,defaultCurrency);
-      break;
-    case 'SECTION':
-      entity = mapSectionToModel(apiGrid.element);
-      break;
-    case 'SUBFORM':
-      entity = mapSubFormToModel(apiGrid.element,currency,defaultCurrency);
-      break;
-    case 'QUESTION_GROUP':
-      entity = mapQuestionGroupToModel(apiGrid.element,currency,defaultCurrency);
-      break;
-    case 'MULTIFIELD':
-      entity = mapMultifieldsToModel(apiGrid.element,currency,defaultCurrency);
-      break;
-    default:
-      throw new Error(`Unknown entity type: ${apiGrid.entityType}`);
-  }
-
-  const whenClause = mapWhenClauseModel(apiGrid.whenClauseDTO);
-  // read actions safely
-  const actions: string[] = Array.isArray(whenClause?.whenClauseActions)
-    ? whenClause.whenClauseActions
-    : [];
-
-  // pick last action if multiple (your UI prevents that but safe handling)
-  const action = actions.length > 0 ? actions[actions.length - 1] : undefined;
-
-  let shouldShow = true; // default visible
-
-  if (action === 'SHOW') {
-    shouldShow = false;  // default hidden when action = SHOW
-  }
-  if (action === 'HIDE') {
-    shouldShow = true;   // default shown when action = HIDE
-  }
-
-  return {
-    entityType: apiGrid.entityType,
-    element: entity,
-    whenClause: whenClause,
-    show: shouldShow
-  };
-}
-
-export function mapWhenClauseModel(whenClauseDTO: any) {
-  // 🧩 Guard: Handle undefined/null or malformed data
-  if (!whenClauseDTO || !Array.isArray(whenClauseDTO.whenClauseCondition)) {
-
-    return {
-      activate: false,
-      whenClauseCondition: [],
-      whenClauseActions: []
-    };
-  }
-
-  return {
-    activate: !!whenClauseDTO.activate,
-    whenClauseActions: whenClauseDTO.whenClauseActions || [],
-    whenClauseCondition: whenClauseDTO.whenClauseCondition.map((condition: any) => ({
-      logic: condition.logic || '',
-      questionid: condition.questionid || '',
-      condition: condition.condition || '',
-      value: condition.value ?? '' // handle null/undefined gracefully
-    }))
-  };
-}
-
-export function mapSectionToModel(apiSection: any): Section {
-  return {
-    id: apiSection.id,
-    title: apiSection.title,
-    description: apiSection.description,
-    testElementName: apiSection.testElementName
-  };
-}
-
-export function mapQuestionToModel(apiQuestion: any, currency:any, defaultCurrency:any): Question {
-  return {
-    count: apiQuestion.count,
-    id: apiQuestion.id,
-    questionNumber: apiQuestion.questionNumber,
-    required: apiQuestion.required,
-    hint: apiQuestion.hint,
-    question: apiQuestion.question,
-    testElementName: apiQuestion.testElementName,
-    answer: apiQuestion?.answer,
-    validation: true,
-    formElement: mapFormElementToModel(apiQuestion.formElement,currency,defaultCurrency),
-    childLogics: apiQuestion?.childLogics?.map((logic: any) =>
-      mapLogicToModel(logic, currency,defaultCurrency)
-    ),
-    answerId: apiQuestion?.answerId,
-    attachments: apiQuestion?.attachments?.map((attachment: any) => mapAttachmentToModel(attachment)) || [],
-    deleteFiles: [],
-    defaultValue:apiQuestion?.defaultValue,
-    disableEdit:apiQuestion?.disableEdit,
-    score:apiQuestion.score,
-    maximumPossibleScore:apiQuestion.maximumPossibleScore,
-    amountInWords: apiQuestion?.amountInWords,
-    answerCurrency:apiQuestion?.currencySymbol
-  };
-}
-
-function mapAttachmentToModel(apiAttachment: any): Attachment {
-  return {
-    fileId: apiAttachment.fileId,
-    fileName: apiAttachment.fileName,
-    fileUrl: apiAttachment.fileUrl,
-    fileSize:apiAttachment?.fileSize
-  };
-}
-
-function mapFormElementToModel(apiFormElement: any, currency:any, defaultCurrency:any): FormElement {
-  return {
-    elementType: apiFormElement.elementType,
-    appearance: mapAppearanceToModel(apiFormElement.appearance,currency,defaultCurrency),
-    validation: mapValidationToModel(apiFormElement.validation),
-    option: mapOptionToModel(apiFormElement?.option),
-    aggregateFunction: mapAggregateFunction(apiFormElement?.aggregateFunction),
-    selectionMatrixLabel: apiFormElement.selectionMatrixLabel,
-    selectionMatrixColumn: apiFormElement.selectionMatrixColumn,
-    termsAndConditionType: maptermsAndCondition(apiFormElement),
-    scoring: mapScoringToModel(apiFormElement.scoring),
-    hiddenField: mapHiddenFieldToModel(apiFormElement?.hiddenField),
-    iFrameProperties: mapIframeProperties(apiFormElement?.iFrameProperties)
-  };
-}
-
-function mapIframeProperties(iFrameProperties: any): IFrameProperties {
-  return {
-    contentType: iFrameProperties?.contentType,
-    url: iFrameProperties?.url,
-    html: iFrameProperties?.html,
-    style: iFrameProperties?.style,
-    script: iFrameProperties?.script
-  }
-}
-
-function mapHiddenFieldToModel(hiddenField: any): HiddenField {
-  return {
-    value: hiddenField?.value,
-    valueSource: hiddenField?.valueSource,
-    key: hiddenField?.key
-  }
-}
-
-function mapAggregateFunction(aggregateFunction: any): AggregateFunction | undefined {
-  if (!aggregateFunction) {
-    return undefined;
-  }
-
-  return {
-    aggregateOperation: aggregateFunction.aggregateOperation,
-    formula: aggregateFunction.formula
-  };
-}
-
-function maptermsAndCondition(Element: any): termsAndConditionType {
-  if(Element.termsAndCondition != undefined){
-    let data = Element.termsAndCondition
-    return {
-      termsAndConditionType: data.termsAndConditionType,
-      fileUrl: data.fileUrl,
-      fileName: data.fileName,
-  };
-  }
-  else{
-    return {
-      termsAndConditionType: '',
-      fileUrl: '',
-      fileName: '',
-    }
-  }
-
-}
-
-function mapLogicToModel(apiLogic: any, currency:any,defaultCurrency:any): Logic {
-  return {
-    id: apiLogic.id,
-    inputValue: apiLogic.inputValue,
-    condition: apiLogic.condition,
-    showLogic: false,
-    rows: apiLogic?.rows?.map((element: any) =>
-      mapRowToModel(element,currency,defaultCurrency)
-    ),
-  };
-}
-
-export function mapSubFormToModel(apiSubForm: any, currency:any,defaultCurrency:any): SubForm {
-  return {
-    id: apiSubForm.id,
-    count: apiSubForm.count,
-    title: apiSubForm.title,
-    description: apiSubForm.description,
-    testElementName: apiSubForm.testElementName,
-    rows: apiSubForm.rows.map((element: any) => mapRowToModel(element,currency,defaultCurrency)),
-    submissions: apiSubForm?.submissions?.map((submission: any) => mapSubmissionToModel(submission)),
-    property: apiSubForm.property ? mapPropertyToModel(apiSubForm.property) : undefined,
-    defaultAnswers: apiSubForm.defaultAnswers ? mapDefaultAnswersToModel(apiSubForm.defaultAnswers) : undefined,
-    deleted: false,
-    scores:apiSubForm.scores,
-    maximumPossibleScore:apiSubForm.maximumPossibleScore,
-    submissionCopyConfig: mapSubmissionCopyConfig(apiSubForm.submissionCopyConfig),
-    required: apiSubForm.required
-  };
-}
-
-export function mapSubmissionCopyConfig(copyConfig:any): SubmissionCopyConfig | undefined {
-  if(!copyConfig) return undefined;
-  return {
-    allowCopyFromOtherSubmissions: copyConfig.allowCopyFromOtherSubmissions,
-    editableQuestions: copyConfig.editableQuestions,
-  };
-}
-
-export function mapDefaultAnswersToModel(apiDefaultAnswers: any): DefaultAnswersModel {
-  return {
-      answers: apiDefaultAnswers.answers.map((entry: any) => mapDefaultAnswerEntry(entry))
-  };
-}
-
-export function mapDefaultAnswerEntry(apiEntry: any): DefaultAnswerEntry {
-  return {
-    isDeleteEnable: apiEntry.isDeleteEnable,
-    defaultQuestionsAnswers: apiEntry.defaultQuestionsAnswers.map((question: any) => mapDefaultQuestionAnswer(question))
-  };
-}
-
-export function mapDefaultQuestionAnswer(apiQuestion: any): DefaultQuestionAnswer {
-  return {
-    defaultAnswer: apiQuestion.defaultAnswer,
-    readOnly: apiQuestion.readOnly,
-    isDeleteEnable: apiQuestion.isDeleteEnable,
-    questionId: apiQuestion.questionId
-  };
-}
-
-function mapPropertyToModel(apiProperty: any): SubformProperty {
-  return {
-    subFormStructure: apiProperty.subFormStructure,
-    subFormType: apiProperty.subFormType,
-    allowDelete: apiProperty.allowDelete,
-    allowCopy: apiProperty.allowCopy,
-    addButtonLabel: apiProperty.addButtonLabel
-  };
-}
-
-export function mapQuestionGroupToModel(apiQuestionGroup: any,currency:any,defaultCurrency:any): QuestionGroup {
-  return {
-    id: apiQuestionGroup.id,
-    count: apiQuestionGroup.count,
-    title: apiQuestionGroup.title,
-    description: apiQuestionGroup.description,
-    testElementName: apiQuestionGroup.testElementName,
-    rows: apiQuestionGroup.rows.map((element: any) => mapRowToModel(element,currency,defaultCurrency)),
-    submissions: apiQuestionGroup?.submissions?.map((submission: any) => mapSubmissionToModel(submission)),
-  };
-}
-
-export function mapMultifieldsToModel(apiQuestionGroup: any,currency:any,defaultCurrency:any): Multifields {
-  return {
-    id: apiQuestionGroup.id,
-    question: apiQuestionGroup.question,
-    questionNumber: apiQuestionGroup.questionNumber,
-    count: apiQuestionGroup.count,
-    testElementName: apiQuestionGroup.testElementName,
-    rows: apiQuestionGroup.rows.map((element: any) => mapRowToModel(element,currency,defaultCurrency)),
-    submissions: apiQuestionGroup?.submissions?.map((submission: any) => mapSubmissionToModel(submission)),
-  };
-}
-
-function mapSubmissionToModel(apiSubmission: any): Submission {
-  return {
-    submissionId: apiSubmission?.submissionId,
-    answers: apiSubmission?.answers?.map((answer: any) => mapAnswerToModel(answer)),
-    configuration: mapSubformConfiguration(apiSubmission?.configuration),
-    scores:apiSubmission.scores,
-    sourceSubmissionId:apiSubmission.sourceSubmissionId,
-    isCopied:apiSubmission.isCopied
-  };
-}
-
-function mapAnswerToModel(apiAnswer: any): Answer {
-  return {
-    questionId: apiAnswer.questionId,
-    answer: apiAnswer?.answer,
-    answerId: apiAnswer?.answerId,
-    attachments: apiAnswer?.attachments?.map((attachment: any) => mapAttachmentToModel(attachment)),
-    scores:apiAnswer.scores,
-    maximumPossibleScore:apiAnswer.maximumPossibleScore,
-    show:apiAnswer?.show,
-    amountInWords: apiAnswer?.amountInWords,
-    answerCurrency:apiAnswer?.currencySymbol
-  };
-}
-
-function mapSubformConfiguration(config: any): SubformConfiguration | undefined {
-  if (!config) return undefined;
-  return {
-    allowDelete: !!config.allowDelete,
-    isDefault: !!config.isDefault,
-  };
-}
-
-export function mapFormElementTypeToModel(
-  apiFormElementType: any
-): FormElementType<any> {
-  return {
-    entityType: apiFormElementType?.entityType,
-    element: apiFormElementType?.element,
-  };
-}
-
-function mapAppearanceToModel(apiAppearance: any, currency:any, defaultCurrency:any): Appearance {
-  return {
-    placeholder: apiAppearance?.placeholder,
-    fontSize: apiAppearance?.fontSize,
-    textAlign: apiAppearance?.textAlign,
-    font: apiAppearance?.font,
-    underline: apiAppearance?.underline,
-    bold: apiAppearance?.bold,
-    italics: apiAppearance?.italics,
-    defaultValue: apiAppearance?.defaultValue,
-    numberOfRows: apiAppearance?.numberOfRows,
-    singleSelection: apiAppearance?.singleSelection,
-    displayCountryCode: apiAppearance?.displayCountryCode,
-    displayFlag: apiAppearance?.displayFlag,
-    displayCode: apiAppearance?.displayCode,
-    showCountryName: apiAppearance?.showCountryName,
-    beautifyNumbers: apiAppearance?.beautifyNumbers,
-    upAndDownButton: apiAppearance?.upAndDownButton,
-    allowNegativeValues: apiAppearance?.allowNegativeValues,
-    showPreviewButton: apiAppearance?.showPreviewButton,
-    confirmPassword: apiAppearance?.confirmPassword,
-    viewButton: apiAppearance?.viewButton,
-    displayStrong: apiAppearance?.displayStrong,
-    dateType: apiAppearance?.dateType,
-    format: apiAppearance?.format,
-    setCurrentPosition: apiAppearance?.setCurrentPosition,
-    defaultZoomLevel: apiAppearance?.defaultZoomLevel,
-    allowFullScreen: apiAppearance?.allowFullScreen,
-    latitude: apiAppearance?.latitude,
-    longitude: apiAppearance?.longitude,
-    showAcceptButton: apiAppearance?.showAcceptButton,
-    labelOnValue: apiAppearance?.labelOnValue,
-    labelOffValue: apiAppearance?.labelOffValue,
-    labelOnColor: apiAppearance?.labelOnColor,
-    labelOffColor: apiAppearance?.labelOffColor,
-    minValue: apiAppearance?.minValue,
-    maxValue: apiAppearance?.maxValue,
-    stepValue: apiAppearance?.stepValue,
-    changeSliderColor: apiAppearance?.changeSliderColor,
-    sliderColor: apiAppearance?.sliderColor,
-    canvasOption: apiAppearance?.canvasOption,
-    selectionType: apiAppearance?.selectionType,
-    dragAndDrop: apiAppearance?.dragAndDrop,
-    previewUploadedFiles: apiAppearance?.previewUploadedFiles,
-    multiFileUploads: apiAppearance?.multiFileUploads,
-    selectionColorRequired: apiAppearance?.selectionColorRequired,
-    selectionColor: apiAppearance?.selectionColor,
-    color: apiAppearance?.color,
-    avatarPicker:apiAppearance?.avatarPicker,
-    timeFormat:apiAppearance?.timeFormat,
-    displayOptionsInColumn:apiAppearance?.displayOptionsInColumn,
-    currencySymbol:apiAppearance?.currencySymbol,
-    decimalPrecision:apiAppearance?.decimalPrecision,
-    symbolPosition:apiAppearance?.symbolPosition,
-    thousandSeparator:apiAppearance?.thousandSeparator,
-    currency:currency,
-    limitCurrencies:apiAppearance?.limitCurrencies,
-    currencyOption:apiAppearance?.currencyOption,
-    specificCurrencySymbol:apiAppearance?.specificCurrencySymbol,
-    limitCurrencySymbol:apiAppearance?.limitCurrencySymbol,
-    width: apiAppearance?.width,
-    height: apiAppearance?.height,
-    showAmountInWords: apiAppearance?.showAmountInWords,
-    defaultCurrency:defaultCurrency
-  };
-}
-
-function mapValidationToModel(apiValidation: any): Validation {
-  return {
-    regexValidation: apiValidation?.regexValidation,
-    regex: apiValidation?.regex,
-    validationMessage: apiValidation?.validationMessage,
-    limitedCharacters: apiValidation?.limitedCharacters,
-    count: apiValidation?.count,
-    minimumSelection: apiValidation?.minimumSelection,
-    maximumSelection: apiValidation?.maximumSelection,
-    countryWiseValidation: apiValidation?.countryWiseValidation,
-    restrictCountry: apiValidation?.restrictCountry,
-    allowedCountries: apiValidation?.allowedCountries,
-    blockedCountries: apiValidation?.blockedCountries,
-    regularExpression: apiValidation?.regularExpression,
-    expectedDomains: apiValidation?.expectedDomains,
-    min: apiValidation?.min,
-    max: apiValidation?.max,
-    minLength: apiValidation?.minLength,
-    maxLength: apiValidation?.maxLength,
-    requireLowercaseLetters: apiValidation?.requireLowercaseLetters,
-    requireUppercaseLetters: apiValidation?.requireUppercaseLetters,
-    requireNumbers: apiValidation?.requireNumbers,
-    requireSpecialCharacters: apiValidation?.requireSpecialCharacters,
-    allowedSpecialCharacters: apiValidation?.allowedSpecialCharacters,
-    minDateOption: apiValidation?.minDateOption,
-    minDate: apiValidation?.minDate,
-    maxDateOption: apiValidation?.maxDateOption,
-    maxDate: apiValidation?.maxDate,
-    regionBoundary: apiValidation?.regionBoundary,
-    region: apiValidation?.region,
-    preventFromProceedingWithoutAgree:
-      apiValidation?.preventFromProceedingWithoutAgree,
-    buttonColour: apiValidation?.buttonColour,
-    maxFileSize: apiValidation?.maxFileSize,
-    minFileSize: apiValidation?.minFileSize,
-    minSelection: apiValidation?.minSelection,
-    maxSelection: apiValidation?.maxSelection,
-    fileTypes: apiValidation?.fileTypes,
-    fileSize: apiValidation?.fileSize,
-    fileSizeUnit: apiValidation?.fileSizeUnit,
-    totalFileSize: apiValidation?.totalFileSize,
-    minSelectionRequired: apiValidation?.minSelectionRequired,
-    minSelectionValue: apiValidation?.minSelectionValue,
-    validationType: apiValidation?.validationType,
-    validation: apiValidation?.validation,
-    minTime: apiValidation?.minTime,
-    maxTime:apiValidation?.maxTime,
-    minTimeOption:apiValidation?.minTimeOption,
-    maxTimeOption: apiValidation?.maxTimeOption,
-  };
-}
-
-function mapElementOptionDBToModel(apiElementOptionDB: any): ElementOptionDB {
-  return {
-    tableName: apiElementOptionDB.tableName,
-    valueField: apiElementOptionDB.valueField,
-    labelField: apiElementOptionDB.labelField,
-    labelPattern: apiElementOptionDB.labelPattern,
-    criteria: apiElementOptionDB?.criteria.map((apiCriteria: any) =>
-      mapElementOptionDBCriteriaToModel(apiCriteria)
-    ),
-  };
-}
-
-function mapElementOptionDBCriteriaToModel(
-  apiElementOptionDBCriteria: any
-): ElementOptionDBCriteria {
-  return {
-    field: apiElementOptionDBCriteria?.field,
-    condition: apiElementOptionDBCriteria?.condition,
-    valueSource: apiElementOptionDBCriteria?.valueSource,
-    inputValue: apiElementOptionDBCriteria?.inputValue,
-    logicalOperator: apiElementOptionDBCriteria?.logicalOperator,
-  };
-}
-
-function mapElementOptionAPIToModel(
-  apiElementOptionAPI: any
-): ElementOptionAPI {
-  return {
-    external: apiElementOptionAPI?.external,
-    url: apiElementOptionAPI?.url,
-    valueField: apiElementOptionAPI?.valueField,
-    labelField: apiElementOptionAPI?.labelField,
-    pathToValue: apiElementOptionAPI?.pathToValue,
-    headers: apiElementOptionAPI?.headers?.map(mapElementOptionAPIDataToModel),
-    params: apiElementOptionAPI?.params?.map(mapElementOptionAPIDataToModel),
-    pathVariables: apiElementOptionAPI?.pathVariables?.map(
-      mapElementOptionAPIDataToModel
-    ),
-     labelPattern:apiElementOptionAPI?.labelPattern
-  };
-}
-
-function mapElementOptionAPIDataToModel(
-  apiElementOptionAPIData: any
-): elementOptionAPIData {
-  return {
-    keyName: apiElementOptionAPIData?.keyName,
-    valueSource: apiElementOptionAPIData?.valueSource,
-    inputValue: apiElementOptionAPIData?.inputValue,
-  };
-}
-
-function mapOptionToModel(apiOption: any): Option {
-  return {
-    optionType: apiOption?.optionType,
-    lookupTable: apiOption?.lookupTable,
-    customOptions: apiOption?.customOptions?.map((option: { value: any }) => ({
-      value: option.value,
-    })),
-    database: apiOption?.database
-      ? mapElementOptionDBToModel(apiOption?.database)
-      : undefined,
-    api: apiOption?.api ? mapElementOptionAPIToModel(apiOption.api) : undefined,
-  };
-}
-
-function mapScoringToModel(apiScoring: any): Scoring | undefined {
-  if (!apiScoring) return undefined;
-
-  return {
-    enableScoring: apiScoring.enableScoring,
-    defaultScore: apiScoring.defaultScore,
-    enableScoringType: apiScoring.enableScoringType,
-    score: apiScoring.score?.map((s: any) => ({
-      label: s.label || [],
-      score: s.score,
-      scoreType: s.scoreType
-    }))
-  };
-}

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

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