| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.s2graph.core |
| |
| import org.apache.s2graph.core.GraphExceptions.IllegalDataTypeException |
| import org.apache.s2graph.core.mysqls.LabelMeta |
| import org.apache.s2graph.core.rest.TemplateHelper |
| import org.apache.s2graph.core.types.{InnerVal, InnerValLike, InnerValLikeWithTs, VertexId} |
| import org.apache.s2graph.core.utils.logger |
| import play.api.libs.json._ |
| |
| |
| object JSONParser { |
| |
| //TODO: check result notation on bigDecimal. |
| def innerValToJsValue(innerVal: InnerValLike, dataType: String): Option[JsValue] = { |
| try { |
| val dType = InnerVal.toInnerDataType(dataType) |
| val jsValue = dType match { |
| case InnerVal.STRING => JsString(innerVal.value.asInstanceOf[String]) |
| case InnerVal.BOOLEAN => JsBoolean(innerVal.value.asInstanceOf[Boolean]) |
| case InnerVal.BYTE | InnerVal.SHORT | InnerVal.INT | InnerVal.LONG | InnerVal.FLOAT | InnerVal.DOUBLE => |
| // case t if InnerVal.NUMERICS.contains(t) => |
| innerVal.value match { |
| case l: Long => JsNumber(l) |
| case i: Int => JsNumber(i) |
| case s: Short => JsNumber(s.toLong) |
| case b: Byte => JsNumber(b.toLong) |
| case f: Float => JsNumber(f.toDouble) |
| case d: Double => |
| // JsNumber(d) |
| dType match { |
| case InnerVal.BYTE => JsNumber(d.toInt) |
| case InnerVal.SHORT => JsNumber(d.toInt) |
| case InnerVal.INT => JsNumber(d.toInt) |
| case InnerVal.LONG => JsNumber(d.toLong) |
| case InnerVal.FLOAT => JsNumber(d.toDouble) |
| case InnerVal.DOUBLE => JsNumber(d.toDouble) |
| case _ => throw new RuntimeException(s"$innerVal, $dType => $dataType") |
| } |
| case num: BigDecimal => |
| // JsNumber(num) |
| // JsNumber(InnerVal.scaleNumber(num.asInstanceOf[BigDecimal], dType)) |
| dType match { |
| case InnerVal.BYTE => JsNumber(num.toInt) |
| case InnerVal.SHORT => JsNumber(num.toInt) |
| case InnerVal.INT => JsNumber(num.toInt) |
| case InnerVal.LONG => JsNumber(num.toLong) |
| case InnerVal.FLOAT => JsNumber(num.toDouble) |
| case InnerVal.DOUBLE => JsNumber(num.toDouble) |
| case _ => throw new RuntimeException(s"$innerVal, $dType => $dataType") |
| } |
| // JsNumber(num.toLong) |
| case _ => throw new RuntimeException(s"$innerVal, Numeric Unknown => $dataType") |
| } |
| // JsNumber(InnerVal.scaleNumber(innerVal.asInstanceOf[BigDecimal], dType)) |
| case _ => throw new RuntimeException(s"$innerVal, Unknown => $dataType") |
| } |
| Some(jsValue) |
| } catch { |
| case e: Exception => |
| logger.info(s"JSONParser.innerValToJsValue: $e") |
| None |
| } |
| } |
| |
| // def innerValToString(innerVal: InnerValLike, dataType: String): String = { |
| // val dType = InnerVal.toInnerDataType(dataType) |
| // InnerVal.toInnerDataType(dType) match { |
| // case InnerVal.STRING => innerVal.toString |
| // case InnerVal.BOOLEAN => innerVal.toString |
| // // case t if InnerVal.NUMERICS.contains(t) => |
| // case InnerVal.BYTE | InnerVal.SHORT | InnerVal.INT | InnerVal.LONG | InnerVal.FLOAT | InnerVal.DOUBLE => |
| // BigDecimal(innerVal.toString).bigDecimal.toPlainString |
| // case _ => innerVal.toString |
| // // throw new RuntimeException("innerVal to jsValue failed.") |
| // } |
| // } |
| |
| // def toInnerVal(str: String, dataType: String, version: String): InnerValLike = { |
| // //TODO: |
| // // logger.error(s"toInnerVal: $str, $dataType, $version") |
| // val s = |
| // if (str.startsWith("\"") && str.endsWith("\"")) str.substring(1, str.length - 1) |
| // else str |
| // val dType = InnerVal.toInnerDataType(dataType) |
| // |
| // dType match { |
| // case InnerVal.STRING => InnerVal.withStr(s, version) |
| // // case t if InnerVal.NUMERICS.contains(t) => InnerVal.withNumber(BigDecimal(s), version) |
| // case InnerVal.BYTE | InnerVal.SHORT | InnerVal.INT | InnerVal.LONG | InnerVal.FLOAT | InnerVal.DOUBLE => |
| // InnerVal.withNumber(BigDecimal(s), version) |
| // case InnerVal.BOOLEAN => InnerVal.withBoolean(s.toBoolean, version) |
| // case InnerVal.BLOB => InnerVal.withBlob(s.getBytes, version) |
| // case _ => |
| // // InnerVal.withStr("") |
| // throw new RuntimeException(s"illegal datatype for string: dataType is $dataType for $s") |
| // } |
| // } |
| def isNumericType(dType: String): Boolean = { |
| dType == InnerVal.LONG || dType == InnerVal.INT || |
| dType == InnerVal.SHORT || dType == InnerVal.BYTE || |
| dType == InnerVal.FLOAT || dType == InnerVal.DOUBLE |
| } |
| |
| //TODO: fix this messy parts |
| def innerValToAny(innerValLike: InnerValLike, dataType: String): Any = { |
| val dType = InnerVal.toInnerDataType(dataType) |
| dType match { |
| case InnerVal.LONG => |
| innerValLike.value match { |
| case b: BigDecimal => b.toLong |
| case l: Long => l |
| case i: Int => i.toLong |
| case f: Float => f.toLong |
| case d: Double => d.toLong |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case InnerVal.INT => |
| innerValLike.value match { |
| case b: BigDecimal => b.toInt |
| case l: Long => l.toInt |
| case i: Int => i |
| case f: Float => f.toInt |
| case d: Double => d.toInt |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case InnerVal.SHORT => |
| innerValLike.value match { |
| case b: BigDecimal => b.toShort |
| case s: Short => s |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case InnerVal.BYTE => |
| innerValLike.value match { |
| case b: BigDecimal => b.toByte |
| case b: Byte => b |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case InnerVal.FLOAT => |
| innerValLike.value match { |
| case b: BigDecimal => b.toFloat |
| case d: Double => d.toFloat |
| case f: Float => f |
| case l: Long => l.toFloat |
| case i: Int => i.toFloat |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case InnerVal.DOUBLE => |
| innerValLike.value match { |
| case b: BigDecimal => b.toDouble |
| case d: Double => d |
| case l: Long => l.toDouble |
| case i: Int => i.toDouble |
| case f: Float => f.toDouble |
| case _ => throw new RuntimeException(s"not supported data type: $innerValLike, ${innerValLike.value.getClass}, $dataType") |
| } |
| case _ => innerValLike.value |
| } |
| } |
| |
| def toInnerVal(any: Any, dataType: String, version: String): InnerValLike = { |
| val dType = InnerVal.toInnerDataType(dataType) |
| val isNumeric = isNumericType(dType) |
| any match { |
| case v: VertexId => v.innerId |
| case a: InnerValLike => a |
| case n: BigDecimal => |
| if (isNumeric) InnerVal.withNumber(n, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(n.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = BigDecimal, [DataType]: $dataType, [Input]: $any") |
| case l: Long => |
| if (isNumeric) InnerVal.withLong(l, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(l.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Long, [DataType]: $dataType, [Input]: $any") |
| case i: Int => |
| if (isNumeric) InnerVal.withInt(i, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(i.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Int, [DataType]: $dataType, [Input]: $any") |
| case sh: Short => |
| if (isNumeric) InnerVal.withInt(sh.toInt, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(sh.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Short, [DataType]: $dataType, [Input]: $any") |
| case b: Byte => |
| if (isNumeric) InnerVal.withInt(b.toInt, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(b.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Byte, [DataType]: $dataType, [Input]: $any") |
| case f: Float => |
| if (isNumeric) InnerVal.withFloat(f, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(f.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Float, [DataType]: $dataType, [Input]: $any") |
| case d: Double => |
| if (isNumeric) InnerVal.withDouble(d, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(d.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Double, [DataType]: $dataType, [Input]: $any") |
| case bl: Boolean => |
| if (dType == InnerVal.BOOLEAN) InnerVal.withBoolean(bl, version) |
| else if (dType == InnerVal.STRING) InnerVal.withStr(bl.toString, version) |
| else throw new IllegalDataTypeException(s"[ValueType] = Boolean, [DataType]: $dataType, [Input]: $any") |
| case _s: String => |
| if (isNumeric) { |
| try { |
| val s = TemplateHelper.replaceVariable(System.currentTimeMillis(), _s.toString) |
| InnerVal.withNumber(BigDecimal(s), version) |
| } catch { |
| case e: Exception => |
| throw new IllegalDataTypeException(s"[ValueType] = String, [DataType]: $dataType, [Input]: $any") |
| } |
| } else { |
| dType match { |
| case InnerVal.BOOLEAN => try { |
| InnerVal.withBoolean(_s.toBoolean, version) |
| } catch { |
| case e: Exception => |
| throw new IllegalDataTypeException(s"[ValueType] = String, [DataType]: boolean, [Input]: $any") |
| } |
| case InnerVal.STRING => InnerVal.withStr(_s, version) |
| } |
| } |
| } |
| } |
| |
| def jsValueToInnerVal(jsValue: JsValue, dataType: String, version: String): Option[InnerValLike] = { |
| val ret = try { |
| val dType = InnerVal.toInnerDataType(dataType.toLowerCase()) |
| jsValue match { |
| case n: JsNumber => |
| dType match { |
| case InnerVal.STRING => Some(InnerVal.withStr(jsValue.toString, version)) |
| // case t if InnerVal.NUMERICS.contains(t) => |
| case InnerVal.BYTE | InnerVal.SHORT | InnerVal.INT | InnerVal.LONG | InnerVal.FLOAT | InnerVal.DOUBLE => |
| Some(InnerVal.withNumber(n.value, version)) |
| case _ => None |
| } |
| case _s: JsString => |
| val s = TemplateHelper.replaceVariable(System.currentTimeMillis(), _s.value) |
| dType match { |
| case InnerVal.STRING => Some(InnerVal.withStr(s, version)) |
| case InnerVal.BOOLEAN => Some(InnerVal.withBoolean(s.toBoolean, version)) |
| // case t if InnerVal.NUMERICS.contains(t) => |
| case InnerVal.BYTE | InnerVal.SHORT | InnerVal.INT | InnerVal.LONG | InnerVal.FLOAT | InnerVal.DOUBLE => |
| Some(InnerVal.withNumber(BigDecimal(s), version)) |
| case _ => None |
| } |
| case b: JsBoolean => |
| dType match { |
| case InnerVal.STRING => Some(InnerVal.withStr(b.toString, version)) |
| case InnerVal.BOOLEAN => Some(InnerVal.withBoolean(b.value, version)) |
| case _ => None |
| } |
| case _ => |
| None |
| } |
| } catch { |
| case e: Exception => |
| logger.error(s"jsValueToInnerVal: jsValue = ${jsValue}, dataType = ${dataType}, version = ${version}", e) |
| None |
| } |
| |
| ret |
| } |
| |
| def anyValToJsValue(value: Any): Option[JsValue] = { |
| try { |
| val v = value match { |
| case null => JsNull |
| case l: Long => JsNumber(l) |
| case i: Int => JsNumber(i) |
| case s: Short => JsNumber(s.toInt) |
| case b: Byte => JsNumber(b.toInt) |
| case f: Float => JsNumber(f.toDouble) |
| case d: Double => JsNumber(d) |
| case bd: BigDecimal => if (bd.isValidLong) JsNumber(bd.toLong) else JsNumber(bd) |
| case s: String => JsString(s) |
| case b: Boolean => JsBoolean(b) |
| case _ => throw new RuntimeException(s"$value, ${value.getClass.getName} is not supported data type.") |
| } |
| Option(v) |
| } catch { |
| case e: Exception => |
| logger.error(s"anyValToJsValue: $value", e) |
| None |
| } |
| } |
| |
| def jsValueToAny(value: JsValue): Option[AnyRef] = { |
| try { |
| value match { |
| case n: JsNumber => Option(n.value) |
| case s: JsString => Option(TemplateHelper.replaceVariable(System.currentTimeMillis(), s.value)) |
| case b: JsBoolean => Option(Boolean.box(b.value)) |
| case _ => None |
| } |
| } catch { |
| case e: Exception => |
| logger.error(s"jsValueToAny: $value", e) |
| None |
| } |
| } |
| |
| def propertiesToJson(props: Map[String, Any], |
| selectColumns: Map[String, Boolean] = Map.empty): Map[String, JsValue] = { |
| if (selectColumns.isEmpty) { |
| for { |
| (k, v) <- props |
| jsValue <- anyValToJsValue(v) |
| // labelMeta <- label.metaPropsInvMap.get(k) |
| // innerVal = toInnerVal(v.toString, labelMeta.dataType, labelMeta.) |
| } yield { |
| k -> jsValue |
| } |
| } else { |
| for { |
| (k, _) <- selectColumns |
| v <- props.get(k) |
| jsValue <- anyValToJsValue(v) |
| } yield k -> jsValue |
| } |
| } |
| |
| def jsValueToString(jsValue: JsValue): String = { |
| jsValue match { |
| case s: JsString => s.value |
| case _ => jsValue.toString |
| } |
| } |
| def fromJsonToProperties(jsObject: JsObject): Map[String, Any] = { |
| val kvs = for { |
| (k, v) <- jsObject.fieldSet |
| } yield { |
| k -> jsValueToString(v) |
| } |
| kvs.toMap |
| } |
| } |
