Converted most of the get functions in the series service to connect to omd2

Series, values, plot, and dataframes need to be converted

Author: Francisco Arrieta

odmtools/controller/WizardMethodController.py

@@ -64,15 +64,15 @@ def getMethod(self):
         m = Method()
         if self.method_view.auto_method_radio.GetValue():
             description = "Values derived from ODM Tools Python"
-            m = self.series_service.get_method_by_description(description)
+            m = self.series_service.get_method_by_code(description)
             if m is None:
                 m = Method()
                 m.description = description
         elif self.method_view.existing_method_radio.GetValue():
             index = self.method_view.existing_method_table.GetFirstSelected()
             desc = self.method_view.existing_method_table.GetItem(index, 0).GetText()
 
-            m = self.series_service.get_method_by_description(desc)
+            m = self.series_service.get_method_by_code(desc)
         elif self.method_view.create_method_radio.GetValue():
             m.description = self.method_view.description_text_ctrl.GetValue()
 

odmtools/controller/WizardProcessLevelController.py

@@ -39,7 +39,7 @@ def __set_create_proces_section(self, active):
 
     def __fetch_data(self):
         series_service = self.service_manager.get_series_service()
-        processes = series_service.get_all_qcls()
+        processes = series_service.get_all_processing_levels()
 
         data = []
         for proc in processes:
@@ -62,6 +62,6 @@ def getQCL(self):
         elif self.processing_level_view.existing_process_radio.GetValue():
             selected_row = self.processing_level_view.existing_process_table.get_selected_row()
             code = selected_row[0]
-            q = self.service_manager.get_series_service().get_qcl_by_code(qcl_code=code)
+            q = self.service_manager.get_series_service().get_processing_level_by_code(proc_level_code=code)
 
         return q

odmtools/gui/pageQCL.py

@@ -122,7 +122,7 @@ def getQCL(self):
             logger.debug("lstQCL: %s" %(self.lstQCL))
             code= self.lstQCL.GetItem(index, 0).GetText()
             logger.debug(code)
-            q= self.series_service.get_qcl_by_code(code)
+            q= self.series_service.get_processing_level_by_code(code)
 
 ##            q.id = self.lstQCL.GetItem(index,3).GetText()
 ##            q.code = self.lstQCL.GetItem(index, 0).GetText()

odmtools/gui/wizSave.py

@@ -48,7 +48,7 @@ def __init__(self, parent, title, series_service, qcl):
         self._init_data(self.panel.series_service)
 
     def _init_data(self, series):
-        qcl = series.get_all_qcls()
+        qcl = series.get_all_processing_levels()
         index = 0
         for q, i in zip(qcl, range(len(qcl))):
             num_items = self.panel.lstQCL.GetItemCount()

odmtools/odmservices/edit_service.py

@@ -284,7 +284,7 @@ def get_filter_list(self):
         return self._filter_list
 
     def get_qcl(self, qcl_id):
-        return self.memDB.series_service.get_qcl_by_id(qcl_id)
+        return self.memDB.series_service.get_processing_level_by_id(qcl_id)
 
     def get_method(self, method_id):
         return self.memDB.series_service.get_method_by_id(method_id)

odmtools/odmservices/series_service.py

@@ -1,27 +1,20 @@
 import logging
-
-
 from sqlalchemy import distinct, func
-
-
 from odmtools.odmdata import SessionFactory
 from odmtools.odmdata import Site
 # from odmtools.odmdata import Variable
 from odm2api.ODM2.models import *
-from odmtools.odmdata import Unit
 from odmtools.odmdata import Series
 from odmtools.odmdata import DataValue
 from odmtools.odmdata import Qualifier
 from odmtools.odmdata import OffsetType
 from odmtools.odmdata import Sample
 # from odmtools.odmdata import Method
-from odm2api.ODM2.models import Methods
 from odmtools.odmdata import QualityControlLevel
 from odmtools.odmdata import ODMVersion
 from odmtools.common.logger import LoggerTool
 import pandas as pd
 from odm2api.ODM2.services.createService import CreateODM2
-from odm2api.ODM2.models import Annotations
 from odm2api.ODM2.services.readService import *
 
 
@@ -51,12 +44,13 @@ def get_db_version(self):
 #####################
 
     # Site methods
-    def get_all_sites(self):
+    def get_all_sites(self):  # Site -> Sampling Feature in ODM2
         """
 
         :return: List[Sites]
         """
-        return self._edit_session.query(Site).order_by(Site.code).all()
+        # return self._edit_session.query(Site).order_by(Site.code).all()
+        return self.read_service.getSamplingFeatures(ids=None, codes=None, uuids=None,type=None, wkt=None)
 
 
     def get_used_sites(self):
@@ -65,10 +59,12 @@ def get_used_sites(self):
         :return: List[Sites]
         """
         try:
-            site_ids = [x[0] for x in self._edit_session.query(distinct(Series.site_id)).all()]
+            site_ids = [site_ids[0] for site_ids in self._edit_session.query(distinct(Results.FeatureActionID)).all()]
         except:
             site_ids = None
 
+        site_ids = self._edit_session.query(FeatureActions.SamplingFeatureID).filter(FeatureActions.FeatureActionID.in_(site_ids)).all()
+
         if not site_ids:
             return None
 
@@ -85,10 +81,11 @@ def get_site_by_id(self, site_id):
         :param site_id: integer- the identification number of the site
         :return: Sites
         """
-        try:
-            return self._edit_session.query(Site).filter_by(id=site_id).first()
-        except:
-            return None
+        # try:
+        #     return self._edit_session.query(Site).filter_by(id=site_id).first()
+        # except:
+        #     return None
+        return self.read_service.getSamplingFeatures(ids=site_id)
 
     # Variables methods
     def get_used_variables(self):
@@ -98,10 +95,12 @@ def get_used_variables(self):
         """
 
         try:
-            var_ids = [x[0] for x in self._edit_session.query(distinct(Series.variable_id)).all()]
+            # var_ids = [x[0] for x in self._edit_session.query(distinct(Series.variable_id)).all()]
+            var_ids = [x[0] for x in self._edit_session.query(distinct(Results.VariableID)).all()]
         except:
             var_ids = None
 
+        var_ids = self._edit_session.query(Results.VariableID).filter(Results.VariableID.in_(var_ids)).all()
         if not var_ids:
             return None
 
@@ -115,32 +114,25 @@ def get_used_variables(self):
 
     def get_all_variables(self):
         """
-
         :return: List[Variables]
         """
-        return self._edit_session.query(Variables).all()
+        return self.read_service.getVariables(ids=None, codes=None)
 
     def get_variable_by_id(self, variable_id):
         """
 
         :param variable_id: int
         :return: Variables
         """
-        try:
-            return self._edit_session.query(Variables).filter_by(id=variable_id).first()
-        except:
-            return None
+        return self.read_service.getVariables(ids=variable_id)
 
     def get_variable_by_code(self, variable_code):
         """
 
         :param variable_code:  str
         :return: Variables
         """
-        try:
-            return self._edit_session.query(Variables).filter_by(code=variable_code).first()
-        except:
-            return None
+        return self.read_service.getVariables(codes=variable_code)
 
     def get_variables_by_site_code(self, site_code):  # covers NoDV, VarUnits, TimeUnits
         """
@@ -163,50 +155,39 @@ def get_variables_by_site_code(self, site_code):  # covers NoDV, VarUnits, TimeU
     # Unit methods
     def get_all_units(self):
         """
-
         :return: List[Units]
         """
-        return self._edit_session.query(Unit).all()
+        return self.read_service.getUnits(ids=None, name=None, type=None)
 
     def get_unit_by_name(self, unit_name):
         """
-
         :param unit_name: str
         :return: Units
         """
-        try:
-            return self._edit_session.query(Unit).filter_by(name=unit_name).first()
-        except:
-            return None
+        return self.read_service.getUnits(name=unit_name)
 
     def get_unit_by_id(self, unit_id):
         """
-
         :param unit_id: int
         :return: Units
         """
-        try:
-            return self._edit_session.query(Unit).filter_by(id=unit_id).first()
-        except:
-            return None
+        self.read_service.getUnits(ids=unit_id)
 
-
-    def get_all_qualifiers(self):
+    def get_all_qualifiers(self):  # Rename to annotations
         """
-
         :return: List[Qualifiers]
         """
         # result = self._edit_session.query(Annotations).order_by(Annotations.AnnotationCode).all()
         # return result
         return self.read_service.getAnnotations(None)
 
-    def get_qualifier_by_code(self, code):
+    def get_qualifier_by_code(self, code):  # Rename to get_annotations_by_type
         """
-
         :return: Qualifiers
         """
-        result = self._edit_session.query(Qualifier).filter(Qualifier.code==code).first()
-        return result
+        # result = self._edit_session.query(Qualifier).filter(Qualifier.code==code).first()
+        # return result
+        return self.read_service.getAnnotations(type=code)
 
     def get_qualifiers_by_series_id(self, series_id):
         """
@@ -218,40 +199,23 @@ def get_qualifiers_by_series_id(self, series_id):
             Series.data_values).filter(Series.id == series_id, DataValue.qualifier_id != None).distinct().subquery()
         return self._edit_session.query(Qualifier).join(subquery).distinct().all()
 
-    #QCL methods
-    def get_all_qcls(self):
-        return self._edit_session.query(QualityControlLevel).all()
+    def get_all_processing_levels(self):
+        return self.read_service.getProcessingLevels(ids=None, codes=None)
 
-    def get_qcl_by_id(self, qcl_id):
-        try:
-            return self._edit_session.query(QualityControlLevel).filter_by(id=qcl_id).first()
-        except:
-            return None
+    def get_processing_level_by_id(self, proc_level_id):
+        return self.read_service.getProcessingLevels(ids=proc_level_id)
 
-    def get_qcl_by_code(self, qcl_code):
-        try:
-            return self._edit_session.query(QualityControlLevel).filter_by(code=qcl_code).first()
-        except:
-            return None
+    def get_processing_level_by_code(self, proc_level_code):
+        return self.read_service.getProcessingLevels(codes=proc_level_code)
 
-    # Method methods
     def get_all_methods(self):
-        return self._edit_session.query(Methods).all()
+        return self.read_service.getMethods(ids=None, codes=None, type=None)
 
     def get_method_by_id(self, method_id):
-        try:
-            result = self._edit_session.query(Methods).filter_by(id=method_id).first()
-        except:
-            result = None
-        return result
+        return self.read_service.getMethods(ids=method_id)
 
-    def get_method_by_description(self, method_code):
-        try:
-            result = self._edit_session.query(Methods).filter_by(description=method_code).first()
-        except:
-            result = None
-            logger.error("method not found")
-        return result
+    def get_method_by_code(self, method_code):
+        return self.read_service.getMethods(codes=method_code)
 
     def get_offset_types_by_series_id(self, series_id):
         """

tests/test_odmservices/test_series_service.py

@@ -248,17 +248,17 @@ def test_get_data_value_by_id(self):
         assert dv.data_value == db_dv.data_value
 
     def test_get_qcl_by_id(self):
-        assert self.series_service.get_qcl_by_id(10) == None
+        assert self.series_service.get_processing_level_by_id(10) == None
 
         qcl = test_util.add_qcl(self.session)
-        db_qcl = self.series_service.get_qcl_by_id(qcl.id)
+        db_qcl = self.series_service.get_processing_level_by_id(qcl.id)
         assert qcl.code == db_qcl.code
 
     def test_get_all_qcls(self):
-        assert self.series_service.get_all_qcls() == []
+        assert self.series_service.get_all_processing_levels() == []
 
         qcl = test_util.add_qcl(self.session)
-        all_qcls = self.series_service.get_all_qcls()
+        all_qcls = self.series_service.get_all_processing_levels()
 
         assert len(all_qcls) == 1
         assert qcl.id == all_qcls[0].id