Upload 7 files

repository/ChatHistoryRepository.py

@@ -0,0 +1,236 @@
+from sqlalchemy.orm import sessionmaker
+import sys
+import os
+app_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, app_path)
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+chat_history = Database_Entity.ChatHistory
+users = Database_Entity.User
+detail_chat = Database_Entity.DetailChat
+from sqlalchemy.orm import sessionmaker
+import sys
+import os
+
+def getIdChatHistoryByUserIdAndNameChat(user_id:int,name_old :str) -> chat_history.id:
+  try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+  except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+
+def getIdChatHistoryByUserIdAndNameChatNew(user_id:int,name_old :str) -> chat_history.id:
+  try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+  except:
+      engine = cf.get_db_engine1()
+      Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+      with Session() as session:
+          email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+          chat_id = session.query(chat_history.id).filter(chat_history.email == email,
+                                                          chat_history.name_chat == name_old).scalar()
+          session.commit()
+          if chat_id:
+              session.close()
+              return chat_id
+          else:
+              session.close()
+              return None
+
+def updateNameChatHistory(user_id: int,name_old :str,name_new:str) -> bool:
+ try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    try:
+      email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+      session.query(chat_history).filter(chat_history.email == email,chat_history.name_chat == name_old).update({chat_history.name_chat: name_new})
+      session.commit()
+      session.close()
+      return True
+    except:
+       session.rollback()
+       session.close()
+       return False
+ except:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    try:
+      email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+      session.query(chat_history).filter(chat_history.email == email,chat_history.name_chat == name_old).update({chat_history.name_chat: name_new})
+      session.commit()
+      session.close()
+      return True
+    except:
+       session.rollback()
+       session.close()
+       return False
+
+def deleteChatHistory(user_id,chat_name: str) -> bool:
+ try:
+  try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    session.query(chat_history).filter(chat_history.email == email, chat_history.name_chat == chat_name).delete()
+    session.commit()
+    session.close()
+    return True
+  except Exception as e:
+        session.rollback()
+        session.close()
+        return False
+ except:
+   try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+     session.query(chat_history).filter(chat_history.email == email, chat_history.name_chat == chat_name).delete()
+     session.commit()
+     session.close()
+     return True
+   except Exception as e:
+        session.rollback()
+        session.close()
+        return False
+
+
+def getChatHistoryByEmail(email: str) -> chat_history:
+   try:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+   except:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+
+
+
+def getChatHistoryByChatIdAndUserId(chat_id: int, user_id: int) -> chat_history:
+    try:
+        engine = cf.get_db_engine()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+            chat_history1 = session.query(chat_history).filter(chat_history.id == chat_id,chat_history.email == email).one_or_none()
+            if chat_history1:
+                session.commit()
+                session.close()
+                return True
+            session.close()
+            return None
+    except:
+        engine = cf.get_db_engine1()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+            chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+            if chat_history1:
+                session.commit()
+                session.close()
+                return True
+            session.close()
+            return None
+
+
+def getChatHistoryById(id: int) -> chat_history:
+   try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+   except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+
+def addChatHistory(user_id: str, name_chat:str)->None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+        new_user = chat_history(
+           email = email,
+           name_chat = name_chat
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+        new_user = chat_history(
+           email = email,
+           name_chat = name_chat
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()

repository/ConfigDatabase.py

@@ -0,0 +1,42 @@
+from sqlalchemy import create_engine, URL
+from sqlalchemy.orm import DeclarativeBase
+Base = DeclarativeBase()
+from sqlalchemy.engine import create_engine, URL
+from dotenv import load_dotenv
+import os
+load_dotenv()
+MYSQL_USER_NAME=os.getenv('MYSQL_USER_NAME')
+MYSQL_PASSWORD=os.getenv('MYSQL_PASSWOR')
+MYSQL_PORT=os.getenv('MYSQL_PORT')
+MYSQL_DATABASE=os.getenv('MYSQL_DATABASE')
+MYSQL_HOST=os.getenv('MYSQL_HOST')
+#IF USE DOCKER HOST = host.docker.internal
+def get_db_engine():
+    dsn = URL.create(
+        drivername="mysql+pymysql",
+        username=MYSQL_USER_NAME,
+        password=MYSQL_PASSWORD,
+        host=MYSQL_HOST,
+        port=MYSQL_PORT,
+        database=MYSQL_DATABASE
+    )
+    connect_args = {}
+    return create_engine(
+        dsn,
+        connect_args=connect_args,
+    )
+
+def get_db_engine1():
+    dsn = URL.create(
+        drivername="mysql+pymysql",
+        username=MYSQL_USER_NAME,
+        password=MYSQL_PASSWORD,
+        host=MYSQL_HOST,
+        port=MYSQL_PORT,
+        database=MYSQL_DATABASE
+    )
+    connect_args = {}
+    return create_engine(
+        dsn,
+        connect_args=connect_args,
+    )

repository/DetailChatRepository.py

@@ -0,0 +1,141 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+detail_chat = Database_Entity.DetailChat
+chat_history = Database_Entity.ChatHistory
+
+def getListDetailChatByChatId(chat_id: int) -> detail_chat:
+  try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    chat_record= session.query(detail_chat).filter(detail_chat.chat_id == chat_id)
+    session.commit()
+    if chat_record:
+        session.close()
+        return chat_record
+    else:
+        session.close()
+        return None
+  except:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    chat_record= session.query(detail_chat).filter(detail_chat.chat_id == chat_id)
+    session.commit()
+    if chat_record:
+        session.close()
+        return chat_record
+    else:
+        session.close()
+        return None
+
+def addDetailChat(chat_id: int, YouMessage: str, AiMessage: str, data_relevant: str, source_file: str) -> None:
+  try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        new_user = detail_chat(
+          chat_id = chat_id,
+          YouMessage = YouMessage,
+          AiMessage = AiMessage,
+          data_relevant = data_relevant,
+          source_file  = source_file
+        )
+        session.add(new_user)
+        session.commit()
+        return new_user.id
+        session.close()
+  except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        new_user = detail_chat(
+            chat_id=chat_id,
+            YouMessage=YouMessage,
+            AiMessage=AiMessage,
+            data_relevant=data_relevant,
+            source_file=source_file
+        )
+        session.add(new_user)
+        session.commit()
+        return new_user.id
+        session.close()
+
+def getDetailChatByChatId(id: int) -> detail_chat:
+    try:
+        engine = cf.get_db_engine()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            try:
+                chat = session.query(detail_chat).filter(detail_chat.id == id).one_or_none()
+                return chat
+            except:
+                session.close()
+                return False
+    except:
+        engine = cf.get_db_engine1()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            try:
+                chat = session.query(detail_chat.id,detail_chat.data_relevant,detail_chat.source_file).filter(detail_chat.id == id).one_or_none()
+                session.commit()
+                session.close()
+                return chat
+            except:
+                session.close()
+                return False
+
+
+def delete_chat_detail(chat_name: str) -> bool:
+ try:
+  engine = cf.get_db_engine()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        detail_chat2 = session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name)
+        session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+ except:
+  engine = cf.get_db_engine1()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+def delete_chat_detail_by_id(id_chat_detail: int) -> bool:
+ try:
+  engine = cf.get_db_engine()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+
+        session.query(detail_chat).filter(detail_chat.id == id_chat_detail).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+ except:
+  engine = cf.get_db_engine1()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        session.query(detail_chat).filter(detail_chat.chat_id == id_chat_detail).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False

repository/OTPRepository.py

@@ -0,0 +1,79 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+otp_user = Database_Entity.OTP
+from sqlalchemy.orm import sessionmaker
+
+def getOtpByEmail(email: str) -> otp_user:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(otp_user).filter(otp_user.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(otp_user).filter(otp_user.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+    
+def addOTP(email: str, otp: str) -> None:
+    try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        otp_record = session.query(otp_user).filter_by(email=email).first()
+        if otp_record:
+            session.delete(otp_record)
+            session.commit()
+        new_user = otp_user(
+           email = email,
+           otp= otp 
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+    except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        otp_record = session.query(otp_user).filter_by(email=email).first()
+        if otp_record:
+            session.delete(otp_record)
+            session.commit()
+        new_user = otp_user(
+           email = email,
+           otp= otp 
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+       
+def deleteOTP(email: str, otp:str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       otp_record = session.query(otp_user).filter_by(email=email, otp=otp).first()
+       if otp_record:
+            session.delete(otp_record)
+            session.commit()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       otp_record = session.query(otp_user).filter_by(email=email, otp=otp).first()
+       if otp_record:
+            session.delete(otp_record)
+            session.commit()

repository/UserInfoRepository.py

@@ -0,0 +1,137 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+user_info = Database_Entity.UserInfo
+users = Database_Entity.User
+from sqlalchemy.orm import sessionmaker
+
+def getUserInfo(user_id: int) -> user_info:
+ try:
+   email = session.query(users.email).filter(users.id == user_id).one_or_none()
+   if email:
+        email = email[0]
+        user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_record:
+         session.close()
+         return user_record
+        else:
+         session.close()
+         return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()
+    if email:
+        email = email[0]
+        user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_record:
+         session.close()
+         return user_record
+        else:
+         session.close()
+         return None
+
+def getUserInfoByEmail(email:str) -> user_info:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+
+
+
+def addUserInfo(uid: str, email: str, display_name: str, photo_url: str) -> None:
+ try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_info(
+           uid = uid,
+           email = email,
+           display_name = display_name,
+           photo_url = photo_url
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_info(
+           uid = uid,
+           email = email,
+           display_name = display_name,
+           photo_url = photo_url
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+def updateUserInfo(user_id, uid: str, email: str, display_name: str, photo_url: str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.uid = uid,
+            user_update.display_name = display_name,
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.uid = uid,
+            user_update.display_name = display_name,
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+
+
+def updateImage(user_id, photo_url: str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       email = session.query(users.email).filter(users.id == user_id).one_or_none()
+       user_update = session.query(user_info).filter(user_info.email == email).one_or_none()
+       if user_update is not None:
+           user_update.photo_url = photo_url
+           session.commit()
+       session.close()
+

repository/UserLoginRepository.py

@@ -0,0 +1,135 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+user_login = Database_Entity.UserLogin
+users = Database_Entity.User
+
+def getUserLogin(email: str) -> user_login:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+
+
+def getUserLoginById(id: int) -> user_login:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+   
+def addUserLogin(user_email: str, session_id : str) -> None:
+ try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_login(
+           user_email = user_email,
+           user_session_id = session_id
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_login(
+           user_email = user_email,
+           user_session_id = session_id
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+
+def updateUserLogin(email: str, session_id : str ) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        user_update= session.query(user_login).filter(user_login.user_email == email).one_or_none()
+        if user_update is not None:
+            user_update.user_session_id = session_id
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        user_update= session.query(user_login).filter(user_login.user_email == email).one_or_none()
+        if user_update is not None:
+            user_update.user_session_id = session_id
+            session.commit()
+        session.close()
+
+
+
+def getUserSessionIdByUserEmail(id: int) -> user_login:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+     session.commit()
+     user_record= session.query(user_login.user_session_id).filter(user_login.user_email == email).one_or_none()[0]
+     session.commit()
+     print(user_record)
+     if user_record:
+        session.close()
+        return user_record
+     else:
+        session.close()
+        return None
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+     session.commit()
+     user_record= session.query(user_login.user_session_id).filter(user_login.user_email == email).one_or_none()[0]
+     session.commit()
+     print(user_record)
+     if user_record:
+        session.close()
+        return user_record
+     else:
+        session.close()
+        return None

repository/UserRepository.py

@@ -0,0 +1,357 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+import pytz , datetime
+from datetime import timedelta
+user = Database_Entity.User
+
+def getUserIdByAccessToken(token:str) -> int:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+
+def getUserIdByAccessTokenAndUserId(token:str,user_id: int) -> int:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token,user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token,user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+
+def getUserByEmail(email: str) -> user:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.email == email).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.email == email).one_or_none()
+        session.close()
+        return user_record
+
+def getUserIdByEmail(email: str) -> user.id:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.email == email).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.email == email).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getUserById(user_id: str) -> user:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+
+def getRefreshTokenUserByAccessToken(token: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+
+
+def getUserIdByRefreshToken(refreshToken: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.refresh_token == refreshToken).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.refresh_token == refreshToken).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getRefreshTokenUserById(user_id: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getEmailUser(email:str) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.email == email).one_or_none()
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.email == email).one_or_none()
+        session.close()
+        return user_email
+
+def getEmailUserById(user_id:int) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_email
+
+def getEmailUserByIdFix(user_id:int) -> user.email:
+  try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_email
+  except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_email
+
+
+
+def getEmailUserByAccessToken(token: str) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_email
+
+
+def addUser(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(bind=engine)
+    with Session() as session:
+        new_user = Database_Entity.User(
+            email=email,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(bind=engine)
+    with Session() as session:
+        new_user = Database_Entity.User(
+            email=email,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+
+def updateUserLogin(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> bool:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.email = email
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+            session.close()
+            return True
+        else:
+            session.close()
+            return False
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.email = email
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+            session.close()
+            return True
+        else:
+            session.close()
+            return False
+
+       
+def updateAccessToken(user_id: int,access_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+
+def updateAccessTokenById(id: int,access_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+
+
+def UpdateAccessTokenRefreshToken(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+
+def UpdateAccessTokenRefreshTokenById(user_id: int,access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()