6657200245

Committed 26 Oct 2023 04:43PM UTC coverage: 30.996% (+0.06%) from 30.937%

Build # 6657200245

Build Type

Committed by

Commit Message

chore: remove unused iris module

Signed-off-by: Anton Baliasnikov <anton.baliasnikov@iohk.io>

Pull Request Pull Request #769: chore: remove unused iris module

Run Details

3943 of 12721 relevant lines covered (31.0%)

0.31 hits per line

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

17.07

/prism-agent/service/server/src/main/scala/io/iohk/atala/issue/controller/IssueServerEndpoints.scala

package io.iohk.atala.issue.controller

import io.iohk.atala.agent.walletapi.model.BaseEntity
import io.iohk.atala.api.http.RequestContext
import io.iohk.atala.api.http.model.PaginationInput
import io.iohk.atala.iam.authentication.Authenticator
import io.iohk.atala.iam.authentication.Authorizer
import io.iohk.atala.iam.authentication.DefaultAuthenticator
import io.iohk.atala.iam.authentication.SecurityLogic
import io.iohk.atala.issue.controller.IssueEndpoints.*
import io.iohk.atala.issue.controller.http.{AcceptCredentialOfferRequest, CreateIssueCredentialRecordRequest}
import io.iohk.atala.shared.models.WalletAccessContext
import sttp.tapir.ztapir.*
import zio.*

class IssueServerEndpoints(
    issueController: IssueController,
    authenticator: Authenticator[BaseEntity] & Authorizer[BaseEntity]
) {

  val createCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =
    createCredentialOffer
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))
      .serverLogic { wac =>
        { case (ctx: RequestContext, request: CreateIssueCredentialRecordRequest) =>
          issueController
            .createCredentialOffer(request)(ctx)
            .provideSomeLayer(ZLayer.succeed(wac))
        }
      }

  val getCredentialRecordsEndpoint: ZServerEndpoint[Any, Any] =
    getCredentialRecords
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))
      .serverLogic { wac =>
        { case (ctx: RequestContext, paginationInput: PaginationInput, thid: Option[String]) =>
          issueController
            .getCredentialRecords(paginationInput, thid)(ctx)
            .provideSomeLayer(ZLayer.succeed(wac))
        }
      }

  val getCredentialRecordEndpoint: ZServerEndpoint[Any, Any] =
    getCredentialRecord
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))
      .serverLogic { wac =>
        { case (ctx: RequestContext, recordId: String) =>
          issueController
            .getCredentialRecord(recordId)(ctx)
            .provideSomeLayer(ZLayer.succeed(wac))
        }
      }

  val acceptCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =
    acceptCredentialOffer
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))
      .serverLogic { wac =>
        { case (ctx: RequestContext, recordId: String, request: AcceptCredentialOfferRequest) =>
          issueController
            .acceptCredentialOffer(recordId, request)(ctx)
            .provideSomeLayer(ZLayer.succeed(wac))
        }
      }

  val issueCredentialEndpoint: ZServerEndpoint[Any, Any] =
    issueCredential
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))
      .serverLogic { wac =>
        { case (ctx: RequestContext, recordId: String) =>
          issueController
            .issueCredential(recordId)(ctx)
            .provideSomeLayer(ZLayer.succeed(wac))
        }
      }

  val all: List[ZServerEndpoint[Any, Any]] = List(
    createCredentialOfferEndpoint,
    getCredentialRecordsEndpoint,
    getCredentialRecordEndpoint,
    acceptCredentialOfferEndpoint,
    issueCredentialEndpoint
  )

}

object IssueServerEndpoints {
  def all: URIO[IssueController & DefaultAuthenticator, List[ZServerEndpoint[Any, Any]]] = {
    for {
      authenticator <- ZIO.service[DefaultAuthenticator]
      issueController <- ZIO.service[IssueController]
      issueEndpoints = new IssueServerEndpoints(issueController, authenticator)
    } yield issueEndpoints.all
  }
}

1	package io.iohk.atala.issue.controller
2
3	import io.iohk.atala.agent.walletapi.model.BaseEntity
4	import io.iohk.atala.api.http.RequestContext
5	import io.iohk.atala.api.http.model.PaginationInput
6	import io.iohk.atala.iam.authentication.Authenticator
7	import io.iohk.atala.iam.authentication.Authorizer
8	import io.iohk.atala.iam.authentication.DefaultAuthenticator
9	import io.iohk.atala.iam.authentication.SecurityLogic
10	import io.iohk.atala.issue.controller.IssueEndpoints.*
11	import io.iohk.atala.issue.controller.http.{AcceptCredentialOfferRequest, CreateIssueCredentialRecordRequest}
12	import io.iohk.atala.shared.models.WalletAccessContext
13	import sttp.tapir.ztapir.*
14	import zio.*
15
16	class IssueServerEndpoints(
17	issueController: IssueController,
18	authenticator: Authenticator[BaseEntity] & Authorizer[BaseEntity]
19	) {
20
21	val createCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =	×
22	createCredentialOffer	×
23	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))	1✔
24	.serverLogic { wac =>	×
25	{ case (ctx: RequestContext, request: CreateIssueCredentialRecordRequest) =>	×
26	issueController	×
27	.createCredentialOffer(request)(ctx)	×
28	.provideSomeLayer(ZLayer.succeed(wac))
29	}
30	}
31
32	val getCredentialRecordsEndpoint: ZServerEndpoint[Any, Any] =	×
33	getCredentialRecords	×
34	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))	1✔
35	.serverLogic { wac =>	×
36	{ case (ctx: RequestContext, paginationInput: PaginationInput, thid: Option[String]) =>	×
37	issueController	×
38	.getCredentialRecords(paginationInput, thid)(ctx)	×
39	.provideSomeLayer(ZLayer.succeed(wac))
40	}
41	}
42
43	val getCredentialRecordEndpoint: ZServerEndpoint[Any, Any] =	×
44	getCredentialRecord	×
45	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))	1✔
46	.serverLogic { wac =>	×
47	{ case (ctx: RequestContext, recordId: String) =>	×
48	issueController	×
49	.getCredentialRecord(recordId)(ctx)	×
50	.provideSomeLayer(ZLayer.succeed(wac))
51	}
52	}
53
54	val acceptCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =	×
55	acceptCredentialOffer	×
56	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))	1✔
57	.serverLogic { wac =>	1✔
58	{ case (ctx: RequestContext, recordId: String, request: AcceptCredentialOfferRequest) =>	1✔
59	issueController	×
60	.acceptCredentialOffer(recordId, request)(ctx)	×
61	.provideSomeLayer(ZLayer.succeed(wac))
62	}
63	}
64
65	val issueCredentialEndpoint: ZServerEndpoint[Any, Any] =	×
66	issueCredential	×
67	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator))	1✔
68	.serverLogic { wac =>	×
69	{ case (ctx: RequestContext, recordId: String) =>	×
70	issueController	×
71	.issueCredential(recordId)(ctx)	×
72	.provideSomeLayer(ZLayer.succeed(wac))
73	}
74	}
75		×
76	val all: List[ZServerEndpoint[Any, Any]] = List(
77	createCredentialOfferEndpoint,
78	getCredentialRecordsEndpoint,
79	getCredentialRecordEndpoint,
80	acceptCredentialOfferEndpoint,
81	issueCredentialEndpoint
82	)
83
84	}
85
86	object IssueServerEndpoints {	×
87	def all: URIO[IssueController & DefaultAuthenticator, List[ZServerEndpoint[Any, Any]]] = {	×
88	for {	×
89	authenticator <- ZIO.service[DefaultAuthenticator]	×
90	issueController <- ZIO.service[IssueController]	×
91	issueEndpoints = new IssueServerEndpoints(issueController, authenticator)
92	} yield issueEndpoints.all
93	}
94	}

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

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