6172829202

Committed 13 Sep 2023 01:00PM UTC coverage: 29.118% (-0.02%) from 29.14%

Build Type

Committed by

Commit Message

Add all async metrics

Signed-off-by: Shota Jolbordi <shota.jolbordi@iohk.io>

Pull Request Pull Request #714: [WIP] Metrics for verification flow

Run Details

16 of 16 new or added lines in 2 files covered. (100.0%)

3456 of 11869 relevant lines covered (29.12%)

0.29 hits per line

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

27.08

/pollux/lib/core/src/main/scala/io/iohk/atala/pollux/core/service/CredentialSchemaServiceImpl.scala

package io.iohk.atala.pollux.core.service
import io.iohk.atala.pollux.core.model.error.CredentialSchemaError
import io.iohk.atala.pollux.core.model.schema.CredentialSchema
import io.iohk.atala.pollux.core.model.schema.CredentialSchema.FilteredEntries
import io.iohk.atala.pollux.core.repository.CredentialSchemaRepository
import io.iohk.atala.pollux.core.repository.Repository.SearchQuery
import io.iohk.atala.pollux.core.service.CredentialSchemaService.Error.*
import zio.ZIO.{fail, getOrFailWith, succeed}
import zio.{URLayer, ZLayer}
import zio.IO

import java.util.UUID

class CredentialSchemaServiceImpl(
    credentialSchemaRepository: CredentialSchemaRepository
) extends CredentialSchemaService {
  override def create(in: CredentialSchema.Input): Result[CredentialSchema] = {
    for {
      credentialSchema <- CredentialSchema.make(in)
      _ <- CredentialSchema.validateCredentialSchema(credentialSchema)
      createdCredentialSchema <- credentialSchemaRepository
        .create(credentialSchema)
    } yield createdCredentialSchema
  }.mapError {
    case e: CredentialSchemaError => CredentialSchemaValidationError(e)
    case t: Throwable             => RepositoryError(t)
  }

  override def getByGUID(guid: UUID): IO[CredentialSchemaService.Error, CredentialSchema] = {
    credentialSchemaRepository
      .getByGuid(guid)
      .mapError[CredentialSchemaService.Error](t => RepositoryError(t))
      .flatMap(
        getOrFailWith(NotFoundError.byGuid(guid))(_)
      )
  }

  def getBy(
      author: String,
      id: UUID,
      version: String
  ): Result[CredentialSchema] = {
    getByGUID(CredentialSchema.makeGUID(author, id, version))
  }

  override def update(
      id: UUID,
      in: CredentialSchema.Input
  ): Result[CredentialSchema] = {
    for {
      cs <- CredentialSchema.make(id, in)
      _ <- CredentialSchema.validateCredentialSchema(cs).mapError(CredentialSchemaValidationError.apply)
      existingVersions <- credentialSchemaRepository
        .getAllVersions(id, in.author)
        .mapError[CredentialSchemaService.Error](RepositoryError.apply)
      _ <- existingVersions.headOption match {
        case None =>
          fail(NotFoundError.byId(id))
        case _ =>
          succeed(cs)
      }
      _ <- existingVersions.find(_ > in.version) match {
        case Some(higherVersion) =>
          fail(
            UpdateError(
              id,
              in.version,
              in.author,
              s"Higher version is found: $higherVersion"
            )
          )
        case None =>
          succeed(cs)
      }
      _ <- existingVersions.find(_ == in.version) match {
        case Some(existingVersion) =>
          fail(
            UpdateError(
              id,
              in.version,
              in.author,
              s"The version already exists: $existingVersion"
            )
          )
        case None => succeed(cs)
      }
      updated <- credentialSchemaRepository
        .create(cs)
        .mapError[CredentialSchemaService.Error](RepositoryError.apply)
    } yield updated
  }
  override def delete(guid: UUID): Result[CredentialSchema] = {
    for {
      deleted_row_opt <- credentialSchemaRepository
        .delete(guid)
        .mapError(RepositoryError.apply)
      deleted_row <- getOrFailWith(NotFoundError.byGuid(guid))(deleted_row_opt)
    } yield deleted_row
  }

  override def lookup(
      filter: CredentialSchema.Filter,
      skip: Int,
      limit: Int
  ): Result[CredentialSchema.FilteredEntries] = {
    credentialSchemaRepository
      .search(SearchQuery(filter, skip, limit))
      .mapError(t => RepositoryError(t))
      .map(sr => FilteredEntries(sr.entries, sr.count.toInt, sr.totalCount.toInt))
  }
}

object CredentialSchemaServiceImpl {
  val layer: URLayer[CredentialSchemaRepository, CredentialSchemaService] =
    ZLayer.fromFunction(CredentialSchemaServiceImpl(_))
}

1	package io.iohk.atala.pollux.core.service
2	import io.iohk.atala.pollux.core.model.error.CredentialSchemaError
3	import io.iohk.atala.pollux.core.model.schema.CredentialSchema
4	import io.iohk.atala.pollux.core.model.schema.CredentialSchema.FilteredEntries
5	import io.iohk.atala.pollux.core.repository.CredentialSchemaRepository
6	import io.iohk.atala.pollux.core.repository.Repository.SearchQuery
7	import io.iohk.atala.pollux.core.service.CredentialSchemaService.Error.*
8	import zio.ZIO.{fail, getOrFailWith, succeed}
9	import zio.{URLayer, ZLayer}
10	import zio.IO
11
12	import java.util.UUID
13
14	class CredentialSchemaServiceImpl(
15	credentialSchemaRepository: CredentialSchemaRepository
16	) extends CredentialSchemaService {	1✔
17	override def create(in: CredentialSchema.Input): Result[CredentialSchema] = {	×
18	for {	×
19	credentialSchema <- CredentialSchema.make(in)	×
20	_ <- CredentialSchema.validateCredentialSchema(credentialSchema)	×
21	createdCredentialSchema <- credentialSchemaRepository	×
22	.create(credentialSchema)
23	} yield createdCredentialSchema
24	}.mapError {	1✔
25	case e: CredentialSchemaError => CredentialSchemaValidationError(e)	×
26	case t: Throwable => RepositoryError(t)
27	}
28		1✔
29	override def getByGUID(guid: UUID): IO[CredentialSchemaService.Error, CredentialSchema] = {	×
30	credentialSchemaRepository	×
31	.getByGuid(guid)
32	.mapError[CredentialSchemaService.Error](t => RepositoryError(t))
33	.flatMap(	1✔
34	getOrFailWith(NotFoundError.byGuid(guid))(_)
35	)
36	}
37		×
38	def getBy(
39	author: String,
40	id: UUID,
41	version: String
42	): Result[CredentialSchema] = {	×
43	getByGUID(CredentialSchema.makeGUID(author, id, version))
44	}
45		1✔
46	override def update(
47	id: UUID,
48	in: CredentialSchema.Input
49	): Result[CredentialSchema] = {	1✔
50	for {	×
51	cs <- CredentialSchema.make(id, in)	1✔
52	_ <- CredentialSchema.validateCredentialSchema(cs).mapError(CredentialSchemaValidationError.apply)	×
53	existingVersions <- credentialSchemaRepository	×
54	.getAllVersions(id, in.author)
55	.mapError[CredentialSchemaService.Error](RepositoryError.apply)	1✔
56	_ <- existingVersions.headOption match {	×
57	case None =>	×
58	fail(NotFoundError.byId(id))	×
59	case _ =>	×
60	succeed(cs)
61	}	×
62	_ <- existingVersions.find(_ > in.version) match {	×
63	case Some(higherVersion) =>	×
64	fail(
65	UpdateError(
66	id,
67	in.version,
68	in.author,	×
69	s"Higher version is found: $higherVersion"
70	)
71	)	×
72	case None =>	×
73	succeed(cs)
74	}	1✔
75	_ <- existingVersions.find(_ == in.version) match {	×
76	case Some(existingVersion) =>	×
77	fail(
78	UpdateError(
79	id,
80	in.version,
81	in.author,	×
82	s"The version already exists: $existingVersion"
83	)
84	)	×
85	case None => succeed(cs)
86	}	1✔
87	updated <- credentialSchemaRepository	×
88	.create(cs)
89	.mapError[CredentialSchemaService.Error](RepositoryError.apply)
90	} yield updated
91	}	×
92	override def delete(guid: UUID): Result[CredentialSchema] = {	×
93	for {	×
94	deleted_row_opt <- credentialSchemaRepository	×
95	.delete(guid)
96	.mapError(RepositoryError.apply)	×
97	deleted_row <- getOrFailWith(NotFoundError.byGuid(guid))(deleted_row_opt)
98	} yield deleted_row
99	}
100		1✔
101	override def lookup(
102	filter: CredentialSchema.Filter,
103	skip: Int,
104	limit: Int
105	): Result[CredentialSchema.FilteredEntries] = {	×
106	credentialSchemaRepository	×
107	.search(SearchQuery(filter, skip, limit))
108	.mapError(t => RepositoryError(t))	1✔
109	.map(sr => FilteredEntries(sr.entries, sr.count.toInt, sr.totalCount.toInt))
110	}
111	}
112
113	object CredentialSchemaServiceImpl {
114	val layer: URLayer[CredentialSchemaRepository, CredentialSchemaService] =	1✔
115	ZLayer.fromFunction(CredentialSchemaServiceImpl(_))
116	}

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

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