10793991050

Committed 10 Sep 2024 01:56PM CUT coverage: 48.504% (-4.5%) from 52.962%

Build Type

push

Committed by

Commit Message

build: sbt and plugins dependency update (#1337)

Signed-off-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Signed-off-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>
Co-authored-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Co-authored-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>

Run Details

7406 of 15269 relevant lines covered (48.5%)

0.49 hits per line

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

36.75

/cloud-agent/service/server/src/main/scala/org/hyperledger/identus/agent/server/CloudAgentApp.scala

package org.hyperledger.identus.agent.server

import org.hyperledger.identus.agent.notification.WebhookPublisher
import org.hyperledger.identus.agent.server.config.AppConfig
import org.hyperledger.identus.agent.server.http.{ZHttp4sBlazeServer, ZHttpEndpoints}
import org.hyperledger.identus.agent.server.jobs.*
import org.hyperledger.identus.agent.walletapi.model.{Entity, Wallet, WalletSeed}
import org.hyperledger.identus.agent.walletapi.service.{EntityService, ManagedDIDService, WalletManagementService}
import org.hyperledger.identus.agent.walletapi.storage.DIDNonSecretStorage
import org.hyperledger.identus.castor.controller.{DIDRegistrarServerEndpoints, DIDServerEndpoints}
import org.hyperledger.identus.castor.core.service.DIDService
import org.hyperledger.identus.connect.controller.ConnectionServerEndpoints
import org.hyperledger.identus.connect.core.service.ConnectionService
import org.hyperledger.identus.credentialstatus.controller.CredentialStatusServiceEndpoints
import org.hyperledger.identus.event.controller.EventServerEndpoints
import org.hyperledger.identus.event.notification.EventNotificationConfig
import org.hyperledger.identus.iam.authentication.apikey.ApiKeyAuthenticator
import org.hyperledger.identus.iam.entity.http.EntityServerEndpoints
import org.hyperledger.identus.iam.wallet.http.WalletManagementServerEndpoints
import org.hyperledger.identus.issue.controller.IssueServerEndpoints
import org.hyperledger.identus.mercury.{DidOps, HttpClient}
import org.hyperledger.identus.oid4vci.CredentialIssuerServerEndpoints
import org.hyperledger.identus.pollux.core.service.{CredentialService, PresentationService}
import org.hyperledger.identus.pollux.credentialdefinition.CredentialDefinitionRegistryServerEndpoints
import org.hyperledger.identus.pollux.credentialschema.{
  SchemaRegistryServerEndpoints,
  VerificationPolicyServerEndpoints
}
import org.hyperledger.identus.pollux.vc.jwt.DidResolver as JwtDidResolver
import org.hyperledger.identus.presentproof.controller.PresentProofServerEndpoints
import org.hyperledger.identus.resolvers.DIDResolver
import org.hyperledger.identus.shared.models.{HexString, WalletAccessContext, WalletAdministrationContext, WalletId}
import org.hyperledger.identus.shared.utils.DurationOps.toMetricsSeconds
import org.hyperledger.identus.system.controller.SystemServerEndpoints
import org.hyperledger.identus.verification.controller.VcVerificationServerEndpoints
import zio.*
import zio.metrics.*

object CloudAgentApp {

  def run = for {
    _ <- AgentInitialization.run
    _ <- issueCredentialDidCommExchangesJob.debug.fork
    _ <- presentProofExchangeJob.debug.fork
    _ <- connectDidCommExchangesJob.debug.fork
    _ <- syncDIDPublicationStateFromDltJob.debug.fork
    _ <- syncRevocationStatusListsJob.debug.fork
    _ <- AgentHttpServer.run.tapDefect(e => ZIO.logErrorCause("Agent HTTP Server failure", e)).fork
    fiber <- DidCommHttpServer.run.tapDefect(e => ZIO.logErrorCause("DIDComm HTTP Server failure", e)).fork
    _ <- WebhookPublisher.layer.build.map(_.get[WebhookPublisher]).flatMap(_.run.debug.fork)
    _ <- fiber.join *> ZIO.log(s"Server End")
    _ <- ZIO.never
  } yield ()

  private val issueCredentialDidCommExchangesJob: RIO[
    AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & CredentialService & DIDNonSecretStorage &
      DIDService & ManagedDIDService & PresentationService & WalletManagementService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (IssueBackgroundJobs.issueCredentialDidCommExchanges @@ Metric
        .gauge("issuance_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.issueBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val presentProofExchangeJob: RIO[
    AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & PresentationService & CredentialService &
      DIDNonSecretStorage & DIDService & ManagedDIDService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (PresentBackgroundJobs.presentProofExchanges @@ Metric
        .gauge("present_proof_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.presentationBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val connectDidCommExchangesJob: RIO[
    AppConfig & DidOps & DIDResolver & HttpClient & ConnectionService & ManagedDIDService & DIDNonSecretStorage &
      WalletManagementService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (ConnectBackgroundJobs.didCommExchanges @@ Metric
        .gauge("connection_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.connect.connectBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val syncRevocationStatusListsJob = {
    for {
      config <- ZIO.service[AppConfig]
      _ <- (StatusListJobs.syncRevocationStatuses @@ Metric
        .gauge("revocation_status_list_sync_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.syncRevocationStatusesBgJobRecurrenceDelay))
    } yield ()
  }

  private val syncDIDPublicationStateFromDltJob: URIO[ManagedDIDService & WalletManagementService, Unit] =
    ZIO
      .serviceWithZIO[WalletManagementService](_.listWallets().map(_._1))
      .flatMap { wallets =>
        ZIO.foreach(wallets) { wallet =>
          DIDStateSyncBackgroundJobs.syncDIDPublicationStateFromDlt
            .provideSomeLayer(ZLayer.succeed(WalletAccessContext(wallet.id)))
        }
      }
      .catchAll(e => ZIO.logError(s"error while syncing DID publication state: $e"))
      .repeat(Schedule.spaced(10.seconds))
      .unit
      .provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))

}

object AgentHttpServer {
  val agentRESTServiceEndpoints = for {
    allCredentialDefinitionRegistryEndpoints <- CredentialDefinitionRegistryServerEndpoints.all
    allSchemaRegistryEndpoints <- SchemaRegistryServerEndpoints.all
    allVerificationPolicyEndpoints <- VerificationPolicyServerEndpoints.all
    allConnectionEndpoints <- ConnectionServerEndpoints.all
    allIssueEndpoints <- IssueServerEndpoints.all
    allStatusListEndpoints <- CredentialStatusServiceEndpoints.all
    allDIDEndpoints <- DIDServerEndpoints.all
    allDIDRegistrarEndpoints <- DIDRegistrarServerEndpoints.all
    allPresentProofEndpoints <- PresentProofServerEndpoints.all
    allVcVerificationEndpoints <- VcVerificationServerEndpoints.all
    allSystemEndpoints <- SystemServerEndpoints.all
    allEntityEndpoints <- EntityServerEndpoints.all
    allWalletManagementEndpoints <- WalletManagementServerEndpoints.all
    allEventEndpoints <- EventServerEndpoints.all
    allOIDCEndpoints <- CredentialIssuerServerEndpoints.all
  } yield allCredentialDefinitionRegistryEndpoints ++
    allSchemaRegistryEndpoints ++
    allVerificationPolicyEndpoints ++
    allConnectionEndpoints ++
    allDIDEndpoints ++
    allDIDRegistrarEndpoints ++
    allIssueEndpoints ++
    allStatusListEndpoints ++
    allPresentProofEndpoints ++
    allVcVerificationEndpoints ++
    allSystemEndpoints ++
    allEntityEndpoints ++
    allWalletManagementEndpoints ++
    allEventEndpoints ++
    allOIDCEndpoints
  def run =
    for {
      allEndpoints <- agentRESTServiceEndpoints
      allEndpointsWithDocumentation = ZHttpEndpoints.withDocumentations[Task](allEndpoints)
      server <- ZHttp4sBlazeServer.make("rest_api")
      appConfig <- ZIO.service[AppConfig]
      _ <- server.start(allEndpointsWithDocumentation, port = appConfig.agent.httpEndpoint.http.port).debug
    } yield ()
}

object AgentInitialization {

  private val defaultWalletId = WalletId.default
  private val defaultWallet = Wallet("default", defaultWalletId)
  private val defaultEntity = Entity.Default

  def run: RIO[AppConfig & WalletManagementService & EntityService & ApiKeyAuthenticator, Unit] =
    for {
      _ <- validateAppConfig
      _ <- initializeDefaultWallet
        .provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))
    } yield ()

  private val validateAppConfig =
    ZIO.serviceWithZIO[AppConfig](conf =>
      ZIO
        .fromEither(conf.validate)
        .mapError(msg => RuntimeException(s"Application configuration is invalid. $msg"))
    )

  private val initializeDefaultWallet =
    for {
      _ <- ZIO.logInfo("Initializing default wallet.")
      config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)
      walletService <- ZIO.service[WalletManagementService]
      isDefaultWalletEnabled = config.enabled
      isDefaultWalletExist <- walletService
        .findWallet(defaultWalletId)
        .map(_.isDefined)
      _ <- ZIO.logInfo(s"Default wallet not enabled.").when(!isDefaultWalletEnabled)
      _ <- ZIO.logInfo(s"Default wallet already exist.").when(isDefaultWalletExist)
      _ <- createDefaultWallet.when(isDefaultWalletEnabled && !isDefaultWalletExist)
    } yield ()

  private val createDefaultWallet =
    for {
      walletService <- ZIO.service[WalletManagementService]
      entityService <- ZIO.service[EntityService]
      apiKeyAuth <- ZIO.service[ApiKeyAuthenticator]
      config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)
      seed <- config.seed.fold(ZIO.none) { seedHex =>
        ZIO
          .fromTry(HexString.fromString(seedHex))
          .map(bytes => WalletSeed.fromByteArray(bytes.toByteArray).left.map(Exception(_)))
          .absolve
          .asSome
      }
      _ <- ZIO.logInfo(s"Default wallet seed is not provided. New seed will be generated.").when(seed.isEmpty)
      _ <- walletService
        .createWallet(defaultWallet, seed)
        .orDieAsUnmanagedFailure
      _ <- entityService.create(defaultEntity).orDieAsUnmanagedFailure
      _ <- apiKeyAuth.add(defaultEntity.id, config.authApiKey)
      _ <- config.webhookUrl.fold(ZIO.unit) { url =>
        val customHeaders = config.webhookApiKey.fold(Map.empty)(apiKey => Map("Authorization" -> s"Bearer $apiKey"))
        walletService
          .createWalletNotification(EventNotificationConfig(defaultWalletId, url, customHeaders))
          .orDieAsUnmanagedFailure
          .provide(ZLayer.succeed(WalletAccessContext(defaultWalletId)))
      }
    } yield ()

}

1	package org.hyperledger.identus.agent.server
2
3	import org.hyperledger.identus.agent.notification.WebhookPublisher
4	import org.hyperledger.identus.agent.server.config.AppConfig
5	import org.hyperledger.identus.agent.server.http.{ZHttp4sBlazeServer, ZHttpEndpoints}
6	import org.hyperledger.identus.agent.server.jobs.*
7	import org.hyperledger.identus.agent.walletapi.model.{Entity, Wallet, WalletSeed}
8	import org.hyperledger.identus.agent.walletapi.service.{EntityService, ManagedDIDService, WalletManagementService}
9	import org.hyperledger.identus.agent.walletapi.storage.DIDNonSecretStorage
10	import org.hyperledger.identus.castor.controller.{DIDRegistrarServerEndpoints, DIDServerEndpoints}
11	import org.hyperledger.identus.castor.core.service.DIDService
12	import org.hyperledger.identus.connect.controller.ConnectionServerEndpoints
13	import org.hyperledger.identus.connect.core.service.ConnectionService
14	import org.hyperledger.identus.credentialstatus.controller.CredentialStatusServiceEndpoints
15	import org.hyperledger.identus.event.controller.EventServerEndpoints
16	import org.hyperledger.identus.event.notification.EventNotificationConfig
17	import org.hyperledger.identus.iam.authentication.apikey.ApiKeyAuthenticator
18	import org.hyperledger.identus.iam.entity.http.EntityServerEndpoints
19	import org.hyperledger.identus.iam.wallet.http.WalletManagementServerEndpoints
20	import org.hyperledger.identus.issue.controller.IssueServerEndpoints
21	import org.hyperledger.identus.mercury.{DidOps, HttpClient}
22	import org.hyperledger.identus.oid4vci.CredentialIssuerServerEndpoints
23	import org.hyperledger.identus.pollux.core.service.{CredentialService, PresentationService}
24	import org.hyperledger.identus.pollux.credentialdefinition.CredentialDefinitionRegistryServerEndpoints
25	import org.hyperledger.identus.pollux.credentialschema.{
26	SchemaRegistryServerEndpoints,
27	VerificationPolicyServerEndpoints
28	}
29	import org.hyperledger.identus.pollux.vc.jwt.DidResolver as JwtDidResolver
30	import org.hyperledger.identus.presentproof.controller.PresentProofServerEndpoints
31	import org.hyperledger.identus.resolvers.DIDResolver
32	import org.hyperledger.identus.shared.models.{HexString, WalletAccessContext, WalletAdministrationContext, WalletId}
33	import org.hyperledger.identus.shared.utils.DurationOps.toMetricsSeconds
34	import org.hyperledger.identus.system.controller.SystemServerEndpoints
35	import org.hyperledger.identus.verification.controller.VcVerificationServerEndpoints
36	import zio.*
37	import zio.metrics.*
38
39	object CloudAgentApp {
40
41	def run = for {	×
42	_ <- AgentInitialization.run	×
43	_ <- issueCredentialDidCommExchangesJob.debug.fork	×
44	_ <- presentProofExchangeJob.debug.fork	×
45	_ <- connectDidCommExchangesJob.debug.fork	×
46	_ <- syncDIDPublicationStateFromDltJob.debug.fork	×
47	_ <- syncRevocationStatusListsJob.debug.fork	×
48	_ <- AgentHttpServer.run.tapDefect(e => ZIO.logErrorCause("Agent HTTP Server failure", e)).fork	×
49	fiber <- DidCommHttpServer.run.tapDefect(e => ZIO.logErrorCause("DIDComm HTTP Server failure", e)).fork	×
50	_ <- WebhookPublisher.layer.build.map(_.get[WebhookPublisher]).flatMap(_.run.debug.fork)	×
51	_ <- fiber.join *> ZIO.log(s"Server End")	×
52	_ <- ZIO.never	×
53	} yield ()	×
54
55	private val issueCredentialDidCommExchangesJob: RIO[
56	AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & CredentialService & DIDNonSecretStorage &
57	DIDService & ManagedDIDService & PresentationService & WalletManagementService,
58	Unit
59	] =
60	for {	×
61	config <- ZIO.service[AppConfig]	×
62	_ <- (IssueBackgroundJobs.issueCredentialDidCommExchanges @@ Metric	×
63	.gauge("issuance_flow_did_com_exchange_job_ms_gauge")	×
64	.trackDurationWith(_.toMetricsSeconds))	×
65	.repeat(Schedule.spaced(config.pollux.issueBgJobRecurrenceDelay))	×
66	.unit
67	} yield ()	×
68
69	private val presentProofExchangeJob: RIO[
70	AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & PresentationService & CredentialService &
71	DIDNonSecretStorage & DIDService & ManagedDIDService,
72	Unit
73	] =
74	for {	×
75	config <- ZIO.service[AppConfig]	×
76	_ <- (PresentBackgroundJobs.presentProofExchanges @@ Metric	×
77	.gauge("present_proof_flow_did_com_exchange_job_ms_gauge")	×
78	.trackDurationWith(_.toMetricsSeconds))	×
79	.repeat(Schedule.spaced(config.pollux.presentationBgJobRecurrenceDelay))	×
80	.unit
81	} yield ()	×
82
83	private val connectDidCommExchangesJob: RIO[
84	AppConfig & DidOps & DIDResolver & HttpClient & ConnectionService & ManagedDIDService & DIDNonSecretStorage &
85	WalletManagementService,
86	Unit
87	] =
88	for {	×
89	config <- ZIO.service[AppConfig]	×
90	_ <- (ConnectBackgroundJobs.didCommExchanges @@ Metric	×
91	.gauge("connection_flow_did_com_exchange_job_ms_gauge")	×
92	.trackDurationWith(_.toMetricsSeconds))	×
93	.repeat(Schedule.spaced(config.connect.connectBgJobRecurrenceDelay))	×
94	.unit
95	} yield ()	×
96
97	private val syncRevocationStatusListsJob = {
98	for {	×
99	config <- ZIO.service[AppConfig]	×
100	_ <- (StatusListJobs.syncRevocationStatuses @@ Metric	×
101	.gauge("revocation_status_list_sync_job_ms_gauge")	×
102	.trackDurationWith(_.toMetricsSeconds))	×
103	.repeat(Schedule.spaced(config.pollux.syncRevocationStatusesBgJobRecurrenceDelay))	×
104	} yield ()	×
105	}
106
107	private val syncDIDPublicationStateFromDltJob: URIO[ManagedDIDService & WalletManagementService, Unit] =
108	ZIO	×
109	.serviceWithZIO[WalletManagementService](_.listWallets().map(_._1))	×
110	.flatMap { wallets =>
111	ZIO.foreach(wallets) { wallet =>	×
112	DIDStateSyncBackgroundJobs.syncDIDPublicationStateFromDlt	×
113	.provideSomeLayer(ZLayer.succeed(WalletAccessContext(wallet.id)))	×
114	}
115	}
116	.catchAll(e => ZIO.logError(s"error while syncing DID publication state: $e"))	×
117	.repeat(Schedule.spaced(10.seconds))	×
118	.unit
119	.provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))	×
120
121	}
122
123	object AgentHttpServer {
124	val agentRESTServiceEndpoints = for {	×
125	allCredentialDefinitionRegistryEndpoints <- CredentialDefinitionRegistryServerEndpoints.all	×
126	allSchemaRegistryEndpoints <- SchemaRegistryServerEndpoints.all	×
127	allVerificationPolicyEndpoints <- VerificationPolicyServerEndpoints.all	×
128	allConnectionEndpoints <- ConnectionServerEndpoints.all	×
129	allIssueEndpoints <- IssueServerEndpoints.all	×
130	allStatusListEndpoints <- CredentialStatusServiceEndpoints.all	×
131	allDIDEndpoints <- DIDServerEndpoints.all	×
132	allDIDRegistrarEndpoints <- DIDRegistrarServerEndpoints.all	×
133	allPresentProofEndpoints <- PresentProofServerEndpoints.all	×
134	allVcVerificationEndpoints <- VcVerificationServerEndpoints.all	×
135	allSystemEndpoints <- SystemServerEndpoints.all	×
136	allEntityEndpoints <- EntityServerEndpoints.all	×
137	allWalletManagementEndpoints <- WalletManagementServerEndpoints.all	×
138	allEventEndpoints <- EventServerEndpoints.all	×
139	allOIDCEndpoints <- CredentialIssuerServerEndpoints.all	×
140	} yield allCredentialDefinitionRegistryEndpoints ++	×
141	allSchemaRegistryEndpoints ++
142	allVerificationPolicyEndpoints ++
143	allConnectionEndpoints ++
144	allDIDEndpoints ++
145	allDIDRegistrarEndpoints ++
146	allIssueEndpoints ++
147	allStatusListEndpoints ++
148	allPresentProofEndpoints ++
149	allVcVerificationEndpoints ++
150	allSystemEndpoints ++
151	allEntityEndpoints ++
152	allWalletManagementEndpoints ++
153	allEventEndpoints ++
154	allOIDCEndpoints
155	def run =	×
156	for {	×
157	allEndpoints <- agentRESTServiceEndpoints	×
158	allEndpointsWithDocumentation = ZHttpEndpoints.withDocumentations[Task](allEndpoints)	×
159	server <- ZHttp4sBlazeServer.make("rest_api")	×
160	appConfig <- ZIO.service[AppConfig]	×
161	_ <- server.start(allEndpointsWithDocumentation, port = appConfig.agent.httpEndpoint.http.port).debug	×
162	} yield ()	×
163	}
164
165	object AgentInitialization {
166
167	private val defaultWalletId = WalletId.default	1✔
168	private val defaultWallet = Wallet("default", defaultWalletId)	1✔
169	private val defaultEntity = Entity.Default
170
171	def run: RIO[AppConfig & WalletManagementService & EntityService & ApiKeyAuthenticator, Unit] =	1✔
172	for {	1✔
173	_ <- validateAppConfig
174	_ <- initializeDefaultWallet	1✔
175	.provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))	1✔
176	} yield ()	1✔
177
178	private val validateAppConfig =
179	ZIO.serviceWithZIO[AppConfig](conf =>	1✔
180	ZIO	1✔
181	.fromEither(conf.validate)	1✔
182	.mapError(msg => RuntimeException(s"Application configuration is invalid. $msg"))	1✔
183	)
184
185	private val initializeDefaultWallet =
186	for {	1✔
187	_ <- ZIO.logInfo("Initializing default wallet.")	1✔
188	config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)	1✔
189	walletService <- ZIO.service[WalletManagementService]	1✔
190	isDefaultWalletEnabled = config.enabled
191	isDefaultWalletExist <- walletService	1✔
192	.findWallet(defaultWalletId)	1✔
193	.map(_.isDefined)	1✔
194	_ <- ZIO.logInfo(s"Default wallet not enabled.").when(!isDefaultWalletEnabled)	1✔
195	_ <- ZIO.logInfo(s"Default wallet already exist.").when(isDefaultWalletExist)	1✔
196	_ <- createDefaultWallet.when(isDefaultWalletEnabled && !isDefaultWalletExist)	1✔
197	} yield ()	1✔
198
199	private val createDefaultWallet =
200	for {	1✔
201	walletService <- ZIO.service[WalletManagementService]	1✔
202	entityService <- ZIO.service[EntityService]	1✔
203	apiKeyAuth <- ZIO.service[ApiKeyAuthenticator]	1✔
204	config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)	1✔
205	seed <- config.seed.fold(ZIO.none) { seedHex =>	1✔
206	ZIO	1✔
207	.fromTry(HexString.fromString(seedHex))	1✔
208	.map(bytes => WalletSeed.fromByteArray(bytes.toByteArray).left.map(Exception(_)))	1✔
209	.absolve
210	.asSome
211	}
212	_ <- ZIO.logInfo(s"Default wallet seed is not provided. New seed will be generated.").when(seed.isEmpty)	1✔
213	_ <- walletService	1✔
214	.createWallet(defaultWallet, seed)	1✔
215	.orDieAsUnmanagedFailure	1✔
216	_ <- entityService.create(defaultEntity).orDieAsUnmanagedFailure	1✔
217	_ <- apiKeyAuth.add(defaultEntity.id, config.authApiKey)	1✔
218	_ <- config.webhookUrl.fold(ZIO.unit) { url =>	1✔
219	val customHeaders = config.webhookApiKey.fold(Map.empty)(apiKey => Map("Authorization" -> s"Bearer $apiKey"))	1✔
220	walletService
221	.createWalletNotification(EventNotificationConfig(defaultWalletId, url, customHeaders))	1✔
222	.orDieAsUnmanagedFailure	1✔
223	.provide(ZLayer.succeed(WalletAccessContext(defaultWalletId)))	1✔
224	}
225	} yield ()	1✔
226
227	}

hyperledger / identus-cloud-agent / 10793991050

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