From a7022dee5401283f9403af3fce7b7107c79e4473 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Rade?= Date: Thu, 30 Jan 2020 18:02:54 +0100 Subject: [PATCH] #42 Demo Temporals 2/3 --- .../org.ro.ui.builder/FieldSetBuilder.kt | 11 ++++-- src/main/kotlin/org/ro/core/Utils.kt | 34 +++++++++++++++++-- src/main/kotlin/org/ro/to/Member.kt | 2 +- src/main/kotlin/org/ro/to/TypeMapper.kt | 28 +++++++++------ .../kotlin/org/ro/ui/kv/FormPanelFactory.kt | 23 +++++++------ src/main/resources/css/kroviz.css | 8 ++++- src/test/kotlin/org/ro/core/UtilsTest.kt | 27 +++++++++++++-- .../kotlin/org/ro/to/FeaturedTypesTest.kt | 22 +++++++----- 8 files changed, 114 insertions(+), 41 deletions(-) diff --git a/src/main/kotlin/org.ro.ui.builder/FieldSetBuilder.kt b/src/main/kotlin/org.ro.ui.builder/FieldSetBuilder.kt index 955dbda..41997a3 100644 --- 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 index a3603c9..03357cf 100644 --- 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 index e46e33b..6704b88 100644 --- 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 index ccb6194..0d0b6db 100644 --- 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 index 636ae68..3a135c7 100644 --- 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) : 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) : 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 index 6d56d9b..bece529 100644 --- 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 index 109067b..2c276c2 100644 --- 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 index 17aea8f..fcab7b6 100644 --- 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) }