fix typo error

Author: Stephanie Reeder

odm2api/ODM2/services/readService.py

@@ -440,7 +440,7 @@ def getResults(self, ids=None, uuids= None,  actionid=None, simulationid = None)
         if simulationid: query = query.join(FeatureActions)\
             .join(Actions)\
             .join(Simulations)\
-            .filter(Simulations.SimulationID == simulationid)
+            .filter_by(SimulationID = simulationid)
         if ids: query = query.filter(Results.ResultID.in_(ids))
         if uuids: query =query.filter(Results.ResultUUID.in_(uuids))
 
@@ -786,10 +786,21 @@ def getRelatedModels(self, id=None, code=None):
         :return:
         :rtype:
         """
+# cdoe from master
+#+            # note this was RelatedModels.RelatedModelID == Models.ModelID which would return all Parent models of  RelatedModelID
+# +            self._session.query(RelatedModels).filter_by(ModelID=modelid).all()
+# +            self._session.query(RelatedModels).join(Models, RelatedModels.ModelID == Models.ModelID).filter(Models.ModelCode == modelcode).all()
 
-        m = self._session.query(Models).select_from(RelatedModels).join(RelatedModels.RelatedModelObj)
+        m = self._session.query(Models).select_from(RelatedModels).join(RelatedModels.ModelObj)
         if id: m = m.filter(RelatedModels.ModelID == id)
-        if code: m = m.filter(RelatedModels.ModelCode == code)
+        if code: m = m.filter(Models.ModelCode == code)
+
+#previous version of code
+        # m = self._session.query(Models).select_from(RelatedModels).join(RelatedModels.RelatedModelObj)
+        # if id: m = m.filter(RelatedModels.ModelID == id)
+        # if code: m = m.filter(RelatedModels.ModelCode == code)
+
+
 
         try:
             return m.all()

tests/test_odm2/data/populated.sql

@@ -340,8 +340,8 @@ CREATE TABLE SamplingFeatures (
 	FOREIGN KEY (SamplingFeatureTypeCV) REFERENCES CV_SamplingFeatureType (Name)
 	ON UPDATE NO ACTION ON DELETE NO ACTION
 );
-INSERT INTO "SamplingFeatures" VALUES(1,'1fe94bae-4524-11e5-b966-7831c1d1cf54','Site','LR_WaterLab_AA','Logan River at the Utah Water Research Laboratory west bridge',NULL,'Point','POINT (41.739034 -111.795742)',1414.0,'EGM96');
-INSERT INTO "SamplingFeatures" VALUES(2,'19b067c7-6a74-475d-8b7f-826b133cd91e','outlet','logan_river_outlet','logan watershed outlet','the outlet of the logan river watershed','point1d',X'0001000000006BD3D85E0BF25B40CF84268925DF44406BD3D85E0BF25B40CF84268925DF44407C010000006BD3D85E0BF25B40CF84268925DF4440FE',4680.0,'epsg:5702');
+INSERT INTO "SamplingFeatures" VALUES(1,'1fe94bae-4524-11e5-b966-7831c1d1cf54','Site','LR_WaterLab_AA','Logan River at the Utah Water Research Laboratory west bridge',NULL,'Point','POINT (41.739034 -111.795742)',NULL, 1414.0,'EGM96');
+INSERT INTO "SamplingFeatures" VALUES(2,'19b067c7-6a74-475d-8b7f-826b133cd91e','outlet','logan_river_outlet','logan watershed outlet','the outlet of the logan river watershed','point1d',X'0001000000006BD3D85E0BF25B40CF84268925DF44406BD3D85E0BF25B40CF84268925DF44407C010000006BD3D85E0BF25B40CF84268925DF4440FE',NULL, 4680.0,'epsg:5702');
 CREATE TABLE TaxonomicClassifiers (
 	TaxonomicClassifierID INTEGER   NOT NULL PRIMARY KEY,
 	TaxonomicClassifierTypeCV VARCHAR (255)  NOT NULL,

tests/test_odm2/test_createservice.py

@@ -186,79 +186,72 @@ def test_createActionBy(self):
     def test_createFeatureAction(self):
         pass
 
-    def test_createResult(self):
-
-        # assert that there are no results
-        res = self.engine.execute('SELECT * FROM Results')
-        assert(len(res.fetchall()) == 0)
-
-        # create a result record
-        # self.writer.createResult(featureactionid = 1,
-        #                         variableid = 1,
-        #                         unitid = 1,
-        #                         processinglevelid = 1,
-        #                         valuecount = 0,
-        #                         sampledmedium = 'unknown',
-        #                         resulttypecv = 'time series',
-        #                         taxonomicclass=None, resultdatetime=None, resultdatetimeutcoffset=None,
-        #                         validdatetime=None, validdatetimeutcoffset=None, statuscv=None)
-
-        r = models.Results(FeatureActionID = 1,
-                    VariableID=1,
-                    UnitsID =1,
-                    ProcessingLevelID = 1,
-                    ValueCount = 0,
-                    SampledMediumCV = 'unknown',
-                    ResultTypeCV = 'time series',
-                    TaxonomicClassifierID = None,
-                    ResultDateTime = None,
-                    ResultDateTimeUTCOffset = None,
-                    ValidDateTime=None,
-                    ValidDateTimeUTCOffset = None,
-                    StatusCV = None,
-                    ResultUUID = uuid.uuid4().hex
-
-            )
-        self.writer.createResult(r)
-
-
-        # assert that there are results
-        res = self.engine.execute('SELECT * FROM Results')
-        assert(len(res.fetchall()) == 1)
+    # def test_createResult(self):
+    #
+    #     # assert that there are no results
+    #     res = self.engine.execute('SELECT * FROM Results')
+    #     assert(len(res.fetchall()) == 0)
+    #
+    #     # create a result record
+    #     # self.writer.createResult(featureactionid = 1,
+    #     #                         variableid = 1,
+    #     #                         unitid = 1,
+    #     #                         processinglevelid = 1,
+    #     #                         valuecount = 0,
+    #     #                         sampledmedium = 'unknown',
+    #     #                         resulttypecv = 'time series',
+    #     #                         taxonomicclass=None, resultdatetime=None, resultdatetimeutcoffset=None,
+    #     #                         validdatetime=None, validdatetimeutcoffset=None, statuscv=None)
+    #
+    #     r = models.Results(FeatureActionID = 1,
+    #                 VariableID=1,
+    #                 UnitsID =1,
+    #                 ProcessingLevelID = 1,
+    #                 ValueCount = 0,
+    #                 SampledMediumCV = 'unknown',
+    #                 ResultTypeCV = 'time series',
+    #                 TaxonomicClassifierID = None,
+    #                 ResultDateTime = None,
+    #                 ResultDateTimeUTCOffset = None,
+    #                 ValidDateTime=None,
+    #                 ValidDateTimeUTCOffset = None,
+    #                 StatusCV = None,
+    #                 ResultUUID = uuid.uuid4().hex
+    #
+    #         )
+    #     self.writer.createResult(r)
+    #
+    #
+    #     # assert that there are results
+    #     res = self.engine.execute('SELECT * FROM Results')
+    #     assert(len(res.fetchall()) == 1)
 
     def test_createTimeSeriesResult(self):
 
         # assert that there are no time series results in the database
         res = self.engine.execute('SELECT * FROM TimeSeriesResults').first()
         assert(res is None)
 
-        # create a result record if it doesnt exist (required to test foriegn key relationship)
-        result = self.engine.execute('SELECT * FROM Results').first()
-        if result is None:
-            # create a basic result record
-            # self.writer.createResult(featureactionid = 1,variableid = 1,unitid = 1,processinglevelid = 1,
-            #                         valuecount = 0,sampledmedium = 'unknown',resulttypecv = 'time series')
 
-            r = models.Results(FeatureActionID = 1,
-                    VariableID=1,
-                    UnitsID =1,
-                    ProcessingLevelID = 1,
-                    ValueCount = 0,
-                    SampledMediumCV = 'unknown',
-                    ResultTypeCV = 'time series',
-                    ResultUUID = uuid.uuid4().hex
+        # create most basic time series result record possible
+        r = models.TimeSeriesResults(FeatureActionID = 1,
+                VariableID=1,
+                UnitsID =1,
+                ProcessingLevelID = 1,
+                ValueCount = 0,
+                SampledMediumCV = 'unknown',
+                ResultTypeCV = 'time series',
+                ResultUUID = uuid.uuid4().hex,
+                AggregationStatisticCV = 'unknown'
+
 
 
-            )
-            self.writer.createResult(r)
-            result = self.engine.execute('SELECT * FROM Results').first()
-            assert(result is not None)
+        )
+        self.writer.createResult(r)
+        result = self.engine.execute('SELECT * FROM Results').first()
+        assert(result is not None)
 
 
-        # create most basic time series result record possible
-        # tsr = self.writer.createTimeSeriesResult(result=result, aggregationstatistic='unknown')
-        # t = models.TimeSeriesResults(ResultID = result.ResultID, AggregationStatisticCV = 'unknown')
-        # tsr= self.writer.createResult(t)
         # assert that this basic tsr exists in the database
         res = self.engine.execute('SELECT * FROM TimeSeriesResults').first()
         assert(res is not None)

tests/test_odm2/test_readservice.py

@@ -76,7 +76,30 @@ def setup(self):
         self.db = globals['db']
 
 
+# ################################################################################
+# Sampling Features
+# ################################################################################
+
+    def test_getAllSamplingFeatures(self):
+
+        # get all models from the database
+        res = self.engine.execute('SELECT * FROM SamplingFeatures').fetchall()
+
+        # get all simulations using the api
+        resapi = self.reader.getSamplingFeatures()
 
+        assert len(res) == len(resapi)
+
+    def test_getSamplingFeatureByID(self):
+
+        # get all models from the database
+        res = self.engine.execute('SELECT * FROM SamplingFeatures').fetchone()
+        sfid=res[0]
+
+        # get all simulations using the api
+        resapi = self.reader.getSamplingFeatures(ids = [sfid])
+
+        assert resapi is not None
 
 # ################################################################################
 # Models
@@ -163,6 +186,49 @@ def test_getRelatedModelsByCode(self):
         assert resapi is None
 
 
+# ################################################################################
+# Results
+# ################################################################################
+    """
+        TABLE Results (
+        ResultID INTEGER   NOT NULL PRIMARY KEY,
+        ResultUUID VARCHAR(36)   NOT NULL,
+        FeatureActionID INTEGER   NOT NULL,
+        ResultTypeCV VARCHAR (255)  NOT NULL,
+        VariableID INTEGER   NOT NULL,
+        UnitsID INTEGER   NOT NULL,
+        TaxonomicClassifierID INTEGER   NULL,
+        ProcessingLevelID INTEGER   NOT NULL,
+        ResultDateTime DATETIME   NULL,
+        ResultDateTimeUTCOffset INTEGER   NULL,
+        ValidDateTime DATETIME   NULL,
+        ValidDateTimeUTCOffset INTEGER   NULL,
+        StatusCV VARCHAR (255)  NULL,
+        SampledMediumCV VARCHAR (255)  NOT NULL,
+        ValueCount INTEGER   NOT NULL
+    """
+    def test_getAllResults(self):
+
+        # get all results from the database
+        res = self.engine.execute('SELECT * FROM Results').fetchall()
+        print res
+        # get all results using the api
+        resapi = self.reader.getResults()
+
+        assert len(res) == len(resapi)
+
+    def test_getResultsByID(self):
+
+        # get a result from the database
+        res = self.engine.execute('SELECT * FROM Results').fetchone()
+        resultid = res[1]
+
+
+        # get the result using the api
+        resapi = self.reader.getResults(ids=[resultid])
+
+        assert resapi is not None
+
 # ################################################################################
 # Simulations
 # ################################################################################