6174691072

Committed 13 Sep 2023 03:35PM UTC coverage: 29.221% (+0.04%) from 29.185%

Build Type

Committed by

Commit Message

docs: update readme with latest release 1.12.0

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

Pull Request Pull Request #715: docs: update readme with latest release 1.12.0

Run Details

3470 of 11875 relevant lines covered (29.22%)

0.29 hits per line

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

40.54

/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.InsertMeta

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) = {
    inline given InsertMeta[VerificationPolicy] = insertMeta(exclude = _.id, _.createdAt, _.updatedAt)
    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))
      )
    )

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

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

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