alter wizsave

Author: stephanie

odmtools/controller/pageExisting.py

@@ -80,4 +80,5 @@ def initTable(self, dbservice, site_id):
 
         self.pnlExisting.olvSeriesList.SetColumns(seriesColumns)
         objects = dbservice.get_series_by_site(site_id=site_id)
+
         self.pnlExisting.olvSeriesList.SetObjects(objects)

odmtools/gui/wizSave.py

@@ -226,7 +226,7 @@ def _init_ctrls(self, prnt):
 
     def get_metadata(self):
         # method = self.currSeries.FeatureActionObj.ActionObj.MethodObj
-        # processing_level = self.currSeries.quality_control_level
+        # processing_level = self.currSeriefs.quality_control_level
         # variable = self.currSeries.variable
         # action =
 
@@ -453,11 +453,10 @@ def on_wizard_finished(self, event):
             '''
 
 
-            TODO: move all of this stuff into the edit_service file
+            #TODO: move all of this stuff into the edit_service file
             # Create action
-            new_result = self.series_service.createResult(var=variable, meth=method, proc=proc_level)
-            #TODO create a timeseriesresult
-            #TODO create a featureaction
+            new_result = self.series_service.getResult(var=variable, meth=method, proc=proc_level)
+
             # action = self.series_service.create.createAction(action)
 
             affiliation = self.action_page.get_affiliation()
@@ -468,15 +467,20 @@ def on_wizard_finished(self, event):
             new_action_by.AffiliationID = affiliation.AffiliationID
             new_action_by.AffiliationObj = affiliation
 
+            #TODO end
+
             try:
                 if rbSave:
                     result = self.record_service.save()
                 elif rbSaveAsNew:
+                    #TODO send in Action, and Actionby
                     result = self.record_service.save_as(variable, method, proc_level)
                 elif rbSaveAsExisting:
                     if overwrite:
+                        #TODO send in just the result
                         result = self.record_service.save_existing(variable, method, proc_level)
                     elif append:
+                        #TODO send in just the result
                         #def save_appending(self, var = None, method =None, qcl = None, overwrite = False):
                         #TODO if i require that original or new is selected I can call once with overwrite = original
                         if original:

odmtools/odmservices/edit_service.py

@@ -482,71 +482,103 @@ def restore(self):
         self.reset_filter()
 
     def save(self,  result=None):
+        values = self.memDB.df
         if not result:
-            result = self.memDB.series_service.get_series(series_id = self.memDB.df['resultid'])[0]
+            result = self.memDB.series_service.get_series(series_id = values['resultid'][0])
         # update result
         self.updateResult(result)
         # upsert values
-        self.memDB.series_service.upsert(self.memDB.df)
+        self.memDB.series_service.upsert(values)
         # save new annotations
         self.add_annotations(self.memDB.annotation_list)
         return result
 
-    def saveAppend(self,  variable, method, proc_level, overwrite=True):
+    def saveAppend(self,  result, overwrite=True):
+        values = self.memDB.df
+
         # get save result
-        result= self.memDB.series_service.get_series_by_id_quint(variable, method, proc_level)
+
         # get value count
+        vc = result.ValueCount
         # set in df
+        values["resultid"] = result.ResultID
         # update result
         self.updateResult(result)
         # count = overlap calc
+        count = self.overlapcalc()
         # set value count = res.vc+valuecount-count
         # insert values
-        # save series
+        self.memDB.series_service.upsert_values(values)
         # save new annotations
+        self.add_annotations(self.memDB.annotation_list)
         return result
 
 
-    def saveAs(self, variable, method, proc_level):
+    def saveAs(self, variable, method, proc_level, action, action_by):
+        values = self.memDB.df
+        # get all annotations for series
+        annolist= self.memDB.series_service.get_annotations_by_result(values["resultid"][0])
+        annolist['valueid']
+
         # create series
-        result= self.createResult(variable, method, proc_level)
+        result= self.getResult(variable, method, proc_level)
         # update result
         self.updateResult(result)
         # set in df
+        values["resultid"] = result.ResultID
         # insert values
+        self.memDB.series_service.insert_values(values)
 
-        # save_new_series
-        # get all annotations for series
         # save all annotations
+        frames = [self.memDB.annotation_list, annolist]
+        annolist = pd.concat(frames)
+        self.add_annotations(annolist)
+
 
         return result
 
-    def saveExisting(self, variable, method, proc_level):
+    def saveExisting(self, result):
+        values = self.memdB.df
         # get save result
-        result = self.memDB.series_service.get_series_by_id_quint(variable, method, proc_level)
+
         # set in df
-        # save(values, result)
-        self.memDB.series_service.
+        values["resultid"]=result.ResultID
+        # save(values)
+        self.memDB.series_service.upsert_values(values)
+        #insert new annotations
+        self.add_annotations(self.memDB.annotation_list)
         return result
 
-        # new series
-
-    def createResult(self, var, meth, proc):
 
-        #if result does not exist
-        #create Action : of type "derivation"
-        #create Actionby
-        #create FeatureAction( using current sampling feature id
-        #create TimeSeriesResult- this should also contain all of the stuff for the Result
+    def getResult(self, var, meth, proc, action, actionby):
 
         # copy old
+        result = self.memDB.series_service.get_series(self.memDB.df["resultid"][0])
+        self.memDB.series_service._session.expunge(result)
+
         # change var, meth proc, in df #intend ts, agg stat
-        Result = None
 
-        return self.updateResult(Result)
+        result.VariableID = var.VariableID
+        result.VariableObj = var
+        result.ProcessingLevelID = proc.ProcessingLevelID
+        result.ProcessingLevelObj = proc
+
+        #if result does not exist
+
+        if self.memDB.series_service.resultExists(result):
+            pass
+            #create Action : of type "derivation"
+            #create Actionby
+            #create FeatureAction( using current sampling feature id
+            #create TimeSeriesResult- this should also contain all of the stuff for the Result
+
+
+
+        return self.updateResult(result)
 
     def updateResult(self, Result):
         # get pd
+        values = self.memDB.df
         # get result
         # update count, dates,
         return Result
@@ -565,6 +597,8 @@ def add_annotations(self, annolist):
 
 
 
+
+
     #
     # def updateSeries(self, result = None, is_new_series=False, overwrite = True, append = False):
     #     """

odmtools/odmservices/series_service.py

@@ -66,12 +66,13 @@ def get_used_variables(self):
 
 
     # Query DetailedResultInfo/series object is for Display purposes
-    def get_all_series(self):
+    def get_all_series(self, sitePid = None):
         """
         Returns all series as a modelObject
         :return: List[Series]
         """
         setSchema(self._session_factory.engine)
+
         return self.read.getDetailedResultInfo('Time Series Coverage')
 
     def get_series(self, series_id=None):
@@ -319,7 +320,7 @@ def get_method_by_code(self, method_code):
 
 
     # Series Catalog methods
-    def get_series_by_id_quint(self, result):
+    def resultExists(self, result):
         """
 
         :param site_id:
@@ -329,29 +330,29 @@ def get_series_by_id_quint(self, result):
         :param qcl_id:
         :return: Series
         """
-        #unique Result
-        #FeatureActionID, ResultTypeCV, VariableID, UnitsID, ProcessingLevelID, SampledMediumCV
+        # unique Result
+        # FeatureActionID, ResultTypeCV, VariableID, UnitsID, ProcessingLevelID, SampledMediumCV
 
 
         try:
             # return self._edit_session.query(Results).filter_by(
             #      VariableID=var_id, MethodID=method_id,
             #      AnnotationID=qcl_id).first()
-            (ret, ), = self._session.query(exists().
-                                           where(Results.FeatureActionID == result.FeatureActionID).
-                                           where(Results.ResultTypeCV == result.ResultTypeCV).
+            res = self._session.query(exists().where(Results.ResultTypeCV == result.ResultTypeCV).
                                            where(Results.VariableID == result.VariableID).
                                            where(Results.UnitsID == result.UnitsID).
                                            where(Results.ProcessingLevelID == result.ProcessingLevelID).
-                                           wehre(Results.SampledMediumCV == result.SampledMediumCV)
-
+                                           where(Results.SampledMediumCV == result.SampledMediumCV)
+                                      )
+        # where(Results.FeatureActionID == result.FeatureActionID).
 
-                        )
 
-            return ret
+            return res
         except:
             return None
 
+
+
     def get_series_from_filter(self):
         # Pass in probably a Series object, match it against the database
         pass
@@ -402,13 +403,13 @@ def get_all_values_df(self):
         query = q.statement.compile(dialect=self._session_factory.engine.dialect)
         data = pd.read_sql_query(sql=query, con=self._session_factory.engine,
                           params=query.params)
-        columns = list(data)
+        #columns = list(data)
 
         # columns.insert(0, columns.pop(columns.index("DataValue")))
         # columns.insert(1, columns.pop(columns.index("ValueDateTime")))
         #columns.insert(2, columns.pop(columns.index("QualifierID")))
 
-        data = data.ix[:, columns]
+        #data = data.ix[:, columns]
         return data.set_index(data['ValueDateTime'])
         # q = self._edit_session.query(TimeSeriesResultValues).order_by(TimeSeriesResultValues.ValueDateTime)
         # query = q.statement.compile(dialect = self._session_factory.engine.dialect)
@@ -596,29 +597,29 @@ def get_current_time_and_utcoffset(self):
 #             raise Exception("Series does not exist, unable to save. Please select 'Save As'")
 #
 #
-    def save_new_series(self, series, dvs):
-        """ Create as a new catalog entry
-        :param series:
-        :param data_values:
-        :return:
-        """
-        # Save As case
-        if self.series_exists(series):
-            msg = "There is already an existing file with this information. Please select 'Save' or 'Save Existing' to overwrite"
-            logger.info(msg)
-            raise Exception(msg)
-        else:
-            try:
-                self._edit_session.add(series)
-                self._edit_session.commit()
-                self.save_values(dvs)
-                #self._edit_session.add_all(dvs)
-            except Exception as e:
-                self._edit_session.rollback()
-                raise e
-
-        logger.info("A new series was added to the database, series id: "+str(series.id))
-        return True
+    # def save_new_series(self, series, dvs):
+    #     """ Create as a new catalog entry
+    #     :param series:
+    #     :param data_values:
+    #     :return:
+    #     """
+    #     # Save As case
+    #     if self.series_exists(series):
+    #         msg = "There is already an existing file with this information. Please select 'Save' or 'Save Existing' to overwrite"
+    #         logger.info(msg)
+    #         raise Exception(msg)
+    #     else:
+    #         try:
+    #             self._edit_session.add(series)
+    #             self._edit_session.commit()
+    #             self.save_values(dvs)
+    #             #self._edit_session.add_all(dvs)
+    #         except Exception as e:
+    #             self._edit_session.rollback()
+    #             raise e
+    #
+    #     logger.info("A new series was added to the database, series id: "+str(series.id))
+    #     return True
 
 
     def update_values(self, updates):
@@ -706,7 +707,7 @@ def create_new_series(self, data_values, site_id, variable_id, method_id, source
         series.source_id = source_id
         series.quality_control_level_id = qcl_id
 
-        return self.create_service.createResult(series)
+        return self.create_service.getResult(series)
 
     def create_method(self, description, link):
         """
@@ -777,6 +778,23 @@ def create_annotation(self, code, text, link=None):
 
         return self.create_annotation_by_anno(annotation)
 
+    def add_annotations(self, anno_list):
+        try:
+            #tablename = TimeSeriesResultValueAnnotations.__tablename__
+            #print ("I am TS saving name the table name", tablename)
+            anno_list.to_sql(name="TimeSeriesResultValueAnnotations",
+                              schema=TimeSeriesResultValueAnnotations.__table_args__['schema'],
+                              if_exists='append',
+                              chunksize=1000,
+                              con=self._session_factory.engine,
+                              index=False)
+            self._session.commit()
+
+            return anno_list
+        except Exception as e:
+            print(e)
+            return None
+
 
     def get_vertical_datum_cvs(self):
         return self.read.getCVs(type="Elevation Datum")
@@ -834,10 +852,21 @@ def get_all_annotations(self):
 
     def get_annotations_by_result(self, resultid):
         setSchema(self._session_factory.engine)
-        ids = [x[0] for x in self.read._session.query(TimeSeriesResultValues.ValueID)\
-                .filter(TimeSeriesResultValues.ResultID == resultid).all()]
-        return self.read._session.query(TimeSeriesResultValueAnnotations)\
-            .filter(TimeSeriesResultValueAnnotations.ValueID.in_(ids)).all()
+
+        # ids = [x[0] for x in self.read._session.query(TimeSeriesResultValues.ValueID)\
+        #         .filter(TimeSeriesResultValues.ResultID == resultid).all()]
+        # q = self.read._session.query(TimeSeriesResultValueAnnotations)\
+        #     .filter(TimeSeriesResultValueAnnotations.ValueID.in_(ids)).all()
+
+        q =self.read._session.query(TimeSeriesResultValueAnnotations.AnnotationID, TimeSeriesResultValueAnnotations.ValueID,
+                                    TimeSeriesResultValues.ResultID, TimeSeriesResultValues.ValueDateTime)\
+                            .filter(TimeSeriesResultValues.ResultID == resultid)\
+                            .filter(TimeSeriesResultValueAnnotations.ValueID == TimeSeriesResultValues.ValueID)
+
+        query = q.statement.compile(dialect=self._session_factory.engine.dialect)
+        data = pd.read_sql_query(sql=query, con=self._session_factory.engine,
+                             params=query.params)
+        return data
 
     def get_aggregation_statistic(self):
         return self.read.getCVs(type="aggregationstatistic")

tests/test_odmservices/test_series_service.py

@@ -191,11 +191,11 @@ def test_get_series_by_id(self):
         assert series.id == db_series.id
 
     def test_get_series_by_id_quint(self):
-        assert self.series_service.get_series_by_id_quint(10, 10, 10, 10, 10) == None
+        assert self.series_service.resultExists(10, 10, 10, 10, 10) == None
 
         series = test_util.add_series(self.session)
-        db_series = self.series_service.get_series_by_id_quint(series.site_id, series.variable_id, series.method_id,
-                                                               series.source_id, series.quality_control_level_id)
+        db_series = self.series_service.resultExists(series.site_id, series.variable_id, series.method_id,
+                                                     series.source_id, series.quality_control_level_id)
 
         assert series.id == db_series.id