Modified property handling to send more meta data for fields, etc. and a helper function to handle converting that structure to the REDHAWK-usable one

Author: Thomas Goodwin

rest/component.py

@@ -64,9 +64,7 @@ def get(self, domain, application, component):
     @gen.coroutine
     def put(self, domain, application, component):
         data = json.loads(self.request.body)
-
-        changes = {}
-        for p in data['properties']:
-            changes[p['id']] = p['value']
+        json_props = data.get('properties', [])
+        changes = self.unformat_properties(json_props)
 
         yield self.redhawk.component_configure(domain, application, component, changes)

rest/device.py

@@ -68,9 +68,9 @@ def put(self, domainName, managerId, deviceId):
             'deallocate'    : self.redhawk.device_deallocate
         }
         data = json.loads(self.request.body)
-        changes = {}
-        for p in data['properties']:
-            changes[p['id']] = p['value']
+        json_props = data.get('properties', [])
+        changes = self.unformat_properties(json_props)
+        
         cb = PUT_METHODS.get(data['method'], None)
         try: 
             r, message = yield cb(domainName, managerId, deviceId, changes)

rest/fei.py

@@ -103,7 +103,8 @@ def put(self, domain_name, dev_mgr_id, dev_id, int_name, allocation_id):
         port = self.find_port(int_name, dev)
         # FEITunerHandler supports 1 PUT: Tune.
         try:
-            for prop in data['properties']:
+            props = PropertyHelper.unformat_properties(data['properties'])
+            for prop in props:
                 self.set_attribute(port, str(allocation_id), prop['id'], prop['value'])
         except Exception as e:
             self._handle_request_exception(e)

rest/helper.py

@@ -25,11 +25,12 @@
 PortHelper -- Convert Port information into dict
 """
 
-from ossie.utils.prop_helpers import Property
+from ossie.utils.prop_helpers import Property, simpleProperty, structProperty, structSequenceProperty, sequenceProperty
 
 
 class PropertyHelper(object):
 
+    """ For going from REDHAWK to JSON """
     @staticmethod
     def format_properties(properties):
         if not properties:
@@ -41,47 +42,95 @@ def format_properties(properties):
 
     @staticmethod
     def _corba_properties(properties):
-        prop_dict = []
+        prop_list = []
         for prop in properties:
             ret = PropertyHelper.__any(prop.value)
             ret['id'] = prop.id
-            prop_dict.append(ret)
+            prop_list.append(ret)
 
-        return prop_dict
+        return prop_list
 
     @staticmethod
     def _property_set(properties):
-        prop_dict = []
-        for prop in properties:
-            # BugFix: write-only props cannot be queried, here's a way to feed
-            # a non-destructive value in place.
-            val = None if ('writeonly' == prop.mode or 'message' in prop.kinds) else prop.queryValue()
-
-            if prop.type not in ['struct', 'structSeq']:
-                if type(val) == list:
-                    prop_type = 'simpleSeq'
-                else:
-                    prop_type = 'simple'
+        def _handle_simple(prop):
+            try:
+                val = prop.queryValue()
+            except:
+                val = None
+
+            if hasattr(prop, 'clean_name'):
+                clean_name = prop.clean_name
             else:
-                prop_type = prop.type
-
-            prop_json = {
-                'id': prop.id,
-                'name': prop.clean_name,
-                'value': val,
-                'scaType': prop_type,
-                'mode': prop.mode,
-                'kinds': prop.kinds
+                clean_name = prop.id.split('::')[-1]
+
+            p_dict = {
+                'id'        : prop.id,
+                'name'      : clean_name,
+                'scaType'   : 'simple',
+                'value'     : val,
+                'type'      : prop.type,
+                'mode'      : prop.mode,
+                'kinds'     : prop.kinds
             }
 
-            if prop_type == 'simple':
-                prop_json['type'] = prop.type;
-
-            if '_enums' in dir(prop) and prop._enums:
-                prop_json['enumerations'] = prop._enums
-
-            prop_dict.append(prop_json)
-        return prop_dict
+            if hasattr(prop, '_enums') and prop._enums:
+                p_dict['enumerations'] = prop._enums
+            return p_dict
+
+        def _handle_simpleseq(prop):
+            p_dict = _handle_simple(prop)
+            p_dict['scaType'] = 'simpleSeq'
+            return p_dict
+
+        def _handle_struct(prop):
+            p_dict = _handle_simple(prop)
+            p_dict.pop('type', None)
+            p_dict['value'] = []
+            for _, m in prop.members.iteritems():
+                m_dict = _handle_simple(m)
+                p_dict['value'].append( m_dict )
+            p_dict['scaType'] = 'struct'
+            return p_dict
+
+        def _handle_structseq(prop):
+            p_dict = _handle_simple(prop)
+            p_dict['value'] = []
+            for idx, _ in enumerate(prop):
+                element_dict = _handle_struct(prop[idx])
+                p_dict['value'].append( element_dict )
+            p_dict['scaType'] = 'structSeq'
+            return p_dict
+
+        prop_list = []
+        for prop in properties:
+            if type(prop) == simpleProperty:
+                prop_list.append( _handle_simple(prop) )
+            elif type(prop) == sequenceProperty:
+                prop_list.append( _handle_simpleseq(prop) )
+            elif type(prop) == structProperty:
+                prop_list.append( _handle_struct(prop) )
+            elif type(prop) == structSequenceProperty:
+                prop_list.append( _handle_structseq(prop) )
+        return prop_list
+
+    """ Going from JSON to REDHAWK Properties """
+    @staticmethod
+    def unformat_properties(properties):
+        def _handle_value(val):
+            out_val = val
+            if type(val) == list:
+                out_val = []
+                for v in val:
+                    if type(v) == dict:
+                        out_val.append({v['id']: _handle_value(v['value'])})
+                    else:
+                        out_val.append(v)
+            return out_val
+
+        props_dict = {}
+        for prop in properties:
+            props_dict[prop['id']] = _handle_value(prop['value'])
+        return props_dict
 
     ###############################################
     # Private