7276763874

Committed 20 Dec 2023 02:26PM UTC coverage: 30.721% (+0.05%) from 30.671%

Build Type

Committed by

Commit Message

feat: add configuration for gRPC usePlainText

Signed-off-by: David Poltorak <david.poltorak@iohk.io>

Pull Request Pull Request #823: feat: add configuration for gRPC usePlainText (enable TLS for gRPC)

Run Details

0 of 5 new or added lines in 1 file covered. (0.0%)

236 existing lines in 73 files now uncovered.

3986 of 12975 relevant lines covered (30.72%)

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: Authorizer[BaseEntity]
) {

  val createCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =
    createCredentialOffer
      .zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))
      .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, authorizer))
      .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, authorizer))
      .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, authorizer))
      .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, authorizer))
      .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, 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],
19	authorizer: Authorizer[BaseEntity]
20	) {
21
22	val createCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =	×
23	createCredentialOffer	×
24	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))	1✔
25	.serverLogic { wac =>	×
26	{ case (ctx: RequestContext, request: CreateIssueCredentialRecordRequest) =>	×
27	issueController	×
28	.createCredentialOffer(request)(ctx)	×
29	.provideSomeLayer(ZLayer.succeed(wac))
30	}
31	}
32
33	val getCredentialRecordsEndpoint: ZServerEndpoint[Any, Any] =	×
34	getCredentialRecords	×
35	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))	1✔
36	.serverLogic { wac =>	×
37	{ case (ctx: RequestContext, paginationInput: PaginationInput, thid: Option[String]) =>	×
38	issueController	×
39	.getCredentialRecords(paginationInput, thid)(ctx)	×
40	.provideSomeLayer(ZLayer.succeed(wac))
41	}
42	}
43
44	val getCredentialRecordEndpoint: ZServerEndpoint[Any, Any] =	×
45	getCredentialRecord	×
46	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))	1✔
47	.serverLogic { wac =>	×
48	{ case (ctx: RequestContext, recordId: String) =>	×
49	issueController	×
50	.getCredentialRecord(recordId)(ctx)	×
51	.provideSomeLayer(ZLayer.succeed(wac))
52	}
53	}
54
55	val acceptCredentialOfferEndpoint: ZServerEndpoint[Any, Any] =	×
56	acceptCredentialOffer	×
57	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))	1✔
58	.serverLogic { wac =>	1✔
59	{ case (ctx: RequestContext, recordId: String, request: AcceptCredentialOfferRequest) =>	1✔
60	issueController	×
UNCOV 61	.acceptCredentialOffer(recordId, request)(ctx)	×
62	.provideSomeLayer(ZLayer.succeed(wac))
63	}
64	}
65
66	val issueCredentialEndpoint: ZServerEndpoint[Any, Any] =	×
67	issueCredential	×
68	.zServerSecurityLogic(SecurityLogic.authorizeWith(_)(authenticator, authorizer))	1✔
69	.serverLogic { wac =>	×
70	{ case (ctx: RequestContext, recordId: String) =>	×
71	issueController	×
72	.issueCredential(recordId)(ctx)	×
73	.provideSomeLayer(ZLayer.succeed(wac))
74	}
75	}
UNCOV 76		×
77	val all: List[ZServerEndpoint[Any, Any]] = List(
78	createCredentialOfferEndpoint,
79	getCredentialRecordsEndpoint,
80	getCredentialRecordEndpoint,
81	acceptCredentialOfferEndpoint,
82	issueCredentialEndpoint
83	)
84
85	}
86
87	object IssueServerEndpoints {	×
88	def all: URIO[IssueController & DefaultAuthenticator, List[ZServerEndpoint[Any, Any]]] = {	×
89	for {	×
90	authenticator <- ZIO.service[DefaultAuthenticator]	×
91	issueController <- ZIO.service[IssueController]	×
92	issueEndpoints = new IssueServerEndpoints(issueController, authenticator, authenticator)
93	} yield issueEndpoints.all
94	}
95	}

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

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