aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/pdsuidomain/formats/json/trialissue.scala
blob: 79882c2c8a464cdc38bca6fa00aa97c7badbafd2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package xyz.driver.pdsuidomain.formats.json

import java.time.LocalDateTime

import spray.json.{RootJsonReader, _}
import xyz.driver.core.{Id, auth}
import xyz.driver.core.auth.User
import xyz.driver.core.json._
import xyz.driver.pdsuicommon.domain.{LongId, StringId}
import xyz.driver.pdsuidomain.entities._

object trialissue {

  import DefaultJsonProtocol._
  import common._

  private def deserializationErrorFieldMessage(field: String, json: JsValue)(implicit className: String) = {
    deserializationError(s"$className json object do not contain '$field' field: $json")
  }

  private def deserializationErrorEntityMessage(json: JsValue)(implicit className: String) = {
    deserializationError(s"Expected Json Object as $className, but got $json")
  }

  def applyUpdateToTrialIssue(json: JsValue, orig: TrialIssue): TrialIssue = {
    json.asJsObject.getFields("text", "evidence", "archiveRequired", "meta") match {
      case Seq(text, evidence, archiveRequired, meta) =>
        orig.copy(
          text = text.convertTo[String],
          evidence = evidence.convertTo[String],
          archiveRequired = archiveRequired.convertTo[Boolean],
          meta = meta.convertTo[String]
        )

      case _ => deserializationError(s"Expected Json Object as partial TrialIssue, but got $json")
    }
  }

  def jsValueToTrialIssue(json: JsValue, trialId: StringId[Trial], userId: xyz.driver.core.Id[User]): TrialIssue = {
    json.asJsObject.getFields("text", "evidence", "meta") match {
      case Seq(text, evidence, meta) =>
        TrialIssue(
          id = json.asJsObject.fields.get("id").flatMap(_.convertTo[Option[LongId[TrialIssue]]]).getOrElse(LongId(0)),
          userId = userId,
          trialId = trialId,
          lastUpdate = LocalDateTime.MIN,
          isDraft = true,
          text = text.convertTo[String],
          evidence = evidence.convertTo[String],
          archiveRequired = false,
          meta = meta.convertTo[String]
        )

      case _ => deserializationError(s"Expected Json Object as TrialIssue, but got $json")
    }

  }

  implicit val trialIssueWriter = new RootJsonWriter[TrialIssue] {
    override def write(obj: TrialIssue) = JsObject(
      "id" -> obj.id.toJson,
      "text" -> obj.text.toJson,
      "lastUpdate" -> obj.lastUpdate.toJson,
      "userId" -> obj.userId.toJson,
      "isDraft" -> obj.isDraft.toJson,
      "evidence" -> obj.evidence.toJson,
      "archiveRequired" -> obj.archiveRequired.toJson,
      "meta" -> obj.meta.toJson
    )
  }

  def trialIssueReader(trialId: StringId[Trial]): RootJsonReader[TrialIssue] =
    new RootJsonReader[TrialIssue] {
      implicit val className: String = "TrialIssue"

      override def read(json: JsValue): TrialIssue = json match {
        case JsObject(fields) =>
          val id = fields
            .get("id")
            .map(_.convertTo[LongId[TrialIssue]])
            .getOrElse(deserializationErrorFieldMessage("id", json))

          val text = fields
            .get("text")
            .map(_.convertTo[String])
            .getOrElse(deserializationErrorFieldMessage("text", json))

          val lastUpdate = fields
            .get("lastUpdate")
            .map(_.convertTo[LocalDateTime])
            .getOrElse(deserializationErrorFieldMessage("lastUpdate", json))

          val userId = fields
            .get("userId")
            .map(_.convertTo[Id[auth.User]])
            .getOrElse(deserializationErrorFieldMessage("userId", json))

          val isDraft = fields
            .get("isDraft")
            .map(_.convertTo[Boolean])
            .getOrElse(deserializationErrorFieldMessage("isDraft", json))

          val evidence = fields
            .get("evidence")
            .map(_.convertTo[String])
            .getOrElse(deserializationErrorFieldMessage("evidence", json))

          val archiveRequired = fields
            .get("archiveRequired")
            .map(_.convertTo[Boolean])
            .getOrElse(deserializationErrorFieldMessage("archiveRequired", json))

          val meta = fields
            .get("meta")
            .map(_.convertTo[String])
            .getOrElse(deserializationErrorFieldMessage("meta", json))

          TrialIssue(
            id = id,
            userId = userId,
            trialId = trialId,
            lastUpdate = lastUpdate,
            isDraft = isDraft,
            text = text,
            evidence = evidence,
            archiveRequired = archiveRequired,
            meta = meta
          )

        case _ => deserializationErrorEntityMessage(json)
      }
    }

}