DSL Updates

Author: Robert Winkler

kotlin-wot-binding-http/src/main/kotlin/http/HttpProtocolServer.kt

@@ -1,7 +1,13 @@
 package ai.ancf.lmos.wot.binding.http
 
 import ai.ancf.lmos.wot.Servient
+import ai.ancf.lmos.wot.thing.ContentManager
 import ai.ancf.lmos.wot.thing.ExposedThing
+import ai.ancf.lmos.wot.thing.action.ExposedThingAction
+import ai.ancf.lmos.wot.thing.form.Form
+import ai.ancf.lmos.wot.thing.form.Operation
+import ai.ancf.lmos.wot.thing.schema.InteractionAffordance
+import ai.anfc.lmos.wot.binding.Content
 import ai.anfc.lmos.wot.binding.ProtocolServer
 import ai.anfc.lmos.wot.binding.ProtocolServerException
 import com.fasterxml.jackson.databind.DeserializationFeature
@@ -30,6 +36,7 @@ class HttpProtocolServer(
     val things: MutableMap<String, ExposedThing> = mutableMapOf()
     var started = false
     private var server: EmbeddedServer<*, *>? = null
+    private val actualAddresses: List<String> = listOf()
 
     companion object {
         private val log = LoggerFactory.getLogger(HttpProtocolServer::class.java)
@@ -56,7 +63,106 @@ class HttpProtocolServer(
         log.info("Exposing thing '{}'", thing.id)
         things[thing.id] = thing
 
-        // Add logic to expose the thing's properties, actions, and events via routes
+        for (address in actualAddresses) {
+            for (contentType in ContentManager.getOfferedMediaTypes()) {
+                // make reporting of all properties optional?
+                val href = (address + "/" + thing.id).toString() + "/all/properties"
+                val form = Form(href = href, contentType = contentType, op =  listOf( Operation.READ_ALL_PROPERTIES,
+                    Operation.READ_MULTIPLE_PROPERTIES))
+
+                thing.forms += form
+                log.debug("Assign '{}' for reading all properties", href)
+
+                exposeProperties(thing, address, contentType)
+                exposeActions(thing, address, contentType)
+                exposeEvents(thing, address, contentType)
+            }
+        }
+    }
+
+    fun exposeProperties(thing: ExposedThing, address: String, contentType: String) {
+        val properties = thing.exposedProperties
+
+        properties.forEach { (name, property) ->
+
+            val href = getHrefWithVariablePattern(address, thing, "properties", name, property)
+
+            // Determine the operations based on readOnly/writeOnly status
+            val operations = when {
+                property.readOnly -> listOf(Operation.READ_PROPERTY)
+                property.writeOnly -> listOf(Operation.WRITE_PROPERTY)
+                else -> listOf(Operation.READ_PROPERTY, Operation.WRITE_PROPERTY)
+            }
+
+            // Create the main form and add it to the property
+            val form = Form(href = href, contentType = contentType, op = operations)
+            property.forms?.plusAssign(form)
+            log.debug("Assign '{}' to Property '{}'", href, name)
+
+            // If the property is observable, add an additional form with an observable href
+            if (property.observable) {
+                val observableHref = "$href/observable"
+                val observableForm = Form(
+                    href = observableHref,
+                    contentType = contentType,
+                    op = listOf(Operation.OBSERVE_PROPERTY),
+                    subprotocol = "longpoll"
+                )
+                property.forms?.plusAssign(observableForm)
+                log.debug("Assign '{}' to observe Property '{}'", observableHref, name)
+            }
+        }
+    }
+
+    fun exposeActions(thing: ExposedThing, address: String, contentType: String) {
+        val actions: Map<String, ExposedThingAction<*, *>> = thing.exposedActions
+        actions.forEach { (name, action) ->
+            val href: String = getHrefWithVariablePattern(address, thing, "actions", name, action)
+            // Initialize the form using named parameters
+            val form = Form(
+                href = href,
+                contentType = contentType,
+                op = listOf(Operation.INVOKE_ACTION)
+            )
+
+            // Add the form to the action
+            action.forms?.plusAssign(form)
+            log.debug("Assign '{}' to Action '{}'", href, name)
+        }
+    }
+
+    fun exposeEvents(thing: ExposedThing, address: String, contentType: String) {
+        val events = thing.exposedEvents
+        events.forEach { (name, event) ->
+            val href = getHrefWithVariablePattern(address, thing, "events", name, event)
+
+            // Create the form using named parameters directly
+            val form = Form(
+                href = href,
+                contentType = contentType,
+                subprotocol = "longpoll",
+                op = listOf(Operation.SUBSCRIBE_EVENT)
+            )
+
+            // Add the form to the event
+            event.forms?.plusAssign(form)
+            log.debug("Assign '{}' to Event '{}'", href, name)
+        }
+    }
+
+    private fun getHrefWithVariablePattern(
+        address: String,
+        thing: ExposedThing,
+        type: String,
+        interactionName: String,
+        interaction: InteractionAffordance
+    ): String {
+        var variables = ""
+        val uriVariables = interaction.uriVariables?.keys
+        if (uriVariables != null) {
+            variables = "{?" + java.lang.String.join(",", uriVariables) + "}"
+        }
+        return "$address/${thing.id}/$type/$interactionName$variables"
     }
 
     // Destroy a thing
@@ -102,9 +208,9 @@ fun Application.setupRouting(servient: Servient) {
                     val id = call.parameters["id"] ?: return@get call.response.status(HttpStatusCode.BadRequest)
                     val propertyName = call.parameters["name"]
                     val thing = servient.things[id] ?: return@get call.response.status(HttpStatusCode.NotFound)
-                    val property = thing.properties[propertyName]
+                    val property = thing.exposedProperties[propertyName]
                     if (property != null) {
-                        call.respond("TODO Return property value", typeInfo<String>())
+                       // call.respond(property.read())
                     } else {
                         call.response.status(HttpStatusCode.NotFound)
                     }
@@ -113,13 +219,15 @@ fun Application.setupRouting(servient: Servient) {
                     val id = call.parameters["id"] ?: return@put call.response.status(HttpStatusCode.BadRequest)
                     val propertyName = call.parameters["name"]
                     val thing = servient.things[id] ?: return@put call.response.status(HttpStatusCode.NotFound)
-                    val property = thing.properties[propertyName]
+                    val property = thing.exposedProperties[propertyName]
                     if (property != null) {
                         if (!property.readOnly) {
-                            val newValue = call.receive<Any>()
-                            // TODO handle write logic
+                            val contentType = getOrDefaultRequestContentType(call.request)
+                            val content = Content(contentType.toString(), call.receiveText())
+                            val input = ContentManager.contentToValue(content, property)
 
-                            call.response.status(HttpStatusCode.OK)
+                            //val newValue = property.write(input)
+                            //call.respond(newValue)
                         } else {
                             call.response.status(HttpStatusCode.BadRequest)
                         }
@@ -132,7 +240,7 @@ fun Application.setupRouting(servient: Servient) {
                 val id = call.parameters["id"] ?: return@post call.response.status(HttpStatusCode.BadRequest)
                 val actionName = call.parameters["name"]
                 val thing = servient.things[id] ?: return@post call.response.status(HttpStatusCode.NotFound)
-                val action = thing.actions[actionName]
+                val action = thing.exposedActions[actionName]
                 if (action != null) {
                     val input = call.receive<Any>()
                     call.respond("TODO Return action response", typeInfo<String>())
@@ -154,4 +262,14 @@ private fun Application.setupJackson() {
             configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
         }
     }
+}
+
+private fun getOrDefaultRequestContentType(request: RoutingRequest): ContentType {
+    val contentType = request.contentType()
+    // Check if the content type is of type `Any` and return the default
+    return if (contentType == ContentType.Any) {
+        ContentType.Application.Json
+    } else {
+        contentType
+    }
 }

kotlin-wot/src/main/kotlin/thing/ContentManager.kt

@@ -13,6 +13,10 @@ interface ContentManager {
         fun valueToContent(parameters: Map<String, Any>, contentType: String): Content {
             TODO("Not yet implemented")
         }
+
+        fun getOfferedMediaTypes(): List<String> {
+            TODO("Not yet implemented")
+        }
     }
 
 }

kotlin-wot/src/main/kotlin/thing/ExposedThing.kt

@@ -44,9 +44,9 @@ import java.util.*
 @Serializable
 data class ExposedThing(private val thing: Thing = Thing()) : ThingDescription by thing {
 
-    private val _properties : MutableMap<String, ExposedThingProperty<*>> = mutableMapOf()
-    private val _actions : MutableMap<String, ExposedThingAction<Any, Any>> = mutableMapOf()
-    private val _events : MutableMap<String, ExposedThingEvent<Any, Any, Any>> = mutableMapOf()
+    val exposedProperties : MutableMap<String, ExposedThingProperty<*>> = mutableMapOf()
+    val exposedActions : MutableMap<String, ExposedThingAction<*, *>> = mutableMapOf()
+    val exposedEvents : MutableMap<String, ExposedThingEvent<*, *, *>> = mutableMapOf()
 
     init {
         thing.properties.forEach { (name, property) ->
@@ -59,15 +59,15 @@ data class ExposedThing(private val thing: Thing = Thing()) : ThingDescription b
                 is ArrayProperty<*> -> ExposedArrayProperty(thing = thing, property = property)
                 is ObjectProperty -> ExposedObjectProperty(thing = thing, property = property)
             }
-            _properties[name] = exposedProperty
+            exposedProperties[name] = exposedProperty
         }
 
         thing.actions.forEach { (name, action) ->
-            _actions[name] = ExposedThingAction(action, thing)
+            exposedActions[name] = ExposedThingAction(action, thing)
         }
 
         thing.events.forEach { (name, event) ->
-            _events[name] = ExposedThingEvent(event)
+            exposedEvents[name] = ExposedThingEvent(event)
         }
     }
 
@@ -78,7 +78,7 @@ data class ExposedThing(private val thing: Thing = Thing()) : ThingDescription b
      */
     suspend fun readProperties(): Map<String, Any> {
         val values: MutableMap<String, Any> = HashMap()
-        _properties.forEach { (name, property) ->
+        exposedProperties.forEach { (name, property) ->
             values[name] = property.read() as Any
         }
         return values
@@ -94,7 +94,7 @@ data class ExposedThing(private val thing: Thing = Thing()) : ThingDescription b
     suspend fun writeProperties(values: Map<String, Any>): Map<String, Any> {
         val returnValues: MutableMap<String, Any> = HashMap()
         values.forEach { (name, value) ->
-            val property = _properties[name]
+            val property = exposedProperties[name]
             if (property != null) {
                 // Check if the property's type matches the value's type
                 when (property) {
@@ -222,8 +222,8 @@ data class Thing (
     @JsonInclude(NON_EMPTY) override var description: String? = null,
     @JsonInclude(NON_EMPTY) override var descriptions: MutableMap<String, String>? = null,
     @JsonInclude(NON_EMPTY) override var properties: MutableMap<String, ThingProperty<*>> = mutableMapOf(),
-    @JsonInclude(NON_EMPTY) override var actions: MutableMap<String, ThingAction<Any, Any>> = mutableMapOf(),
-    @JsonInclude(NON_EMPTY) override var events: MutableMap<String, ThingEvent<Any, Any, Any>> = mutableMapOf(),
+    @JsonInclude(NON_EMPTY) override var actions: MutableMap<String, ThingAction<*, *>> = mutableMapOf(),
+    @JsonInclude(NON_EMPTY) override var events: MutableMap<String, ThingEvent<*, *, *>> = mutableMapOf(),
     @JsonInclude(NON_EMPTY) override var forms: List<Form> = emptyList(),
     @JsonFormat(with = [JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY]) @JsonInclude(NON_EMPTY) override var security: List<String> = emptyList(),
     @JsonInclude(NON_EMPTY) override var securityDefinitions: MutableMap<String, SecurityScheme> = mutableMapOf(),
@@ -238,6 +238,17 @@ data class Thing (
     @JsonInclude(NON_EMPTY) override var uriVariables: MutableMap<String, DataSchema<@Contextual Any>>? = null
 ) : ThingDescription {
 
+    inline fun <reified T> property(name: String, configure: ThingProperty<T>.() -> Unit) {
+        val property: ThingProperty<T> = when (T::class) {
+            String::class -> StringProperty() as ThingProperty<T>
+            Int::class -> IntProperty() as ThingProperty<T>
+            Boolean::class -> BooleanProperty() as ThingProperty<T>
+            else -> throw IllegalArgumentException("Unsupported property type")
+        }
+        property.configure()
+        properties[name] = property
+    }
+
     fun Thing.stringProperty(name: String, configure: StringProperty.() -> Unit) {
         this.properties[name] = StringProperty().apply(configure)
     }
@@ -247,15 +258,15 @@ data class Thing (
     fun Thing.booleanProperty(name: String, configure: BooleanProperty.() -> Unit) {
         this.properties[name] = BooleanProperty().apply(configure)
     }
-
-    fun Thing.action(name: String, configure: ThingAction<Any, Any>.() -> Unit) {
-        this.actions[name] = ThingAction<Any, Any>().apply(configure)
+    fun <I : Any, O : Any> Thing.action(name: String, configure: ThingAction<I, O>.() -> Unit) {
+        val action = ThingAction<I, O>().apply(configure)
+        actions[name] = action
     }
 
-    fun Thing.event(name: String, configure: ThingEvent<Any, Any, Any>.() -> Unit) {
-        this.events[name] = ThingEvent<Any, Any, Any>().apply(configure)
+    fun <T, S, C> Thing.event(name: String, configure: ThingEvent<T, S, C>.() -> Unit) {
+        val event = ThingEvent<T, S, C>().apply(configure)
+        events[name] = event
     }
-
     /*
 
     fun getPropertiesByObjectType(objectType: String): Map<String, ThingProperty<Any>> {

kotlin-wot/src/main/kotlin/thing/schema/ArraySchema.kt

@@ -91,4 +91,4 @@ open class ArraySchema<T>(
         result = 31 * result + (maxItems ?: 0)
         return result
     }
-}
+}

kotlin-wot/src/main/kotlin/thing/schema/BooleanSchema.kt

@@ -79,4 +79,8 @@ open class BooleanSchema(
         result = 31 * result + (format?.hashCode() ?: 0)
         return result
     }
+}
+
+fun booleanSchema(initializer: BooleanSchema.() -> Unit): BooleanSchema {
+    return BooleanSchema().apply(initializer)
 }

kotlin-wot/src/main/kotlin/thing/schema/IntegerSchema.kt

@@ -105,4 +105,8 @@ open class IntegerSchema(
         result = 31 * result + (multipleOf ?: 0)
         return result
     }
+}
+
+fun integerSchema(initializer: IntegerSchema.() -> Unit): IntegerSchema {
+    return IntegerSchema().apply(initializer)
 }

kotlin-wot/src/main/kotlin/thing/schema/NumberSchema.kt

@@ -99,4 +99,8 @@ open class NumberSchema(
         result = 31 * result + (multipleOf ?: 0)
         return result
     }
+}
+
+fun numberSchema(initializer: NumberSchema.() -> Unit): NumberSchema {
+    return NumberSchema().apply(initializer)
 }

kotlin-wot/src/main/kotlin/thing/schema/ObjectSchema.kt

@@ -85,4 +85,8 @@ open class ObjectSchema(
         result = 31 * result + (format?.hashCode() ?: 0)
         return result
     }
+}
+
+fun objectSchema(initializer: ObjectSchema.() -> Unit): ObjectSchema {
+    return ObjectSchema().apply(initializer)
 }

kotlin-wot/src/main/kotlin/thing/schema/StringSchema.kt

@@ -105,3 +105,7 @@ open class StringSchema(
         return result
     }
 }
+
+fun stringSchema(initializer: StringSchema.() -> Unit): StringSchema {
+    return StringSchema().apply(initializer)
+}

kotlin-wot/src/main/kotlin/thing/schema/ThingDescription.kt

@@ -85,15 +85,15 @@ interface ThingDescription : BaseSchema {
      * @return a map of action affordances.
      */
     @get:JsonInclude(JsonInclude.Include.NON_EMPTY)
-    var actions: MutableMap<String, ThingAction<Any, Any>> // Optional: Map of ActionAffordance
+    var actions: MutableMap<String, ThingAction<*, *>> // Optional: Map of ActionAffordance
 
     /**
      * All Event-based Interaction Affordances of the Thing.
      *
      * @return a map of event affordances.
      */
     @get:JsonInclude(JsonInclude.Include.NON_EMPTY)
-    var events: MutableMap<String, ThingEvent<Any, Any, Any>> // Optional: Map of EventAffordance
+    var events: MutableMap<String, ThingEvent<*, *, *>> // Optional: Map of EventAffordance
 
     /**
      * Provides Web links to arbitrary resources that relate to the specified Thing Description.