5553345276

Committed 14 Jul 2023 10:56AM UTC coverage: 28.759% (+0.1%) from 28.655%

Build Type

Committed by

Commit Message

Merge branch 'main' into fix/align-dod-doc-translation

Pull Request Pull Request #595: fix(castor): align DID document translation logic

Run Details

81 of 81 new or added lines in 8 files covered. (100.0%)

2825 of 9823 relevant lines covered (28.76%)

0.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.0

/pollux/lib/core/src/main/scala/io/iohk/atala/pollux/core/service/CredentialServiceNotifier.scala

package io.iohk.atala.pollux.core.service

import io.circe.Json
import io.iohk.atala.castor.core.model.did.CanonicalPrismDID
import io.iohk.atala.event.notification.*
import io.iohk.atala.mercury.model.DidId
import io.iohk.atala.mercury.protocol.issuecredential.{IssueCredential, OfferCredential, RequestCredential}
import io.iohk.atala.pollux.core.model.error.CredentialServiceError
import io.iohk.atala.pollux.core.model.{DidCommID, IssueCredentialRecord, PublishedBatchData}
import io.iohk.atala.pollux.vc.jwt.{Issuer, JWT, PresentationPayload, W3cCredentialPayload}
import io.iohk.atala.prism.crypto.MerkleInclusionProof
import zio.{IO, URLayer, ZIO, ZLayer}

import java.time.Instant

class CredentialServiceNotifier(
    svc: CredentialService,
    eventNotificationService: EventNotificationService
) extends CredentialService {

  private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"

  override def createIssueCredentialRecord(
      pairwiseIssuerDID: DidId,
      pairwiseHolderDID: DidId,
      thid: DidCommID,
      maybeSchemaId: Option[_root_.java.lang.String],
      claims: Json,
      validityPeriod: Option[Double],
      automaticIssuance: Option[Boolean],
      awaitConfirmation: Option[Boolean],
      issuingDID: Option[CanonicalPrismDID]
  ): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(
      svc.createIssueCredentialRecord(
        pairwiseIssuerDID,
        pairwiseHolderDID,
        thid,
        maybeSchemaId,
        claims,
        validityPeriod,
        automaticIssuance,
        awaitConfirmation,
        issuingDID
      )
    )

  override def markOfferSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markOfferSent(recordId))

  override def receiveCredentialOffer(offer: OfferCredential): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialOffer(offer))

  override def acceptCredentialOffer(
      recordId: DidCommID,
      subjectId: String
  ): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.acceptCredentialOffer(recordId, subjectId))

  override def generateCredentialRequest(
      recordId: DidCommID,
      signedPresentation: JWT
  ): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateCredentialRequest(recordId, signedPresentation))

  override def markRequestSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markRequestSent(recordId))

  override def receiveCredentialRequest(request: RequestCredential): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialRequest(request))

  override def acceptCredentialRequest(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.acceptCredentialRequest(recordId))

  override def markCredentialGenerated(
      recordId: DidCommID,
      issueCredential: IssueCredential
  ): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markCredentialGenerated(recordId, issueCredential))

  override def markCredentialSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markCredentialSent(recordId))

  override def receiveCredentialIssue(issue: IssueCredential): IO[CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialIssue(issue))

  private[this] def notifyOnSuccess(effect: IO[CredentialServiceError, IssueCredentialRecord]) =
    for {
      record <- effect
      _ <- notify(record)
    } yield record

  private[this] def notify(record: IssueCredentialRecord) = {
    val result = for {
      producer <- eventNotificationService.producer[IssueCredentialRecord]("Issue")
      _ <- producer.send(Event(issueCredentialRecordUpdatedEvent, record))
    } yield ()
    result.catchAll(e => ZIO.logError(s"Notification service error: $e"))
  }

  override def createPresentationPayload(
      recordId: DidCommID,
      subject: Issuer
  ): IO[CredentialServiceError, PresentationPayload] =
    svc.createPresentationPayload(recordId, subject)

  override def createCredentialPayloadFromRecord(
      record: IssueCredentialRecord,
      issuer: Issuer,
      issuanceDate: Instant
  ): IO[CredentialServiceError, W3cCredentialPayload] =
    svc.createCredentialPayloadFromRecord(record, issuer, issuanceDate)

  override def publishCredentialBatch(
      credentials: Seq[W3cCredentialPayload],
      issuer: Issuer
  ): IO[CredentialServiceError, PublishedBatchData] =
    svc.publishCredentialBatch(credentials, issuer)

  override def markCredentialRecordsAsPublishQueued(
      credentialsAndProofs: Seq[(W3cCredentialPayload, MerkleInclusionProof)]
  ): IO[CredentialServiceError, Int] =
    svc.markCredentialRecordsAsPublishQueued(credentialsAndProofs)

  override def markCredentialPublicationPending(
      recordId: DidCommID
  ): IO[CredentialServiceError, IssueCredentialRecord] =
    svc.markCredentialPublicationPending(recordId)

  override def markCredentialPublicationQueued(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    svc.markCredentialPublicationQueued(recordId)

  override def markCredentialPublished(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =
    svc.markCredentialPublished(recordId)

  override def reportProcessingFailure(
      recordId: DidCommID,
      failReason: Option[_root_.java.lang.String]
  ): IO[CredentialServiceError, Unit] =
    svc.reportProcessingFailure(recordId, failReason)

  override def extractIdFromCredential(credential: W3cCredentialPayload): Option[DidCommID] =
    svc.extractIdFromCredential(credential)

  override def getIssueCredentialRecord(
      recordId: DidCommID
  ): IO[CredentialServiceError, Option[IssueCredentialRecord]] =
    svc.getIssueCredentialRecord(recordId)

  override def getIssueCredentialRecordByThreadId(
      thid: DidCommID
  ): IO[CredentialServiceError, Option[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordByThreadId(thid)

  override def getIssueCredentialRecords(
      offset: Option[Int] = None,
      limit: Option[Int] = None
  ): IO[CredentialServiceError, (Seq[IssueCredentialRecord], Int)] =
    svc.getIssueCredentialRecords(offset, limit)

  override def getIssueCredentialRecordsByStates(
      ignoreWithZeroRetries: Boolean,
      limit: Int,
      states: IssueCredentialRecord.ProtocolState*
  ): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordsByStates(ignoreWithZeroRetries, limit, states: _*)
}

object CredentialServiceNotifier {
  val layer: URLayer[CredentialService & EventNotificationService, CredentialServiceNotifier] =
    ZLayer.fromFunction(CredentialServiceNotifier(_, _))
}

1	package io.iohk.atala.pollux.core.service
2
3	import io.circe.Json
4	import io.iohk.atala.castor.core.model.did.CanonicalPrismDID
5	import io.iohk.atala.event.notification.*
6	import io.iohk.atala.mercury.model.DidId
7	import io.iohk.atala.mercury.protocol.issuecredential.{IssueCredential, OfferCredential, RequestCredential}
8	import io.iohk.atala.pollux.core.model.error.CredentialServiceError
9	import io.iohk.atala.pollux.core.model.{DidCommID, IssueCredentialRecord, PublishedBatchData}
10	import io.iohk.atala.pollux.vc.jwt.{Issuer, JWT, PresentationPayload, W3cCredentialPayload}
11	import io.iohk.atala.prism.crypto.MerkleInclusionProof
12	import zio.{IO, URLayer, ZIO, ZLayer}
13
14	import java.time.Instant
15
16	class CredentialServiceNotifier(
17	svc: CredentialService,
18	eventNotificationService: EventNotificationService
19	) extends CredentialService {
20
21	private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"
22		1✔
23	override def createIssueCredentialRecord(
24	pairwiseIssuerDID: DidId,
25	pairwiseHolderDID: DidId,
26	thid: DidCommID,
27	maybeSchemaId: Option[_root_.java.lang.String],
28	claims: Json,
29	validityPeriod: Option[Double],
30	automaticIssuance: Option[Boolean],
31	awaitConfirmation: Option[Boolean],
32	issuingDID: Option[CanonicalPrismDID]
33	): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
34	notifyOnSuccess(	1✔
35	svc.createIssueCredentialRecord(
36	pairwiseIssuerDID,
37	pairwiseHolderDID,
38	thid,
39	maybeSchemaId,
40	claims,
41	validityPeriod,
42	automaticIssuance,
43	awaitConfirmation,
44	issuingDID
45	)
46	)
47		1✔
48	override def markOfferSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
49	notifyOnSuccess(svc.markOfferSent(recordId))
50		1✔
51	override def receiveCredentialOffer(offer: OfferCredential): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
52	notifyOnSuccess(svc.receiveCredentialOffer(offer))
53		1✔
54	override def acceptCredentialOffer(
55	recordId: DidCommID,
56	subjectId: String
57	): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
58	notifyOnSuccess(svc.acceptCredentialOffer(recordId, subjectId))
59		1✔
60	override def generateCredentialRequest(
61	recordId: DidCommID,
62	signedPresentation: JWT
63	): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
64	notifyOnSuccess(svc.generateCredentialRequest(recordId, signedPresentation))
65		1✔
66	override def markRequestSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
67	notifyOnSuccess(svc.markRequestSent(recordId))
68		1✔
69	override def receiveCredentialRequest(request: RequestCredential): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
70	notifyOnSuccess(svc.receiveCredentialRequest(request))
71		1✔
72	override def acceptCredentialRequest(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
73	notifyOnSuccess(svc.acceptCredentialRequest(recordId))
74		1✔
75	override def markCredentialGenerated(
76	recordId: DidCommID,
77	issueCredential: IssueCredential
78	): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
79	notifyOnSuccess(svc.markCredentialGenerated(recordId, issueCredential))
80		1✔
81	override def markCredentialSent(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
82	notifyOnSuccess(svc.markCredentialSent(recordId))
83		1✔
84	override def receiveCredentialIssue(issue: IssueCredential): IO[CredentialServiceError, IssueCredentialRecord] =	1✔
85	notifyOnSuccess(svc.receiveCredentialIssue(issue))
86		1✔
87	private[this] def notifyOnSuccess(effect: IO[CredentialServiceError, IssueCredentialRecord]) =	1✔
88	for {
89	record <- effect	1✔
90	_ <- notify(record)
91	} yield record
92		1✔
93	private[this] def notify(record: IssueCredentialRecord) = {	1✔
94	val result = for {	×
95	producer <- eventNotificationService.producer[IssueCredentialRecord]("Issue")	1✔
96	_ <- producer.send(Event(issueCredentialRecordUpdatedEvent, record))
97	} yield ()	×
98	result.catchAll(e => ZIO.logError(s"Notification service error: $e"))
99	}
100		×
101	override def createPresentationPayload(
102	recordId: DidCommID,
103	subject: Issuer
104	): IO[CredentialServiceError, PresentationPayload] =	×
105	svc.createPresentationPayload(recordId, subject)
106		×
107	override def createCredentialPayloadFromRecord(
108	record: IssueCredentialRecord,
109	issuer: Issuer,
110	issuanceDate: Instant
111	): IO[CredentialServiceError, W3cCredentialPayload] =	×
112	svc.createCredentialPayloadFromRecord(record, issuer, issuanceDate)
113		×
114	override def publishCredentialBatch(
115	credentials: Seq[W3cCredentialPayload],
116	issuer: Issuer
117	): IO[CredentialServiceError, PublishedBatchData] =	×
118	svc.publishCredentialBatch(credentials, issuer)
119		×
120	override def markCredentialRecordsAsPublishQueued(
121	credentialsAndProofs: Seq[(W3cCredentialPayload, MerkleInclusionProof)]
122	): IO[CredentialServiceError, Int] =	×
123	svc.markCredentialRecordsAsPublishQueued(credentialsAndProofs)
124		×
125	override def markCredentialPublicationPending(
126	recordId: DidCommID
127	): IO[CredentialServiceError, IssueCredentialRecord] =	×
128	svc.markCredentialPublicationPending(recordId)
129		×
130	override def markCredentialPublicationQueued(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	×
131	svc.markCredentialPublicationQueued(recordId)
132		×
133	override def markCredentialPublished(recordId: DidCommID): IO[CredentialServiceError, IssueCredentialRecord] =	×
134	svc.markCredentialPublished(recordId)
135		×
136	override def reportProcessingFailure(
137	recordId: DidCommID,
138	failReason: Option[_root_.java.lang.String]
139	): IO[CredentialServiceError, Unit] =	×
140	svc.reportProcessingFailure(recordId, failReason)
141		×
142	override def extractIdFromCredential(credential: W3cCredentialPayload): Option[DidCommID] =	×
143	svc.extractIdFromCredential(credential)
144		×
145	override def getIssueCredentialRecord(
146	recordId: DidCommID
147	): IO[CredentialServiceError, Option[IssueCredentialRecord]] =	×
148	svc.getIssueCredentialRecord(recordId)
149		×
150	override def getIssueCredentialRecordByThreadId(
151	thid: DidCommID
152	): IO[CredentialServiceError, Option[IssueCredentialRecord]] =	×
153	svc.getIssueCredentialRecordByThreadId(thid)
154		×
155	override def getIssueCredentialRecords(	×
156	offset: Option[Int] = None,	×
157	limit: Option[Int] = None
158	): IO[CredentialServiceError, (Seq[IssueCredentialRecord], Int)] =	×
159	svc.getIssueCredentialRecords(offset, limit)
160		×
161	override def getIssueCredentialRecordsByStates(
162	ignoreWithZeroRetries: Boolean,
163	limit: Int,
164	states: IssueCredentialRecord.ProtocolState*
165	): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =	×
166	svc.getIssueCredentialRecordsByStates(ignoreWithZeroRetries, limit, states: _*)
167	}
168
169	object CredentialServiceNotifier {
170	val layer: URLayer[CredentialService & EventNotificationService, CredentialServiceNotifier] =	1✔
171	ZLayer.fromFunction(CredentialServiceNotifier(_, _))
172	}

input-output-hk / atala-prism-building-blocks / 5553345276

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous