From 2d18861299868ea54675afc43d25b9e5ccb4efca Mon Sep 17 00:00:00 2001
From: Yasien Mac Mini <yasienmeth@gmail.com>
Date: Wed, 23 Jul 2025 16:33:47 +0200
Subject: [PATCH] change folder name

---
 .../__pycache__/__init__.cpython-310.pyc      | Bin 126 -> 0 bytes
 .../__pycache__/dbConnection.cpython-310.pyc  | Bin 393 -> 0 bytes
 .../{database => mih_database}/__init__.py    |   0
 .../dbConnection.py                           |   0
 backend/mih_database/mihDbConnections.py      |  75 ++++
 backend/mih_database/mihDbObjects.py          |  73 ++++
 backend/routers/access_request.py             |  12 +-
 backend/routers/appointments.py               |  14 +-
 backend/routers/business.py                   |  18 +-
 backend/routers/business_user.py              |  18 +-
 backend/routers/claim_statement_files.py      |  12 +-
 backend/routers/docOffices.py                 |  12 +-
 backend/routers/mzansi_directory.py           | 403 ++++++++++--------
 backend/routers/mzansi_wallet.py              |  16 +-
 backend/routers/notifications.py              |  12 +-
 backend/routers/patient_access.py             |  16 +-
 backend/routers/patients.py                   |  22 +-
 backend/routers/patients_files.py             |  14 +-
 backend/routers/patients_notes.py             |  16 +-
 backend/routers/patients_queue.py             |  14 +-
 backend/routers/users.py                      |  22 +-
 21 files changed, 485 insertions(+), 284 deletions(-)
 delete mode 100644 backend/database/__pycache__/__init__.cpython-310.pyc
 delete mode 100644 backend/database/__pycache__/dbConnection.cpython-310.pyc
 rename backend/{database => mih_database}/__init__.py (100%)
 rename backend/{database => mih_database}/dbConnection.py (100%)
 create mode 100644 backend/mih_database/mihDbConnections.py
 create mode 100644 backend/mih_database/mihDbObjects.py

diff --git a/backend/database/__pycache__/__init__.cpython-310.pyc b/backend/database/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 515081a7feb4967a6859b9e11c61d7a168f085ec..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 126
zcmd1j<>g`k0>P92QbF`%5P=LBfgA@QE@lA|DGb33nv8xc8Hzx{2;!Hbequp^eo|s`
vc4}UVeoA6VVp3vps(yTYW?p7Ve7s&k<t+}I-29Z%oK!oI)?y|g!NLFlApjXw

diff --git a/backend/database/__pycache__/dbConnection.cpython-310.pyc b/backend/database/__pycache__/dbConnection.cpython-310.pyc
deleted file mode 100644
index 12bd1fa462abb2a6ce17be40b4bad7e20deffc6c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 393
zcmYjMu};G<5Oq>FO`xF*zrc{C5d%Xdgeqn4!qx>jISX16JJ_yJnOXS@7XAeB3AZx!
z7Z5_6(^7iYJ>R?Y^RsoD9x;m7k01F?`==*|5fYhF+EW5x5Y%iQKnT5OHV+}VW*Ohm
zgv~0ChY=AeC_ANN%V0_8y%IR|UpOhF84jAYeW;;CZnSn!$Hmk*t=0Kta)F~(xP?^i
zrV&cqN|SNqciKASD=Q5~t+4hHFb3g7DXh$T*zc~xq|!>s%4vgxUHQh$kRH>)*I6#w
zHZMhWFBRl}`W(t)t6OL_Zr7OX8$JIIuaAOox1w)zLJcw<b*AIJr%Ak#AO2fztCV^e
SUp5+6wY&<5SxykMVfYLCfMG)b

diff --git a/backend/database/__init__.py b/backend/mih_database/__init__.py
similarity index 100%
rename from backend/database/__init__.py
rename to backend/mih_database/__init__.py
diff --git a/backend/database/dbConnection.py b/backend/mih_database/dbConnection.py
similarity index 100%
rename from backend/database/dbConnection.py
rename to backend/mih_database/dbConnection.py
diff --git a/backend/mih_database/mihDbConnections.py b/backend/mih_database/mihDbConnections.py
new file mode 100644
index 00000000..12526d06
--- /dev/null
+++ b/backend/mih_database/mihDbConnections.py
@@ -0,0 +1,75 @@
+from sqlalchemy import create_engine
+import mysql.connector
+from urllib.parse import quote_plus
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+dbUser = os.getenv("DB_USER")
+dbPass = os.getenv("DB_PASSWD")
+dbHost = "mysqldb"
+dbPort = 3306
+encoded_dbPass = quote_plus(dbPass)
+base_connect_url = f"mysql+mysqlconnector://{dbUser}:{encoded_dbPass}@{dbHost}:{dbPort}/"
+
+def dbPatientManagerConnect():
+    return create_engine(base_connect_url+"patient_manager", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="patient_manager"
+    # )
+
+def dbAppDataConnect():
+    return create_engine(base_connect_url+"app_data", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="app_data"
+    # )
+
+def dbDataAccessConnect():
+    return create_engine(base_connect_url+"data_access", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="data_access"
+    # )
+
+def dbMzansiWalletConnect():
+    return create_engine(base_connect_url+"mzansi_wallet", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="mzansi_wallet"
+    # )
+
+def dbMzansiDirectoryConnect():
+    return create_engine(base_connect_url+"mzansi_directory", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="mzansi_directory"
+    # )
+
+def dbMzansiCalendarConnect():
+    return create_engine(base_connect_url+"mzansi_calendar", echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    #     database="mzansi_calendar"
+    # )
+
+def dbAllConnect():
+    return create_engine(base_connect_url, echo=True, pool_recycle=3600)
+    # return mysql.connector.connect(
+    #     host="mysqldb",
+    #     user=dbUser,
+    #     passwd=dbPass,
+    # )
\ No newline at end of file
diff --git a/backend/mih_database/mihDbObjects.py b/backend/mih_database/mihDbObjects.py
new file mode 100644
index 00000000..0ce1045f
--- /dev/null
+++ b/backend/mih_database/mihDbObjects.py
@@ -0,0 +1,73 @@
+from sqlalchemy import DateTime, Column, Integer, String
+from sqlalchemy.orm import declarative_base
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = 'users'
+    __table_args__ = {'schema': 'app_data'}
+    idusers = Column(Integer, primary_key=True) 
+    email = Column(String(128), nullable=False, unique=True)
+    fname = Column(String(128), nullable=False)
+    lname = Column(String(128), nullable=False)
+    type = Column(String(128), nullable=False)
+    app_id = Column(String(128), nullable=False)
+    username = Column(String(128), nullable=False)
+    pro_pic_path = Column(String(128), nullable=False)
+    purpose = Column(String(256), nullable=False, server_default="")
+
+    def __repr__(self):
+        return (
+            f"<User(idusers={self.idusers}, email='{self.email}', "
+            f"fname='{self.fname}', lname='{self.lname}', type='{self.type}', "
+            f"app_id='{self.app_id}', username='{self.username}', "
+            f"pro_pic_path='{self.pro_pic_path}', purpose='{self.purpose}')>"
+        )
+
+class Business(Base):
+    __tablename__ = 'business'
+    __table_args__ = {'schema': 'app_data'}
+    idbusiness = Column(Integer, primary_key=True)
+    business_id = Column(String(128), nullable=False, unique=True)
+    Name = Column(String(128))  
+    type = Column(String(128))
+    registration_no = Column(String(128))
+    logo_name = Column(String(128))
+    logo_path = Column(String(128))
+    contact_no = Column(String(45))
+    bus_email = Column(String(128))
+    gps_location = Column(String(128))
+    practice_no = Column(String(45))
+    vat_no = Column(String(45))
+    website = Column(String(128))
+    rating = Column(String(45), server_default="''") # Changed to match image default
+    mission_vision = Column(String(256))
+
+    def __repr__(self):
+        return (
+            f"<Business(idbusiness={self.idbusiness}, business_id='{self.business_id}', "
+            f"Name='{self.Name}', type='{self.type}', "
+            f"registration_no='{self.registration_no}', logo_name='{self.logo_name}', "
+            f"logo_path='{self.logo_path}', contact_no='{self.contact_no}', "
+            f"bus_email='{self.bus_email}', gps_location='{self.gps_location}', "
+            f"practice_no='{self.practice_no}', vat_no='{self.vat_no}', "
+            f"website='{self.website}', rating='{self.rating}', "
+            f"mission_vision='{self.mission_vision}')>"
+        )
+
+class BusinessRating(Base):
+    __tablename__ = 'business_ratings'
+    __table_args__ = {'schema': 'mzansi_directory'}
+    idbusiness_ratings = Column(Integer, primary_key=True)
+    app_id = Column(String(128), nullable=False, server_default="")
+    business_id = Column(String(128), nullable=False, server_default="")
+    rating_title = Column(String(128), nullable=False, server_default="")
+    rating_description = Column(String(256), nullable=False, server_default="")
+    rating_score = Column(String(45), nullable=False, server_default="")
+    date_time = Column(DateTime, nullable=True)
+
+    def __repr__(self):
+        return (
+            f"<BusinessRating(idbusiness_ratings={self.idbusiness_ratings}, app_id='{self.app_id}', "
+            f"business_id='{self.business_id}', rating_title='{self.rating_title}', rating_description='{self.rating_description}', "
+            f"rating_score='{self.rating_score}', date_time='{self.date_time}')>"
+        )
\ No newline at end of file
diff --git a/backend/routers/access_request.py b/backend/routers/access_request.py
index b40a7598..2424ee1e 100644
--- a/backend/routers/access_request.py
+++ b/backend/routers/access_request.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import date
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -32,7 +32,7 @@ class accessExtensionRequest(BaseModel):
 
 @router.get("/access-requests/{app_id}", tags=["Access Requests"])
 async def read_all_access_request_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT patient_queue.idpatient_queue, patient_queue.business_id, "
     query += "patient_queue.app_id, patient_queue.date_time, patient_queue.access, patient_queue.revoke_date, "
@@ -63,7 +63,7 @@ async def read_all_access_request_by_app_id(app_id: str, session: SessionContain
 
 @router.put("/access-requests/update/", tags=["Access Requests"])
 async def Update_access_request_approcal(itemRequest : accessUpdateRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "update patient_queue "
     query += "set access=%s"
@@ -86,7 +86,7 @@ async def Update_access_request_approcal(itemRequest : accessUpdateRequest): #,
 
 @router.put("/access-requests/extension/", tags=["Access Requests"])
 async def Update_access_request_approcal(itemRequest : accessExtensionRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "update patient_queue "
     query += "set access=%s, revoke_date=%s"
@@ -111,7 +111,7 @@ async def Update_access_request_approcal(itemRequest : accessExtensionRequest):
 # # Get List of all files
 # @router.get("/files/patients/", tags="patients_files")
 # async def read_all_files(session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patient_files"
 #     cursor.execute(query)
diff --git a/backend/routers/appointments.py b/backend/routers/appointments.py
index 6856fbbd..cfe4b97e 100644
--- a/backend/routers/appointments.py
+++ b/backend/routers/appointments.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import datetime, timedelta, date
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -32,7 +32,7 @@ class appointmentDeleteRequest(BaseModel):
 # Get List of all files by patient
 @router.get("/appointments/business/{business_id}", tags=["Appointments"])
 async def read_all_appointments_by_business_id(business_id: str, date: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiCalendarConnect()
+    db = mih_database.dbConnection.dbMzansiCalendarConnect()
     requestDate = datetime.strptime(date, '%Y-%m-%d').date()
     cursor = db.cursor()
     query = "SELECT appointments.idappointments, appointments.app_id, "
@@ -60,7 +60,7 @@ async def read_all_appointments_by_business_id(business_id: str, date: str, sess
 # Get List of all files by patient
 @router.get("/appointments/personal/{app_id}", tags=["Appointments"])
 async def read_all_appointments_by_business_id(app_id: str, date: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiCalendarConnect()
+    db = mih_database.dbConnection.dbMzansiCalendarConnect()
     requestDate = datetime.strptime(date, '%Y-%m-%d').date()
     cursor = db.cursor()
     query = "SELECT appointments.idappointments, appointments.app_id, "
@@ -90,7 +90,7 @@ async def read_all_appointments_by_business_id(app_id: str, date: str, session:
 @router.post("/appointment/insert/", tags=["Appointments"], status_code=201)
 async def insert_appointment(itemRequest : appointmentInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
     date_time = itemRequest.date + " " + itemRequest.time + ":00"
-    db = database.dbConnection.dbMzansiCalendarConnect()
+    db = mih_database.dbConnection.dbMzansiCalendarConnect()
     cursor = db.cursor()
     query = "insert into appointments "
     query += "(app_id, business_id, title, description, date_time) "
@@ -117,7 +117,7 @@ async def Update_appointment(itemRequest : appointmentUpdateRequest, session: Se
     
     date_time = itemRequest.date + " " + itemRequest.time + ":00"
 
-    db = database.dbConnection.dbMzansiCalendarConnect()
+    db = mih_database.dbConnection.dbMzansiCalendarConnect()
     cursor = db.cursor()
     query = "update appointments "
     query += "set date_time=%s, title=%s, description=%s "
@@ -140,7 +140,7 @@ async def Update_appointment(itemRequest : appointmentUpdateRequest, session: Se
 # Update Patient on table
 @router.delete("/appointment/delete/", tags=["Appointments"])
 async def Delete_appointment(itemRequest : appointmentDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiCalendarConnect()
+    db = mih_database.dbConnection.dbMzansiCalendarConnect()
     cursor = db.cursor()
     query = "delete from appointments "
     query += "where idappointments=%s"
diff --git a/backend/routers/business.py b/backend/routers/business.py
index 7ea28092..a3a91826 100644
--- a/backend/routers/business.py
+++ b/backend/routers/business.py
@@ -1,15 +1,13 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
 from fastapi import Depends
 import uuid
 
-import database.dbConnection
-
 router = APIRouter()
 
 # class userRequest(BaseModel):
@@ -64,7 +62,7 @@ class businessUpdateRequestV2(BaseModel):
 # Get List of all files
 @router.get("/businesses/search/{search}", tags=["MIH Business"])
 async def read_all_businesses(search: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT business.business_id, business.Name, business.type, business.registration_no, "
     query += "business.logo_name, business.logo_path, business.contact_no, business.bus_email, "
@@ -103,7 +101,7 @@ async def read_all_businesses(search: str, session: SessionContainer = Depends(v
 # Get List of all files
 @router.get("/business/business_id/{business_id}", tags=["MIH Business"])
 async def read_business_by_business_id(business_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT business.business_id, business.Name, business.type, business.registration_no, "
     query += "business.logo_name, business.logo_path, business.contact_no, business.bus_email, "
@@ -150,7 +148,7 @@ async def read_business_by_business_id(business_id: str, session: SessionContain
 # Get List of all files
 @router.get("/business/app_id/{app_id}", tags=["MIH Business"])
 async def read_business_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT business.business_id, business.Name, business.type, business.registration_no, "
     query += "business.logo_name, business.logo_path, business.contact_no, business.bus_email, "
@@ -195,7 +193,7 @@ async def read_business_by_app_id(app_id: str, session: SessionContainer = Depen
 # Insert Patient into table
 @router.post("/business/insert/", tags=["MIH Business"], status_code=201)
 async def insert_business_details(itemRequest : businessInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "insert into business "
     query += "(business_id, Name, type, registration_no, logo_name, logo_path, contact_no, bus_email, gps_location, practice_no, vat_no, website, rating, mission_vision) "
@@ -230,7 +228,7 @@ async def insert_business_details(itemRequest : businessInsertRequest, session:
 
 @router.put("/business/update/", tags=["MIH Business"])
 async def Update_Business_details(itemRequest : businessUpdateRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     # print(itemRequest.gps_location)
     cursor = db.cursor()
     query = "update business "
@@ -260,7 +258,7 @@ async def Update_Business_details(itemRequest : businessUpdateRequest, session:
 
 @router.put("/business/update/v2/", tags=["MIH Business"])
 async def Update_Business_details(itemRequest : businessUpdateRequestV2, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     # print(itemRequest.gps_location)
     cursor = db.cursor()
     query = "update business "
diff --git a/backend/routers/business_user.py b/backend/routers/business_user.py
index 9cf8f493..d5e6d751 100644
--- a/backend/routers/business_user.py
+++ b/backend/routers/business_user.py
@@ -1,14 +1,12 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
 from fastapi import Depends
 
-import database.dbConnection
-
 router = APIRouter()
 
 # class userRequest(BaseModel):
@@ -44,7 +42,7 @@ class employeeDeleteRequest(BaseModel):
 # Get List of all files
 @router.get("/business-user/{app_id}", tags=["MIH Business_User"])
 async def read_business_users_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT * FROM business_users where app_id = %s"
     try:
@@ -73,7 +71,7 @@ async def read_business_users_by_app_id(app_id: str, session: SessionContainer =
 # Get List of all files
 @router.get("/business-user/employees/{business_id}", tags=["MIH Business_User"])
 async def read_business_users_by_business_id(business_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = ""
     query += "SELECT business_users.business_id, business_users.app_id, business_users.title, business_users.access, "
@@ -108,7 +106,7 @@ async def read_business_users_by_business_id(business_id: str, session: SessionC
 # Insert Patient into table
 @router.post("/business-user/insert/", tags=["MIH Business_User"], status_code=201)
 async def insert_User_details(itemRequest : businessUserInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     checkQuery = "SELECT * FROM business_users where app_id = %s"
     try:
@@ -175,7 +173,7 @@ async def insert_User_details(itemRequest : businessUserInsertRequest, session:
 # Update User on table
 @router.put("/business-user/update/", tags=["MIH Business_User"])
 async def Update_User_details(itemRequest : BusinessUserUpdateRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "update business_users "
     query += "set signature=%s,sig_path=%s, title=%s, access=%s"
@@ -200,7 +198,7 @@ async def Update_User_details(itemRequest : BusinessUserUpdateRequest, session:
 # Update User on table
 @router.put("/business-user/employees/update/", tags=["MIH Business_User"])
 async def Update_User_details(itemRequest : EmployeeUpdateRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "update business_users "
     query += "set title=%s, access=%s"
@@ -225,7 +223,7 @@ async def Update_User_details(itemRequest : EmployeeUpdateRequest, session: Sess
 @router.delete("/business-user/employees/delete/", tags=["MIH Business_User"])
 async def Delete_Patient_note(itemRequest : employeeDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
     # today = date.today()
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "delete from business_users "
     query += "where business_id=%s "
diff --git a/backend/routers/claim_statement_files.py b/backend/routers/claim_statement_files.py
index 87104724..d7c187e4 100644
--- a/backend/routers/claim_statement_files.py
+++ b/backend/routers/claim_statement_files.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import date
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -24,7 +24,7 @@ class claimStatementInsertRequest(BaseModel):
 # Get List of all files by patient
 @router.get("/files/claim-statement/patient/{app_id}", tags=["Claim Statement Files"])
 async def read_all_claim_statement_files_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM claim_statement_file where app_id = %s ORDER BY insert_date DESC"
     cursor.execute(query, (app_id,))
@@ -46,7 +46,7 @@ async def read_all_claim_statement_files_by_app_id(app_id: str, session: Session
 # Get List of all files by patient
 @router.get("/files/claim-statement/business/{business_id}", tags=["Claim Statement Files"])
 async def read_all_claim_statement_files_by_business_id(business_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM claim_statement_file where business_id = %s ORDER BY insert_date DESC"
     cursor.execute(query, (business_id,))
@@ -69,7 +69,7 @@ async def read_all_claim_statement_files_by_business_id(business_id: str, sessio
 @router.delete("/files/claim-statement/delete/", tags=["Claim Statement Files"])
 async def Delete_Patient_File(itemRequest : claimStatementDeleteRequest, session: SessionContainer = Depends(verify_session())): #session: SessionContainer = Depends(verify_session())
     # today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "delete from claim_statement_file "
     query += "where idclaim_statement_file=%s"
@@ -88,7 +88,7 @@ async def Delete_Patient_File(itemRequest : claimStatementDeleteRequest, session
 @router.post("/files/claim-statement/insert/", tags=["Claim Statement Files"], status_code=201)
 async def insert_Patient_Files(itemRequest : claimStatementInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
     today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "insert into claim_statement_file "
     query += "(app_id, business_id, file_path, file_name, insert_date) "
diff --git a/backend/routers/docOffices.py b/backend/routers/docOffices.py
index 4c1f951b..acd484e8 100644
--- a/backend/routers/docOffices.py
+++ b/backend/routers/docOffices.py
@@ -1,20 +1,18 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
 from fastapi import Depends
 
-import database.dbConnection
-
 router = APIRouter()
 
 # Get Doctors Office By ID
 @router.get("/docOffices/{docOffic_id}", tags=["Doctor Office"])
 async def read_docOffice_By_ID(docOffic_id: int, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM doctor_offices WHERE iddoctor_offices=%s"
     cursor.execute(query, (docOffic_id,))
@@ -29,7 +27,7 @@ async def read_docOffice_By_ID(docOffic_id: int, session: SessionContainer = Dep
 # Get Doctors Office By user
 @router.get("/docOffices/user/{user}", tags=["Doctor Office"])
 async def read_docOffice_By_ID(user: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM users WHERE email=%s"
     cursor.execute(query, (user,))
@@ -50,7 +48,7 @@ async def read_docOffice_By_ID(user: str, session: SessionContainer = Depends(ve
 # Get List of all Doctors Office
 @router.get("/docOffices/", tags=["Doctor Office"])
 async def read_All_Doctors_Office(session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM doctor_offices"
     cursor.execute(query)
diff --git a/backend/routers/mzansi_directory.py b/backend/routers/mzansi_directory.py
index 1ad55797..23fa9e9a 100644
--- a/backend/routers/mzansi_directory.py
+++ b/backend/routers/mzansi_directory.py
@@ -1,11 +1,16 @@
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, status
+from sqlalchemy import desc 
+from sqlalchemy.orm import Session
 from pydantic import BaseModel
 from datetime import datetime
-import database
+import mih_database.mihDbConnections
+from mih_database.mihDbObjects import User, Business, BusinessRating
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
 from fastapi import Depends
 
+
+
 router = APIRouter()
 
 # class BusinessRatingUserGet(BaseModel):
@@ -37,200 +42,254 @@ class BusinessRatingUpdateRequest(BaseModel):
 
 @router.get("/mzansi-directory/business-ratings/user/{app_id}/{business_id}", tags=["Mzansi Directory"])
 async def read_all_ratings_by_business_id(app_id: str,business_id: str, session: SessionContainer = Depends(verify_session())): # , session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAllConnect()
-    cursor = db.cursor()
-    query = ""
-    query += "SELECT business_ratings.idbusiness_ratings, business_ratings.app_id, business_ratings.business_id, "
-    query += "business_ratings.rating_title, business_ratings.rating_description, business_ratings.rating_score, "
-    query += "business_ratings.date_time, users.username as 'reviewer' "
-    query += "FROM mzansi_directory.business_ratings "
-    query += "inner join app_data.users "
-    query += "on business_ratings.app_id = users.app_id "
-    query += "where business_ratings.business_id = %s and business_ratings.app_id = %s;"
-    cursor.execute(query, (business_id,
-                           app_id,))
-    item = cursor.fetchone() # Get only one row
-    cursor.close()
-    db.close()
+    dbEngine = mih_database.mihDbConnections.dbAllConnect() 
+    dbSession = Session(dbEngine)
+    try:
+        queryResults = dbSession.query(BusinessRating, User).\
+            join(User, BusinessRating.app_id == User.app_id).\
+            filter(
+                BusinessRating.business_id == business_id,
+                BusinessRating.app_id == app_id
+            ).first()
+        if queryResults:
+            rating_obj, user_obj = queryResults
+            # Return a single dictionary
+            return {
+                "idbusiness_ratings": rating_obj.idbusiness_ratings,
+                "app_id": rating_obj.app_id,
+                "business_id": rating_obj.business_id,
+                "rating_title": rating_obj.rating_title,
+                "rating_description": rating_obj.rating_description,
+                "rating_score": rating_obj.rating_score,
+                "date_time": rating_obj.date_time,
+                "reviewer": user_obj.username,
+            }
+        else:
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business rating not found for the given app_id and business_id."
+            )
+    except HTTPException as http_exc:
+        # Re-raise HTTPException directly if it was raised within the try block
+        raise http_exc
+    except Exception as e:
+        print(f"An error occurred during the ORM query: {e}")
+        if dbSession.is_active:
+            dbSession.rollback()
+        raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to retrieve records due to an internal server error."
+            )
+    finally:
+        dbSession.close()
     
-    if item:
-        # Return a single dictionary
-        return {
-            "idbusiness_ratings": item[0],
-            "app_id": item[1],
-            "business_id": item[2],
-            "rating_title": item[3],
-            "rating_description": item[4],
-            "rating_score": item[5],
-            "date_time": item[6],
-            "reviewer": item[7],
-        }
-    else:
-        # Return an empty response or a specific message
-        return None
-    # items = [
-    #     {
-    #         "idbusiness_ratings": item[0],
-    #         "app_id": item[1],
-    #         "business_id": item[2],
-    #         "rating_title": item[3],
-    #         "rating_description": item[4],
-    #         "rating_score": item[5],
-    #         "date_time": item[6],
-    #         "reviewer": item[7],
-    #     }
-    #     for item in cursor.fetchall()
-    # ]
-    # cursor.close()
-    # db.close()
-    # return items[0]
-
 @router.get("/mzansi-directory/business-ratings/all/{business_id}", tags=["Mzansi Directory"])
 async def read_all_ratings_by_business_id(business_id: str, session: SessionContainer = Depends(verify_session())): # , session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAllConnect()
-    cursor = db.cursor()
-    query = ""
-    query += "SELECT business_ratings.idbusiness_ratings, business_ratings.app_id, business_ratings.business_id, "
-    query += "business_ratings.rating_title, business_ratings.rating_description, business_ratings.rating_score, "
-    query += "business_ratings.date_time, users.username as 'reviewer' "
-    query += "FROM mzansi_directory.business_ratings "
-    query += "inner join app_data.users "
-    query += "on business_ratings.app_id = users.app_id "
-    query += "where business_ratings.business_id = %s "
-    query += "order by business_ratings.date_time desc;"
-    cursor.execute(query, (business_id,))
-    items = [
-        {
-            "idbusiness_ratings": item[0],
-            "app_id": item[1],
-            "business_id": item[2],
-            "rating_title": item[3],
-            "rating_description": item[4],
-            "rating_score": item[5],
-            "date_time": item[6],
-            "reviewer": item[7],
-        }
-        for item in cursor.fetchall()
-    ]
-    cursor.close()
-    db.close()
-    return items
+    dbEngine = mih_database.mihDbConnections.dbAllConnect()
+    dbSession = Session(dbEngine)
+    try:
+        queryResults = dbSession.query(BusinessRating, User).\
+            join(User, BusinessRating.app_id == User.app_id).\
+            filter(
+                BusinessRating.business_id == business_id,
+            ).order_by(
+                desc(BusinessRating.date_time)
+            ).all()
+        response_data = []
+        for rating_obj, user_obj in queryResults:
+           response_data.append({
+                "idbusiness_ratings": rating_obj.idbusiness_ratings,
+                "app_id": rating_obj.app_id,
+                "business_id": rating_obj.business_id,
+                "rating_title": rating_obj.rating_title,
+                "rating_description": rating_obj.rating_description,
+                "rating_score": rating_obj.rating_score,
+                "date_time": rating_obj.date_time,
+                "reviewer": user_obj.username,
+            })
+        if len(response_data) > 0:
+            return response_data
+        else:
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business rating not found for the given business_id."
+            )
+    except HTTPException as http_exc:
+        # Re-raise HTTPException directly if it was raised within the try block
+        raise http_exc
+    except Exception as e:
+        print(f"An error occurred during the ORM query: {e}")
+        if dbSession.is_active:
+            dbSession.rollback()
+        raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to retrieve records due to an internal server error."
+            )
+    finally:
+        dbSession.close()
 
 @router.post("/mzansi-directory/business-rating/insert/", tags=["Mzansi Directory"], status_code=201)
 async def insert_loyalty_card(itemRequest : BusinessRatingInsertRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAllConnect()
+    dbEngine = mih_database.mihDbConnections.dbAllConnect()
     nowDateTime = datetime.now()
     formatedDateTime = nowDateTime.strftime("%Y-%m-%d %H:%M:%S")
-    cursor = db.cursor()
+    dbSession = Session(dbEngine)
     try:
         # Get No Of reviews for business
-        businessReviewCountQuery = "select count(*) from mzansi_directory.business_ratings where business_ratings.business_id = %s"
-        countData = (itemRequest.business_id,)
-        cursor.execute(businessReviewCountQuery, countData) 
-        countResult = cursor.fetchone()
-        row_count = countResult[0] if countResult else 0
-        print(f"Number of rows in business_ratings: {row_count}")
+        businessReviewCountQueryResults = dbSession.query(BusinessRating).\
+            filter(
+                BusinessRating.business_id == itemRequest.business_id,
+            ).all()
+        businessReviewCount = len(businessReviewCountQueryResults)
+        print(f"Number of rows in business_ratings: {businessReviewCount}")
+        dbSession.flush()  # Ensure the session is flushed before adding new records
         # add business rating
-        addQuery = "insert into mzansi_directory.business_ratings "
-        addQuery += "(business_ratings.app_id, business_ratings.business_id, business_ratings.rating_title, business_ratings.rating_description, business_ratings.rating_score, business_ratings.date_time) "
-        addQuery += "values (%s, %s, %s, %s, %s, %s)"
-        addQueryData = (itemRequest.app_id, 
-                        itemRequest.business_id,
-                        itemRequest.rating_title,
-                        itemRequest.rating_description,
-                        itemRequest.rating_score,
-                        formatedDateTime,
-                        )
-        cursor.execute(addQuery, addQueryData) 
+        new_rating = BusinessRating(
+            app_id=itemRequest.app_id,
+            business_id=itemRequest.business_id,
+            rating_title=itemRequest.rating_title,
+            rating_description=itemRequest.rating_description,
+            rating_score=itemRequest.rating_score,
+            date_time=formatedDateTime
+        )
+        dbSession.add(new_rating)
+        dbSession.flush()  # Ensure the new rating is added to the session
         # Calc New Rating and update business rating 
-        newRating = ((float(itemRequest.current_rating) * row_count) + float(itemRequest.rating_score)) / (row_count + 1)
-        print(f"New Rating: {newRating}")
-        updateBusinessQuery = "update app_data.business "
-        updateBusinessQuery += "set rating = %s "
-        updateBusinessQuery += "where business_id = %s"
-        updateBusinessData = (newRating, itemRequest.business_id)
-        cursor.execute(updateBusinessQuery, updateBusinessData)
-        db.commit()
-    except Exception as error:
-        print(error)
-        raise HTTPException(status_code=404, detail="Failed to Create Record")
-        # return {"message": error}
-    cursor.close()
-    db.close()
-    return {"message": "Successfully Created Record"}
+        newRating = ((float(itemRequest.current_rating) * businessReviewCount) + float(itemRequest.rating_score)) / (businessReviewCount + 1)
+        businessToUpdate = dbSession.query(Business).filter(Business.business_id == itemRequest.business_id).first()
+        if businessToUpdate:
+            businessToUpdate.rating = str(newRating)
+            dbSession.commit()
+        else:
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business not found for the given business_id."
+            )
+    except HTTPException as http_exc:
+        # Re-raise HTTPException directly if it was raised within the try block
+        raise http_exc
+    except Exception as e:
+        print(f"An error occurred during the ORM query: {e}")
+        if dbSession.is_active:
+            dbSession.rollback()
+        raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to insert records due to an internal server error."
+            )
+    finally:
+        dbSession.close()
+        return {"message": "Successfully Created Record"}
 
 @router.delete("/mzansi-directory/business-rating/delete/", tags=["Mzansi Directory"])
 async def Delete_loyalty_card(itemRequest : BusinessRatingDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAllConnect()
-    cursor = db.cursor()
+    dbEngine = mih_database.mihDbConnections.dbAllConnect()
+    dbSession = Session(dbEngine)
     try:
         # Get No Of reviews for business
-        businessReviewCountQuery = "select count(*) from mzansi_directory.business_ratings where business_ratings.business_id = %s"
-        countData = (itemRequest.business_id,)
-        cursor.execute(businessReviewCountQuery, countData) 
-        countResult = cursor.fetchone()
-        row_count = countResult[0] if countResult else 0
-        print(f"Number of rows in business_ratings: {row_count}")
-        # Delete business rating
-        query = "delete from mzansi_directory.business_ratings "
-        query += "where business_ratings.idbusiness_ratings=%s"
-        cursor.execute(query, (str(itemRequest.idbusiness_ratings),)) 
+        businessReviewCountQueryResults = dbSession.query(BusinessRating).\
+            filter(
+                BusinessRating.business_id == itemRequest.business_id,
+            ).all()
+        businessReviewCount = len(businessReviewCountQueryResults)
+        print(f"Number of rows in business_ratings: {businessReviewCount}")
+        dbSession.flush()  # Ensure the session is flushed before adding new records
+        # delete business rating
+        rating_to_delete = dbSession.query(BusinessRating).\
+            get(
+                itemRequest.idbusiness_ratings
+            )
+        if not rating_to_delete:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Business rating with ID {itemRequest.idbusiness_ratings} not found."
+            )
+        dbSession.delete(rating_to_delete)
+        dbSession.flush()  # Ensure the new rating is added to the session
         # Calc New Rating and update business rating 
-        if(row_count <= 1):
-            newRating = 0.0
+        newRating = ((float(itemRequest.current_rating) * businessReviewCount) - float(itemRequest.rating_score)) / (businessReviewCount - 1)
+        businessToUpdate = dbSession.query(Business).filter(Business.business_id == itemRequest.business_id).first()
+        if businessToUpdate:
+            businessToUpdate.rating = str(newRating)
+            dbSession.commit()
         else:
-            newRating = ((float(itemRequest.current_rating) * row_count) - float(itemRequest.rating_score)) / (row_count - 1)
-        print(f"New Rating: {newRating}")
-        updateBusinessQuery = "update app_data.business "
-        updateBusinessQuery += "set rating = %s "
-        updateBusinessQuery += "where business_id = %s"
-        updateBusinessData = (newRating, itemRequest.business_id)
-        cursor.execute(updateBusinessQuery, updateBusinessData)
-        db.commit()
-    except Exception as error:
-        print(error)
-        raise HTTPException(status_code=404, detail="Failed to Delete Record")
-    cursor.close()
-    db.close()
-    return {"message": "Successfully deleted Record"}
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business not found for the given business_id."
+            )
+    except HTTPException as http_exc:
+        # Re-raise HTTPException directly if it was raised within the try block
+        raise http_exc
+    except Exception as e:
+        print(f"An error occurred during the ORM query: {e}")
+        if dbSession.is_active:
+            dbSession.rollback()
+        raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to insert records due to an internal server error."
+            )
+    finally:
+        dbSession.close()
+        return {"message": "Successfully Deleted Record"}
 
 @router.put("/mzansi-directory/business-rating/update/", tags=["Mzansi Directory"])
 async def UpdatePatient(itemRequest : BusinessRatingUpdateRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbMzansiDirectoryConnect()
-    cursor = db.cursor()
+    dbEngine = mih_database.mihDbConnections.dbAllConnect()
     nowDateTime = datetime.now()
     formatedDateTime = nowDateTime.strftime("%Y-%m-%d %H:%M:%S")
+    dbSession = Session(dbEngine)
     try:
         # Get No Of reviews for business
-        businessReviewCountQuery = "select count(*) from mzansi_directory.business_ratings where business_ratings.business_id = %s"
-        countData = (itemRequest.business_id,)
-        cursor.execute(businessReviewCountQuery, countData) 
-        countResult = cursor.fetchone()
-        row_count = countResult[0] if countResult else 0
-        print(f"Number of rows in business_ratings: {row_count}")
+        businessReviewCountQueryResults = dbSession.query(BusinessRating).\
+            filter(
+                BusinessRating.business_id == itemRequest.business_id,
+            ).all()
+        businessReviewCount = len(businessReviewCountQueryResults)
+        print(f"Number of rows in business_ratings: {businessReviewCount}")
+        dbSession.flush()  # Ensure the session is flushed before adding new records
         # Update business rating
-        query = "update business_ratings "
-        query += "set rating_title=%s, rating_description=%s, rating_score=%s, date_time=%s "
-        query += "where idbusiness_ratings=%s"
-        notetData = (itemRequest.rating_title, 
-                    itemRequest.rating_description,
-                    itemRequest.rating_new_score,
-                    formatedDateTime,
-                    itemRequest.idbusiness_ratings,
-                    )
-        cursor.execute(query, notetData) 
-        # Calc New Rating and update business rating
-        # add new rating and old rating params
-        newRating = ((float(itemRequest.current_rating) * row_count) - float(itemRequest.rating_old_score) + float(itemRequest.rating_new_score)) / (row_count)
-        print(f"New Rating: {newRating}")
-        updateBusinessQuery = "update app_data.business "
-        updateBusinessQuery += "set rating = %s "
-        updateBusinessQuery += "where business_id = %s"
-        updateBusinessData = (newRating, itemRequest.business_id)
-        cursor.execute(updateBusinessQuery, updateBusinessData)
-        db.commit()
-    except Exception as error:
-        raise HTTPException(status_code=404, detail="Failed to Update Record")
-    cursor.close()
-    db.close()
-    return {"message": "Successfully Updated Record"}
\ No newline at end of file
+        rating_to_update = dbSession.query(BusinessRating).\
+            get(
+                itemRequest.idbusiness_ratings
+            )
+        if rating_to_update:
+            rating_to_update.rating_title = itemRequest.rating_title
+            rating_to_update.rating_description = itemRequest.rating_description
+            rating_to_update.rating_score = itemRequest.rating_new_score
+            rating_to_update.date_time = formatedDateTime
+            dbSession.flush()  # Ensure the new rating is added to the session
+        else:
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business not found for the given business_id."
+            )
+        # Calc New Rating and update business rating 
+        newRating = ((float(itemRequest.current_rating) * businessReviewCount) - float(itemRequest.rating_old_score) + float(itemRequest.rating_new_score)) / (businessReviewCount)
+        businessToUpdate = dbSession.query(Business).filter(Business.business_id == itemRequest.business_id).first()
+        if businessToUpdate:
+            businessToUpdate.rating = str(newRating)
+            dbSession.commit()
+        else:
+            # Return an empty response or a specific message
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Business not found for the given business_id."
+            )
+    except HTTPException as http_exc:
+        # Re-raise HTTPException directly if it was raised within the try block
+        raise http_exc
+    except Exception as e:
+        print(f"An error occurred during the ORM query: {e}")
+        if dbSession.is_active:
+            dbSession.rollback()
+        raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to insert records due to an internal server error."
+            )
+    finally:
+        dbSession.close()
+        return {"message": "Successfully wUpdated Record"}
\ No newline at end of file
diff --git a/backend/routers/mzansi_wallet.py b/backend/routers/mzansi_wallet.py
index 37888447..88069b44 100644
--- a/backend/routers/mzansi_wallet.py
+++ b/backend/routers/mzansi_wallet.py
@@ -1,8 +1,8 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from datetime import date
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
@@ -38,7 +38,7 @@ class MzansiWalletUpdateRequest(BaseModel):
 # Get List of all loyalty cards by user
 @router.get("/mzasni-wallet/loyalty-cards/{app_id}", tags=["Mzansi Wallet"])
 async def read_all_loyalty_cards_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())): # , session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiWalletConnect()
+    db = mih_database.dbConnection.dbMzansiWalletConnect()
     cursor = db.cursor()
     query = "SELECT * FROM loyalty_cards where app_id = %s ORDER BY shop_name Asc"
     cursor.execute(query, (app_id,))
@@ -61,7 +61,7 @@ async def read_all_loyalty_cards_by_app_id(app_id: str, session: SessionContaine
 # Get List of favourite loyalty cards by user
 @router.get("/mzasni-wallet/loyalty-cards/favourites/{app_id}", tags=["Mzansi Wallet"])
 async def read_favourite_loyalty_cards_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())): # , session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiWalletConnect()
+    db = mih_database.dbConnection.dbMzansiWalletConnect()
     cursor = db.cursor()
     query = "SELECT * FROM loyalty_cards where app_id = %s and favourite != '' ORDER BY priority_index Asc"
     cursor.execute(query, (app_id,))
@@ -84,7 +84,7 @@ async def read_favourite_loyalty_cards_by_app_id(app_id: str, session: SessionCo
 # Get List of all notes by patient
 # @router.get("/notes/patients-docOffice/", tags="patients_notes")
 # async def read_all_patientsby(itemRequest: noteRequest, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "select patient_notes.idpatient_notes, patient_notes.note_name, patient_notes.note_text, patient_notes.patient_id, patient_notes.insert_date, patients.doc_office_id "
 #     query += "from patient_manager.patient_notes "
@@ -108,7 +108,7 @@ async def read_favourite_loyalty_cards_by_app_id(app_id: str, session: SessionCo
 # Insert loyalty cards into table
 @router.post("/mzasni-wallet/loyalty-cards/insert/", tags=["Mzansi Wallet"], status_code=201)
 async def insert_loyalty_card(itemRequest : MzansiWalletInsertRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbMzansiWalletConnect()
+    db = mih_database.dbConnection.dbMzansiWalletConnect()
     cursor = db.cursor()
     query = "insert into loyalty_cards "
     query += "(app_id, shop_name, card_number, favourite, priority_index, nickname) "
@@ -135,7 +135,7 @@ async def insert_loyalty_card(itemRequest : MzansiWalletInsertRequest): #, sessi
 @router.delete("/mzasni-wallet/loyalty-cards/delete/", tags=["Mzansi Wallet"])
 async def Delete_loyalty_card(itemRequest : LoyaltyCardDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
     # today = date.today()
-    db = database.dbConnection.dbMzansiWalletConnect()
+    db = mih_database.dbConnection.dbMzansiWalletConnect()
     cursor = db.cursor()
     query = "delete from loyalty_cards "
     query += "where idloyalty_cards=%s"
@@ -155,7 +155,7 @@ async def Delete_loyalty_card(itemRequest : LoyaltyCardDeleteRequest, session: S
 @router.put("/mzasni-wallet/loyalty-cards/update/", tags=["Mzansi Wallet"])
 async def UpdatePatient(itemRequest : MzansiWalletUpdateRequest, session: SessionContainer = Depends(verify_session())):
     today = date.today()
-    db = database.dbConnection.dbMzansiWalletConnect()
+    db = mih_database.dbConnection.dbMzansiWalletConnect()
     cursor = db.cursor()
     query = "update loyalty_cards "
     query += "set favourite=%s, priority_index=%s, nickname=%s, card_number=%s "
diff --git a/backend/routers/notifications.py b/backend/routers/notifications.py
index fbf7f732..2091d3f9 100644
--- a/backend/routers/notifications.py
+++ b/backend/routers/notifications.py
@@ -2,8 +2,8 @@ import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from datetime import datetime, timedelta
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
@@ -43,7 +43,7 @@ class notificationInsertRequest(BaseModel):
 # Get Notifications By app ID
 @router.get("/notifications/{app_id}", tags=["Notifications"])
 async def read_notifications_By_app_ID(app_id: str, amount: int, session: SessionContainer = Depends(verify_session())): # , session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     #query = "SELECT * FROM patients"
     query = "Select * from notifications " 
@@ -72,7 +72,7 @@ async def read_notifications_By_app_ID(app_id: str, amount: int, session: Sessio
 # Insert Patient into table
 @router.post("/notifications/insert/", tags=["Notifications"], status_code=201)
 async def insert_Patient(itemRequest : notificationInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     now = datetime.now() + timedelta(hours=2)
     notificationDateTime = now.strftime("%Y-%m-%d %H:%M:%S")
     print(notificationDateTime)
@@ -103,7 +103,7 @@ async def insert_Patient(itemRequest : notificationInsertRequest, session: Sessi
 # Update Patient on table
 @router.put("/notifications/update/{notification_id}", tags=["Notifications"])
 async def Update_Patient(notification_id : str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "update notifications "
     query += "set notification_read=%s "
@@ -124,7 +124,7 @@ async def Update_Patient(notification_id : str, session: SessionContainer = Depe
 # # delete Patient on table
 # @router.delete("/patients/delete/", tags=["Patients"])
 # async def Delete_Patient(itemRequest : patientDeleteRequest, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "delete from patients "
 #     query += "where app_id=%s"
diff --git a/backend/routers/patient_access.py b/backend/routers/patient_access.py
index cdfad554..263f7f19 100644
--- a/backend/routers/patient_access.py
+++ b/backend/routers/patient_access.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import date, datetime, timedelta
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -29,7 +29,7 @@ class accessRequestReapplyRequest(BaseModel):
 
 @router.get("/access-requests/{access_type}/check/{business_id}", tags=["Patient Access"])
 async def check_business_id_has_access(access_type: str,business_id: str, app_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "select "
     query += "patient_business_access.business_id, business.Name, "
@@ -73,7 +73,7 @@ async def check_business_id_has_access(access_type: str,business_id: str, app_id
 
 @router.get("/access-requests/business/{access_type}/{business_id}", tags=["Patient Access"])
 async def read_all_patient_access_by_business_id(access_type: str,business_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "select "
     query += "patient_business_access.business_id, business.Name, "
@@ -115,7 +115,7 @@ async def read_all_patient_access_by_business_id(access_type: str,business_id: s
 
 @router.get("/access-requests/personal/{access_type}/{app_id}", tags=["Patient Access"])
 async def read_all_patient_access_by_app_id(access_type: str,app_id: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "select "
     query += "patient_business_access.business_id, business.Name, "
@@ -158,7 +158,7 @@ async def read_all_patient_access_by_app_id(access_type: str,app_id: str, sessio
 # Insert Patient into table
 @router.post("/access-requests/insert/", tags=["Patient Access"], status_code=201)
 async def insert_Patient_access(itemRequest : accessRequestInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbDataAccessConnect()
+    db = mih_database.dbConnection.dbDataAccessConnect()
     now = datetime.now() + timedelta(hours=2)
     notificationDateTime = now.strftime("%Y-%m-%d %H:%M:%S")
     print(notificationDateTime)
@@ -190,7 +190,7 @@ async def insert_Patient_access(itemRequest : accessRequestInsertRequest, sessio
 # Update Patient on table
 @router.put("/access-requests/update/permission/", tags=["Patient Access"])
 async def Update_Patient_access(itemRequest: accessRequestUpdateRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbDataAccessConnect()
+    db = mih_database.dbConnection.dbDataAccessConnect()
     now = datetime.now() + timedelta(hours=2)
     notificationDateTime = now.strftime("%Y-%m-%d %H:%M:%S")
     print(notificationDateTime)
@@ -218,7 +218,7 @@ async def Update_Patient_access(itemRequest: accessRequestUpdateRequest): #, ses
 # Reapply Patient on table
 @router.put("/access-requests/re-apply/", tags=["Patient Access"])
 async def Reapply_Patient_access(itemRequest: accessRequestReapplyRequest): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbDataAccessConnect()
+    db = mih_database.dbConnection.dbDataAccessConnect()
     now = datetime.now() + timedelta(hours=2)
     notificationDateTime = now.strftime("%Y-%m-%d %H:%M:%S")
     print(notificationDateTime)
diff --git a/backend/routers/patients.py b/backend/routers/patients.py
index 1d446495..16991437 100644
--- a/backend/routers/patients.py
+++ b/backend/routers/patients.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
@@ -46,7 +46,7 @@ class patientDeleteRequest(BaseModel):
 # # Get Patient By ID Number
 # @router.get("/patients/search/{search}", tags=["Patients"])
 # async def read_patientByID(search: str): #, session: SessionContainer = Depends(verify_session())
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patients WHERE idpatients like %%%s%%" % search
 #     #return {"query": query}
@@ -72,7 +72,7 @@ class patientDeleteRequest(BaseModel):
 # Get Patient By app ID
 @router.get("/patients/{app_id}", tags=["Patients"])
 async def read_patient_By_app_ID(app_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM patients WHERE app_id=%s"
     cursor.execute(query, (app_id,))
@@ -99,7 +99,7 @@ async def read_patient_By_app_ID(app_id: str, session: SessionContainer = Depend
 # # Get Patient By ID Number
 # @router.get("/patients/email/{email}", tags="patients")
 # async def read_patientByID(email: str, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patients WHERE lower(email)=%s"
 #     cursor.execute(query, (email.lower(),))
@@ -126,7 +126,7 @@ async def read_patient_By_app_ID(app_id: str, session: SessionContainer = Depend
 # Get List of all patients
 @router.get("/patients/search/{search}", tags=["Patients"])
 async def read_all_patientsByUser(search: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     #query = "SELECT * FROM patients"
     query = "Select * from patients " 
@@ -160,7 +160,7 @@ async def read_all_patientsByUser(search: str, session: SessionContainer = Depen
 # # Get List of all patients
 # @router.get("/patients/", tags="patients")
 # async def read_all_patients(session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patients"
 #     cursor.execute(query)
@@ -187,7 +187,7 @@ async def read_all_patientsByUser(search: str, session: SessionContainer = Depen
 # # Get List of all patients by Doctors Office
 # @router.get("/patients/docOffice/{docoff_id}", tags="patients")
 # async def read_all_patientsby(docoff_id: str, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patients where doc_office_id=%s"
 #     cursor.execute(query, (docoff_id,))
@@ -214,7 +214,7 @@ async def read_all_patientsByUser(search: str, session: SessionContainer = Depen
 # Insert Patient into table
 @router.post("/patients/insert/", tags=["Patients"], status_code=201)
 async def insert_Patient(itemRequest : patientInsertRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "insert into patients "
     query += "(id_no, first_name, last_name, email, cell_no, medical_aid, "
@@ -247,7 +247,7 @@ async def insert_Patient(itemRequest : patientInsertRequest, session: SessionCon
 # Update Patient on table
 @router.put("/patients/update/", tags=["Patients"])
 async def Update_Patient(itemRequest : patientUpdateRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "update patients "
     query += "set id_no=%s, first_name=%s, last_name=%s, email=%s, cell_no=%s, medical_aid=%s, "
@@ -281,7 +281,7 @@ async def Update_Patient(itemRequest : patientUpdateRequest, session: SessionCon
 # delete Patient on table
 @router.delete("/patients/delete/", tags=["Patients"])
 async def Delete_Patient(itemRequest : patientDeleteRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "delete from patients "
     query += "where app_id=%s"
diff --git a/backend/routers/patients_files.py b/backend/routers/patients_files.py
index b0ab97cd..538020f6 100644
--- a/backend/routers/patients_files.py
+++ b/backend/routers/patients_files.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import date
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -22,7 +22,7 @@ class fileInsertRequest(BaseModel):
 # # Get List of all files
 # @router.get("/files/patients/", tags="patients_files")
 # async def read_all_files(session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patient_files"
 #     cursor.execute(query)
@@ -43,7 +43,7 @@ class fileInsertRequest(BaseModel):
 # Get List of all files by patient
 @router.get("/patient_files/get/{app_id}", tags=["Patients Files"])
 async def read_all_patient_files_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM patient_files where app_id = %s ORDER BY insert_date DESC"
     cursor.execute(query, (app_id,))
@@ -64,7 +64,7 @@ async def read_all_patient_files_by_app_id(app_id: str, session: SessionContaine
 # # Get List of all files by patient & DocOffice
 # @router.get("/files/patients-docOffice/", tags="patients_files")
 # async def read_all_files_by_patient(itemRequest: fileRequest, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "select patient_files.idpatient_files, patient_files.file_path, patient_files.file_name, patient_files.patient_id, patient_files.insert_date, patients.doc_office_id "
 #     query += "from patient_manager.patient_files "
@@ -92,7 +92,7 @@ async def read_all_patient_files_by_app_id(app_id: str, session: SessionContaine
 @router.delete("/patient_files/delete/", tags=["Patients Files"])
 async def Delete_Patient_File(itemRequest : fileDeleteRequest, session: SessionContainer = Depends(verify_session())): #session: SessionContainer = Depends(verify_session())
     # today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "delete from patient_files "
     query += "where idpatient_files=%s"
@@ -111,7 +111,7 @@ async def Delete_Patient_File(itemRequest : fileDeleteRequest, session: SessionC
 @router.post("/patient_files/insert/", tags=["Patients Files"], status_code=201)
 async def insert_Patient_Files(itemRequest : fileInsertRequest, session: SessionContainer = Depends(verify_session())):
     today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "insert into patient_files "
     query += "(file_path, file_name, insert_date, app_id) "
diff --git a/backend/routers/patients_notes.py b/backend/routers/patients_notes.py
index 94c27643..31b02b15 100644
--- a/backend/routers/patients_notes.py
+++ b/backend/routers/patients_notes.py
@@ -2,8 +2,8 @@ import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from datetime import date
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
@@ -32,7 +32,7 @@ class patientNoteUpdateRequest(BaseModel):
 # Get List of all notes
 # @router.get("/notes/patients/", tags="patients_notes")
 # async def read_all_notes(session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM patient_notes"
 #     cursor.execute(query)
@@ -52,7 +52,7 @@ class patientNoteUpdateRequest(BaseModel):
 # Get List of all notes by patient
 @router.get("/notes/patients/{app_id}", tags=["Patients Notes"])
 async def read_all_patient_notes_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "SELECT * FROM patient_notes where app_id = %s ORDER BY insert_date DESC"
     cursor.execute(query, (app_id,))
@@ -75,7 +75,7 @@ async def read_all_patient_notes_by_app_id(app_id: str, session: SessionContaine
 # Get List of all notes by patient
 # @router.get("/notes/patients-docOffice/", tags="patients_notes")
 # async def read_all_patientsby(itemRequest: noteRequest, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "select patient_notes.idpatient_notes, patient_notes.note_name, patient_notes.note_text, patient_notes.patient_id, patient_notes.insert_date, patients.doc_office_id "
 #     query += "from patient_manager.patient_notes "
@@ -100,7 +100,7 @@ async def read_all_patient_notes_by_app_id(app_id: str, session: SessionContaine
 @router.post("/notes/insert/", tags=["Patients Notes"], status_code=201)
 async def insert_Patient_Note(itemRequest : patientNoteInsertRequest, session: SessionContainer = Depends(verify_session())):
     today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "insert into patient_notes "
     query += "(note_name, note_text, insert_date, doc_office, doctor, app_id) "
@@ -126,7 +126,7 @@ async def insert_Patient_Note(itemRequest : patientNoteInsertRequest, session: S
 @router.delete("/notes/delete/", tags=["Patients Notes"])
 async def Delete_Patient_note(itemRequest : noteDeleteRequest, session: SessionContainer = Depends(verify_session()) ): #session: SessionContainer = Depends(verify_session())
     # today = date.today()
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "delete from patient_notes "
     query += "where idpatient_notes=%s"
@@ -145,7 +145,7 @@ async def Delete_Patient_note(itemRequest : noteDeleteRequest, session: SessionC
 # @router.put("/notes/update/", tags="patients_notes")
 # async def UpdatePatient(itemRequest : patientNoteUpdateRequest, session: SessionContainer = Depends(verify_session())):
 #     today = date.today()
-#     db = database.dbConnection.dbPatientManagerConnect()
+#     db = mih_database.dbConnection.dbPatientManagerConnect()
 #     cursor = db.cursor()
 #     query = "update patient_notes "
 #     query += "set note_name=%s, note_text=%s, patient_id=%s, insert_date=%s "
diff --git a/backend/routers/patients_queue.py b/backend/routers/patients_queue.py
index 86b1175b..3b24dd63 100644
--- a/backend/routers/patients_queue.py
+++ b/backend/routers/patients_queue.py
@@ -1,8 +1,8 @@
 import mysql.connector
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 from datetime import datetime, timedelta, date
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
@@ -31,7 +31,7 @@ class queueDeleteRequest(BaseModel):
 # Get List of all files by patient
 @router.get("/queue/appointments/business/{business_id}", tags=["Patients Queue"])
 async def read_all_patient_queue_by_business_id(business_id: str, date: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     requestDate = datetime.strptime(date, '%Y-%m-%d').date()
     #print("request date: " + str(requestDate))
     cursor = db.cursor()
@@ -73,7 +73,7 @@ async def read_all_patient_queue_by_business_id(business_id: str, date: str, ses
 # Get List of all files by patient
 @router.get("/queue/appointments/personal/{app_id}", tags=["Patients Queue"])
 async def read_all_patient_queue_by_business_id(app_id: str, date: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     requestDate = datetime.strptime(date, '%Y-%m-%d').date()
     cursor = db.cursor()
     query = "SELECT patient_queue.idpatient_queue, patient_queue.business_id, "
@@ -109,7 +109,7 @@ async def read_all_patient_queue_by_business_id(app_id: str, date: str, session:
 @router.post("/queue/appointment/insert/", tags=["Patients Queue"], status_code=201)
 async def insert_Patient_Files(itemRequest : queueInsertRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
     date_time = itemRequest.date + " " + itemRequest.time + ":00"
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "insert into patient_queue "
     query += "(business_id, app_id, date_time) "
@@ -134,7 +134,7 @@ async def Update_Queue(itemRequest : queueUpdateRequest, session: SessionContain
     
     date_time = itemRequest.date + " " + itemRequest.time + ":00"
 
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "update patient_queue "
     query += "set date_time=%s "
@@ -155,7 +155,7 @@ async def Update_Queue(itemRequest : queueUpdateRequest, session: SessionContain
 # Update Patient on table
 @router.delete("/queue/appointment/delete/", tags=["Patients Queue"])
 async def Delete_Queue(itemRequest : queueDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbPatientManagerConnect()
+    db = mih_database.dbConnection.dbPatientManagerConnect()
     cursor = db.cursor()
     query = "delete from patient_queue "
     query += "where idpatient_queue=%s"
diff --git a/backend/routers/users.py b/backend/routers/users.py
index 9d9a44c0..60f0d1f2 100644
--- a/backend/routers/users.py
+++ b/backend/routers/users.py
@@ -1,7 +1,7 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-#from ..database import dbConnection
-import database
+#from ..mih_database import dbConnection
+import mih_database
 #SuperToken Auth from front end
 from supertokens_python.recipe.session.framework.fastapi import verify_session
 from supertokens_python.recipe.session import SessionContainer
@@ -9,7 +9,7 @@ from supertokens_python.asyncio import delete_user
 
 from fastapi import Depends
 
-import database.dbConnection
+import mih_database.dbConnection
 import Minio_Storage.minioConnection
 
 router = APIRouter()
@@ -46,7 +46,7 @@ class userDeleteRequest(BaseModel):
 # #get user by email & doc Office ID
 # @router.get("/users/profile/{email}", tags="users")
 # async def read_all_users(email: str, session: SessionContainer = Depends(verify_session())):
-#     db = database.dbConnection.dbAppDataConnect()
+#     db = mih_database.dbConnection.dbAppDataConnect()
 #     cursor = db.cursor()
 #     query = "SELECT * FROM users where email = %s"
 #     cursor.execute(query, (email.lower(),)) 
@@ -70,7 +70,7 @@ class userDeleteRequest(BaseModel):
 # Get List of all files
 @router.get("/users/search/{search}", tags=["MIH Users"])
 async def read_all_users(search: str, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = ""
     query += "SELECT * FROM users "
@@ -101,7 +101,7 @@ async def read_all_users(search: str, session: SessionContainer = Depends(verify
 # Get List of all files
 @router.get("/users/validate/username/{username}", tags=["MIH Users"])
 async def read_all_users(username: str, session: SessionContainer = Depends(verify_session()) ): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT * FROM users WHERE LOWER(username) = %s"
     # search_term = f"%{username.lower()}%"  # Add wildcards and lowercase
@@ -114,7 +114,7 @@ async def read_all_users(username: str, session: SessionContainer = Depends(veri
 # Get List of all files
 @router.get("/user/{app_id}", tags=["MIH Users"])
 async def read_users_by_app_id(app_id: str, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "SELECT * FROM users where app_id = %s"
     cursor.execute(query, (app_id,))
@@ -139,7 +139,7 @@ async def read_users_by_app_id(app_id: str, session: SessionContainer = Depends(
 # Insert Patient into table
 @router.post("/user/insert/", tags=["MIH Users"], status_code=201)
 async def insert_User_details(itemRequest : userInsertRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "insert into users "
     query += "(email, fname, lname, type, app_id, username, pro_pic_path, purpose) "
@@ -159,7 +159,7 @@ async def insert_User_details(itemRequest : userInsertRequest, session: SessionC
 # Update User on table
 @router.put("/user/update/v2/", tags=["MIH Users"])
 async def Update_User_details(itemRequest : userUpdateRequestV2, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "update users "
     query += "set username=%s, fname=%s, lname=%s, type=%s, pro_pic_path=%s, purpose=%s "
@@ -185,7 +185,7 @@ async def Update_User_details(itemRequest : userUpdateRequestV2, session: Sessio
 # Update User on table
 @router.put("/user/update/", tags=["MIH Users"])
 async def Update_User_details(itemRequest : userUpdateRequest, session: SessionContainer = Depends(verify_session())):
-    db = database.dbConnection.dbAppDataConnect()
+    db = mih_database.dbConnection.dbAppDataConnect()
     cursor = db.cursor()
     query = "update users "
     query += "set username=%s, fname=%s, lname=%s, type=%s, pro_pic_path=%s "
@@ -210,7 +210,7 @@ async def Update_User_details(itemRequest : userUpdateRequest, session: SessionC
 # Get List of all files
 @router.delete("/user/delete/all/", tags=["MIH Users"])
 async def delete_users_data_by_app_id(itemRequest:  userDeleteRequest, session: SessionContainer = Depends(verify_session())): #, session: SessionContainer = Depends(verify_session())
-    db = database.dbConnection.dbAllConnect()
+    db = mih_database.dbConnection.dbAllConnect()
     cursor = db.cursor()
     db.start_transaction()
     try: