PIN-5086 PIN-5088 Create first descriptor inside createEService and e…

…dit logic inside createDescriptor (#301)

src/main/resources/interface-specification.yml

@@ -2116,7 +2116,7 @@ paths:
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/CreatedResource'
+                $ref: '#/components/schemas/CreatedEServiceDescriptor'
         '400':
           description: Invalid input
           headers:
@@ -2398,13 +2398,6 @@ paths:
           schema:
             type: string
             format: uuid
-      requestBody:
-        description: An E-Service Descriptor seed
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/EServiceDescriptorSeed'
-        required: true
       responses:
         '200':
           description: EService Descriptor created.
@@ -10782,37 +10775,6 @@ components:
           type: string
       required:
         - description
-    EServiceDescriptorSeed:
-      required:
-        - audience
-        - voucherLifespan
-        - dailyCallsPerConsumer
-        - dailyCallsTotal
-        - agreementApprovalPolicy
-        - attributes
-      type: object
-      properties:
-        description:
-          type: string
-        audience:
-          type: array
-          items:
-            type: string
-        voucherLifespan:
-          type: integer
-          format: int32
-        dailyCallsPerConsumer:
-          description: 'maximum number of daily calls that this descriptor can afford.'
-          type: integer
-          format: int32
-        dailyCallsTotal:
-          description: 'total daily calls available for this e-service.'
-          type: integer
-          format: int32
-        agreementApprovalPolicy:
-          $ref: '#/components/schemas/AgreementApprovalPolicy'
-        attributes:
-          $ref: '#/components/schemas/DescriptorAttributesSeed'
     CatalogEServiceDescriptor:
       type: object
       required:

src/main/scala/it/pagopa/interop/backendforfrontend/api/impl/EServicesApiMarshallerImpl.scala

@@ -37,9 +37,6 @@ object EServicesApiMarshallerImpl extends EservicesApiMarshaller with SprayJsonS
   override implicit def fromEntityUnmarshallerUpdateEServiceDescriptorSeed
     : FromEntityUnmarshaller[UpdateEServiceDescriptorSeed] = sprayJsonUnmarshaller[UpdateEServiceDescriptorSeed]
 
-  override implicit def fromEntityUnmarshallerEServiceDescriptorSeed: FromEntityUnmarshaller[EServiceDescriptorSeed] =
-    sprayJsonUnmarshaller[EServiceDescriptorSeed]
-
   override implicit def fromEntityUnmarshallerUpdateEServiceDescriptorDocumentSeed
     : FromEntityUnmarshaller[UpdateEServiceDescriptorDocumentSeed] =
     sprayJsonUnmarshaller[UpdateEServiceDescriptorDocumentSeed]

src/main/scala/it/pagopa/interop/backendforfrontend/api/impl/EServicesApiServiceImpl.scala

@@ -86,15 +86,16 @@ final case class EServicesApiServiceImpl(
   override def createEService(eServiceSeed: EServiceSeed)(implicit
     contexts: Seq[(String, String)],
     toEntityMarshallerProblem: ToEntityMarshaller[Problem],
-    toEntityMarshallerCreatedResource: ToEntityMarshaller[CreatedResource]
+    toEntityMarshallerCreatedEServiceDescriptor: ToEntityMarshaller[CreatedEServiceDescriptor]
   ): Route = {
-    val result: Future[CreatedResource] =
-      catalogProcessService.createEService(eServiceSeed.toProcess)(contexts, ec).map(_.toApi)
+    val result: Future[CreatedEServiceDescriptor] = catalogProcessService
+      .createEService(eServiceSeed.toProcess)(contexts, ec)
+      .map(eservice => eservice.toApiWithDescriptorId(eservice.descriptors.head.id))
 
     onComplete(result) {
       val headers: List[HttpHeader] = headersFromContext()
-      handleError(s"Error creating eservice with seed: $eServiceSeed", headers) orElse { case Success(eservice) =>
-        createEService200(headers)(eservice)
+      handleError(s"Error creating eservice with seed: $eServiceSeed", headers) orElse { case Success(ids) =>
+        createEService200(headers)(ids)
       }
     }
   }
@@ -137,21 +138,63 @@ final case class EServicesApiServiceImpl(
     }
   }
 
-  override def createDescriptor(eServiceId: String, eServiceDescriptorSeed: EServiceDescriptorSeed)(implicit
+  override def createDescriptor(eServiceId: String)(implicit
     contexts: Seq[(String, String)],
     toEntityMarshallerProblem: ToEntityMarshaller[Problem],
     toEntityMarshallerCreatedResource: ToEntityMarshaller[CreatedResource]
   ): Route = {
+
+    def cloneDocument(
+      clonedDocumentId: UUID,
+      doc: CatalogProcess.EServiceDoc
+    ): Future[CatalogProcess.CreateEServiceDescriptorDocumentSeed] =
+      fileManager
+        .copy(ApplicationConfiguration.eServiceDocumentsContainer, ApplicationConfiguration.eServiceDocumentsPath)(
+          doc.path,
+          clonedDocumentId.toString,
+          doc.name
+        )
+        .map(clonedPath =>
+          CatalogProcess.CreateEServiceDescriptorDocumentSeed(
+            documentId = clonedDocumentId,
+            kind = CatalogProcess.EServiceDocumentKind.DOCUMENT,
+            contentType = doc.contentType,
+            prettyName = doc.prettyName,
+            fileName = doc.name,
+            filePath = clonedPath,
+            checksum = doc.checksum,
+            serverUrls = Seq()
+          )
+        )
+
     val result: Future[CreatedResource] = for {
-      eServiceUuid <- eServiceId.toFutureUUID
-      descriptor   <- catalogProcessService.createDescriptor(eServiceUuid, eServiceDescriptorSeed.toProcess)(contexts)
+      eServiceUuid       <- eServiceId.toFutureUUID
+      eService           <- catalogProcessService.getEServiceById(eServiceUuid)
+      previousDescriptor <- Either
+        .cond(
+          eService.descriptors.nonEmpty,
+          eService.descriptors.maxBy(_.version),
+          NoDescriptorInEservice(eServiceUuid)
+        )
+        .toFuture
+      clonedDocuments    <- Future.traverse(previousDescriptor.docs)(cloneDocument(UUIDSupplier.get(), _))
+      eServiceDescriptorSeed = CatalogProcess.EServiceDescriptorSeed(
+        description = previousDescriptor.description,
+        audience = Seq(),
+        voucherLifespan = previousDescriptor.voucherLifespan,
+        dailyCallsPerConsumer = previousDescriptor.dailyCallsPerConsumer,
+        dailyCallsTotal = previousDescriptor.dailyCallsTotal,
+        agreementApprovalPolicy = previousDescriptor.agreementApprovalPolicy,
+        attributes = previousDescriptor.attributes.toSeed,
+        docs = clonedDocuments
+      )
+      descriptor <- catalogProcessService.createDescriptor(eServiceUuid, eServiceDescriptorSeed)(contexts)
     } yield descriptor.toApi
 
     onComplete(result) {
       val headers: List[HttpHeader] = headersFromContext()
-      handleError(s"Error creating descriptor with seed: $eServiceDescriptorSeed", headers) orElse {
-        case Success(descriptor) =>
-          createDescriptor200(headers)(descriptor)
+      handleError(s"Error creating descriptor in EService $eServiceId", headers) orElse { case Success(descriptor) =>
+        createDescriptor200(headers)(descriptor)
       }
     }
   }
@@ -1188,14 +1231,22 @@ final case class EServicesApiServiceImpl(
         name = importedEservice.name,
         description = importedEservice.description,
         technology = importedEservice.technology.toProcess,
-        mode = importedEservice.mode.toProcess
+        mode = importedEservice.mode.toProcess,
+        descriptor = CatalogProcess.DescriptorSeedForEServiceCreation(
+          description = importedEservice.descriptor.description,
+          audience = importedEservice.descriptor.audience,
+          voucherLifespan = importedEservice.descriptor.voucherLifespan,
+          dailyCallsPerConsumer = importedEservice.descriptor.dailyCallsPerConsumer,
+          dailyCallsTotal = importedEservice.descriptor.dailyCallsTotal,
+          agreementApprovalPolicy = importedEservice.descriptor.agreementApprovalPolicy.toProcess
+        )
       )
-      eService   <- catalogProcessService.createEService(eserviceSeed).recoverWith { case ex: Throwable =>
+      eService <- catalogProcessService.createEService(eserviceSeed).recoverWith { case ex: Throwable =>
         deleteTempDirectory(folderPath)
         Future.failed(ex)
       }
-      _          <- pollEServiceById(catalogProcessService.getEServiceById(eService.id), _ => true)
-      _          <- Future.traverse(importedEservice.riskAnalysis) { ra =>
+      _        <- pollEServiceById(catalogProcessService.getEServiceById(eService.id), _.descriptors.nonEmpty)
+      _        <- Future.traverse(importedEservice.riskAnalysis) { ra =>
         catalogProcessService
           .createRiskAnalysis(
             eServiceId = eService.id,
@@ -1207,31 +1258,18 @@ final case class EServicesApiServiceImpl(
           }
           .flatMap(_ => pollEServiceById(catalogProcessService.getEServiceById(eService.id), _.riskAnalysis.nonEmpty))
       }
-      descriptorSeed = CatalogProcess.EServiceDescriptorSeed(
-        description = importedEservice.descriptor.description,
-        audience = importedEservice.descriptor.audience,
-        voucherLifespan = importedEservice.descriptor.voucherLifespan,
-        dailyCallsPerConsumer = importedEservice.descriptor.dailyCallsPerConsumer,
-        dailyCallsTotal = importedEservice.descriptor.dailyCallsTotal,
-        agreementApprovalPolicy = importedEservice.descriptor.agreementApprovalPolicy.toProcess,
-        attributes = CatalogProcess.AttributesSeed(certified = Seq.empty, declared = Seq.empty, verified = Seq.empty)
-      )
-      descriptor <- catalogProcessService.createDescriptor(eService.id, descriptorSeed).recoverWith {
-        case ex: Throwable =>
-          deleteTempDirectory(folderPath)
-          catalogProcessService.deleteEService(eService.id).flatMap(_ => Future.failed(ex))
-      }
-      _          <- pollEServiceById(catalogProcessService.getEServiceById(eService.id), _.descriptors.nonEmpty)
-      _          <- importedEservice.descriptor.interface match {
+
+      descriptor = eService.descriptors.head
+      _ <- importedEservice.descriptor.interface match {
         case Some(interface) =>
           verifyAndCreateImportedDoc(eService, descriptor, folderPath, interface, "INTERFACE")
         case None            => Future.unit
       }
-      _          <- pollEServiceById(
+      _ <- pollEServiceById(
         catalogProcessService.getEServiceById(eService.id),
         _.descriptors.exists(d => d.id == descriptor.id && d.interface.isDefined)
       )
-      _          <- importedEservice.descriptor.docs
+      _ <- importedEservice.descriptor.docs
         .traverse(doc =>
           verifyAndCreateImportedDoc(eService, descriptor, folderPath, doc, "DOCUMENT")
             .flatMap(_ =>

src/main/scala/it/pagopa/interop/backendforfrontend/api/impl/package.scala

@@ -211,9 +211,6 @@ package object impl extends SprayJsonSupport with DefaultJsonProtocol {
   implicit val problemErrorFormat: RootJsonFormat[ProblemError] = jsonFormat2(ProblemError)
   implicit val problemFormat: RootJsonFormat[Problem]           = jsonFormat6(Problem)
 
-  implicit val eServiceDescriptorSeedFormat: RootJsonFormat[EServiceDescriptorSeed] = jsonFormat7(
-    EServiceDescriptorSeed
-  )
   implicit val updateEServiceDescriptorDocumentSeedFormat: RootJsonFormat[UpdateEServiceDescriptorDocumentSeed] =
     jsonFormat1(UpdateEServiceDescriptorDocumentSeed)
 

src/main/scala/it/pagopa/interop/backendforfrontend/error/Handlers.scala

@@ -60,6 +60,7 @@ object Handlers {
     case Failure(err: EServiceRiskAnalysisNotFound)        => notFound(err, logMessage, headers)
     case Failure(err: PrivacyNoticeNotFound)               => notFound(err, logMessage, headers)
     case Failure(err: ContractNotFound)                    => notFound(err, logMessage, headers)
+    case Failure(err: NoDescriptorInEservice)              => conflict(err, logMessage, headers)
     case Failure(err)                                      => internalServerError(err, logMessage, headers)
 
   }

src/main/scala/it/pagopa/interop/backendforfrontend/service/types/CatalogProcessServiceTypes.scala

@@ -96,22 +96,18 @@ object CatalogProcessServiceTypes {
         name = es.name,
         description = es.description,
         technology = es.technology.toProcess,
-        mode = es.mode.toProcess
+        mode = es.mode.toProcess,
+        descriptor = CatalogProcess.DescriptorSeedForEServiceCreation(
+          description = None,
+          audience = Seq(),
+          voucherLifespan = 60,
+          dailyCallsPerConsumer = 1,
+          dailyCallsTotal = 1,
+          agreementApprovalPolicy = AgreementApprovalPolicy.AUTOMATIC.toProcess
+        )
       )
   }
 
-  implicit class EServiceDescriptorSeedConverter(private val seed: EServiceDescriptorSeed) extends AnyVal {
-    def toProcess: CatalogProcess.EServiceDescriptorSeed = CatalogProcess.EServiceDescriptorSeed(
-      description = seed.description,
-      audience = seed.audience,
-      voucherLifespan = seed.voucherLifespan,
-      dailyCallsPerConsumer = seed.dailyCallsPerConsumer,
-      dailyCallsTotal = seed.dailyCallsTotal,
-      agreementApprovalPolicy = seed.agreementApprovalPolicy.toProcess,
-      attributes = seed.attributes.toProcess
-    )
-  }
-
   implicit class EServiceConverter(private val coes: CatalogProcess.EService) extends AnyVal {
     def toApi: CreatedResource                                               = CreatedResource(id = coes.id)
     def toApiWithDescriptorId(descriptorId: UUID): CreatedEServiceDescriptor =
@@ -215,6 +211,9 @@ object CatalogProcessServiceTypes {
   implicit class AttributeValueWrapper(private val av: CatalogProcess.Attribute) extends AnyVal {
     def toPersistent: CatalogManagement.CatalogAttribute =
       CatalogManagement.CatalogAttribute(av.id, av.explicitAttributeVerification)
+
+    def toSeed: CatalogProcess.AttributeSeed =
+      CatalogProcess.AttributeSeed(av.id, av.explicitAttributeVerification)
   }
 
   implicit class AttributesWrapper(private val eServiceAttributes: CatalogProcess.Attributes) extends AnyVal {
@@ -225,6 +224,12 @@ object CatalogProcessServiceTypes {
       verified = eServiceAttributes.verified.map(_.map(_.toPersistent))
     )
 
+    def toSeed: CatalogProcess.AttributesSeed = CatalogProcess.AttributesSeed(
+      certified = eServiceAttributes.certified.map(_.map(_.toSeed)),
+      declared = eServiceAttributes.declared.map(_.map(_.toSeed)),
+      verified = eServiceAttributes.verified.map(_.map(_.toSeed))
+    )
+
     def toApi(attributes: Seq[AttributeProcess.Attribute]): Future[DescriptorAttributes] = {
       val attributeNames: Map[UUID, AttributeDetails] =
         attributes.map(attr => attr.id -> AttributeDetails(attr.name, attr.description)).toMap