merge in changes from use_api:

Author: stephanie

odmtools/controller/NewFlagValuesController.py

@@ -1,20 +1,24 @@
 import wx
 from odmtools.view.NewFlagValuesView import NewFlagValuesView
+import odmtools.controller.olvAddPoint
 
 
 class NewFlagValuesController(NewFlagValuesView):
     def __init__(self, parent, series_service, qualifier_choice, record_service):
 
         NewFlagValuesView.__init__(self, parent)
+        self.parent = parent
         self.series_service = series_service
         self.qualifer_choice = qualifier_choice
         self.record_service = record_service
         self.__new_annotation = "New Annontation"
 
-        annotations = self.series_service.get_all_annotations()
-        self.append_items_to_annotation(annotations)
-        self.annotation_combo.SetSelection(0)
+        if self.qualifer_choice:
+            annotations = self.series_service.get_all_annotations()
+            self.append_items_to_annotation(annotations)
+
         self.annotation_combo.Append(self.__new_annotation)
+        self.annotation_combo.SetSelection(0)
 
         self.cancel_button.Bind(wx.EVT_BUTTON, self.on_cancel)
         self.Bind(wx.EVT_CLOSE, self.on_cancel)
@@ -32,7 +36,9 @@ def append_items_to_annotation(self, annotations):
     def on_cancel(self, event):
         self.MakeModal(False)
         self.Destroy()
-        event.Skip()
+
+        if event:
+            event.Skip()
 
     def on_ok(self, event):
         selection = self.annotation_combo.GetValue()
@@ -46,6 +52,9 @@ def on_ok(self, event):
             annotation = self.series_service.get_annotation_by_code(code)
         self.record_service.flag(annotation.AnnotationID)
 
+        if isinstance(self.parent, odmtools.controller.olvAddPoint.OLVAddPoint):
+            self.parent.refresh_annotations()
+
         self.on_cancel(event)
 
 if __name__ == '__main__':

odmtools/controller/WizardActionController.py

@@ -1,8 +1,10 @@
 import wx
 from odmtools.view.WizardActionView import WizardActionView
 from wx.wizard import WizardPageSimple
+from odm2api.ODM2.models import Affiliations
 
 
+# Should we rename this to Affiliations instead of actions? Action is created else where
 class WizardActionController(WizardPageSimple):
     def __init__(self, parent, affiliations):
         WizardPageSimple.__init__(self, parent)
@@ -16,6 +18,34 @@ def __init__(self, parent, affiliations):
         if self.affiliations is None:
             return
         # Populate table with the affiliations
+        self.populate_affiliations_table()
+
+    def populate_affiliations_table(self):
+        """
+        self.affiliations must be a list affiliations
+        :return:
+        """
+        if not isinstance(self.affiliations, list):
+            return
+        if not len(self.affiliations) and not isinstance(self.affiliations[0], Affiliations):
+            return
+
+        data = []
+        for affiliation in self.affiliations:
+            data.append([
+                affiliation.PersonObj.PersonFirstName + " " + affiliation.PersonObj.PersonLastName,
+                affiliation.OrganizationObj.OrganizationName
+            ])
+
+        columns = ["Person", "Organization"]
+        self.action_view.affiliations_table.set_columns(columns)
+        self.action_view.affiliations_table.set_table_content(data)
+
+    def get_affiliation(self):
+        index = self.action_view.affiliations_table.GetFirstSelected()
+        return self.affiliations[index]
+
+
 
 
 if __name__ == '__main__':

odmtools/controller/WizardMethodController.py

@@ -5,10 +5,11 @@
 
 
 class WizardMethodController(WizardPageSimple):
-    def __init__(self, parent, series_service):
+    def __init__(self, parent, series_service, current_method=None):
         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)
@@ -17,24 +18,40 @@ def __init__(self, parent, series_service):
         table_columns = ["ID", "Descriptions", "Link", "Code", "Type"]
         self.cv_types = []
         self.method_view.existing_method_table.set_columns(table_columns)
+
         self.on_auto_radio(None)
 
+        self.all_methods = []
+        self.current_method_in_series = current_method  # Not the same as the selected method in the table
+        self.__populate_table()
+        self.select_current_method()
+        self.method_view.method_type_combo.AppendItems(self.cv_types)
+        self.on_existing_method_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()
-        self.method_view.method_type_combo.AppendItems(self.cv_types)
+    def select_current_method(self):
+        if self.current_method_in_series is None:
+            return
+
+        if self.current_method_in_series not in self.all_methods:
+            return  # the current method is not in the table
+
+        index = self.all_methods.index(self.current_method_in_series)
+        self.method_view.existing_method_table.Select(index)
 
     def on_auto_radio(self, event):
-        self.method_view.existing_method_table.Enable(False)
-        self.__set_create_method_section_(False)
+        self.method_view.existing_method_table.Disable()
+        self.enable_create_method_section(False)
 
     def on_existing_method_radio(self, event):
         self.method_view.existing_method_table.Enable()
-        self.__set_create_method_section_(False)
+        self.enable_create_method_section(False)
+        self.method_view.existing_method_table.SetFocus()
 
-    def __set_create_method_section_(self, active):
+    def enable_create_method_section(self, active):
         if not isinstance(active, bool):
             raise Exception("active must be type bool")
 
@@ -47,12 +64,12 @@ def __set_create_method_section_(self, active):
 
     def on_create_method_radio(self, event):
         self.method_view.existing_method_table.Disable()
-        self.__set_create_method_section_(True)
+        self.enable_create_method_section(True)
 
-    def __fetch_data(self):
-        methods = self.series_service.get_all_methods()
+    def __populate_table(self):
+        self.all_methods = self.series_service.get_all_methods()
         data = []
-        for meth in methods:
+        for meth in self.all_methods:
             data.append([
                 meth.MethodID, meth.MethodDescription,
                 meth.MethodLink, meth.MethodCode,
@@ -64,7 +81,7 @@ def __fetch_data(self):
 
         self.method_view.existing_method_table.set_table_content(data=data)
 
-    def getMethod(self):
+    def get_method(self):
         if self.method_view.auto_method_radio.GetValue():
             return self.__auto_generate_a_method()
 
@@ -87,14 +104,7 @@ def __auto_generate_a_method(self):
 
     def __select_existing_method(self):
         index = self.method_view.existing_method_table.GetFirstSelected()
-        desc = self.method_view.existing_method_table.GetItem(index, 1).GetText()
-        link = self.method_view.existing_method_table.GetItem(index, 2).GetText()
-        code = self.method_view.existing_method_table.GetItem(index, 3).GetText()
-
-        method = self.series_service.get_method_by_code(method_code=code)
-        method.MethodLink = link
-        method.MethodDescription = desc
-        return method
+        return self.all_methods[index]
 
     def __create_new_method(self):
         code = self.method_view.method_code_text_ctrl.GetValue()

odmtools/controller/WizardProcessLevelController.py

@@ -5,7 +5,7 @@
 
 
 class WizardProcessLevelController(WizardPageSimple):
-    def __init__(self, parent, service_manager):
+    def __init__(self, parent, service_manager, current_processing_level=None):
         WizardPageSimple.__init__(self, parent)
 
         self.service_manager = service_manager
@@ -14,20 +14,37 @@ def __init__(self, parent, service_manager):
         main_sizer.Add(self.processing_level_view, 1, wx.EXPAND | wx.RIGHT, -16)
         self.SetSizer(main_sizer)
 
+        self.all_processing_level = []
         table_columns = ["Code", "Definition", "Explanation", "ID"]
         self.processing_level_view.existing_process_table.set_columns(table_columns)
+        self.current_processing_level = current_processing_level
         self.__fetch_data()
+        self.select_current_processing_level()
 
         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 select_current_processing_level(self):
+        if self.current_processing_level is None:
+            return
+
+        index = -1
+        for i in range(len(self.all_processing_level)):
+            if self.all_processing_level[i].ProcessingLevelID == self.current_processing_level.ProcessingLevelID:
+                index = i
+                break
+
+        if index >= 0:
+            self.processing_level_view.existing_process_table.Select(index)
+
     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)
+        self.processing_level_view.existing_process_table.SetFocus()
 
     def __set_create_proces_section(self, active):
         if not isinstance(active, bool):
@@ -39,10 +56,10 @@ def __set_create_proces_section(self, active):
 
     def __fetch_data(self):
         series_service = self.service_manager.get_series_service()
-        processes = series_service.get_all_processing_levels()
+        self.all_processing_level = series_service.get_all_processing_levels()
 
         data = []
-        for proc in processes:
+        for proc in self.all_processing_level:
             data.append([
                 proc.ProcessingLevelCode,
                 proc.Definition,
@@ -54,18 +71,16 @@ def __fetch_data(self):
 
     def get_processing_level(self):
         if self.processing_level_view.create_process_level_radio.GetValue():
-            return self.__select_existing_processing_level()
+            return self.__create_processing_level()
 
         if self.processing_level_view.existing_process_radio.GetValue():
             return self.__select_existing_processing_level()
 
         return None
 
     def __select_existing_processing_level(self):
-        selected_row = self.processing_level_view.existing_process_table.get_selected_row()
-        code = selected_row[0]
-        proc_level = self.service_manager.get_series_service().get_processing_level_by_code(codes=code)
-        return proc_level
+        index = self.processing_level_view.existing_process_table.GetFirstSelected()
+        return self.all_processing_level[index]
 
     def __create_processing_level(self):
         code = self.processing_level_view.level_code_text_ctrl.GetValue()

odmtools/controller/WizardVariableController.py

@@ -10,6 +10,8 @@ def __init__(self, parent, service_manager, current_variable):
 
         self.service_manager = service_manager
         self.current_variable = current_variable
+        self.all_variables = []
+
         main_sizer = wx.BoxSizer(wx.VERTICAL)
         self.variable_view = WizardVariableView(self)
         main_sizer.Add(self.variable_view, 1, wx.EXPAND | wx.RIGHT, -16)
@@ -20,23 +22,48 @@ def __init__(self, parent, service_manager, current_variable):
         self.on_current_radio(None)
 
         self.__fetch_data()
+        self.select_current_variable()
+
         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 select_current_variable(self):
+        if self.current_variable is None:
+            return
+
+        index = -1
+        for i in range(len(self.all_variables)):
+            if self.all_variables[i].VariableID == self.current_variable.VariableID:
+                index = i
+                break
+
+        if index >= 0:
+            self.variable_view.variable_table.Select(index)
+
     def on_current_radio(self, event):
         self.variable_view.variable_table.Enable(False)
-        self.__set_create_variable_section(False)
+        self.__enable_create_variable_section(False)
+
+        if event:
+            event.Skip()
 
     def on_create_radio(self, event):
         self.variable_view.variable_table.Enable(False)
-        self.__set_create_variable_section(True)
+        self.__enable_create_variable_section(True)
+
+        if event:
+            event.Skip()
 
     def on_existing_radio(self, event):
         self.variable_view.variable_table.Enable(True)
-        self.__set_create_variable_section(False)
+        self.__enable_create_variable_section(False)
+        self.variable_view.variable_table.SetFocus()
+
+        if event:
+            event.Skip()
 
-    def __set_create_variable_section(self, active):
+    def __enable_create_variable_section(self, active):
         if not isinstance(active, bool):
             raise Exception("active must be type bool")
 
@@ -61,9 +88,9 @@ def __fetch_data(self):
 
     def __populate_variable_table(self):
         series_serivce = self.service_manager.get_series_service()
-        variables = series_serivce.get_all_variables()
+        self.all_variables = series_serivce.get_all_variables()
         data = []
-        for var in variables:
+        for var in self.all_variables:
             data.append([var.VariableCode,
                          var.VariableNameCV,
                          var.SpeciationCV,
@@ -74,27 +101,28 @@ def __populate_variable_table(self):
         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)
+            return self.current_variable
 
-        elif self.variable_view.create_variable_radio.GetValue():
-            return self.get_new_variable()
+        if self.variable_view.existing_variable_radio.GetValue():
+            return self.__select_existing_variable()
 
-        return v
+        if self.variable_view.create_variable_radio.GetValue():
+            return self.__create_new_variable()
+
+        return None
+
+    def __select_existing_variable(self):
+        index = self.variable_view.variable_table.GetFirstSelected()
+        return self.all_variables[index]
 
-    def get_new_variable(self):
+    def __create_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