7753152857

Committed 02 Feb 2024 08:12AM UTC coverage: 31.346% (+0.05%) from 31.294%

Build Type

Committed by

Commit Message

docs(prism-agent): run scalafmtAll

Signed-off-by: Benjamin Voiturier <benjamin.voiturier@iohk.io>

Pull Request Pull Request #854: docs(prism-agent): improve Connect OAS documentation

Run Details

0 of 10 new or added lines in 2 files covered. (0.0%)

334 existing lines in 72 files now uncovered.

4016 of 12812 relevant lines covered (31.35%)

0.31 hits per line

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

28.26

/pollux/lib/sql-doobie/src/main/scala/io/iohk/atala/pollux/sql/model/db/VerificationPolicy.scala

package io.iohk.atala.pollux.sql.model.db

import io.getquill.*
import io.getquill.doobie.DoobieContext
import io.iohk.atala.shared.models.WalletId
import java.util.UUID

import java.time.OffsetDateTime

case class VerificationPolicy(
    id: UUID,
    nonce: Int,
    name: String,
    description: String,
    createdAt: OffsetDateTime,
    updatedAt: OffsetDateTime,
    walletId: WalletId
)

case class VerificationPolicyConstraint(
    fk_id: UUID,
    index: Int,
    `type`: String,
    schemaId: String,
    trustedIssuers: Seq[String]
)

object VerificationPolicySql extends DoobieContext.Postgres(SnakeCase) {
  import io.iohk.atala.pollux.sql.repository.VerificationPolicyExtensions._

  def insert(verificationPolicy: VerificationPolicy) = {
    run(quote(query[VerificationPolicy].insertValue(lift(verificationPolicy)).returning(vp => vp)))
  }

  def insertConstraints(constraints: Seq[VerificationPolicyConstraint]) = {
    run(
      quote(liftQuery(constraints).foreach(c => query[VerificationPolicyConstraint].insertValue(c).returning(c => c)))
    )
  }

  def dropConstraintsByVerificationPolicyId(fk_id: UUID) = {
    run(quote(query[VerificationPolicyConstraint].filter(_.fk_id == lift(fk_id)).delete))
  }

  def getById(id: UUID) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
      )
    ).map(_.headOption)

  def getHashById(id: UUID) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
          .map(_.nonce)
      )
    ).map(_.headOption)

  def exists(id: UUID) =
    run(quote(query[VerificationPolicy].filter(_.id == lift(id)).isEmpty))

  def exists(id: UUID, hash: Int) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
          .filter(_.nonce == lift(hash))
          .isEmpty
      )
    )

  def getVerificationPolicyConstrains(fk_ids: Seq[UUID]) =
    run(
      quote(
        query[VerificationPolicyConstraint]
          .filter(vpc => liftQuery(fk_ids).contains(vpc.fk_id))
          .sortBy(_.index)(Ord.asc)
      )
    )

  def update(verificationPolicy: VerificationPolicy, nonce: Int) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(verificationPolicy.id))
          .filter(_.nonce == lift(nonce))
          .update(
            _.nonce -> lift(verificationPolicy.nonce),
            _.description -> lift(verificationPolicy.description),
            _.name -> lift(verificationPolicy.name),
            _.updatedAt -> lift(verificationPolicy.updatedAt)
          )
          .returning(vp => vp)
      )
    )

  def delete(id: UUID) =
    run(
      quote(query[VerificationPolicy])
        .filter(_.id == lift(id))
        .delete
        .returning(vp => vp)
    )

  def delete(id: UUID, hash: Int) =
    run(
      quote(query[VerificationPolicy])
        .filter(_.id == lift(id))
        .filter(_.nonce == lift(hash))
        .delete
        .returning(vp => vp)
    )

  def deleteAll() = run(quote(query[VerificationPolicy].delete))

  def deleteConstraints(fk_id: UUID) =
    run(quote(query[VerificationPolicyConstraint]).filter(_.fk_id == lift(fk_id)).delete)

  def count() = run(quote(query[VerificationPolicy].size))

  def countOfConstraints() = run(quote(query[VerificationPolicyConstraint]).size)

  def countFiltered(nameOpt: Option[String]) =
    run(
      quote(query[VerificationPolicy]).dynamic
        .filterOpt(nameOpt)((vp, name) => quote(vp.name.like(name)))
        .size
    )

  def filteredVerificationPolicies(nameOpt: Option[String], offsetOpt: Option[Int], limitOpt: Option[Int]) = run {

    quote(query[VerificationPolicy]).dynamic
      .filterOpt(nameOpt)((vcs, name) => quote(vcs.name.like(name)))
      .sortBy(_.id)
      .dropOpt(offsetOpt)
      .take(limitOpt.getOrElse(1000))
  }
}

1	package io.iohk.atala.pollux.sql.model.db
2
3	import io.getquill.*
4	import io.getquill.doobie.DoobieContext
5	import io.iohk.atala.shared.models.WalletId
6	import java.util.UUID
7
8	import java.time.OffsetDateTime
9
10	case class VerificationPolicy(
11	id: UUID,
12	nonce: Int,
13	name: String,
14	description: String,
15	createdAt: OffsetDateTime,
16	updatedAt: OffsetDateTime,
17	walletId: WalletId
18	)
19
20	case class VerificationPolicyConstraint(
21	fk_id: UUID,
22	index: Int,
23	`type`: String,
24	schemaId: String,
25	trustedIssuers: Seq[String]
26	)
27
28	object VerificationPolicySql extends DoobieContext.Postgres(SnakeCase) {
29	import io.iohk.atala.pollux.sql.repository.VerificationPolicyExtensions._
30		1✔
UNCOV 31	def insert(verificationPolicy: VerificationPolicy) = {	×
32	run(quote(query[VerificationPolicy].insertValue(lift(verificationPolicy)).returning(vp => vp)))
33	}
34		1✔
35	def insertConstraints(constraints: Seq[VerificationPolicyConstraint]) = {	×
36	run(	1✔
37	quote(liftQuery(constraints).foreach(c => query[VerificationPolicyConstraint].insertValue(c).returning(c => c)))
38	)
39	}
40		1✔
41	def dropConstraintsByVerificationPolicyId(fk_id: UUID) = {	1✔
42	run(quote(query[VerificationPolicyConstraint].filter(_.fk_id == lift(fk_id)).delete))
43	}
44		1✔
45	def getById(id: UUID) =	×
46	run(
47	quote(
48	query[VerificationPolicy]
49	.filter(_.id == lift(id))
50	)	1✔
51	).map(_.headOption)
52		×
53	def getHashById(id: UUID) =	×
54	run(
55	quote(
56	query[VerificationPolicy]
57	.filter(_.id == lift(id))
58	.map(_.nonce)
59	)	×
60	).map(_.headOption)
61		×
62	def exists(id: UUID) =	×
63	run(quote(query[VerificationPolicy].filter(_.id == lift(id)).isEmpty))
64		×
65	def exists(id: UUID, hash: Int) =	×
66	run(
67	quote(
68	query[VerificationPolicy]
69	.filter(_.id == lift(id))
70	.filter(_.nonce == lift(hash))
UNCOV 71	.isEmpty	×
72	)
73	)
74		1✔
UNCOV 75	def getVerificationPolicyConstrains(fk_ids: Seq[UUID]) =	×
76	run(
77	quote(
UNCOV 78	query[VerificationPolicyConstraint]	×
79	.filter(vpc => liftQuery(fk_ids).contains(vpc.fk_id))
80	.sortBy(_.index)(Ord.asc)
81	)
UNCOV 82	)	×
83		1✔
84	def update(verificationPolicy: VerificationPolicy, nonce: Int) =	×
UNCOV 85	run(	×
86	quote(
87	query[VerificationPolicy]
88	.filter(_.id == lift(verificationPolicy.id))
89	.filter(_.nonce == lift(nonce))
90	.update(
91	_.nonce -> lift(verificationPolicy.nonce),
UNCOV 92	_.description -> lift(verificationPolicy.description),	×
93	_.name -> lift(verificationPolicy.name),
94	_.updatedAt -> lift(verificationPolicy.updatedAt)
95	)
UNCOV 96	.returning(vp => vp)	×
97	)
98	)
99		1✔
UNCOV 100	def delete(id: UUID) =	×
101	run(
102	quote(query[VerificationPolicy])
103	.filter(_.id == lift(id))
104	.delete
UNCOV 105	.returning(vp => vp)	×
106	)
107		×
108	def delete(id: UUID, hash: Int) =	×
109	run(
UNCOV 110	quote(query[VerificationPolicy])	×
111	.filter(_.id == lift(id))
112	.filter(_.nonce == lift(hash))
113	.delete
114	.returning(vp => vp)
115	)
116		1✔
117	def deleteAll() = run(quote(query[VerificationPolicy].delete))
118		×
119	def deleteConstraints(fk_id: UUID) =	×
120	run(quote(query[VerificationPolicyConstraint]).filter(_.fk_id == lift(fk_id)).delete)
121		1✔
122	def count() = run(quote(query[VerificationPolicy].size))
123		×
124	def countOfConstraints() = run(quote(query[VerificationPolicyConstraint]).size)
125		×
126	def countFiltered(nameOpt: Option[String]) =	×
127	run(	×
128	quote(query[VerificationPolicy]).dynamic
129	.filterOpt(nameOpt)((vp, name) => quote(vp.name.like(name)))	×
130	.size
131	)
132		×
133	def filteredVerificationPolicies(nameOpt: Option[String], offsetOpt: Option[Int], limitOpt: Option[Int]) = run {
134		×
135	quote(query[VerificationPolicy]).dynamic
136	.filterOpt(nameOpt)((vcs, name) => quote(vcs.name.like(name)))
137	.sortBy(_.id)
138	.dropOpt(offsetOpt)	×
139	.take(limitOpt.getOrElse(1000))
140	}
141	}	1✔

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

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