#42 Demo Temporals 2/3

joerg-rade · Jan 30, 2020 · a7022de · a7022de
1 parent 5ca62bc
commit a7022de
Show file tree

Hide file tree

Showing 8 changed files with 114 additions and 41 deletions.
diff --git a/src/main/kotlin/org.ro.ui.builder/FieldSetBuilder.kt b/src/main/kotlin/org.ro.ui.builder/FieldSetBuilder.kt
@@ -2,7 +2,7 @@ package org.ro.ui.builder
 
 import org.ro.layout.FieldSetLayout
 import org.ro.to.TObject
-import org.ro.to.TypeMapperType
+import org.ro.to.ValueType
 import org.ro.ui.FormItem
 import org.ro.ui.kv.FormPanelFactory
 import org.ro.ui.kv.RoDisplay
@@ -25,14 +25,19 @@ class FieldSetBuilder {
             val member = members.firstOrNull() { it.id == label }
 
             if (member != null) {
-                if (p.multiLine.asDynamic() != null) {
-                    member.type = TypeMapperType.TEXT_AREA.type
+                var size = 1
+                console.log("[FSB.create] p.multiline")
+                console.log(p.multiLine)
+                if (p.multiLine != null && p.multiLine > 1) {
+                    member.type = ValueType.TEXT_AREA.type
+                    size = p.multiLine
                 }
 
                 val fi = FormItem(
                         label = label,
                         type = member.type!!,
                         content = member.value?.content,
+                        size = size,
                         description = p.describedAs,
                         member = member,
                         tab = tab)

diff --git a/src/main/kotlin/org/ro/core/Utils.kt b/src/main/kotlin/org/ro/core/Utils.kt
@@ -153,9 +153,37 @@ object Utils {
         return "\"" + s + "\""
     }
 
-    fun toDate(dateStr: String): Date {
-        val millis = Date.parse(dateStr)
-        return Date(millis)
+    //TODO move to Value.init?
+    fun toDate(content: Any?): Date {
+        val result = when (content) {
+            is String -> {
+                var s = content
+                if (!s.contains("-")) {
+                    s = convertJavaOffsetDateTimeToISO(content)
+                }
+                val millis = Date.parse(s)
+                Date(millis)
+            }
+            is Long -> {
+                Date(content as Number)
+            }
+            else -> {
+                Date()
+            }
+        }
+        console.log("[Utils.toDate]")
+        console.log(result)
+        return result
+    }
+
+    fun convertJavaOffsetDateTimeToISO(input: String): String {
+        val year = input.substring(0, 4)
+        val month = input.substring(4, 6)
+        val dayEtc = input.substring(6, 11)
+        val minutes = input.substring(11, 13)
+        val rest = input.substring(13, input.length)
+        val output = "$year-$month-$dayEtc:$minutes:$rest"
+        return output
     }
 
 }
diff --git a/src/main/kotlin/org/ro/to/Member.kt b/src/main/kotlin/org/ro/to/Member.kt
@@ -15,7 +15,7 @@ data class Member(val id: String,
                   val optional: Boolean = false
 ) : TransferObject {
 
-    var type: String? = TypeMapperType.TEXT.type
+    var type: String? = ValueType.TEXT.type
 
     init {
         if (memberType == MemberType.PROPERTY.type

diff --git a/src/main/kotlin/org/ro/to/TypeMapper.kt b/src/main/kotlin/org/ro/to/TypeMapper.kt
@@ -2,13 +2,15 @@ package org.ro.to
 
 import org.ro.core.Utils
 
-enum class TypeMapperType(val type: String) {
+enum class ValueType(val type: String) {
     BOOLEAN("Boolean"),
     DATE("Date"),
     HTML("Html"),
     NUMERIC("Numeric"),
+    PASSWORD("Password"),
     TEXT("Text"),
     TEXT_AREA("TextArea"),
+    TIME("Time"),
     SIMPLE_SELECT("SimpleSelect")
 }
 
@@ -18,26 +20,30 @@ class TypeMapper {
         val mf = member.format
         val mex = member.extensions?.xIsisFormat
         return when {
-            mf == "int" -> TypeMapperType.NUMERIC.type
-            mf == "date" -> TypeMapperType.DATE.type
-            mf == "date-time" -> TypeMapperType.DATE.type
-            mex == "boolean" -> TypeMapperType.BOOLEAN.type
+            mf == "int" -> ValueType.NUMERIC.type
+            mf == "date" -> ValueType.DATE.type
+            mf == "date-time" -> ValueType.TIME.type
+            mf == "utc-millisec" -> ValueType.TIME.type
+            mex == "boolean" -> ValueType.BOOLEAN.type
+            //mex == "javasqltimestamp" -> TypeMapperType.DATE.type
+            //mex == "javautildate" -> TypeMapperType.DATE.type
             else -> {
                 match(member.value)
             }
         }
     }
 
-    private val ISO_DATE = Regex("/^([\\+-]?\\d{4}(?!\\d{2}\\b))((-?)((0[1-9]|1[0-2])(\\3([12]\\d|0[1-9]|3[01]))?|W([0-4]\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\d|[12]\\d{2}|3([0-5]\\d|6[1-6])))([T\\s]((([01]\\d|2[0-3])((:?)[0-5]\\d)?|24\\:?00)([\\.,]\\d+(?!:))?)?(\\17[0-5]\\d([\\.,]\\d+)?)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?)?)?\$")
-//    private val JAVA_LANG_LONG = Regex("\\d{19}")  //9223372036854775807
+    private val ISO_DATE = Regex("^([\\+-]?\\d{4}(?!\\d{2}\\b))((-?)((0[1-9]|1[0-2])(\\3([12]\\d|0[1-9]|3[01]))?|W([0-4]\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\d|[12]\\d{2}|3([0-5]\\d|6[1-6])))([T\\s]((([01]\\d|2[0-3])((:?)[0-5]\\d)?|24\\:?00)([\\.,]\\d+(?!:))?)?(\\17[0-5]\\d([\\.,]\\d+)?)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?)?)?\$")
+    private val JAVA_LANG_LONG = Regex("\\d{19}")  //9223372036854775807
+//    private val JAVA_OFFSET_DATE_TIME = Regex("\\d{19}")  //20200125T140705.356+0100
 
     private fun match(value: Value?): String {
         val contentStr = value?.content.toString()
         return when {
-            ISO_DATE.matches(contentStr) -> TypeMapperType.DATE.type
-            //           JAVA_LANG_LONG.matches(contentStr) -> NUMERIC
-            Utils.isXml(contentStr) -> TypeMapperType.HTML.type
-            else -> TypeMapperType.TEXT.type
+            ISO_DATE.matches(contentStr) -> ValueType.DATE.type
+//            JAVA_LANG_LONG.matches(contentStr) -> TypeMapperType.NUMERIC.type
+            Utils.isXml(contentStr) -> ValueType.HTML.type
+            else -> ValueType.TEXT.type
         }
     }
 

diff --git a/src/main/kotlin/org/ro/ui/kv/FormPanelFactory.kt b/src/main/kotlin/org/ro/ui/kv/FormPanelFactory.kt
@@ -1,6 +1,7 @@
 package org.ro.ui.kv
 
 import org.ro.core.Utils
+import org.ro.to.ValueType
 import org.ro.ui.FormItem
 import pl.treksoft.kvision.core.*
 import pl.treksoft.kvision.form.FormPanel
@@ -28,15 +29,15 @@ class FormPanelFactory(items: List<FormItem>) : VPanel() {
             margin = 10.px
             for (fi: FormItem in items) {
                 when (fi.type) {
-                    "Text" -> add(createText(fi))
-                    "Password" -> add(createPassword(fi))
-                    "TextArea" -> add(createTextArea(fi))
-                    "SimpleSelect" -> add(createSelect(fi))
-                    "Html" -> add(createHtml(fi))
-                    "Numeric" -> add(createNumeric(fi))
-                    "Date" -> add(createDate(fi))
-                    "Time" -> add(createTime(fi))
-                    "Boolean" -> add(createBoolean(fi))
+                    ValueType.TEXT.type -> add(createText(fi))
+                    ValueType.PASSWORD.type -> add(createPassword(fi))
+                    ValueType.TEXT_AREA.type -> add(createTextArea(fi))
+                    ValueType.SIMPLE_SELECT.type -> add(createSelect(fi))
+                    ValueType.HTML.type -> add(createHtml(fi))
+                    ValueType.NUMERIC.type -> add(createNumeric(fi))
+                    ValueType.DATE.type -> add(createDate(fi))
+                    ValueType.TIME.type -> add(createTime(fi))
+                    ValueType.BOOLEAN.type -> add(createBoolean(fi))
                 }
             }
         }
@@ -52,13 +53,13 @@ class FormPanelFactory(items: List<FormItem>) : VPanel() {
     }
 
     private fun createTime(fi: FormItem): DateTime {
-        val date = Utils.toDate(fi.content as String)
+        val date = Utils.toDate(fi.content)
         val item = dateTime(format = "HH:mm", label = fi.label, value = date)
         return item
     }
 
     private fun createDate(fi: FormItem): DateTime {
-        val date = Utils.toDate(fi.content as String)
+        val date = Utils.toDate(fi.content)
         val item = dateTime(
                 format = "YYYY-MM-DD",
                 label = fi.label,

diff --git a/src/main/resources/css/kroviz.css b/src/main/resources/css/kroviz.css
@@ -76,6 +76,12 @@ pre.highlight {
     background: #FDF6E3;
 }
 
-code.language-java {
+.language-java {
     color: #657B83 !important;
 }
+
+.header {
+    color: #2C3E50 !important;
+    background: #ECF0F1 !important;
+    padding: 3px 15px !important;
+}
diff --git a/src/test/kotlin/org/ro/core/UtilsTest.kt b/src/test/kotlin/org/ro/core/UtilsTest.kt
@@ -13,16 +13,37 @@ class UtilsTest {
     @Test
     fun testDate() {
         // given
-        val dateStr = "2020-01-25T13:07:05Z"
+        val rawDate:Any? = "2020-01-25T13:07:05Z"
         //when
-        val dateTime = Utils.toDate(dateStr)
+        val dateTime = Utils.toDate(rawDate)
         // then
         assertNotNull(dateTime)
         assertEquals(2020, dateTime.getFullYear())
         assertEquals(0, dateTime.getMonth()) // c braintwist strikes again
-        assertEquals(7, dateTime.getMinutes())
+        assertEquals(14, dateTime.getHours())  // MEZ = GMT + 1
+        assertEquals(7, dateTime.getMinutes())  // and again? shouldn't it be 7??
     }
 
+    @Test
+    fun test_javaOffsetDateTime() {
+        // given
+        val rawDate:Any? = "20200125T140705.356+0100"
+        val expected:String = "2020-01-25T14:07:05.356+0100"
+        //when Then
+
+        val actual = Utils.convertJavaOffsetDateTimeToISO(rawDate as String)
+        assertEquals(expected, actual as String)
+
+        val dateTime = Utils.toDate(actual)
+        assertNotNull(dateTime)
+        assertEquals(2020, dateTime.getFullYear())
+        assertEquals(0, dateTime.getMonth()) // c braintwist strikes again
+        assertEquals(25, dateTime.getDate())
+        assertEquals(14, dateTime.getHours())  // MEZ = GMT + 1
+        assertEquals(7, dateTime.getMinutes())  // and again? shouldn't it be 7??
+    }
+
+
     // @Test
     fun test_argumentsAsBody() {
         //given

diff --git a/src/test/kotlin/org/ro/to/FeaturedTypesTest.kt b/src/test/kotlin/org/ro/to/FeaturedTypesTest.kt
@@ -23,13 +23,19 @@ class FeaturedTypesTest {
         val javaSqlDate = properties.firstOrNull { it.id == "javaSqlDate" }!!
         assertEquals("date", javaSqlDate.format) // 2
         assertEquals("javasqldate", javaSqlDate.extensions!!.xIsisFormat) //3
-        assertEquals(true, javaSqlDate.type == TypeMapperType.DATE.type) //4
-        console.log("[FTT.testTemporals]")
-        console.log(javaSqlDate.value!!)
-        console.log(javaSqlDate.value!!.content)
+        assertEquals(true, javaSqlDate.type == ValueType.DATE.type) //4
         val dt = javaSqlDate.value?.content
         assertEquals("2020-01-24", dt as String) //5
 
+        val javaSqlTimestamp = properties.firstOrNull { it.id == "javaSqlTimestamp" }!!
+        assertEquals("utc-millisec", javaSqlTimestamp.format) // 6
+        assertEquals("javasqltimestamp", javaSqlTimestamp.extensions!!.xIsisFormat) //7
+        assertEquals(true, javaSqlTimestamp.type == ValueType.TIME.type) //8
+        console.log("[FTT.testTemporals]")
+        console.log(javaSqlTimestamp.value!!)
+        console.log(javaSqlTimestamp.value!!.content)
+        val ts = javaSqlTimestamp.value?.content
+        assertEquals(1579957625356, ts) //9
     }
 
     @Test
@@ -47,23 +53,23 @@ class FeaturedTypesTest {
         val description = properties.firstOrNull { it.id == "description" }!!
         assertEquals("string", description.format) //3
         assertEquals("string", description.extensions!!.xIsisFormat) //4
-        assertEquals(true, description.type == TypeMapperType.HTML.type) //5
+        assertEquals(true, description.type == ValueType.HTML.type) //5
 
         val javaLangBoolean = properties.firstOrNull { it.id == "javaLangBoolean" }!!
         assertEquals("boolean", javaLangBoolean.extensions!!.xIsisFormat) //6
-        assertEquals(true, javaLangBoolean.type == TypeMapperType.BOOLEAN.type) //7
+        assertEquals(true, javaLangBoolean.type == ValueType.BOOLEAN.type) //7
 
         val javaLangByte = properties.firstOrNull { it.id == "javaLangByte" }!!
         assertEquals("int", javaLangByte.format)
         assertEquals("byte", javaLangByte.extensions!!.xIsisFormat)
-        assertEquals(true, javaLangByte.type == TypeMapperType.NUMERIC.type)
+        assertEquals(true, javaLangByte.type == ValueType.NUMERIC.type)
         val jlb = javaLangByte.value?.content as Long
         assertEquals(127.toLong(), jlb)
 
         val primitiveByte = properties.firstOrNull { it.id == "primitiveByte" }!!
         assertEquals("int", primitiveByte.format)
         assertEquals("byte", primitiveByte.extensions!!.xIsisFormat)
-        assertEquals(true, primitiveByte.type == TypeMapperType.NUMERIC.type)
+        assertEquals(true, primitiveByte.type == ValueType.NUMERIC.type)
         val pb = primitiveByte.value?.content as Long
         assertEquals(-128.toLong(), pb)
     }