@piserve-tech/form-submission 1.3.314 → 1.3.316

package/src/services/mapper.service.ts

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

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