Merge pull request #591 from FreeTAKTeam/581-TCPtoDP

581 tc pto dp

FreeTAKServer/components/core/domain/controllers/dict_to_node_controller.py

@@ -4,7 +4,9 @@
 from digitalpy.core.zmanager.response import Response
 from digitalpy.core.zmanager.action_mapper import ActionMapper
 from digitalpy.core.digipy_configuration.configuration import Configuration
+from digitalpy.core.parsing.load_configuration import Configuration as LoadConf
 from digitalpy.core.domain.node import Node
+from .domain import Domain
 from lxml import etree
 
 class DictToNodeController(Controller):
@@ -16,6 +18,11 @@ def __init__(
         configuration: Configuration,
     ) -> None:
         super().__init__(request, response, sync_action_mapper, configuration)
+        self.domain_controller = Domain(request, response, sync_action_mapper, configuration)
+
+    def initialize(self, request, response):
+        super().initialize(request, response)
+        self.domain_controller.initialize(request, response)
 
     def execute(self, method=None):
         return getattr(self, method)(**self.request.get_values())
@@ -48,14 +55,16 @@ def convert_dict_to_node(
     def serialize(self, dictionary, node):
         """recursively serialize a single layer of the given dictionary
         to a node object until a nested dictionary is found"""
-        for key, value in dictionary.items():
-            self.add_value_to_node(key, value, node)
-        return node
-
+        try:
+            for key, value in dictionary.items():
+                self.add_value_to_node(key, value, node)
+            return node
+        except Exception as ex:
+            print(ex)
     def add_value_to_node(self, key, value, node):
         """add a value to a node object"""
         if key == "#text":
-            setattr(node, "INTAG", value)
+            setattr(node, "text", value)
 
         elif not hasattr(node, key.strip("@")):
             self.handle_missing_attribute(key, value, node)
@@ -66,8 +75,11 @@ def add_value_to_node(self, key, value, node):
             self.serialize(value, getattr(node, key))
 
         elif isinstance(value, list) and isinstance(getattr(node, key, None), list):
-            for l_item in value:
-                self.add_value_to_node(key, l_item, node)
+            self.serialize(value[0], getattr(node, key)[0])
+
+            for i in range(1,len(value)):
+                new_node = self.domain_controller.create_node(LoadConf(), key)
+                self.serialize(value[i], new_node)
 
         elif isinstance(getattr(node, key, None), list):
             self.serialize(value, getattr(node, key)[0])

FreeTAKServer/components/core/domain/controllers/domain.py

@@ -40,7 +40,7 @@ def add_child(self, node: Node, child: Node, **kwargs) -> None:
         """
         return node.add_child(child)
 
-    def create_node(self, configuration: Configuration, object_class_name: str, id:str=str(uuid.uuid1()), **kwargs) -> None:
+    def create_node(self, configuration: Configuration, object_class_name: str, id:str=str(uuid.uuid1()), **kwargs) -> Node:
         """this method creates a new node object
 
         Args:
@@ -59,6 +59,7 @@ def create_node(self, configuration: Configuration, object_class_name: str, id:s
         object_class_instance = object_class(configuration, self.domain, oid=oid)
         # set the module object
         self.response.set_value("model_object", object_class_instance)
+        return object_class_instance
 
     def _extend_domain(self, domain: ModuleType, extended_domain: dict) -> ModuleType:
         """this method is responsible for adding domain extensions from a given component

FreeTAKServer/components/core/domain/domain/_dest.py

@@ -6,8 +6,8 @@
 
 
 class dest(CoTNode):
-    def __init__(self, configuration: Configuration, model):
-        super().__init__(self.__class__.__name__, configuration, model)
+    def __init__(self, configuration: Configuration, model, oid=None):
+        super().__init__(self.__class__.__name__, configuration, model, oid)
         self.cot_attributes["callsign"] = None
 
     @CoTProperty

FreeTAKServer/components/core/domain/domain/_emergency.py

@@ -23,7 +23,7 @@ def __init__(self, configuration, model):
         self.cot_attributes["alert"] = None
         # if true the Emergency beacon is canceled
         self.cot_attributes["cancel"] = None
-        self.cot_attributes["INTAG"] = None
+        self.cot_attributes["text"] = None
 
     @CoTProperty
     def type(self):
@@ -50,9 +50,9 @@ def cancel(self, cancel=None):
         self.cot_attributes["cancel"] = cancel
 
     @CoTProperty
-    def INTAG(self):
-        return self.cot_attributes.get("INTAG", None)
+    def text(self):
+        return self.cot_attributes.get("text", None)
 
-    @INTAG.setter
-    def INTAG(self, INTAG=None):
-        self.cot_attributes["INTAG"] = INTAG
+    @text.setter
+    def text(self, text=None):
+        self.cot_attributes["text"] = text

FreeTAKServer/components/extended/emergency/controllers/emergency_general_controller.py

@@ -61,10 +61,13 @@ def convert_type(self, model_object, **kwargs)->None:
 
     def filter_by_distance(self, emergency: Event):
         """filter who receives this emergency based on their distance from the emergency"""
-        self.connections = self.retrieve_users()
-        for connection_obj in self.connections:
-            if self.validate_user_distance(emergency, connection_obj):
-                self.request.get_value('recipients').append(str(connection_obj.get_oid()))
+        if config.EmergencyRadius==0:
+            self.request.set_value('recipients', "*")
+        else:
+            self.connections = self.retrieve_users()
+            for connection_obj in self.connections:
+                if self.validate_user_distance(emergency, connection_obj):
+                    self.request.get_value('recipients').append(str(connection_obj.get_oid()))
 
     def validate_user_distance(self, emergency: Event, connection):
         connection_model_object = connection.model_object
@@ -73,7 +76,6 @@ def validate_user_distance(self, emergency: Event, connection):
         # check that the distance between the user and the emergency is less than 10km
         # TODO: this hardcoded distance should be added to the business rules
         return (
-            config.EmergencyRadius==0 or
             distance.geodesic(
                 (connection_location.lat, connection_location.lon),
                 (emergency.point.lat, emergency.point.lon),

FreeTAKServer/components/extended/emergency/domain/_emergency.py

@@ -23,7 +23,7 @@ def __init__(self, configuration, model):
         self.cot_attributes["alert"] = None
         # if true the Emergency beacon is canceled
         self.cot_attributes["cancel"] = None
-        self.cot_attributes["INTAG"] = None
+        self.cot_attributes["text"] = None
 
     @CoTProperty
     def type(self):
@@ -50,9 +50,9 @@ def cancel(self, cancel=None):
         self.cot_attributes["cancel"] = cancel
 
     @CoTProperty
-    def INTAG(self):
-        return self.cot_attributes.get("INTAG", None)
+    def text(self):
+        return self.cot_attributes.get("text", None)
 
-    @INTAG.setter
-    def INTAG(self, INTAG=None):
-        self.cot_attributes["INTAG"] = INTAG
+    @text.setter
+    def text(self, text=None):
+        self.cot_attributes["text"] = text

FreeTAKServer/core/configuration/MainConfig.py

@@ -9,7 +9,7 @@
 
 # the version information of the server (recommended to leave as default)
 
-FTS_VERSION = "FreeTAKServer-2.0.66"
+FTS_VERSION = "FreeTAKServer-2.0.69"
 API_VERSION = "3.0"
 ROOTPATH = "/"
 MAINPATH = Path(__file__).parent.parent.parent

FreeTAKServer/core/parsers/JsonController.py

@@ -34,7 +34,7 @@ def serialize_emergency_post(self, json: dict):
         full_json = {
             "event": {
                 "@uid": str(uuid.uuid4()),
-                "@type": "b-a-o-tbl",
+                "@type": "EmergencyAlert",
                 "@how": "h-e",
                 "@time": None,   # these will be automatically created during object serialization
                 "@start": None,  
@@ -66,7 +66,7 @@ def serialize_emergency_delete(self, json):
                 "@time": None,   # these will be automatically created during object serialization
                 "@start": None,  
                 "@stale": None,
-                "@type": "b-a-o-can",
+                "@type": "EmergencyCancelled",
                 "@uid": json.get("uid"),
                 "@version": "2.0",
                 "detail": {

FreeTAKServer/services/rest_api_service/rest_api_service_main.py

@@ -55,6 +55,7 @@
 from FreeTAKServer.core.parsers.JsonController import JsonController
 from FreeTAKServer.core.serializers.SqlAlchemyObjectController import SqlAlchemyObjectController
 from FreeTAKServer.components.extended.excheck.controllers.ExCheckController import ExCheckController
+from .views.connections_view_controller import ManageConnections
 
 app = Flask(__name__)
 login_manager = LoginManager()
@@ -154,24 +155,7 @@ def authenticate(token):
 @socketio.on('users')
 @socket_auth(session=session)
 def show_users(empty=None):
-    output = dbController.query_user()
-    for i in range(0, len(output)):
-        try:
-            original = output[i]
-            output[i] = output[i].__dict__
-            print(output[i])
-            try:
-                output[i]['callsign'] = original.CoT.detail.contact.callsign
-                output[i]['team'] = original.CoT.detail._group.name
-            except:
-                output[i]['callsign'] = "undefined"
-                output[i]['team'] = "undefined"
-            del (output[i]['_sa_instance_state'])
-            del (output[i]['CoT_id'])
-            del (output[i]['CoT'])
-        except Exception as e:
-            logger.error(str(e))
-    socketio.emit('userUpdate', json.dumps({"Users": output}))
+    socketio.emit('userUpdate', json.dumps({"Users": ManageConnections().get_users()}))
 
 
 @socketio.on('logs')
@@ -1987,6 +1971,7 @@ def delete_repeated_messages(self):
 # this will require changing it from using the API Pipe to use the ZManager instead
 
 ManageEmergency.decorators.append(auth.login_required)
+app.add_url_rule('/ManageEmergency/<method>', view_func=ManageEmergency.as_view('/ManageEmergency/<method>'), methods=["POST", "GET","DELETE"])
 app.add_url_rule('/ManageGeoObject/<method>', view_func=ManageGeoObjects.as_view('/ManageGeoObject/<method>'), methods=["POST", "GET","DELETE"])
 
 APPLICATION_PROTOCOL = "xml"

FreeTAKServer/services/rest_api_service/views/connections_view_controller.py

@@ -0,0 +1,27 @@
+from FreeTAKServer.services.rest_api_service.views.base_view_controller import BaseViewController
+from FreeTAKServer.core.configuration.CreateLoggerController import CreateLoggerController
+from FreeTAKServer.core.configuration.LoggingConstants import LoggingConstants
+
+loggingConstants = LoggingConstants(log_name="FTS-ManageConnectionsView")
+logger = CreateLoggerController("FTS-ManageConnectionsView", logging_constants=loggingConstants).getLogger()
+
+class ManageConnections(BaseViewController):
+    decorators = []
+
+    def __init__(self) -> None:
+        pass
+
+    def get_users(self):
+        response = self.make_request("GetAllConnections", service_id="rest_api_service")
+        connections = response.get_value("connections")
+        output = []
+        for connection in connections:
+            try:
+                serialized_user = {
+                    "callsign": connection.model_object.detail.contact.callsign,
+                    "team": connection.model_object.detail._group.name,
+                }
+                output.append(serialized_user)
+            except AttributeError as ex:
+                logger.error("emergency model object missing attribute %s", ex)
+        return output

FreeTAKServer/services/rest_api_service/views/emergency_view.py

@@ -33,11 +33,14 @@ def get_emergency(self):
         output = {"json_list": []}
         for emergency in emergencies:
             try:
+                name = emergency.detail.contact.callsign
+                if emergency.detail.contact.callsign is None:
+                    name = emergency.detail.emergency.text
                 serialized_emergency = {
                     "lat": emergency.point.lat,
                     "lon": emergency.point.lon,
                     "type": emergency.detail.emergency.type,
-                    "name": emergency.detail.contact.callsign,
+                    "name": name,
                     "uid": emergency.uid
                 }
                 output["json_list"].append(serialized_emergency)
@@ -48,18 +51,16 @@ def get_emergency(self):
     def post_emergency(self):
         jsondata = request.get_json(force=True)
         jsonobj = JsonController().serialize_emergency_post(jsondata)
-        emergency_object = SendEmergencyController(jsonobj).getCoTObject()
-        self.make_request("SaveEmergency", {"model_object": emergency_object.modelObject})
-        APIPipe.put(emergency_object)
-        return emergency_object.modelObject.getuid(), 200
-
+        self.make_request("EmergencyAlert", {"dictionary": jsonobj}, False, "tcp_cot_service") # send the request output to the tcp cot service
+        self.make_request("EmergencyAlert", {"dictionary": jsonobj}, False, "ssl_cot_service") # send the request output to the ssl cot service
+        return jsonobj.get("event").get("@uid"), 200 
+
     def delete_emergency(self) -> str:
         """delete an emergency from the emergency persistence
 
         """
         jsondata = request.get_json(force=True)
         jsonobj = JsonController().serialize_emergency_delete(jsondata)
-        emergency_object = SendEmergencyController(jsonobj).getCoTObject()
-        APIPipe.put(emergency_object)
-        self.make_request("DeleteEmergency", {"model_object": emergency_object.modelObject})
-        return 'success', 200
+        self.make_request("EmergencyCancelled", {"dictionary": jsonobj}, False, "tcp_cot_service") # send the request output to the tcp cot service
+        self.make_request("EmergencyCancelled", {"dictionary": jsonobj}, False, "ssl_cot_service") # send the request output to the ssl cot service
+        return jsonobj.get("@uid"), 200

FreeTAKServer/services/ssl_cot_service/ssl_cot_service_main.py

@@ -291,6 +291,7 @@ def component_handler(self, xml_cot):
         request.set_format("pickled")
         human_readable_type = self.get_human_readable_type(dict_cot)
         request.set_action(human_readable_type)
+        dict_cot["event"]["@type"] = human_readable_type
         request.set_context("XMLCoT")
         request.set_sender(self.__class__.__name__.lower())
         request.set_value("dictionary", dict_cot)

FreeTAKServer/services/tcp_cot_service/tcp_cot_service_main.py

@@ -296,6 +296,7 @@ def component_handler(self, xml_cot):
         request.set_format("pickled")
         human_readable_type = self.get_human_readable_type(dict_cot)
         request.set_action(human_readable_type)
+        dict_cot["event"]["@type"] = human_readable_type
         request.set_context("XMLCoT")
         request.set_sender(self.__class__.__name__.lower())
         request.set_value("dictionary", dict_cot)

setup.py

@@ -10,7 +10,7 @@
     packages=find_packages(
         include=["FreeTAKServer", "FreeTAKServer.*", "*.json", "*.ini", "*.conf"]
     ),
-    version="2.0.66",
+    version="2.0.69",
     license="EPL-2.0",
     description="An open source server for the TAK family of applications.",
     long_description=long_description,