5507500681

Committed 10 Jul 2023 11:26AM UTC coverage: 28.366% (+0.3%) from 28.076%

Build Type

Committed by

Commit Message

chore(prism-agent): fixing last PR comments

Pull Request Pull Request #575: feat(prism-agent): simple event mechanism using webhook

Run Details

409 of 409 new or added lines in 17 files covered. (100.0%)

2758 of 9723 relevant lines covered (28.37%)

0.28 hits per line

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

12.5

/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.{Task, URLayer, ZLayer}

import java.util.UUID

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

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

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