stinger-ipc 0.0.10__py3-none-any.whl → 0.0.26__py3-none-any.whl

stingeripc/templates/cpp/src/client.cpp.jinja2

@@ -1,3 +1,7 @@
+{% import "partials/deserialize.jinja2" as deser %}
+{% import "partials/serialize.jinja2" as ser %}
+{% import "partials/args.jinja2" as ar %}
+{%macro prop_value_type(prop) -%}{%if prop.arg_list|length > 1%}struct {%endif%}{{prop.name | UpperCamelCase}}Property{%endmacro%}
 
 #include <vector>
 #include <iostream>
@@ -16,20 +20,22 @@
 #include "{{stinger.cpp.enum_header_file}}"
 #include "ibrokerconnection.hpp"
 
-
 constexpr const char {{stinger.cpp.client_class_name}}::NAME[];
 constexpr const char {{stinger.cpp.client_class_name}}::INTERFACE_VERSION[];
 
 {{stinger.cpp.client_class_name}}::{{stinger.cpp.client_class_name}}(std::shared_ptr<IBrokerConnection> broker) : _broker(broker)
 {
-    _broker->AddMessageCallback([this](const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<std::string> unusedRespTopic, const boost::optional<MethodResultCode> optResultCode)
+    _broker->AddMessageCallback([this](
+            const std::string& topic, 
+            const std::string& payload, 
+            const MqttProperties& mqttProps)
     {
-        _receiveMessage(topic, payload, optCorrelationId, optResultCode);
+        _receiveMessage(topic, payload, mqttProps);
     });
 
     {%-for sig_name, sig in stinger.signals.items() %}
-    _broker->Subscribe("{{sig.topic}}", 1);
-    {%endfor%}
+    _{{sig_name | lowerCamelCase}}SignalSubscriptionId = _broker->Subscribe("{{sig.topic}}", 2);
+    {%-endfor%}
     {%-for method_name, method in stinger.methods.items() %}
     { // Restrict scope
         std::stringstream responseTopicStringStream;
@@ -37,21 +43,24 @@ constexpr const char {{stinger.cpp.client_class_name}}::INTERFACE_VERSION[];
         _broker->Subscribe(responseTopicStringStream.str(), 2);
     }
     {%-endfor%}
+
+    {%-for prop_name, prop in stinger.properties.items() %}
+    _{{prop_name | lowerCamelCase}}PropertySubscriptionId = _broker->Subscribe("{{prop.value_topic}}", 1);
+    {%-endfor%}
 }
 
 void {{stinger.cpp.client_class_name}}::_receiveMessage(
         const std::string& topic, 
         const std::string& payload, 
-        const boost::optional<std::string> optCorrelationId, 
-        const boost::optional<MethodResultCode> optResultCode)
+        const MqttProperties& mqttProps)
 {
     {%-for sig_name, sig in stinger.signals.items() %}
-    if (_broker->TopicMatchesSubscription(topic, "{{sig.topic}}"))
+    if ((mqttProps.subscriptionId && (*mqttProps.subscriptionId == _{{sig_name | lowerCamelCase}}SignalSubscriptionId)) || _broker->TopicMatchesSubscription(topic, "{{sig.topic}}"))
     {
         //Log("Handling {{sig_name}} signal");
         rapidjson::Document doc;
         try {
-            if (_{{sig_name | camelCase}}Callback)
+            if (_{{sig_name | camelCase}}SignalCallbacks.size() > 0)
             {
                 rapidjson::ParseResult ok = doc.Parse(payload.c_str());
                 if (!ok)
@@ -82,9 +91,11 @@ void {{stinger.cpp.client_class_name}}::_receiveMessage(
                     {%endif%}
                     }
                 }
-                {%endfor%}
-
-                _{{sig_name | camelCase}}Callback({%for arg in sig.arg_list%}temp{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%});
+                {%endfor%}{# for signal args #}
+                for (const auto& cb : _{{sig_name | lowerCamelCase}}SignalCallbacks)
+                {
+                    cb({%for arg in sig.arg_list%}temp{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%});
+                }
             }
         }
         catch (const boost::bad_lexical_cast&)
@@ -94,21 +105,29 @@ void {{stinger.cpp.client_class_name}}::_receiveMessage(
             // TODO: Log this failure
         }
     }
-    {%-endfor%}
+    {%-endfor%}{# for signals #}
+
     {%-for method_name, method in stinger.methods.items() %}
-    {%if not loop.first%}else {%endif%}if (_broker->TopicMatchesSubscription(topic, "{{method.response_topic('+')}}") && optCorrelationId)
+    {%if not loop.first%}else {%endif%}if (_broker->TopicMatchesSubscription(topic, "{{method.response_topic('+')}}") && mqttProps.correlationId)
     {
         std::cout << "Matched topic for {{method_name}} response" << std::endl;
-        _handle{{method_name|UpperCamelCase}}Response(topic, payload, *optCorrelationId);
+        _handle{{method_name|UpperCamelCase}}Response(topic, payload, *mqttProps.correlationId);
     }
-    {%-endfor%}
+    {%-endfor%}{# for methods #}
+
+    {%-for prop_name, prop in stinger.properties.items() %}
+    {%if not loop.first%}else {%endif%}if ((mqttProps.subscriptionId && (*mqttProps.subscriptionId == _{{prop_name | lowerCamelCase}}PropertySubscriptionId)) || topic == "{{prop.value_topic}}")
+    {
+        _receive{{prop_name | UpperCamelCase}}PropertyUpdate(topic, payload, mqttProps.propertyVersion);
+    }
+    {%-endfor%}{# for properties #}
 }
 
 
 {%-for sig_name, sig in stinger.signals.items() %}
 void {{stinger.cpp.client_class_name}}::register{{sig_name | UpperCamelCase}}Callback(const std::function<void({%for arg in sig.arg_list%}{{arg.cpp_type}}{%if not loop.last%}, {%endif%}{%endfor%})>& cb)
 {
-    _{{sig_name | camelCase}}Callback = cb;
+    _{{sig_name | lowerCamelCase}}SignalCallbacks.push_back(cb);
 }
 {%-endfor%}
 
@@ -122,31 +141,19 @@ boost::future<{{method.return_value_cpp_class}}> {{stinger.cpp.client_class_name
     rapidjson::Document doc;
     doc.SetObject();
 
-    {%-macro addToDoc(arg)%}
-    {%-if arg.arg_type.name.lower() == 'primitive'%}
-    {%-if arg.optional %}if ({{arg.name}}) {%endif-%}
-    {%-if arg.type.name.lower() == 'string'%}
-    { // restrict scope
-        rapidjson::Value tempStringValue;
-        tempStringValue.SetString({{arg.name}}{%-if arg.optional %}->{%else%}.{%endif-%}c_str(), {{arg.name}}.size(), doc.GetAllocator());
-        doc.AddMember("{{arg.name}}", tempStringValue, doc.GetAllocator());
-    }
-    {%-else%}
-    doc.AddMember("{{arg.name}}", {%-if arg.optional %}*{%endif-%}{{arg.name}}, doc.GetAllocator());
-    {%-endif%}
-    {%elif arg.arg_type.name.lower() == 'enum'%}
-    doc.AddMember("{{arg.name}}", static_cast<int>({{arg.name}}), doc.GetAllocator());
-    {%-endif-%}
-    {%endmacro%}
     {%for arg in method.arg_list%}
-    {{addToDoc(arg)}}
+    {{ser.addToValue('doc', arg, 'doc.GetAllocator()') | indent(4)}}
     {%endfor%}
     rapidjson::StringBuffer buf;
     rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
     doc.Accept(writer);
     std::stringstream responseTopicStringStream;
     responseTopicStringStream << boost::format("{{method.response_topic('%1%')}}") % _broker->GetClientId();
-    _broker->Publish("{{method.topic}}", buf.GetString(), 2, false, correlationIdStr, responseTopicStringStream.str(), MethodResultCode::SUCCESS);
+    MqttProperties mqttProps;
+    mqttProps.correlationId = correlationIdStr;
+    mqttProps.responseTopic = responseTopicStringStream.str();
+    mqttProps.resultCode = MethodResultCode::SUCCESS;
+    _broker->Publish("{{method.topic}}", buf.GetString(), 2, false, mqttProps);
 
     return _pending{{method_name|UpperCamelCase}}MethodCalls[correlationId].get_future();
 }
@@ -157,6 +164,7 @@ void {{stinger.cpp.client_class_name}}::_handle{{method_name|UpperCamelCase}}Res
         const std::string &correlationId) 
 {
     std::cout << "In response handler for " << topic << " with correlationId=" << correlationId << std::endl;
+    {%if method.return_value_type is not false%}
     rapidjson::Document doc;
     rapidjson::ParseResult ok = doc.Parse(payload.c_str());
     if (!ok)
@@ -164,11 +172,10 @@ void {{stinger.cpp.client_class_name}}::_handle{{method_name|UpperCamelCase}}Res
         //Log("Could not JSON parse {{method_name}} signal payload.");
         throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
     }
-
     if (!doc.IsObject()) {
         throw std::runtime_error("Received payload is not an object");
     }
-
+    {%endif%}
     boost::uuids::uuid correlationIdUuid = boost::lexical_cast<boost::uuids::uuid>(correlationId);
     auto promiseItr = _pending{{method_name|UpperCamelCase}}MethodCalls.find(correlationIdUuid);
     if (promiseItr != _pending{{method_name|UpperCamelCase}}MethodCalls.end())
@@ -204,4 +211,70 @@ void {{stinger.cpp.client_class_name}}::_handle{{method_name|UpperCamelCase}}Res
 
     std::cout << "End of response handler for " << topic << std::endl;
 }
-{%endfor%}
+{%endfor%}{# end for each method #}
+{%for prop_name, prop in stinger.properties.items()%}
+void {{stinger.cpp.client_class_name}}::_receive{{prop_name | UpperCamelCase}}PropertyUpdate(const std::string& topic, const std::string& payload, boost::optional<int> optPropertyVersion)
+{
+    rapidjson::Document doc;
+    rapidjson::ParseResult ok = doc.Parse(payload.c_str());
+    if (!ok)
+    {
+        //Log("Could not JSON parse {{prop_name}} property update payload.");
+        throw std::runtime_error(rapidjson::GetParseError_En(ok.Code()));
+    }
+
+    if (!doc.IsObject()) {
+        throw std::runtime_error("Received {{prop_name}} payload is not an object");
+    }
+    {{prop.name | UpperCamelCase}}Property tempValue;
+    {{deser.deserialize('tempValue', prop.arg_list, 'doc') | indent(4)}}
+
+    { // Scope lock
+        std::lock_guard<std::mutex> lock(_{{prop_name | lowerCamelCase}}PropertyMutex);
+        _{{prop_name | lowerCamelCase}}Property = tempValue;
+        _last{{prop_name | UpperCamelCase}}PropertyVersion = optPropertyVersion ? *optPropertyVersion : -1;
+    }
+    // Notify all registered callbacks.
+    { // Scope lock
+        std::lock_guard<std::mutex> lock(_{{prop_name | lowerCamelCase}}PropertyCallbacksMutex);
+        for (const auto& cb : _{{prop_name | lowerCamelCase}}PropertyCallbacks)
+        {
+            // Don't need a mutex since we're using tempValue.
+            {%if prop.arg_list | length > 1 %}
+            cb({%for arg in prop.arg_list %}tempValue.{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%});
+            {%else %}
+            cb(tempValue);
+            {%endif %}
+        }
+    }
+}
+
+boost::optional<{{prop_value_type(prop)}}> {{stinger.cpp.client_class_name}}::get{{prop_name | UpperCamelCase}}Property() const
+{
+    std::lock_guard<std::mutex> lock(_{{prop_name | lowerCamelCase}}PropertyMutex);
+    return _{{prop_name | lowerCamelCase}}Property;
+}
+
+void {{stinger.cpp.client_class_name}}::register{{prop_name | UpperCamelCase}}PropertyCallback(const std::function<void({{ar.methodParams(prop.arg_list)}})>& cb)
+{
+    std::lock_guard<std::mutex> lock(_{{prop_name | lowerCamelCase}}PropertyCallbacksMutex);
+    _{{prop_name | lowerCamelCase}}PropertyCallbacks.push_back(cb);
+}
+{% if not prop.read_only %}
+boost::future<bool> {{stinger.cpp.client_class_name}}::update{{prop_name | UpperCamelCase}}Property({{ar.methodParams(prop.arg_list)}}) const
+{
+
+    rapidjson::Document doc;
+    doc.SetObject();
+    {%for item in prop.arg_list %}
+    {{ser.addToValue('doc', item, 'doc.GetAllocator()') | indent(4)}}
+    {%endfor %}
+    rapidjson::StringBuffer buf;
+    rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
+    doc.Accept(writer);
+    MqttProperties mqttProps;
+    return _broker->Publish("{{prop.update_topic}}", buf.GetString(), 1, false, mqttProps);
+
+}
+{%endif%}
+{% endfor %} {# for properties #}

stingeripc/templates/cpp/src/property_structs.cpp.jinja2

@@ -0,0 +1,25 @@
+{% import "partials/deserialize.jinja2"  as deser %}
+{% import "partials/serialize.jinja2" as ser %}
+#include "property_structs.hpp"
+#include <rapidjson/document.h>
+
+{%for prop_name, prop in stinger.properties.items()%}
+{%- if prop.arg_list| length > 1 %}
+{{prop.name | UpperCamelCase}}Property {{prop.name | UpperCamelCase}}Property::FromRapidJsonObject(const rapidjson::Value& jsonObj)
+{
+    {{prop.name | UpperCamelCase}}Property {{prop.name | lowerCamelCase }};
+    {{deser.deserialize(prop.name|lowerCamelCase, prop.arg_list, 'jsonObj') | indent(4)}}
+
+    return {{prop.name | lowerCamelCase}};
+};
+
+rapidjson::Value {{prop.name | UpperCamelCase}}Property::ToRapidJsonObject(rapidjson::Document::AllocatorType& allocator) const
+{
+    rapidjson::Value obj(rapidjson::kObjectType);
+    {%for arg in prop.arg_list%}
+    {{ser.addToValue('obj', arg, 'allocator') | indent(4)}}
+    {%- endfor %}
+    return obj;
+}
+{%- endif %}
+{% endfor %}

stingeripc/templates/cpp/src/server.cpp.jinja2

@@ -1,4 +1,6 @@
 
+{% import "partials/serialize.jinja2" as ser %}
+
 #include <vector>
 #include <iostream>
 #include <boost/format.hpp>
@@ -19,9 +21,12 @@ constexpr const char {{stinger.cpp.server_class_name}}::NAME[];
 constexpr const char {{stinger.cpp.server_class_name}}::INTERFACE_VERSION[];
 
 {{stinger.cpp.server_class_name}}::{{stinger.cpp.server_class_name}}(std::shared_ptr<IBrokerConnection> broker) : _broker(broker) {
-    _broker->AddMessageCallback([this](const std::string& topic, const std::string& payload, const boost::optional<std::string> optCorrelationId, const boost::optional<std::string> optResponseTopic, const boost::optional<MethodResultCode> unusedRc)
+    _broker->AddMessageCallback([this](
+            const std::string& topic, 
+            const std::string& payload, 
+            const MqttProperties& mqttProps)
     {
-        _receiveMessage(topic, payload, optCorrelationId, optResponseTopic);
+        _receiveMessage(topic, payload, mqttProps);
     });
     {%for method in stinger.methods.values()%}
     _broker->Subscribe("{{method.topic}}", 2);
@@ -31,8 +36,7 @@ constexpr const char {{stinger.cpp.server_class_name}}::INTERFACE_VERSION[];
 void {{stinger.cpp.server_class_name}}::_receiveMessage(
         const std::string& topic, 
         const std::string& payload, 
-        const boost::optional<std::string> optCorrelationId, 
-        const boost::optional<std::string> optResponseTopic)
+        const MqttProperties& mqttProps)
 {
     {%for method_name, method in stinger.methods.items()%}
     if (_broker->TopicMatchesSubscription(topic, "{{method.topic}}"))
@@ -53,7 +57,7 @@ void {{stinger.cpp.server_class_name}}::_receiveMessage(
                     throw std::runtime_error("Received payload is not an object");
                 }
 
-                _call{{method_name | UpperCamelCase}}Handler(topic, doc, optCorrelationId, optResponseTopic);
+                _call{{method_name | UpperCamelCase}}Handler(topic, doc, mqttProps.correlationId, mqttProps.responseTopic);
             }
         }
         catch (const boost::bad_lexical_cast&)
@@ -71,29 +75,14 @@ boost::future<bool> {{stinger.cpp.server_class_name}}::emit{{sig_name | UpperCam
 {
     rapidjson::Document doc;
     doc.SetObject();
-    {%macro addToDoc(arg)%}
-    {%-if arg.optional%}if ({{arg.name}}){%endif%}
-    {%-if arg.arg_type.name.lower() == 'primitive'%}
-    {%-if arg.type.name.lower() == 'string'%}
-    { // restrict scope
-        rapidjson::Value tempStringValue;
-        tempStringValue.SetString({{arg.name}}{%-if arg.optional%}->{%else%}.{%endif%}c_str(), {{arg.name}}.size(), doc.GetAllocator());
-        doc.AddMember("{{arg.name}}", tempStringValue, doc.GetAllocator());
-    }
-    {%-else%}
-    doc.AddMember("{{arg.name}}", {%-if arg.optional%}*{%endif%}{{arg.name}}, doc.GetAllocator());
-    {%-endif%}
-    {%-elif arg.arg_type.name.lower() == 'enum'%}
-    doc.AddMember("{{arg.name}}", static_cast<int>({%-if arg.optional%}*{%endif%}{{arg.name}}), doc.GetAllocator());
-    {%-endif-%}
-    {%-endmacro%}
     {%-for arg in sig.arg_list%}
-    {{addToDoc(arg)}}
-    {%endfor%}
+    {{ser.addToValue('doc', arg, 'doc.GetAllocator()') | indent}}
+    {%-endfor%}
     rapidjson::StringBuffer buf;
     rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
     doc.Accept(writer);
-    return _broker->Publish("{{sig.topic}}", buf.GetString(), 1, false, boost::none, boost::none, boost::none);
+    MqttProperties mqttProps;
+    return _broker->Publish("{{sig.topic}}", buf.GetString(), 1, false, mqttProps);
 }
 {%endfor%}
 
@@ -163,7 +152,10 @@ void {{stinger.cpp.server_class_name}}::_call{{method_name | UpperCamelCase}}Han
             rapidjson::StringBuffer buf;
             rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
             responseJson.Accept(writer);
-            _broker->Publish(*optResponseTopic, buf.GetString(), 2, false, optCorrelationId, boost::none, MethodResultCode::SUCCESS);
+            MqttProperties mqttProps;
+            mqttProps.correlationId = optCorrelationId;
+            mqttProps.resultCode = MethodResultCode::SUCCESS;
+            _broker->Publish(*optResponseTopic, buf.GetString(), 2, false, mqttProps);
         }
     }
 }

stingeripc/templates/cpp/src/structs.cpp.jinja2

@@ -0,0 +1,13 @@
+{% import "partials/deserialize.jinja2"  as deser %}
+#include "structs.hpp"
+
+
+{%for istruct_name, istruct in stinger.structs.items() %}
+{{istruct_name | UpperCamelCase }} {{istruct_name | UpperCamelCase }}::FromRapidJsonObject(const rapidjson::Value& jsonObj)
+{
+    {{istruct_name | UpperCamelCase }} {{istruct_name | lowerCamelCase }};
+    {{deser.deserialize(istruct_name|lowerCamelCase, istruct.members, 'jsonObj') | indent(4)}}
+
+    return {{istruct_name | lowerCamelCase}};
+};
+{%endfor%}

stingeripc/templates/html/app.js.jinja2

@@ -1,14 +1,14 @@
 const clientId = "{{stinger.name}}-web-" + new Date().getTime();
 
-const signalSubIdStart = 1;
-const propertySubIdStart = {{10 + stinger.signals|length}};
+const responseTopic = "client/" + clientId + "/responses";
+var responseSubscriptionId = null;
 
 function makeRequestProperties() {
     const correlationData = Math.random().toString(16).substr(2, 8);
     return {
         "contentType": "application/json",
         "correlationData": correlationData,
-        "responseTopic": responseTopic + correlationData
+        "responseTopic": responseTopic
     }
 }
 
@@ -22,17 +22,58 @@ app.controller("myCtrl", function ($scope, $filter, $location) {
 
     $scope.timePattern = new RegExp("^[0-2][0-9]:[0-5][0-9]$");
     $scope.online = false;
+
+    $scope.enums = {
+        {%-for enum_name, enum in stinger.enums.items() %}
+        // {{enum}}
+        "{{enum_name | snake_case}}": [
+            {%-for e in enum.values %}
+            {"name": "{{e}}", "id": {{loop.index}} }{%if not loop.last%},{%endif%}
+            {%endfor-%}
+        ]{%if not loop.last%},{%endif%}
+    {%endfor-%} };
+
     $scope.signals = { {%-for sig_name, signal in stinger.signals.items() %}
-        "{{sig_name | lowerCamelCase}}": {
+        "{{sig_name | snake_case}}": {
             "subscription_id": null,
             "name": "{{sig_name}}",
-            "received": [],
+            "received": null,
+            "received_time": null,
             "mqtt_topic": "{{signal.topic}}"
         }{%if not loop.last%},{%endif%}
     {%endfor-%} };
 
-    $scope.properties = {
+    $scope.properties = { {%-for prop_name, prop in stinger.properties.items() %}
+        "{{prop_name | snake_case}}": {
+            "subscription_id": null,
+            "name": "{{prop_name}}",
+            "received": { {%for arg in prop.arg_list %}
+                "{{arg.name|snake_case}}": {%if arg.type == "argtype.primitive"%}{%else%}{ {%for member in arg.members %}
+                    "{{member.name|snake_case}}": "{{member.value}}"{%if not loop.last%},{%endif%}
+                {%endfor%} }{%endif%}{%if not loop.last%},{%endif%}
+            {%endfor%} },
+            "mqtt_topic": "{{prop.value_topic}}"{%if not prop.read_only %},
+            "update_topic": "{{prop.update_topic}}"{%endif%}
+        }{%if not loop.last%},{%endif%}
+    {%endfor-%} };
 
+    $scope.methods = {
+        {%-for method_name, method in stinger.methods.items() %}
+        "{{method_name | snake_case}}": {
+            "name": "{{method_name}}",
+            "mqtt_topic": "{{method.topic}}",
+            "response_topic": "{{method.response_topic('"+clientId+"')}}",
+            "pending_correlation_id": null,
+            "args": { {%-for arg in method.arg_list %}
+                "{{arg.name|snake_case}}": {
+                    "type": "{{arg.type}}",
+                    "value": null
+                }{%if not loop.last%},{%endif%}
+            {%endfor-%} },
+            "received": null,
+            "received_time": null
+        }{%if not loop.last%},{%endif%}
+        {%-endfor%}
     };
 
     $scope.console = {
@@ -63,26 +104,17 @@ app.controller("myCtrl", function ($scope, $filter, $location) {
         console.log(name + " Sending to " + topic);
         console.log(payload);
         let props = makeRequestProperties();
-        props 
         $scope.console.requests.unshift({"name":name, "correlationData":props.correlationData, "topic": topic, "payload": payload, "response": null, "requestTime": Date.now()});
         client.publish(topic, payload, { "qos": qos, retain: false, properties: props});
         return props.correlationData;
     }
 
     client.on('message', function(topic, message, packet) {
-        console.log("Message Arrived: " + topic);
-
+        
         const subid = packet.properties.subscriptionIdentifier;
 
-        if (subid >= signalSubIdStart && subid < propertySubIdStart) {
-            const signal_index = subid - signalSubIdStart;
-            console.log("Signal index: " + signal_index);
-            $scope.data.signals[signal_index] = JSON.parse(message.toString());
-        } else if (subid >= propertySubIdStart && subid < propertySubIdStart + {{stinger.properties|length}}) {
-            const prop_index = subid - propertySubIdStart;
-            console.log("Property index: " + prop_index);
-            $scope.data.properties[prop_index] = JSON.parse(message.toString());
-        }
+        console.log("Message Arrived: " + topic + " (" + subid + ")");
+        console.log($scope.properties);
 
         var obj;
         if (message.toString().length == 0) {
@@ -92,34 +124,103 @@ app.controller("myCtrl", function ($scope, $filter, $location) {
         }
         console.log(obj);
 
+        for (const key in $scope.signals) {
+            if (!$scope.signals.hasOwnProperty(key)) continue;
+            const sig = $scope.signals[key];
+            if (sig.subscription_id == subid) {
+                sig.received = obj;
+                sig.received_time = new Date();
+            }
+        }
+        for (const key in $scope.properties) {
+            if (!$scope.properties.hasOwnProperty(key)) continue;
+            const prop = $scope.properties[key];
+            if (prop.subscription_id == subid) {
+                prop.received = obj;
+                console.log("Set property received object to ", prop.received);
+            }
+        }
+        for (const key in $scope.methods) {
+            if (!$scope.methods.hasOwnProperty(key)) continue;
+            const method = $scope.methods[key];
+            if (responseSubscriptionId == subid) {
+                if (packet.properties.correlationData && method.pending_correlation_id == packet.properties.correlationData) {
+                    method.received = obj;
+                    method.received_time = new Date();
+                    for (let i=0; i<$scope.console.requests.length; i++) {
+                        const req = $scope.console.requests[i];
+                        if (req.correlationData == packet.properties.correlationData) {
+                            req.response = obj;
+                            req.responseTime = Date.now();
+                        }
+                    }
+                }
+            }
+        }
+
         $scope.$apply();
     });
 
     client.on('connect', function() {
+        $scope.online = true;
+
+        var subscription_count = 10;
         console.log("Connected with ", client);
-        {%for signal_name, signal in stinger.signals.items() %}
-        const {{sig_name}}_sub_opts = {
+
+        var responseSubscriptionId = subscription_count++;
+        const responseSubOpts = {
             "qos": 1,
             "properties": {
-                "subscriptionIdentifier": (signalSubIdStart + {{loop.index}})
+                "subscriptionIdentifier": responseSubscriptionId
             }
         };
-        client.subscribe("{{signal.topic}}", {{sig_name}}_sub_opts);
-        console.log("Subscribing to {{signal.topic}} with id {{loop.index}}");
-        {%endfor%}
-        {%for prop_name, prop in stinger.properties.items() %}
-        const {{prop_name}}_sub_opts = {
+        client.subscribe(responseTopic, responseSubOpts);
+        console.log("Subscribing to response topic " + responseTopic + " with id " + responseSubscriptionId);
+        
+        {%for signal_name, signal in stinger.signals.items() %}
+        const {{signal_name|snake_case}}_sub_opts = {
             "qos": 1,
             "properties": {
-                "subscriptionIdentifier": (propertySubIdStart + {{loop.index}})
+                "subscriptionIdentifier": subscription_count
             }
         };
-        client.subscribe("{{prop.value_topic}}", {{prop_name}}_sub_opts);
-        console.log("Subscribing to {{prop.value_topic}} with id {{loop.index + stinger.signals|length}}");
+        $scope.signals["{{signal_name | lowerCamelCase}}"].subscription_id = subscription_count;
+        client.subscribe("{{signal.topic}}", {{signal_name|snake_case}}_sub_opts);
+        console.log("Subscribing to signal {{signal.topic}} with id ", subscription_count);
+        subscription_count++;
         {%endfor%}
+
+        for (const key in $scope.properties) {
+            if (!$scope.properties.hasOwnProperty(key)) continue;
+            var sub_id = subscription_count++;
+            const prop_sub_opts = {
+                "qos": 1,
+                "properties": {
+                    "subscriptionIdentifier": sub_id
+                }
+            };
+            $scope.properties[key].subscription_id = sub_id;
+            client.subscribe($scope.properties[key].mqtt_topic, prop_sub_opts);
+            console.log("Subscribing to property " + $scope.properties[key].mqtt_topic + " with id " + $scope.properties[key].subscription_id);
+        }
+
         subscription_state = 1;
         $scope.$apply();
     });
 
+    $scope.updateProperty = function(prop) {
+        const payload = JSON.stringify(prop.received);
+        publish("Property Update", prop.update_topic, payload, 1);
+    };
  
+    $scope.callMethod = function(method) {
+        const payload = {};
+        for (const key in method.args) {
+            if (!method.args.hasOwnProperty(key)) continue;
+            payload[key] = method.args[key].value;
+        }
+        const payload_str = JSON.stringify(payload);
+        console.log("Method Call", method.mqtt_topic, payload_str, 1);
+        method.pending_correlation_id = publish("Method Call", method.mqtt_topic, payload_str, 1);
+    };
 });