merging test_util

Author: sreeder

ODMTools.py

@@ -60,11 +60,6 @@ def OnInit(self):
         app= self.frame
         return True
 
-def runODM():
-    app = wx.App(False)
-    #frame = create(None)
-    #frame.Show()
-    app.MainLoop()
 
 if __name__ == '__main__':
     logger.info("Welcome to ODMTools Python. Please wait as system loads")

doc/wxFormBuilder/clsIntro.py

@@ -29,7 +29,7 @@ def __init__( self, parent ):
 
 		bSizer2 = wx.BoxSizer( wx.VERTICAL )
 
-		self.lblHow = wx.StaticText( self.m_panel2, wx.ID_ANY, u"How would you like to save the series?", wx.DefaultPosition, wx.DefaultSize, 0 )
+		self.lblHow = wx.StaticText( self.m_panel2, wx.ID_ANY, u"How would you like to save the series_service?", wx.DefaultPosition, wx.DefaultSize, 0 )
 		self.lblHow.Wrap( -1 )
 		bSizer2.Add( self.lblHow, 0, wx.ALL, 15 )
 

odmtools/common/taskServer.py

@@ -131,8 +131,13 @@ def worker(cls, dispatcher):
             if task_type == "InitEditValues":
                 connection = SeriesService("sqlite:///:memory:")
                 df = task[1]
+<<<<<<< HEAD
                 logger.debug("Load series from db")
                 df.to_sql(name="DataValues", con=connection._connection.engine, flavor='sqlite', index = False, chunksize = 10000)
+=======
+                logger.debug("Load series_service from db")
+                df.to_sql(name="DataValues", con=connection._session_factory.engine, flavor='sqlite', index = False, chunksize = 10000)
+>>>>>>> origin/update_cvs
                 logger.debug("done loading database")
                 result = connection
             if task_type == "UpdateEditDF":

odmtools/controller/WizardMethodController.py

@@ -0,0 +1,80 @@
+import wx
+from wx.wizard import WizardPageSimple
+from odmtools.view.WizardMethodView import WizardMethodView
+from odmtools.odmdata import Method
+
+
+class WizardMethodController(WizardPageSimple):
+    def __init__(self, parent, series_service):
+        WizardPageSimple.__init__(self, parent)
+
+        main_sizer = wx.BoxSizer(wx.VERTICAL)
+        self.method_view = WizardMethodView(self)
+        main_sizer.Add(self.method_view, 1, wx.EXPAND | wx.RIGHT, -16)  # Sufficient to hide the scroll bar
+        self.SetSizer(main_sizer)
+
+        self.series_service = series_service
+        table_columns = ["Descriptions", "Link", "ID"]
+        self.method_view.existing_method_table.set_columns(table_columns)
+        self.method_view.method_type_combo.AppendItems(["ABC"])
+        self.on_auto_radio(None)
+
+        self.method_view.auto_method_radio.Bind(wx.EVT_RADIOBUTTON, self.on_auto_radio)
+        self.method_view.existing_method_radio.Bind(wx.EVT_RADIOBUTTON, self.on_existing_method_radio)
+        self.method_view.create_method_radio.Bind(wx.EVT_RADIOBUTTON, self.on_create_method_radio)
+
+        self.__fetch_data()
+
+    def on_auto_radio(self, event):
+        self.method_view.existing_method_table.Enable(False)
+        self.__set_create_method_section_(False)
+
+    def on_existing_method_radio(self, event):
+        self.method_view.existing_method_table.Enable()
+        self.__set_create_method_section_(False)
+
+    def __set_create_method_section_(self, active):
+        if not isinstance(active, bool):
+            raise Exception("active must be type bool")
+
+        self.method_view.method_code_text_ctrl.Enable(active)
+        self.method_view.method_name_text_ctrl.Enable(active)
+        self.method_view.method_type_combo.Enable(active)
+        self.method_view.organization_combo.Enable(active)
+        self.method_view.method_link_text_ctrl.Enable(active)
+        self.method_view.description_text_ctrl.Enable(active)
+
+    def on_create_method_radio(self, event):
+        self.method_view.existing_method_table.Disable()
+        self.__set_create_method_section_(True)
+
+    def __fetch_data(self):
+        methods = self.series_service.get_all_methods()
+        data = []
+        for meth in methods:
+            data.append([
+                meth.description,
+                meth.link,
+                meth.id
+            ])
+
+        self.method_view.existing_method_table.set_table_content(data=data)
+
+    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_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_code(desc)
+        elif self.method_view.create_method_radio.GetValue():
+            m.description = self.method_view.description_text_ctrl.GetValue()
+
+
+        return m

odmtools/controller/WizardProcessLevelController.py

@@ -0,0 +1,67 @@
+import wx
+from odmtools.view.WizardProcessLevelView import WizardProcessLevelView
+from wx.wizard import WizardPageSimple
+from odmtools.odmdata import QualityControlLevel
+
+
+class WizardProcessLevelController(WizardPageSimple):
+    def __init__(self, parent, service_manager):
+        WizardPageSimple.__init__(self, parent)
+
+        self.service_manager = service_manager
+        main_sizer = wx.BoxSizer(wx.VERTICAL)
+        self.processing_level_view = WizardProcessLevelView(self)
+        main_sizer.Add(self.processing_level_view, 1, wx.EXPAND | wx.RIGHT, -16)
+        self.SetSizer(main_sizer)
+
+        table_columns = ["Code", "Definition", "Explanation", "ID"]
+        self.processing_level_view.existing_process_table.set_columns(table_columns)
+        self.__fetch_data()
+
+        self.processing_level_view.create_process_level_radio.Bind(wx.EVT_RADIOBUTTON, self.on_create_radio)
+        self.processing_level_view.existing_process_radio.Bind(wx.EVT_RADIOBUTTON, self.on_existing_radio)
+
+    def on_create_radio(self, event):
+        self.processing_level_view.existing_process_table.Enable(False)
+        self.__set_create_proces_section(True)
+
+    def on_existing_radio(self, event):
+        self.processing_level_view.existing_process_table.Enable(True)
+        self.__set_create_proces_section(False)
+
+    def __set_create_proces_section(self, active):
+        if not isinstance(active, bool):
+            raise Exception("activet must be type bool")
+
+        self.processing_level_view.level_code_text_ctrl.Enable(active)
+        self.processing_level_view.definition_text_ctrl.Enable(active)
+        self.processing_level_view.explanation_text_ctrl.Enable(active)
+
+    def __fetch_data(self):
+        series_service = self.service_manager.get_series_service()
+        processes = series_service.get_all_processing_levels()
+
+        data = []
+        for proc in processes:
+            data.append([
+                proc.code,
+                proc.definition,
+                proc.explanation,
+                proc.id
+            ])
+
+        self.processing_level_view.existing_process_table.set_table_content(data=data)
+
+    def getQCL(self):
+        q = QualityControlLevel()
+        if self.processing_level_view.create_process_level_radio.GetValue():
+            q.code = self.processing_level_view.level_code_text_ctrl.GetValue()
+            q.definition = self.processing_level_view.definition_text_ctrl.GetValue()
+            q.explanation = self.processing_level_view.explanation_text_ctrl.GetValue()
+
+        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_processing_level_by_code(proc_level_code=code)
+
+        return q

odmtools/controller/WizardVariableController.py

@@ -0,0 +1,114 @@
+import wx
+from odmtools.view.WizardVariableView import WizardVariableView
+from wx.wizard import WizardPageSimple
+from odmtools.odmdata import Variable
+
+
+class WizardVariableController(WizardPageSimple):
+    def __init__(self, parent, service_manager, current_variable):
+        WizardPageSimple.__init__(self, parent)
+
+        self.service_manager = service_manager
+        self.current_variable = current_variable
+        main_sizer = wx.BoxSizer(wx.VERTICAL)
+        self.variable_view = WizardVariableView(self)
+        main_sizer.Add(self.variable_view, 1, wx.EXPAND | wx.RIGHT, -16)
+        self.SetSizer(main_sizer)
+
+        table_columns = ["Code", "Name", "Speciation", "Units",
+                         "Sample Medium", "Value Type", "IsRegular", "Time Support",
+                         "Time Units", "DataType", "Genaral Category", "NoDataValue", "ID"]
+        self.variable_view.variable_table.set_columns(table_columns)
+        self.on_current_radio(None)
+
+        self.__fetch_data()
+        self.variable_view.current_variable_radio.Bind(wx.EVT_RADIOBUTTON, self.on_current_radio)
+        self.variable_view.existing_variable_radio.Bind(wx.EVT_RADIOBUTTON, self.on_existing_radio)
+        self.variable_view.create_variable_radio.Bind(wx.EVT_RADIOBUTTON, self.on_create_radio)
+
+    def on_current_radio(self, event):
+        self.variable_view.variable_table.Enable(False)
+        self.__set_create_variable_section(False)
+
+    def on_create_radio(self, event):
+        self.variable_view.variable_table.Enable(False)
+        self.__set_create_variable_section(True)
+
+    def on_existing_radio(self, event):
+        self.variable_view.variable_table.Enable(True)
+        self.__set_create_variable_section(False)
+
+    def __set_create_variable_section(self, active):
+        if not isinstance(active, bool):
+            raise Exception("active must be type bool")
+
+        self.variable_view.variable_code_text_ctrl.Enable(active)
+        self.variable_view.variable_name_combo.Enable(active)
+        self.variable_view.variable_type_combo.Enable(active)
+        self.variable_view.no_data_value_text_ctrl.Enable(active)
+        self.variable_view.speciation_combo.Enable(active)
+        self.variable_view.definition_text_ctrl.Enable(active)
+
+    def __fetch_data(self):
+        self.__populate_variable_table()
+
+        cv_service = self.service_manager.get_cv_service()
+        name_list = [x.term for x in cv_service.get_variable_name_cvs()]
+        var_unit = [x.name for x in cv_service.get_units_names()]
+        spec_list = [x.term for x in cv_service.get_speciation_cvs()]
+
+        self.variable_view.variable_name_combo.AppendItems(name_list)
+        self.variable_view.speciation_combo.AppendItems(spec_list)
+        self.variable_view.variable_type_combo.AppendItems(var_unit)
+
+    def __populate_variable_table(self):
+        series_serivce = self.service_manager.get_series_service()
+        variables = series_serivce.get_all_variables()
+        data = []
+        for var in variables:
+            data.append([var.code,
+                         var.name,
+                         var.speciation,
+                         var.variable_unit.name,
+                         var.sample_medium,
+                         var.value_type,
+                         var.is_regular,
+                         var.time_support,
+                         var.time_unit.name,
+                         var.data_type,
+                         var.general_category,
+                         var.no_data_value,
+                         var.id])
+
+        self.variable_view.variable_table.set_table_content(data=data)
+
+    def get_variable(self):
+        v = Variable()
+        if self.variable_view.current_variable_radio.GetValue():
+            v = self.current_variable
+        elif self.variable_view.existing_variable_radio.GetValue():
+            row = self.variable_view.variable_table.get_selected_row()
+            code = row[0]
+            v = self.service_manager.get_series_service().get_variable_by_code(code)
+
+        elif self.variable_view.create_variable_radio.GetValue():
+            # v = self.createdVar
+            v = self.get_new_variable()
+
+        return v
+
+    def get_new_variable(self):
+        v = Variable()
+        v.code = self.variable_view.variable_code_text_ctrl.GetValue() if self.variable_view.variable_code_text_ctrl.GetValue() <> "" else None
+        v.name = self.variable_view.variable_name_combo.GetValue() if self.variable_view.variable_name_combo.GetValue() <> "" else None
+        v.speciation = self.variable_view.speciation_combo.GetValue() if self.variable_view.speciation_combo.GetValue() <> "" else None
+        v.variable_unit = self.service_manager.get_series_service()
+        v.no_data_value = self.variable_view.no_data_value_text_ctrl.GetValue() if self.variable_view.no_data_value_text_ctrl.GetValue() <> "" else None
+        # Need unit name, time support but neither of them are in the form...
+
+        return v
+
+
+
+
+

odmtools/controller/frmAddPoints.py

@@ -111,8 +111,10 @@ def validateInput(self, conn_dict):
 
     # Returns a dictionary of the database values entered in the form
     def getFieldValues(self):
-        conn_dict = {}
+        if self.isFormEmpty():
+            return {}
 
+        conn_dict = {}
         conn_dict['engine'] = self.choices[self.cbDatabaseType.GetValue()]
         conn_dict['user'] = self.txtUser.GetValue()
         conn_dict['password'] = self.txtPass.GetValue()
@@ -122,6 +124,28 @@ def getFieldValues(self):
 
         return conn_dict
 
+    def isFormEmpty(self):
+        """
+        If any of the entries are empty return true
+        :return:
+        """
+        if not self.cbDatabaseType.GetValue().strip():
+            return True
+
+        if not self.txtUser.GetValue().strip():
+            return True
+
+        if not self.txtPass.GetValue().strip():
+            return True
+
+        if not self.txtServer.GetValue().strip():
+            return True
+
+        if not self.txtDBName.GetValue().strip():
+            return True
+
+        return False
+
     def set_field_values(self):
         conn = self.service_manager.is_valid_connection()
         if conn is not None: