IMN-657 GET EService descriptor by ID

packages/api-clients/src/bffApi.ts

@@ -3,7 +3,7 @@ import { QueryParametersByAlias } from "./utils.js";
 
 type BffApi = typeof bffApi.eservicesApi.api;
 
-export type GetCatalogQueryParam = QueryParametersByAlias<
+export type BffGetCatalogQueryParam = QueryParametersByAlias<
   BffApi,
   "getEServicesCatalog"
 >;

packages/bff/src/model/api/converters/catalogClientApiConverter.ts

@@ -0,0 +1,211 @@
+/* eslint-disable functional/immutable-data */
+/* eslint-disable max-params */
+import { DescriptorWithOnlyAttributes } from "pagopa-interop-agreement-lifecycle";
+import {
+  agreementApi,
+  bffApi,
+  catalogApi,
+  tenantApi,
+  attributeRegistryApi,
+} from "pagopa-interop-api-clients";
+import {
+  EServiceAttribute,
+  tenantMailKind,
+  unsafeBrandId,
+} from "pagopa-interop-models";
+import { attributeNotExists } from "../../domain/errors.js";
+import { agreementApiState } from "../agreementTypes.js";
+import { descriptorApiState } from "../catalogTypes.js";
+
+export function toEserviceCatalogProcessQueryParams(
+  queryParams: bffApi.BffGetCatalogQueryParam
+): catalogApi.GetCatalogQueryParam {
+  return {
+    ...queryParams,
+    eservicesIds: [],
+    name: queryParams.q,
+  };
+}
+
+export function toBffCatalogApiEService(
+  eservice: catalogApi.EService,
+  producerTenant: tenantApi.Tenant,
+  hasCertifiedAttributes: boolean,
+  isRequesterEqProducer: boolean,
+  activeDescriptor?: catalogApi.EServiceDescriptor,
+  agreement?: agreementApi.Agreement
+): bffApi.CatalogEService {
+  const isUpgradable = (agreement: agreementApi.Agreement): boolean => {
+    const eserviceDescriptor = eservice.descriptors.find(
+      (e) => e.id === agreement.descriptorId
+    );
+
+    return (
+      eserviceDescriptor !== undefined &&
+      eservice.descriptors
+        .filter((d) => Number(d.version) > Number(eserviceDescriptor.version))
+        .find(
+          (d) =>
+            (d.state === descriptorApiState.PUBLISHED ||
+              d.state === descriptorApiState.SUSPENDED) &&
+            (agreement.state === agreementApiState.ACTIVE ||
+              agreement.state === agreementApiState.SUSPENDED)
+        ) !== undefined
+    );
+  };
+
+  const partialEnhancedEservice = {
+    id: eservice.id,
+    name: eservice.name,
+    description: eservice.description,
+    producer: {
+      id: eservice.producerId,
+      name: producerTenant.name,
+    },
+    isMine: isRequesterEqProducer,
+    hasCertifiedAttributes,
+  };
+
+  return {
+    ...partialEnhancedEservice,
+    ...(activeDescriptor
+      ? {
+          activeDescriptor: {
+            id: activeDescriptor.id,
+            version: activeDescriptor.version,
+            audience: activeDescriptor.audience,
+            state: activeDescriptor.state,
+          },
+        }
+      : {}),
+    ...(agreement
+      ? {
+          agreement: {
+            id: agreement.id,
+            state: agreement.state,
+            canBeUpgraded: isUpgradable(agreement),
+          },
+        }
+      : {}),
+  };
+}
+
+export function toBffCatalogApiDescriptorAttribute(
+  attributes: attributeRegistryApi.Attribute[],
+  descriptorAttributes: catalogApi.Attribute[]
+): bffApi.DescriptorAttribute[] {
+  return descriptorAttributes.map((attribute) => {
+    const foundAttribute = attributes.find((att) => att.id === attribute.id);
+    if (!foundAttribute) {
+      throw attributeNotExists(unsafeBrandId(attribute.id));
+    }
+
+    return {
+      id: attribute.id,
+      name: foundAttribute.name,
+      description: foundAttribute.description,
+      explicitAttributeVerification: attribute.explicitAttributeVerification,
+    };
+  });
+}
+
+export function toBffCatalogApiDescriptorInterface(
+  document: catalogApi.EServiceDoc
+): bffApi.EServiceDoc {
+  return {
+    id: document.id,
+    name: document.name,
+    contentType: document.contentType,
+    prettyName: document.prettyName,
+  };
+}
+
+export function toBffCatalogApiEserviceRiskAnalysis(
+  riskAnalysis: catalogApi.EServiceRiskAnalysis
+): bffApi.EServiceRiskAnalysis {
+  const answers: { [key: string]: string[] } = {};
+
+  riskAnalysis.riskAnalysisForm.singleAnswers
+    .concat(riskAnalysis.riskAnalysisForm.multiAnswers)
+    .map((answer) => ({
+      questionId: answer.questionId,
+      answer: answer.value,
+    }))
+    .forEach((QA) => {
+      if (answers[`${QA.questionId}`] && QA.answer) {
+        answers[`${QA.questionId}`] = [
+          ...answers[`${QA.questionId}`],
+          QA.answer,
+        ];
+      } else {
+        answers[`${QA.questionId}`] = [];
+      }
+    });
+
+  const riskAnalysisForm: bffApi.RiskAnalysisForm = {
+    riskAnalysisId: riskAnalysis.id,
+    version: riskAnalysis.riskAnalysisForm.version,
+    answers,
+  };
+
+  return {
+    id: riskAnalysis.id,
+    name: riskAnalysis.name,
+    createdAt: riskAnalysis.createdAt,
+    riskAnalysisForm,
+  };
+}
+
+export function toBffCatalogApiProducerDescriptorEService(
+  eservice: catalogApi.EService,
+  producer: tenantApi.Tenant
+): bffApi.ProducerDescriptorEService {
+  const producerMail = producer.mails.find(
+    (m) => m.kind === tenantMailKind.ContactEmail
+  );
+
+  const notDraftDecriptor: bffApi.CompactDescriptor[] =
+    eservice.descriptors.filter((d) => d.state !== descriptorApiState.DRAFT);
+
+  const draftDescriptor: bffApi.CompactDescriptor | undefined =
+    eservice.descriptors.find((d) => d.state === descriptorApiState.DRAFT);
+
+  return {
+    id: eservice.id,
+    name: eservice.name,
+    description: eservice.description,
+    technology: eservice.technology,
+    mode: eservice.mode,
+    mail: producerMail && {
+      address: producerMail.address,
+      description: producerMail.description,
+    },
+    draftDescriptor,
+    riskAnalysis: eservice.riskAnalysis.map(
+      toBffCatalogApiEserviceRiskAnalysis
+    ),
+    descriptors: notDraftDecriptor,
+  };
+}
+
+export function toEserviceAttribute(
+  attributes: catalogApi.Attribute[]
+): EServiceAttribute[] {
+  return attributes.map((attribute) => ({
+    ...attribute,
+    id: unsafeBrandId(attribute.id),
+  }));
+}
+
+export function toDescriptorWithOnlyAttributes(
+  descriptor: catalogApi.EServiceDescriptor
+): DescriptorWithOnlyAttributes {
+  return {
+    ...descriptor,
+    attributes: {
+      certified: descriptor.attributes.certified.map(toEserviceAttribute),
+      declared: descriptor.attributes.declared.map(toEserviceAttribute),
+      verified: descriptor.attributes.verified.map(toEserviceAttribute),
+    },
+  };
+}