gerrit.onap Code Review - ccsdk/cds.git/blob

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2019 IBM.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.controllerblueprints.core
  19
  20 import com.fasterxml.jackson.databind.JsonNode
  21 import com.fasterxml.jackson.databind.node.*
  22 import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
  23 import org.slf4j.helpers.MessageFormatter
  24 import kotlin.reflect.KClass
  25
  26 /**
  27  *
  28  *
  29  * @author Brinda Santh
  30  */
  31
  32 fun String.asJsonPrimitive(): TextNode {
  33     return TextNode(this)
  34 }
  35
  36 fun Boolean.asJsonPrimitive(): BooleanNode {
  37     return BooleanNode.valueOf(this)
  38 }
  39
  40 fun Int.asJsonPrimitive(): IntNode {
  41     return IntNode.valueOf(this)
  42 }
  43
  44 fun Double.asJsonPrimitive(): DoubleNode {
  45     return DoubleNode.valueOf(this)
  46 }
  47
  48 fun <T : Any?> T.asJsonType(): JsonNode {
  49     return if (this == null) {
  50         NullNode.instance
  51     } else {
  52         when (this) {
  53             is JsonNode ->
  54                 this
  55             is String ->
  56                 TextNode(this)
  57             is Boolean ->
  58                 BooleanNode.valueOf(this)
  59             is Int ->
  60                 IntNode.valueOf(this.toInt())
  61             is Double ->
  62                 DoubleNode.valueOf(this.toDouble())
  63             else ->
  64                 JacksonUtils.jsonNodeFromObject(this)
  65         }
  66     }
  67 }
  68
  69 fun Map<String, *>.asJsonNode(): JsonNode {
  70     return JacksonUtils.jsonNodeFromObject(this)
  71 }
  72
  73 fun Map<String, *>.asObjectNode(): ObjectNode {
  74     return JacksonUtils.objectNodeFromObject(this)
  75 }
  76
  77 fun format(message: String, vararg args: Any?): String {
  78     if (args != null && args.isNotEmpty()) {
  79         return MessageFormatter.arrayFormat(message, args).message
  80     }
  81     return message
  82 }
  83
  84 fun <T : Any> Map<String, *>.castOptionalValue(key: String, valueType: KClass<T>): T? {
  85     if (containsKey(key)) {
  86         return get(key) as? T
  87     } else {
  88         return null
  89     }
  90 }
  91
  92 fun <T : Any> Map<String, *>.castValue(key: String, valueType: KClass<T>): T {
  93     if (containsKey(key)) {
  94         return get(key) as T
  95     } else {
  96         throw BluePrintException("couldn't find the key $key")
  97     }
  98 }
  99
 100 fun ArrayNode.asListOfString(): List<String> {
 101     return JacksonUtils.getListFromJsonNode(this, String::class.java)
 102 }
 103
 104 fun JsonNode.returnNullIfMissing(): JsonNode? {
 105     return if (this is NullNode || this is MissingNode) {
 106         null
 107     } else this
 108 }
 109
 110 /**
 111  * Convert Json to map of json node, the root fields will be map keys
 112  */
 113 fun JsonNode.rootFieldsToMap(): MutableMap<String, JsonNode> {
 114     if (this is ObjectNode) {
 115         val propertyMap: MutableMap<String, JsonNode> = hashMapOf()
 116         this.fields().forEach {
 117             propertyMap[it.key] = it.value
 118         }
 119         return propertyMap
 120     } else {
 121         throw BluePrintException("json node should be Object Node Type")
 122     }
 123 }
 124
 125
 126 fun MutableMap<String, JsonNode>.putJsonElement(key: String, value: Any) {
 127     val convertedValue = value.asJsonType()
 128     this[key] = convertedValue
 129 }
 130
 131 fun Map<String, JsonNode>.getAsString(key: String): String {
 132     return this[key]?.asText() ?: throw BluePrintException("couldn't find value for key($key)")
 133 }
 134
 135 fun Map<String, JsonNode>.getAsBoolean(key: String): Boolean {
 136     return this[key]?.asBoolean() ?: throw BluePrintException("couldn't find value for key($key)")
 137 }
 138
 139 fun Map<String, JsonNode>.getAsInt(key: String): Int {
 140     return this[key]?.asInt() ?: throw BluePrintException("couldn't find value for key($key)")
 141 }
 142
 143 fun Map<String, JsonNode>.getAsDouble(key: String): Double {
 144     return this[key]?.asDouble() ?: throw BluePrintException("couldn't find value for key($key)")
 145 }
 146
 147 // Checks
 148
 149 inline fun checkEquals(value1: String?, value2: String?, lazyMessage: () -> Any): Boolean {
 150     if (value1.equals(value2, ignoreCase = true)) {
 151         return true
 152     } else {
 153         throw BluePrintException(lazyMessage().toString())
 154     }
 155 }
 156
 157 inline fun checkNotEmpty(value: String?, lazyMessage: () -> Any): String {
 158     if (value == null || value.isEmpty()) {
 159         val message = lazyMessage()
 160         throw IllegalStateException(message.toString())
 161     } else {
 162         return value
 163     }
 164 }
 165
 166 inline fun checkNotBlank(value: String?, lazyMessage: () -> Any): String {
 167     if (value == null || value.isBlank()) {
 168         val message = lazyMessage()
 169         throw IllegalStateException(message.toString())
 170     } else {
 171         return value
 172     }
 173 }
 174
 175 fun isNotEmpty(value: String?): Boolean {
 176     return value != null && value.isNotEmpty()
 177 }
 178
 179 fun isNotBlank(value: String?): Boolean {
 180     return value != null && value.isNotBlank()
 181 }
 182
 183
 184 fun nullToEmpty(value: String?): String {
 185     return if (isNotEmpty(value)) value!! else ""
 186 }
 187
 188