• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

hyperledger / identus-cloud-agent / 10793991050

10 Sep 2024 01:56PM CUT coverage: 48.504% (-4.5%) from 52.962%
10793991050

push

web-flow
build: sbt and plugins dependency update (#1337)

Signed-off-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Signed-off-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>
Co-authored-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Co-authored-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>

7406 of 15269 relevant lines covered (48.5%)

0.49 hits per line

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

0.0
/mercury/agent-didcommx/src/main/scala/org/hyperledger/identus/mercury/MessagingService.scala
1
package org.hyperledger.identus.mercury
2

3
import io.circe.*
4
import org.hyperledger.identus.mercury.model.*
5
import org.hyperledger.identus.mercury.model.error.*
6
import org.hyperledger.identus.mercury.protocol.routing.*
7
import org.hyperledger.identus.resolvers.DIDResolver
8
import zio.*
9

10
import scala.jdk.CollectionConverters.*
11

12
type HttpOrDID = String //TODO
13
case class ServiceEndpoint(uri: HttpOrDID, accept: Option[Seq[String]], routingKeys: Option[Seq[String]])
14
case class MessageAndAddress(msg: Message, url: String)
15

16
object MessagingService {
17

18
  /** Encrypted payload (message) and make the Forward Message */
19
  def makeForwardMessage(message: Message, mediator: DidId): URIO[DidOps & DidAgent, ForwardMessage] =
×
20
    for {
×
21
      didCommService <- ZIO.service[DidOps]
×
22
      encrypted <- didCommService.packEncrypted(message, to = message.to.head) // TODO head
×
23
      msg = ForwardMessage(
×
24
        to = mediator,
25
        expires_time = None,
26
        body = ForwardBody(next = message.to.head), // TODO check msg head
×
27
        attachments = Seq(AttachmentDescriptor.buildJsonAttachment(payload = encrypted.asJson)),
×
28
      )
29
    } yield (msg)
×
30

31
  /** Create a Message and any Forward Message as needed */
32
  def makeMessage(msg: Message): ZIO[
×
33
    DidOps & DidAgent & DIDResolver & HttpClient,
34
    SendMessageError,
35
    MessageAndAddress
36
  ] =
37
    for {
×
38
      didCommService <- ZIO.service[DidOps]
×
39
      resolver <- ZIO.service[DIDResolver]
×
40
      sendToDID <- msg.to match {
×
41
        case Seq() => // TODO support for anonymous message
×
42
          ZIO.fail(
×
43
            SendMessageError(
×
44
              new RuntimeException("Missing the destination DID - TODO support for anonymous message")
×
45
            )
46
          )
47
        case Seq(value) =>
×
48
          ZIO.succeed(value)
49
        case head +: tail => // TODO support for multiple destinations
×
50
          ZIO.fail(
×
51
            SendMessageError(
×
52
              new RuntimeException("TODO multiple destinations")
×
53
            )
54
          )
55
      }
56

57
      serviceEndpoint <- resolver
×
58
        .didCommServices(sendToDID) /* Seq[DIDCommService] */
×
59
        .catchAll { case ex => ZIO.fail(SendMessageError(ex)) }
×
60
        .flatMap {
61
          case Seq() =>
×
62
            ZIO.fail(
×
63
              SendMessageError(
×
64
                new RuntimeException("To send a Message you need a destination") // TODO ERROR
×
65
              )
66
            )
67
          case Seq(v) =>
×
68
            ZIO.succeed(
69
              ServiceEndpoint(
70
                uri = v.getServiceEndpoint(),
×
71
                accept = Option(v.getAccept()).map(_.asScala.toSeq),
×
72
                routingKeys = Option(v.getRoutingKeys()).map(_.asScala.toSeq)
×
73
              )
74
            )
75
          case headDID +: tail =>
×
76
            ZIO.logError("TODO multiple destinations") *>
×
77
              ZIO.succeed(
78
                ServiceEndpoint(
79
                  uri = headDID.getServiceEndpoint(),
×
80
                  accept = Option(headDID.getAccept()).map(_.asScala.toSeq),
×
81
                  routingKeys = Option(headDID.getRoutingKeys()).map(_.asScala.toSeq)
×
82
                )
83
              )
84
        }
85

86
      msgToSend <- serviceEndpoint match {
×
87
        case ServiceEndpoint(url, _, None) if url.startsWith("http") =>
×
88
          ZIO.log(s"No Forward Message needed. (send to $url)") *>
×
89
            ZIO.succeed(MessageAndAddress(msg, url))
90
        case ServiceEndpoint(url, _, Some(Seq())) if url.startsWith("http") =>
×
91
          ZIO.log(s"No Forward Message needed. (send to $url)") *>
×
92
            ZIO.succeed(MessageAndAddress(msg, url))
93
        case ServiceEndpoint(did, _, _) if did.startsWith("did:") =>
×
94
          for {
×
95
            _ <- ZIO.log(s"Make Forward Message for Mediator '$did'")
×
96
            mediator = DidId(did)
×
97
            forwardMessage <- makeForwardMessage(message = msg, mediator = mediator)
×
98
            finalMessage <- makeMessage(forwardMessage.asMessage) // Maybe it needs a double warping
×
99
          } yield finalMessage
100
        case ServiceEndpoint(uri, _, Some(routingKeys)) =>
×
101
          ZIO.log(s"RoutingDID: $routingKeys") *>
×
102
            ZIO.fail(
×
103
              SendMessageError(
×
104
                RuntimeException("routingKeys is not supported at the moment")
×
105
              )
106
            )
107
        case s @ ServiceEndpoint(_, _, None) =>
×
108
          ZIO.logError(s"Unxpected ServiceEndpoint $s") *> ZIO.fail(
×
109
            SendMessageError(new RuntimeException(s"Unxpected ServiceEndpoint $s"))
×
110
          )
111
      }
112
    } yield (msgToSend)
113

114
  /** Encrypt and send a Message via HTTP
115
    *
116
    * TODO Move this method to another model
117
    */
118
  def send(msg: Message): ZIO[DidOps & DidAgent & DIDResolver & HttpClient, SendMessageError, HttpResponse] =
×
119
    ZIO.logAnnotate("msgId", msg.id) {
×
120
      for {
×
121
        auxFinalMessage <- makeMessage(msg)
×
122
        MessageAndAddress(finalMessage, serviceEndpoint) = auxFinalMessage
×
123
        didCommService <- ZIO.service[DidOps]
×
124
        to <- finalMessage.to match {
×
125
          case Seq()            => ZIO.fail(SendMessageError(new RuntimeException("Message must have a recipient")))
×
126
          case firstTo +: Seq() => ZIO.succeed(firstTo)
×
127
          case all @ (firstTo +: _) =>
×
128
            ZIO.logWarning(s"Message have multi recipients: $all") *> ZIO.succeed(firstTo)
×
129
        }
130
        encryptedMessage <-
×
131
          if (finalMessage.`type` == ForwardMessage.PIURI) didCommService.packEncryptedAnon(msg = finalMessage, to = to)
×
132
          else didCommService.packEncrypted(msg = finalMessage, to = to)
×
133

134
        _ <- ZIO.log(s"Sending a Message to '$serviceEndpoint'")
×
135
        resp <- org.hyperledger.identus.mercury.HttpClient
×
136
          .postDIDComm(url = serviceEndpoint, data = encryptedMessage.string)
×
137
          .catchAll { case ex => ZIO.fail(SendMessageError(ex, Some(encryptedMessage.string))) }
×
138
        _ <- ZIO.when(resp.status >= 300)(
×
139
          ZIO.logWarning(
×
140
            s"Message to '$serviceEndpoint' return [${resp.status}] '${resp.bodyAsString}' for the request '${encryptedMessage.string}'"
×
141
          )
142
        )
143

144
      } yield (resp)
×
145
    }
146

147
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc