updating for odmtools

Author: stephanie

odm2api/ODM2/models.py

@@ -2048,6 +2048,9 @@ def _changeSchema(schema):
         import sqlalchemy.ext.declarative.api as api
 
         if isinstance(Tbl, api.DeclarativeMeta):
+            #check to see if the schema is already set correctly
+            if Tbl.__table__.schema ==schema:
+                return
             Tbl.__table__.schema = schema
             Tbl.__table_args__["schema"]=schema
 
@@ -2063,8 +2066,12 @@ def _getSchema(engine):
     return insp.default_schema_name
 
 def setSchema(engine):
+    # import datetime
+    # start = datetime.datetime.now()
     s = _getSchema(engine)
     if s is None:
         s = ''
     _changeSchema(s)
+    # end = datetime.datetime.now()
+    # print end-start, ": elapsed time to change schema"
 

odm2api/ODM2/services/createService.py

@@ -48,6 +48,8 @@ def createProcessingLevel(self, proclevel):
 
     #send in any type of sampling feature
     def createSamplingFeature(self, samplingfeature):
+        if samplingfeature.SamplingFeatureUUID is None:
+            samplingfeature.SamplingFeatureUUID = str(uuid.uuid1())
         self._session.add(samplingfeature)
         self._session.commit()
 
@@ -117,8 +119,8 @@ def createRelatedAction(self, relatedaction):
 
     #send in any type of result object
     def createResult(self, result):
-        if result.UUID is None:
-            result.UUID = str(uuid.uuid1())
+        if result.ResultUUID is None:
+            result.ResultUUID = str(uuid.uuid1())
         self._session.add(result)
         self._session.commit()
         return result

odm2api/ODM2/services/deleteService.py

@@ -93,11 +93,16 @@ def test(self):
 # Result Values
 # ################################################################################
 
-    def deleteTSRValues(self, ids=None, dates=None):
+    def deleteTSRValues(self, ids=None, startdate = None, dates=None):
 
         q = self._session.query(TimeSeriesResultValues)
         if ids:
             q = q.filter(TimeSeriesResultValues.ResultID.in_(ids))
+        if startdate:
+            #delete all values on or after the startdate
+            q = q.filter(TimeSeriesResultValues.ValueDateTime >= startdate)
         if dates:
             q = q.filter(TimeSeriesResultValues.ValueDateTime.in_(dates))
-        return q.delete(False)
+        numvals = q.count()
+        q.delete(False)
+        return numvals

odm2api/ODM2/services/updateService.py

@@ -35,24 +35,33 @@ def updateResultValidDateTime(self, resultId, dateTime):
             dt = dateTime.to_datetime()
         else:
             dt = dateTime
-            q = self._session.query(Results).filter(Results.ResultID==int(resultId)).update({'ValidDateTime':dt})
+            q = self._session.query(Results).filter(Results.ResultID == int(resultId)).update({'ValidDateTime':dt})
             self._session.commit()
 
-    def updateResult(self, resultID, valuecount = None):
-        q = self._session.query(Results).filter(Results.ResultID ==int(resultID))
-        if valuecount:
-            q.update({"ValueCount":valuecount})
-
+    def updateResult(self, resultID=None, valuecount=None, result=None):
+        if resultID:
+            q = self._session.query(Results).filter(Results.ResultID == int(resultID))
+            if valuecount:
+                q.update({"ValueCount": valuecount})
+        if result:
+            self._session.add(result)
         self._session.commit()
 
 
-    def updateAction(self, actionID, begin=None, end=None):
-        q = self._session.query(Actions).filter(Actions.ActionID == int(actionID))
-        if begin:
-            q.update({"BeginDateTime": begin})
-        if end:
-            q.update({"EndDateTime": end})
-
+    def updateAction(self, actionID=None, begin=None, end=None, action = None):
+        if actionID:
+            q = self._session.query(Actions).filter(Actions.ActionID == int(actionID))
+            # if (type(begin) != datetime):
+            #     begin = begin.to_datetime()
+            # if (type(end) != datetime):
+            #     end = end.to_datetime()
+
+            if begin:
+                q.update({"BeginDateTime": begin})
+            if end:
+                q.update({"EndDateTime": end})
+        elif action:
+            self._session.add(action)
         self._session.commit()
 
 

odm2api/ODMconnection.py

@@ -1,7 +1,7 @@
 
 from sqlalchemy.exc import SQLAlchemyError, DBAPIError
 from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import sessionmaker, scoped_session
 
 from odm2api.ODM2.models import Variables as Variable2, setSchema
 
@@ -15,29 +15,31 @@
 
 class SessionFactory():
     def __init__(self, connection_string, echo=True, version = 2.0):
+
         if 'sqlite' in connection_string:
             self.engine = create_engine(connection_string,  encoding='utf-8', echo=echo)
             self.test_engine = self.engine
-
         elif 'mssql' in connection_string:
-              import pyodbc
-              self.engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600)
-              self.test_engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600, connect_args={'timeout': 1})
+            self.engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600)
+            self.test_engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600,
+                                             connect_args={'timeout': 1})
         elif 'postgresql' in connection_string or 'mysql' in connection_string:
-            self.engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600, pool_timeout=5, pool_size=20, max_overflow=0)
-            self.test_engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600, pool_timeout=5, max_overflow=0, connect_args={'connect_timeout': 1})
+            self.engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600,
+                                        pool_timeout=1000, pool_size=20, max_overflow=0)
+            self.test_engine = create_engine(connection_string, encoding='utf-8', echo=echo, pool_recycle=3600,
+                                             pool_timeout=5, max_overflow=0, connect_args={'connect_timeout': 1})
 
         # Create session maker
-        self.Session = sessionmaker(bind=self.engine, autoflush=True)
-        self.test_Session = sessionmaker(bind=self.test_engine)
+        self.Session = scoped_session(sessionmaker(bind=self.engine, autoflush=True))
+        self.test_Session = scoped_session(sessionmaker(bind=self.test_engine))
         setSchema(self.engine)
         self.version=version
 
     def getSession(self):
         return self.Session()
 
     def __repr__(self):
-        return "<SessionFactory('%s')>" % (self.engine)
+        return "<SessionFactory('%s')>" % self.engine
 
 
 class dbconnection():
@@ -48,88 +50,84 @@ def __init__(self, debug=False):
         self._connection_format_nopassword = "%s+%s://%s@%s/%s"
 
     @classmethod
-    def createConnection(self, engine, address, db=None, user=None, password=None, dbtype = 2.0, echo=False):
+    def createConnection(self, engine, address, db=None, user=None, password=None, dbtype=2.0, echo=False):
 
         if engine == 'sqlite':
-            connection_string = engine +':///'+address
+            connection_string = engine + ':///' + address
             return self.createConnectionFromString(connection_string, dbtype, echo)
 
         else:
             connection_string = dbconnection.__buildConnectionString(dbconnection(), engine, address, db, user, password)
             if self.isValidConnection(connection_string, dbtype):
                 return self.createConnectionFromString(connection_string, dbtype, echo)
-            else :
+            else:
                 return None
-        # if self.testConnection(connection_string):
-
 
     @classmethod
-    def createConnectionFromString(self, conn_string, dbtype= 2.0, echo = False):
+    def createConnectionFromString(self, conn_string, dbtype=2.0, echo=False):
         s = SessionFactory(conn_string, echo=echo, version=dbtype)
         return s
 
     @classmethod
     def isValidConnection(self, connection_string=None,  dbtype=2.0):
-        #refreshDB(dbtype)
+        # refreshDB(dbtype)
         if dbtype == 2.0:
             if self.testEngine(connection_string):
-                # print "sucess"
-               return True
+                return True
             else:
                 return False
         else:
             if self.testEngine1_1(connection_string):
-                # print "sucess"
                 return True
             else:
                 return False
 
     @classmethod
-    def testEngine(self, connection_string, echo = False ):
-        s = SessionFactory(connection_string, echo=echo, version = 2.0)
+    def testEngine(self, connection_string, echo=False):
+        s = SessionFactory(connection_string, echo=echo, version=2.0)
         try:
             setSchema(s.test_engine)
             s.test_Session().query(Variable2.VariableCode).limit(1).first()
 
         except Exception as e:
             print("Connection was unsuccessful ", e.message)
             return False
+        finally:
+            dbconnection.closeConnection(s.test_Session)
         return True
 
     @classmethod
-    def testEngine1_1(self, connection_string, echo = False ):
-        s = SessionFactory(connection_string, echo=echo, version = 1.1)
+    def testEngine1_1(self, connection_string, echo=False):
+        s = SessionFactory(connection_string, echo=echo, version=1.1)
         try:
-            # s.ms_test_Session().query(Variable1).limit(1).first()
             s.test_Session().query(ODM.Variable.code).limit(1).first()
 
         except Exception as e:
             print("Connection was unsuccessful ", e.message)
             return False
+        finally:
+            dbconnection.closeConnection(s.test_Session)
         return True
 
+
     @classmethod
     def buildConnectionString(self, engine, address, db, user, password):
         return dbconnection.__buildConnectionString(dbconnection(), engine, address, db, user, password)
 
-
-
-
-    ## ###################
+    @classmethod
+    def closeConnection(self, session):
+        session.remove()
+    # ####################
     # private variables
-    ## ###################
-
+    # # ###################
 
     def __buildConnectionString(self, engine=None, address=None, db=None, user=None, password=None):
 
         if engine == 'mssql' and sys.platform != 'win32':
             driver = "pyodbc"
             quoted = urllib.quote_plus('DRIVER={FreeTDS};DSN=%s;UID=%s;PWD=%s;' % (address, user, password))
-            # quoted = urllib.quote_plus('DRIVER={FreeTDS};DSN=%s;UID=%s;PWD=%s;DATABASE=%s' %
-            #                            (conn_dict['address'], conn_dict['user'], conn_dict['password'],conn_dict['db'],
-            #                             ))
             conn_string = 'mssql+pyodbc:///?odbc_connect={}'.format(quoted)
-        elif engine=='sqlite':
+        elif engine == 'sqlite':
             driver = 'sqlite'
             conn_string = "%s:///%s" % (driver, address)
         else:
@@ -151,7 +149,7 @@ def __buildConnectionString(self, engine=None, address=None, db=None, user=None,
 
         return conn_string
 
-    def constringBuilder(self, engine=None, address=None, db=None, user=None, password=None, driver= None):
+    def constringBuilder(self, engine=None, address=None, db=None, user=None, password=None, driver=None):
         if password is None or not password:
             conn_string = self._connection_format_nopassword % (
                 engine, driver, user, address, db)