update caloverlap

Author: stephanie

odmtools/controller/WizardActionController.py

@@ -46,6 +46,8 @@ def get_affiliation(self):
         return self.affiliations[index]
 
 
+
+
 if __name__ == '__main__':
     app = wx.App(False)
     controller = WizardActionController(None, None)

odmtools/controller/logicCellEdit.py

@@ -40,7 +40,7 @@ def fetchCensorCodeChoices(self):
             return [NULL]
 
         series_service = self.serviceManager.get_series_service()
-        return [NULL] + [x.Term for x in series_service.get_censor_code_cvs()]
+        return [NULL] + [x.Name for x in series_service.get_censor_code_cvs()]
 
     def fetchQualityCodeChoices(self):
         """
@@ -50,7 +50,7 @@ def fetchQualityCodeChoices(self):
             return [NULL]
 
         series_service = self.serviceManager.get_series_service()
-        return [NULL] + [x.Term for x in series_service.get_quality_code()]
+        return [NULL] + [x.Name for x in series_service.get_quality_code()]
 
     def fetchTimeUnitChoices(self):
         if not self.serviceManager:

odmtools/controller/logicEditTools.py

@@ -257,7 +257,7 @@ def save(self, var=None, method=None, qcl=None):
             Publisher.sendMessage("scroll")
         return result
 
-    def save_as(self, var=None, method=None, qcl=None, action = None, actionby = None):
+    def save_as(self, variable=None, method=None, proc_level=None, action = None, action_by = None):
         """
 
         :param var:
@@ -266,10 +266,10 @@ def save_as(self, var=None, method=None, qcl=None, action = None, actionby = Non
         :param override:
         :return:
         """
-        result = self._edit_service.save_as(var=var, method=method, qcl=qcl, action = action, actionby = actionby)
+        result = self._edit_service.save_as(variable=variable, method=method, proc_level=proc_level, action = action, action_by = action_by)
         if self._record:
             self._script(
-                "edit_service.save_as(%s, %s, %s, %s, %s)\n" % (self.saveFactory(var, method, qcl, action, actionby)),
+                "edit_service.save_as(%s, %s, %s, %s, %s)\n" % (self.saveFactory(variable, method, proc_level, action, action_by)),
                 'black')
             #self._script("edit_service.save(%s, %s, %s, saveAs=%s)\n" % (var, method, qcl, isSave), 'black')
             Publisher.sendMessage("scroll")

odmtools/gui/wizSave.py

@@ -272,6 +272,7 @@ def get_metadata(self):
         action.ActionFileLink = self.action_page.action_view.action_file_link_text_box.GetValue()
         action.MethodObj.OrganizationObj = affiliation.OrganizationObj
         action.BeginDateTime = self.currSeries.ResultDateTime
+        action.BeginDateTimeUTCOffset = self.currSeries.ResultDateTimeUTCOffset
 
         return site, variable, method, action, processing_level
 
@@ -454,7 +455,7 @@ def on_wizard_finished(self, event):
             affiliation = self.action_page.get_affiliation()
 
             action_by = ActionBy()
-            action_by.ActionID = action.ActionID
+            #action_by.ActionID = action.ActionID
             action_by.RoleDescription = self.action_page.action_view.role_description_text_box.GetValue()
             action_by.AffiliationID = affiliation.AffiliationID
             action_by.AffiliationObj = affiliation

odmtools/odmdata/memory_database.py

@@ -160,7 +160,7 @@ def chunking(self, data):
 
 
     #break into chunks to get around sqlite's restriction. allowing user to send in only 999 arguments at once
-    #TODO update to work with odm2
+
 
     def updateFlag(self, ids, value):
 
@@ -211,8 +211,9 @@ def addPoints(self, points):
                     "resultid":self.df["resultid"][0]
                     # todo: Add annotations
                     }
-            if point[8]:
-                self.updateFlag(point[1], self.series_service.get_annotation_by_id(point[8]).AnnotationID)
+            if point[8] != 'NULL':
+                print point[8]
+                self.updateFlag([point[1]], [point[8]])
 
             setSchema(self.mem_service._session_factory.engine)
             self.mem_service._session.execute(stmt, vals)

odmtools/odmservices/edit_service.py

@@ -499,50 +499,40 @@ def save(self,  result=None):
         self.add_annotations(self.memDB.annotation_list)
         return result
 
+    def save_existing(self, result):
+        result = self.save(result)
+        return result
+
     def save_appending(self, result, overwrite=True):
         values = self.memDB.getDataValuesDF()
 
-        # get save result
-
         # get value count
         vc = result.ValueCount
         # set in df
         values["resultid"] = result.ResultID
         # update result
         self.updateResult(result)
         # count = overlap calc
-        count = self.overlapcalc()
+        count = self.overlapcalc(result, values, overwrite)
         # set value count = res.vc+valuecount-count
-        result.ValueCount = result.ValueCount+ vc -count
+        result.ValueCount = result.ValueCount + vc - count
+        self.memDB.series_service.update.updateResult(result.ResultID, result.ValueCount)
         # insert values
         self.memDB.series_service.upsert_values(values)
         # save new annotations
         self.add_annotations(self.memDB.annotation_list)
-        return result
-
-
-    def save_existing(self, result):
-        #values = self.memDB.getDataValuesDF()
-        # get save result
-
-        # set in df
-        #values["resultid"]=result.ResultID
-
-        # save(values)
-        self.save(result)
 
         return result
 
     def save_as(self, variable, method, proc_level, action, action_by):
         #save as new series
         values = self.memDB.getDataValuesDF()
         # get all annotations for series
-        annolist= self.memDB.series_service.get_annotations_by_result(values["resultid"][0])
-        annolist['valueid']
+        annolist= self.memDB.series_service.get_annotations_by_result(str(values["resultid"][0]))
+        annolist['valueid']=None
 
         # create series
-        result = self.getResult(variable, method, proc_level)
-        result.ValueCount = 0
+        result = self.getResult(variable, method, proc_level, action, action_by)
 
         # set in df
         values["resultid"] = result.ResultID
@@ -557,14 +547,15 @@ def save_as(self, variable, method, proc_level, action, action_by):
 
         return result
 
-    def getResult(self, var, meth, proc, action, actionby):
+    def getResult(self, var, meth, proc, action, action_by):
         values = self.memDB.getDataValuesDF()
         # copy old
-        result = self.memDB.series_service.get_series(values["resultid"][0])
-        sampling_feature = result.FeatureActionObj.SamplingFeatureObj
-        # self.memDB.series_service._session.expunge(result)
+        result = self.memDB.series_service.get_series(str(values["resultid"][0]))
+        result.ResultID = None
+        result.ResultUUID = None
+
 
-        # change var, meth proc, in df #intend ts, agg stat
+        # change var, meth proc, in df #intend ts, agg sta
         if var:
             result.VariableID = var.VariableID
             result.VariableObj = var
@@ -574,43 +565,98 @@ def getResult(self, var, meth, proc, action, actionby):
             result.ProcessingLevelObj = proc
 
         if meth:
+            action.MethodID = meth.MethodID
             result.FeatureActionObj.ActionObj.MethodID = meth.MethodID
-            result.FeatureActionObj.ActionObj.MethodObj = meth
 
         #if result does not exist
-        if self.memDB.series_service.resultExists(result):
-            action.ActionTypeCV = "derivation"
-            # create Actionby done
-
-            # create FeatureAction (using current sampling feature id)
-            feature_action = FeatureActions()
-            feature_action.SamplingFeatureID = sampling_feature.SamplingFeatureID
-            feature_action.SamplingFeatureObj = sampling_feature
-
-            # create TimeSeriesResult - this should also contain all of the stuff for the Result  (hopefully the result will actually be of type, TimeSeriesResult)
-            series = TimeSeriesResults()
-
-
-
+        if not self.memDB.series_service.resultExists(result):
+            try:
+                #create Action
+                action.ActionID = None
+                #action.MethodObj = None
+                action.ActionTypeCV = "Derivation"
+                self.memDB.series_service.read._session.expunge(action.MethodObj.OrganizationObj)
+                self.memDB.series_service.read._session.expunge(action.MethodObj)
+                action = self.memDB.series_service.create.create(action)
+                print action
+
+
+                # create Actionby done
+                action_by.ActionID = action.ActionID
+                action_by= self.memDB.series_service.create.createActionby(action_by)
+                print action_by
+
+
+                # create FeatureAction (using current sampling feature id)
+                sampling_feature = result.FeatureActionObj.SamplingFeatureObj
+                self.memDB.series_service.read._session.expunge(result.FeatureActionObj.SamplingFeatureObj)
+
+                feature_action = FeatureActions()
+                feature_action.SamplingFeatureID = sampling_feature.SamplingFeatureID
+                feature_action.ActionID = action.ActionID
+                feature_action.ActionObj = action
+                feature_action.SamplingFeatureObj = sampling_feature
+                feature_action = self.memDB.series_service.create.createFeatureAction(feature_action)
+                print feature_action
+
+                # create TimeSeriesResult - this should also contain all of the stuff for the Result
+                time, offset = self.get_current_time_and_utcoffset()
+
+                result.ValueCount = 0
+                result.FeatureActionID = feature_action.FeatureActionID
+                result.ResultDateTime = time
+                result.ResultDateTimeUTCOffset = offset
+                result.FeatureActionObj= feature_action
+                self.memDB.series_service.read._session.expunge(result.ProcessingLevelObj)
+                self.memDB.series_service.read._session.expunge(result.VariableObj)
+                self.memDB.series_service.read._session.expunge(result)
+
+
+                result = self.memDB.series_service.create.createResult(result)
+                print result
+            except Exception as ex:
+                print ex
         return self.updateResult(result)
 
-    form = "%Y-%m-%d %H:%M:%S"
-    def updateResult(self, Result):
+
+    def updateResult(self, result):
         form = "%Y-%m-%d %H:%M:%S"
         # get pd
         values = self.memDB.getDataValuesDF()
 
         # update count, dates,
-        Action = Result.FeatureActionObj.ActionObj
-        Action.BeginDateTime= datetime.datetime.strptime(str(np.min(values['valuedatetime'])), form)
-        Action.EndDateTime = datetime.datetime.strptime(str(np.max(values["valuedatetime"])), form)
-        Result.ValueCount = len(values)
-        return Result
+        action = result.FeatureActionObj.ActionObj
+        action.BeginDateTime= datetime.datetime.strptime(str(np.min(values['valuedatetime'])), form)
+        action.EndDateTime = datetime.datetime.strptime(str(np.max(values["valuedatetime"])), form)
+        result.ValueCount = len(values)
+        self.memDB.series_service.update.updateResult(result.ResultID, result.ValueCount)
+        self.memDB.series_service.update.updateAction(actionID=action.ActionID, begin=action.BeginDateTime, end=action.EndDateTime)
 
-    def overlapcalc(self):
-        pass
+        return result
+
+    def overlapcalc(self, result, values,  overwrite):
+        form = "%Y-%m-%d %H:%M:%S"
+
+        #is there any overlap
+        dbend = result.FeatureActionObj.ActionObj.EndDateTime
+        dfstart = datetime.datetime.strptime(str(np.min(values["valuedatetime"])), form)
+        overlap = dbend>= dfstart
+        #number of overlapping values
+        overlapdf = values[(values["valuedatetime"]>= dfstart) & (values["valudatetime"]<= dbend)]
+        count =len(overlapdf)
+        #if not overwrite. remove any overlapping values from df
+        if overlap:
+            if not overwrite:
+                values = values[values["valuedatetime"] > dbend]
+
+        # return the number of overlapping values
+        return count
 
     def add_annotations(self, annolist):
+        #match up with existing values and get value id
+        #get df with only ValueID and AnnotationID
+        #remove any duplicates
+        #save df to db
         pass
 
 
@@ -810,3 +856,11 @@ def reconcile_dates(self, parent_series_id):
         pass
 
 
+    def get_current_time_and_utcoffset(self):
+        current_time = datetime.datetime.now()
+        utc_time = datetime.datetime.utcnow()
+
+        difference_in_timezone = current_time - utc_time
+        offset_in_hours = difference_in_timezone.total_seconds() / 3600
+
+        return current_time, offset_in_hours

odmtools/odmservices/series_service.py

@@ -340,7 +340,7 @@ def resultExists(self, result):
             # return self._edit_session.query(Results).filter_by(
             #      VariableID=var_id, MethodID=method_id,
             #      AnnotationID=qcl_id).first()
-            res = self._session.query(exists().where(Results.ResultTypeCV == result.ResultTypeCV).
+            ret = self._session.query(exists().where(Results.ResultTypeCV == result.ResultTypeCV).
                                            where(Results.VariableID == result.VariableID).
                                            where(Results.UnitsID == result.UnitsID).
                                            where(Results.ProcessingLevelID == result.ProcessingLevelID).
@@ -349,7 +349,7 @@ def resultExists(self, result):
         # where(Results.FeatureActionID == result.FeatureActionID).
 
 
-            return res
+            return ret.scalar()
         except:
             return None
 
@@ -870,7 +870,7 @@ def get_quality_code(self):
 
     def get_annotation_by_code(self, code):
         return self.read.getAnnotations(codes=[code])[0]
-    def get_annotation_by_id (self, id):
+    def get_annotation_by_id(self, id):
         return self.read.getAnnotations(ids=[id])[0]
     def get_all_annotations(self):
         return self.read.getAnnotations(type=None)