Bring deployments helper methods into parity

Author: tipatterson-dev

conSys/con_sys_api.py

@@ -24,6 +24,7 @@ def make_request(self):
                 print(f'PUT request: {self}')
                 return put_request(self.url, self.body, self.headers, self.auth)
             case 'DELETE':
+                print(f'DELETE request: {self}')
                 return delete_request(self.url, self.params, self.headers, self.auth)
             case _:
                 raise ValueError('Invalid request method')

conSys/part_1/deployments.py

@@ -1,10 +1,12 @@
+from typing import Union
+
 from pydantic import HttpUrl
 
 from conSys.con_sys_api import ConnectedSystemsRequestBuilder
 from conSys.constants import APITerms
 
 
-def list_all_deployments(server_addr: HttpUrl, api_root: str = APITerms.API.value):
+def list_all_deployments(server_addr: HttpUrl, api_root: str = APITerms.API.value, headers: dict = None):
     """
     Lists all deployments in the server at the default API endpoint
     :return:
@@ -14,11 +16,14 @@ def list_all_deployments(server_addr: HttpUrl, api_root: str = APITerms.API.valu
                    .with_api_root(api_root)
                    .for_resource_type(APITerms.DEPLOYMENTS.value)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('GET')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
-def create_new_deployments(server_addr: HttpUrl, request_body: dict, api_root: str = APITerms.API.value):
+def create_new_deployments(server_addr: HttpUrl, request_body: Union[str, dict], api_root: str = APITerms.API.value,
+                           headers: dict = None):
     """
     Create a new deployment as defined by the request body
     :return:
@@ -29,11 +34,14 @@ def create_new_deployments(server_addr: HttpUrl, request_body: dict, api_root: s
                    .for_resource_type(APITerms.DEPLOYMENTS.value)
                    .with_request_body(request_body)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('POST')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
-def retrieve_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root: str = APITerms.API.value):
+def retrieve_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root: str = APITerms.API.value,
+                              headers: dict = None):
     """
     Retrieve a deployment by its ID
     :return:
@@ -44,12 +52,14 @@ def retrieve_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root
                    .for_resource_type(APITerms.DEPLOYMENTS.value)
                    .with_resource_id(deployment_id)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('GET')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
-def update_deployment_by_id(server_addr: HttpUrl, deployment_id: str, request_body: dict,
-                            api_root: str = APITerms.API.value):
+def update_deployment_by_id(server_addr: HttpUrl, deployment_id: str, request_body: Union[str, dict],
+                            api_root: str = APITerms.API.value, headers: dict = None):
     """
     Update a deployment by its ID
     :return:
@@ -61,11 +71,14 @@ def update_deployment_by_id(server_addr: HttpUrl, deployment_id: str, request_bo
                    .with_resource_id(deployment_id)
                    .with_request_body(request_body)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('PUT')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
-def delete_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root: str = APITerms.API.value):
+def delete_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root: str = APITerms.API.value,
+                            headers: dict = None):
     """
     Delete a deployment by its ID
     :return:
@@ -76,11 +89,14 @@ def delete_deployment_by_id(server_addr: HttpUrl, deployment_id: str, api_root:
                    .for_resource_type(APITerms.DEPLOYMENTS.value)
                    .with_resource_id(deployment_id)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('DELETE')
                    .build())
     return api_request
 
 
-def list_deployed_systems(server_addr: HttpUrl, deployment_id, api_root: str = APITerms.API.value):
+def list_deployed_systems(server_addr: HttpUrl, deployment_id, api_root: str = APITerms.API.value,
+                          headers: dict = None):
     """
     Lists all deployed systems in the server at the default API endpoint
     :return:
@@ -92,12 +108,14 @@ def list_deployed_systems(server_addr: HttpUrl, deployment_id, api_root: str = A
                    .with_resource_id(deployment_id)
                    .for_sub_resource_type(APITerms.SYSTEMS.value)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('GET')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
 def add_systems_to_deployment(server_addr: HttpUrl, deployment_id: str, uri_list: str,
-                              api_root: str = APITerms.API.value):
+                              api_root: str = APITerms.API.value, headers: dict = None):
     """
     Lists all systems in the server at the default API endpoint
     :return:
@@ -110,12 +128,14 @@ def add_systems_to_deployment(server_addr: HttpUrl, deployment_id: str, uri_list
                    .for_sub_resource_type(APITerms.SYSTEMS.value)
                    .with_request_body(uri_list)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('POST')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
 def retrieve_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, system_id: str,
-                                   api_root: str = APITerms.API.value):
+                                   api_root: str = APITerms.API.value, headers: dict = None):
     """
     Retrieves a system by its id
     :return:
@@ -130,12 +150,14 @@ def retrieve_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, sys
                    .for_sub_resource_type(APITerms.SYSTEMS.value)
                    .with_secondary_resource_id(system_id)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('GET')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
 def update_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, system_id: str, request_body: dict,
-                                 api_root: str = APITerms.API.value):
+                                 api_root: str = APITerms.API.value, headers: dict = None):
     """
     Update a system by its ID
     :return:
@@ -149,13 +171,15 @@ def update_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, syste
                    .with_secondary_resource_id(system_id)
                    .with_request_body(request_body)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('PUT')
                    .build())
 
     return api_request
 
 
 def delete_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, system_id: str,
-                                 api_root: str = APITerms.API.value):
+                                 api_root: str = APITerms.API.value, headers: dict = None):
     """
     Delete a system by its ID
     :return:
@@ -168,11 +192,14 @@ def delete_deployed_system_by_id(server_addr: HttpUrl, deployment_id: str, syste
                    .for_sub_resource_type(APITerms.SYSTEMS.value)
                    .with_secondary_resource_id(system_id)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('DELETE')
                    .build())
-    return api_request
+    return api_request.make_request()
 
 
-def list_deployments_of_specific_system(server_addr: HttpUrl, system_id: str, api_root: str = APITerms.API.value):
+def list_deployments_of_specific_system(server_addr: HttpUrl, system_id: str, api_root: str = APITerms.API.value,
+                                        headers: dict = None):
     """
     Lists all deployments of a specific system in the server at the default API endpoint
     :return:
@@ -184,4 +211,7 @@ def list_deployments_of_specific_system(server_addr: HttpUrl, system_id: str, ap
                    .with_resource_id(system_id)
                    .for_sub_resource_type(APITerms.DEPLOYMENTS.value)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('GET')
                    .build())
+    return api_request.make_request()

conSys/part_1/systems.py

@@ -123,7 +123,7 @@ def update_system_description(server_addr: HttpUrl, system_id: str, request_body
     return resp
 
 
-def delete_system_by_id(server_addr: HttpUrl, system_id: str, api_root: str = APITerms.API.value):
+def delete_system_by_id(server_addr: HttpUrl, system_id: str, api_root: str = APITerms.API.value, headers: dict = None):
     """
     Deletes a system by its id
     :return:
@@ -134,9 +134,10 @@ def delete_system_by_id(server_addr: HttpUrl, system_id: str, api_root: str = AP
                    .for_resource_type(APITerms.SYSTEMS.value)
                    .with_resource_id(system_id)
                    .build_url_from_base()
+                   .with_headers(headers)
+                   .with_request_method('DELETE')
                    .build())
-    resp = requests.delete(api_request.url, params=api_request.body, headers=api_request.headers)
-    return resp
+    return api_request.make_request()
 
 
 def list_system_components(server_addr: HttpUrl, system_id: str, api_root: str = APITerms.API.value):

conSys/request_bodies.py

@@ -2,6 +2,7 @@
 
 from pydantic import BaseModel, HttpUrl, Field, model_serializer, RootModel, SerializeAsAny
 
+from conSys import Geometry
 from conSys.datamodels.datastreams import DatastreamSchema
 from conSys.sensor_ml.sml import TypeOf
 from conSys.constants import DatastreamResultTypes
@@ -14,7 +15,7 @@ class GeoJSONBody(BaseModel):
     type: str
     id: str
     properties: dict = None
-    geometry: dict = None
+    geometry: Geometry = None
     bbox: list = None
     links: list = None
 

tests/test_script_full_suite.py

@@ -1,7 +1,7 @@
 import random
 
 from conSys import Systems, SamplingFeatures, Datastreams, SmlJSONBody, GeoJSONBody, model_utils, \
-    DatastreamBodyJSON, ObservationFormat, URI
+    DatastreamBodyJSON, ObservationFormat, URI, Procedures, Geometry, Deployments
 from conSys.datamodels.datastreams import SWEDatastreamSchema
 from conSys.datamodels.encoding import JSONEncoding
 from conSys.datamodels.swe_components import BooleanSchema, TimeSchema, DataRecordSchema
@@ -107,6 +107,63 @@ def test_update_systems():
                                           headers=sml_json_headers)
 
 
+"""
+Deployments Section
+"""
+
+
+def test_create_deployments():
+    deployment = GeoJSONBody(type='Feature', id=str(random.randint(1000, 9999)), properties={
+        "featureType": "http://www.w3.org/ns/ssn/Deployment",
+        "uid": "urn:test:client:geo-deployment",
+        "name": "Test Deployment - GeoJSON",
+        "description": "A Test Deployment inserted from the Python CSAPI Client",
+        "validTime": ["2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z"]
+    }, geometry=Geometry(type="Point", coordinates=[-80.0, 35.0]))
+    resp = Deployments.create_new_deployments(server_url, deployment.model_dump_json(exclude_none=True, by_alias=True),
+                                              headers=geo_json_headers)
+    print(resp)
+
+
+def test_list_all_deployments():
+    deployments = Deployments.list_all_deployments(server_url)
+    print(deployments.json())
+
+
+def test_retrieve_deployment_by_id():
+    deployments = Deployments.list_all_deployments(server_url)
+
+    deployment = Deployments.retrieve_deployment_by_id(server_url, deployments.json()['items'][0]['id'])
+    print(deployment.json())
+    assert deployment.json()['id'] == deployments.json()['items'][0]['id']
+
+
+def test_update_deployment_by_id():
+    deployments = Deployments.list_all_deployments(server_url)
+
+    deployment = GeoJSONBody(type='Feature', id=str(random.randint(1000, 9999)), properties={
+        "featureType": "http://www.w3.org/ns/ssn/Deployment",
+        "uid": "urn:test:client:geo-deployment",
+        "name": "Test Deployment - GeoJSON (Updated)",
+        "description": "A Test Deployment updated from the Python CSAPI Client",
+        "validTime": ["2024-01-01T00:00:00Z", "2024-12-31T23:59:59Z"]
+    }, geometry=Geometry(type="Point", coordinates=[-80.0, 35.0]))
+    resp = Deployments.update_deployment_by_id(server_url, deployments.json()['items'][0]['id'],
+                                               deployment.model_dump_json(exclude_none=True, by_alias=True),
+                                               headers=geo_json_headers)
+    print(resp)
+
+
+def test_add_systems_to_deployment():
+    deployments = Deployments.list_all_deployments(server_url)
+    systems = Systems.list_all_systems(server_url, headers=json_headers)
+    system_link = {'href': f"{server_url}/api/systems/{systems['items'][0]['id']}"}
+    # uri_list = str(system_links).replace("'", "\"")
+    resp = Deployments.add_systems_to_deployment(server_url, deployments.json()['items'][0]['id'], str(system_link),
+                                                 headers=geo_json_headers)
+    print(resp)
+
+
 """
 Procedure Tests
 """
@@ -224,17 +281,69 @@ def test_create_datastreams():
                                                  headers=json_headers)
     print(resp)
 
+"""
+Command and Control Channel Section
+"""
+def test_create_control_channel():
+    geo_json_body = GeoJSONBody(type='Feature', id=str(random.randint(1000, 9999)),
+                                description="Test Insertion of Control Channel via GEOJSON",
+                                properties={
+                                    "featureType": "http://www.w3.org/ns/ssn/ControlChannel",
+                                    "name": f'Test Control Channel - GeoJSON',
+                                    "uid": f'urn:test:client:geo-cc',
+                                    "description": "A Test Control Channel inserted from the Python CSAPI Client",
+                                })
+    resp = ControlChannels.create_new_control_channels(server_url, geo_json_body.model_dump_json(exclude_none=True, by_alias=True),
+                                                         headers=geo_json_headers)
+
 
 """
 Teardown Section
 """
 
+# def test_delete_all_collections():
+#     pass
+#
+#
+# def test_delete_all_sampling_features():
+#     sf_list = SamplingFeatures.list_all_sampling_features(server_url).json()
+#     print(sf_list)
+#
+#     for sf in sf_list["items"]:
+#         print(sf)
+#
+#         SamplingFeatures.delete_sampling_feature_by_id(server_url, sf["id"])
+#         print(f"Deleted sampling feature {sf['id']}")
+#
+#
+# def test_delete_all_datastreams():
+#     ds_list = Datastreams.list_all_datastreams(server_url).json()
+#     print(ds_list)
+#
+#     for ds in ds_list["items"]:
+#         print(ds)
+#
+#         Datastreams.delete_datastream_by_id(server_url, ds["id"])
+#         print(f"Deleted datastream {ds['id']}")
+#
+#
+# def test_delete_all_procedures():
+#     proc_list = Procedures.list_all_procedures(server_url).json()
+#     print(proc_list)
+#
+#     for proc in proc_list["items"]:
+#         print(proc)
+#
+#         Procedures.delete_procedure_by_id(server_url, proc["id"])
+#         print(f"Deleted procedure {proc['id']}")
+#
+#
 # def test_delete_all_systems():
-#     sys_list = Systems.list_all_systems("http://localhost:8181/sensorhub")["items"]
+#     sys_list = Systems.list_all_systems(server_url)["items"]
 #     print(sys_list)
 #
 #     for system in sys_list:
 #         print(system)
 #
-#         Systems.delete_system_by_id("http://localhost:8181/sensorhub", system["id"])
+#         Systems.delete_system_by_id(server_url, system["id"])
 #         print(f"Deleted system {system['id']}")