8819221863

Committed 24 Apr 2024 03:32PM UTC coverage: 50.082% (+18.2%) from 31.912%

Build # 8819221863

Build Type

Committed by

Commit Message

minor cleanup

Signed-off-by: mineme0110 <shailesh.patil@iohk.io>

Pull Request Pull Request #973: feat: Align the repo with new name identus-cloud-agent

Run Details

1 of 6 new or added lines in 4 files covered. (16.67%)

2998 existing lines in 264 files now uncovered.

7340 of 14656 relevant lines covered (50.08%)

0.5 hits per line

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

60.71

/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 org.hyperledger.identus.event.notification.*
import org.hyperledger.identus.mercury.model.DidId
import org.hyperledger.identus.mercury.protocol.issuecredential.{IssueCredential, OfferCredential, RequestCredential}
import io.iohk.atala.pollux.core.model.error.CredentialServiceError
import io.iohk.atala.pollux.core.model.{DidCommID, IssueCredentialRecord}
import io.iohk.atala.shared.models.WalletAccessContext
import zio.{URLayer, ZIO, ZLayer, IO}

import java.util.UUID

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

  private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"

  override def createJWTIssueCredentialRecord(
      pairwiseIssuerDID: DidId,
      pairwiseHolderDID: DidId,
      thid: DidCommID,
      maybeSchemaId: Option[String],
      claims: Json,
      validityPeriod: Option[Double],
      automaticIssuance: Option[Boolean],
      issuingDID: CanonicalPrismDID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(
      svc.createJWTIssueCredentialRecord(
        pairwiseIssuerDID,
        pairwiseHolderDID,
        thid,
        maybeSchemaId,
        claims,
        validityPeriod,
        automaticIssuance,
        issuingDID
      )
    )

  override def createAnonCredsIssueCredentialRecord(
      pairwiseIssuerDID: DidId,
      pairwiseHolderDID: DidId,
      thid: DidCommID,
      credentialDefinitionGUID: UUID,
      credentialDefinitionId: _root_.java.lang.String,
      claims: Json,
      validityPeriod: Option[Double],
      automaticIssuance: Option[Boolean]
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(
      svc.createAnonCredsIssueCredentialRecord(
        pairwiseIssuerDID,
        pairwiseHolderDID,
        thid,
        credentialDefinitionGUID,
        credentialDefinitionId,
        claims,
        validityPeriod,
        automaticIssuance
      )
    )

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

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

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

  override def generateJWTCredentialRequest(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateJWTCredentialRequest(recordId))

  override def generateAnonCredsCredentialRequest(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateAnonCredsCredentialRequest(recordId))

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

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

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

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

  override def receiveCredentialIssue(
      issueCredential: IssueCredential
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialIssue(issueCredential))

  override def generateJWTCredential(
      recordId: DidCommID,
      statusListRegistryUrl: String
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateJWTCredential(recordId, statusListRegistryUrl))

  override def generateAnonCredsCredential(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateAnonCredsCredential(recordId))

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

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

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

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

  override def getIssueCredentialRecordByThreadId(
      thid: DidCommID,
      ignoreWithZeroRetries: Boolean
  ): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordByThreadId(thid, ignoreWithZeroRetries)

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

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

  override def getIssueCredentialRecordsByStatesForAllWallets(
      ignoreWithZeroRetries: Boolean,
      limit: Int,
      states: IssueCredentialRecord.ProtocolState*
  ): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordsByStatesForAllWallets(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 org.hyperledger.identus.event.notification.*
6	import org.hyperledger.identus.mercury.model.DidId
7	import org.hyperledger.identus.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}
10	import io.iohk.atala.shared.models.WalletAccessContext
11	import zio.{URLayer, ZIO, ZLayer, IO}
12
13	import java.util.UUID
14
15	class CredentialServiceNotifier(
16	svc: CredentialService,
17	eventNotificationService: EventNotificationService
18	) extends CredentialService {
19
20	private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"
21
22	override def createJWTIssueCredentialRecord(	1✔
23	pairwiseIssuerDID: DidId,
24	pairwiseHolderDID: DidId,
25	thid: DidCommID,
26	maybeSchemaId: Option[String],
27	claims: Json,
28	validityPeriod: Option[Double],
29	automaticIssuance: Option[Boolean],
30	issuingDID: CanonicalPrismDID
31	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
32	notifyOnSuccess(	1✔
33	svc.createJWTIssueCredentialRecord(	1✔
34	pairwiseIssuerDID,
35	pairwiseHolderDID,
36	thid,
37	maybeSchemaId,
38	claims,
39	validityPeriod,
40	automaticIssuance,
41	issuingDID
42	)
43	)
44
UNCOV 45	override def createAnonCredsIssueCredentialRecord(	×
46	pairwiseIssuerDID: DidId,
47	pairwiseHolderDID: DidId,
48	thid: DidCommID,
49	credentialDefinitionGUID: UUID,
50	credentialDefinitionId: _root_.java.lang.String,
51	claims: Json,
52	validityPeriod: Option[Double],
53	automaticIssuance: Option[Boolean]
54	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
55	notifyOnSuccess(	×
UNCOV 56	svc.createAnonCredsIssueCredentialRecord(	×
57	pairwiseIssuerDID,
58	pairwiseHolderDID,
59	thid,
60	credentialDefinitionGUID,
61	credentialDefinitionId,
62	claims,
63	validityPeriod,
64	automaticIssuance
65	)
66	)
67
68	override def markOfferSent(	1✔
69	recordId: DidCommID
70	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
71	notifyOnSuccess(svc.markOfferSent(recordId))	1✔
72
73	override def receiveCredentialOffer(	1✔
74	offer: OfferCredential
75	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
76	notifyOnSuccess(svc.receiveCredentialOffer(offer))	1✔
77
78	override def acceptCredentialOffer(	1✔
79	recordId: DidCommID,
80	subjectId: Option[String]
81	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
82	notifyOnSuccess(svc.acceptCredentialOffer(recordId, subjectId))	1✔
83
84	override def generateJWTCredentialRequest(	1✔
85	recordId: DidCommID
86	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
87	notifyOnSuccess(svc.generateJWTCredentialRequest(recordId))	1✔
88
UNCOV 89	override def generateAnonCredsCredentialRequest(	×
90	recordId: DidCommID
91	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
UNCOV 92	notifyOnSuccess(svc.generateAnonCredsCredentialRequest(recordId))	×
93
94	override def markRequestSent(	1✔
95	recordId: DidCommID
96	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
97	notifyOnSuccess(svc.markRequestSent(recordId))	1✔
98
99	override def receiveCredentialRequest(	1✔
100	request: RequestCredential
101	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
102	notifyOnSuccess(svc.receiveCredentialRequest(request))	1✔
103
104	override def acceptCredentialRequest(	1✔
105	recordId: DidCommID
106	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
107	notifyOnSuccess(svc.acceptCredentialRequest(recordId))	1✔
108
109	override def markCredentialSent(	1✔
110	recordId: DidCommID
111	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
112	notifyOnSuccess(svc.markCredentialSent(recordId))	1✔
113
114	override def receiveCredentialIssue(	1✔
115	issueCredential: IssueCredential
116	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
117	notifyOnSuccess(svc.receiveCredentialIssue(issueCredential))	1✔
118
119	override def generateJWTCredential(	1✔
120	recordId: DidCommID,
121	statusListRegistryUrl: String
122	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
123	notifyOnSuccess(svc.generateJWTCredential(recordId, statusListRegistryUrl))	1✔
124
UNCOV 125	override def generateAnonCredsCredential(	×
126	recordId: DidCommID
127	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
UNCOV 128	notifyOnSuccess(svc.generateAnonCredsCredential(recordId))	×
129
130	private[this] def notifyOnSuccess[R](effect: ZIO[R, CredentialServiceError, IssueCredentialRecord]) =	1✔
131	for {	1✔
132	record <- effect
133	_ <- notify(record)	1✔
134	} yield record	1✔
135
136	private[this] def notify(record: IssueCredentialRecord) = {	1✔
137	val result = for {	1✔
138	walletId <- ZIO.serviceWith[WalletAccessContext](_.walletId)	1✔
139	producer <- eventNotificationService.producer[IssueCredentialRecord]("Issue")	1✔
140	_ <- producer.send(Event(issueCredentialRecordUpdatedEvent, record, walletId))	1✔
141	} yield ()	1✔
UNCOV 142	result.catchAll(e => ZIO.logError(s"Notification service error: $e"))	×
143	}
144
UNCOV 145	override def reportProcessingFailure(	×
146	recordId: DidCommID,
147	failReason: Option[_root_.java.lang.String]
148	): ZIO[WalletAccessContext, CredentialServiceError, Unit] =
UNCOV 149	svc.reportProcessingFailure(recordId, failReason)	×
150
UNCOV 151	override def getIssueCredentialRecord(	×
152	recordId: DidCommID
153	): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =
UNCOV 154	svc.getIssueCredentialRecord(recordId)	×
155
UNCOV 156	override def getIssueCredentialRecordByThreadId(	×
157	thid: DidCommID,
158	ignoreWithZeroRetries: Boolean
159	): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =
UNCOV 160	svc.getIssueCredentialRecordByThreadId(thid, ignoreWithZeroRetries)	×
161
UNCOV 162	override def getIssueCredentialRecords(	×
163	ignoreWithZeroRetries: Boolean,
164	offset: Option[Int] = None,	×
UNCOV 165	limit: Option[Int] = None	×
166	): ZIO[WalletAccessContext, CredentialServiceError, (Seq[IssueCredentialRecord], Int)] =
UNCOV 167	svc.getIssueCredentialRecords(ignoreWithZeroRetries, offset, limit)	×
168
UNCOV 169	override def getIssueCredentialRecordsByStates(	×
170	ignoreWithZeroRetries: Boolean,
171	limit: Int,
172	states: IssueCredentialRecord.ProtocolState*
173	): ZIO[WalletAccessContext, CredentialServiceError, Seq[IssueCredentialRecord]] =
UNCOV 174	svc.getIssueCredentialRecordsByStates(ignoreWithZeroRetries, limit, states: _*)	×
175
UNCOV 176	override def getIssueCredentialRecordsByStatesForAllWallets(	×
177	ignoreWithZeroRetries: Boolean,
178	limit: Int,
179	states: IssueCredentialRecord.ProtocolState*
180	): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =
UNCOV 181	svc.getIssueCredentialRecordsByStatesForAllWallets(ignoreWithZeroRetries, limit, states: _*)	×
182	}
183
184	object CredentialServiceNotifier {
185	val layer: URLayer[CredentialService & EventNotificationService, CredentialServiceNotifier] =
186	ZLayer.fromFunction(CredentialServiceNotifier(_, _))	1✔
187	}

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

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