contact getContact

  async getContactData(id: number): Promise<ContactResponseDto> {
    try {
      const existingContactDetails = await this.getExistingContactDetails(id);
      const contactRelations: any = [
        "contactAddresses.address.addressType",
        "contactDocMaps",
        "communicationDetails",
        "companyLocation",
      ];
      if (
        existingContactDetails?.contactRecordType?.lookUpValue.toLowerCase() ===
        enumRecordType.COMPANY
      ) {
        contactRelations.push(
          "companyContactMaps.company.companyAddresses.address.addressType",
          "reportingTo",
          "assistant"
        );
      } else if (
        existingContactDetails?.contactRecordType?.lookUpValue.toLowerCase() ===
        enumRecordType.INSURER
      ) {
        contactRelations.push(
          "insurerContacts.insurer.insurerAddresses.address.addressType",
          "insurerContacts.insurer.isLife",
          "insurerContacts.insurer.companyType",
          "insurerContacts.insurer.companyTag",
          "insurerContacts.insurer.status"
        );
      } else if (
        existingContactDetails?.contactRecordType?.lookUpValue.toLowerCase() ===
        enumRecordType.TPA
      ) {
        contactRelations.push(
          "tpaContacts.tpa.tpaAddresses.address.addressType",
          "tpaContacts.tpa.status"
        );
      }
      const contact = await this.contactRepository.findOne({
        where: { id },
        relations: contactRelations,
      });

      if (!contact) {
        throw new NotFoundException(`Contact with ID ${id} not found`);
      }

      const lookUpValues = await this.entityService.getLookupValues([
        contact.salutationId,
        contact?.tagId ?? 0,
        contact?.contactTypeId ?? 0,
        contact.departmentId,
        contact.designationId,
        contact.statusId,
        contact.contactRecordTypeId,
      ]);

      const salutation =
        lookUpValues.find((item) => item.id === contact.salutationId) ?? null;
      const tag =
        lookUpValues.find((item) => item.id === contact.tagId) ?? null;
      const contactType =
        lookUpValues.find((item) => item.id === contact.contactTypeId) ?? null;
      const department =
        lookUpValues.find((item) => item.id === contact.departmentId) ?? null;
      const designation =
        lookUpValues.find((item) => item.id === contact.designationId) ?? null;
      const status =
        lookUpValues.find((item) => item.id === contact.statusId) ?? null;
      const contactRecordType =
        lookUpValues.find((item) => item.id === contact.contactRecordTypeId) ??
        null;
      // Enrich the contact object with lookup values
      const enrichedContact = {
        ...contact,
        salutation,
        tag,
        contactType,
        department,
        designation,
        status,
        contactRecordType,
      };
      if (
        contactRecordType?.lookUpValue.toLowerCase() === enumRecordType.COMPANY
      ) {
        const [
          contactDetails,
          professionalExperiences,
          qualificationExperiences,
        ] = await Promise.all([
          this.contactDetailsRepository.find({
            where: { contact: { id } },
          }),
          this.professionalExperienceRepository.find({
            where: { contact: { id } },
          }),
          this.qualificationExperienceRepository.find({
            where: { contact: { id } },
          }),
        ]);

        let enrichedContactDetails = contactDetails;

        if (contactDetails.length > 0) {
          const lookupKeys = ["gender", "spouseWorkingStatus", "maritalStatus"];
          const lookupValueSet = new Set<number>();

          // Collect unique lookup IDs
          for (const detail of contactDetails) {
            for (const key of lookupKeys) {
              const value = detail[key];
              if (typeof value === "number") {
                lookupValueSet.add(value);
              }
            }
          }

          // Fetch lookup values in one go
          const lookupValues = await this.entityService.getLookupValues([
            ...lookupValueSet,
          ]);

          // Enrich each contactDetail with lookup values and childDetails
          enrichedContactDetails = await Promise.all(
            contactDetails.map(async (detail: any) => {
              const genderType =
                lookupValues.find((val) => val.id === detail.gender) ?? null;
              const spouseWorkingStatusType =
                lookupValues.find(
                  (val) => val.id === detail.spouseWorkingStatus
                ) ?? null;
              const maritalStatusType =
                lookupValues.find((val) => val.id === detail.maritalStatus) ??
                null;

              const childDetails = await this.childDetailsRepository.find({
                where: { contactDetails: { id: detail.id } },
              });

              return {
                ...detail,
                genderType,
                spouseWorkingStatusType,
                maritalStatusType,
                childDetails,
              };
            })
          );
        }

        const enrichedCompanyContact = {
          ...enrichedContact,
          contactDetails: enrichedContactDetails,
          professionalExperiences,
          qualificationExperiences,
        };
        return this.transformContacts(enrichedCompanyContact);
      } else {
        return this.transformContacts(enrichedContact);
      }
    } catch (error) {
      throw new InternalServerErrorException(
        createErrorResponse(
          statusCode.badRequest,
          errorMessages.contactQueryFetchFailed
        )
      );
    }
  }