fix:memperbaiki koneksi database

backend/routes/auth.py

@@ -85,8 +85,8 @@ async def forgot_password(data: ForgotPasswordRequest, db: Session = Depends(get
     hashed_password = bcrypt.hashpw(data.new_password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
 
     # Update password di database
-    conn.execute(users.update().where(users.c.email == data.email).values(password=hashed_password))
+    db.execute(users.update().where(users.c.email == data.email).values(password=hashed_password))
-    conn.commit()
+    db.commit()
 
     return {"message": "Password berhasil diperbarui"}
 
@@ -107,7 +107,7 @@ async def check_email(email: str = Query(..., description="Email yang akan dicek
 
     except SQLAlchemyError as e:
         try:
-            conn.rollback()  # Jika sebelumnya ada transaksi yang belum selesai
+            db.rollback()  # Jika sebelumnya ada transaksi yang belum selesai
         except:
             pass
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")

backend/routes/riwayatPengujian.py

@@ -32,57 +32,83 @@ async def get_all_riwayat(db: Session = Depends(get_db)):
         raise HTTPException(status_code=500, detail=f"Terjadi kesalahan: {str(e)}")
 
 
-#  Get riwayat pengujian by ID
+# Get riwayat pengujian by ID
 @riwayat_router.get("/{id}", dependencies=[Depends(verify_token)])
-async def get_riwayat_by_id(id: int):
+async def get_riwayat_by_id(id: int, db: Session = Depends(get_db)):
-    query = select(riwayatPengujian).where(riwayatPengujian.c.id == id)
+    try:
-    result = conn.execute(query).fetchone()
+        query = select(riwayatPengujian).where(riwayatPengujian.c.id == id)
-    if result:
+        result = db.execute(query).fetchone()
-        return dict(result._mapping)
+        if result:
-    raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
+            return dict(result._mapping)
+        raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
+    except SQLAlchemyError as e:
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
-#  Create new riwayat pengujian
+# Create new riwayat pengujian
 @riwayat_router.post("/", dependencies=[Depends(verify_token)])
-async def create_riwayat(data: RiwayatPengujian):
+async def create_riwayat(data: RiwayatPengujian, db: Session = Depends(get_db)):
-    query = insert(riwayatPengujian).values(
+    try:
-        id_kernel=data.id_kernel,
+        query = insert(riwayatPengujian).values(
-        tanggal=data.tanggal,
+            id_kernel=data.id_kernel,
-        infoHyperparameter=data.infoHyperparameter,
+            tanggal=data.tanggal,
-        MAE=data.MAE,
+            infoHyperparameter=data.infoHyperparameter,
-        RMSE=data.RMSE,
+            MAE=data.MAE,
-        MAPE=data.MAPE
+            RMSE=data.RMSE,
-    )
+            MAPE=data.MAPE
-    conn.execute(query)
+        )
-    conn.commit()
+        db.execute(query)
-    return {"message": "Riwayat Pengujian berhasil ditambahkan"}
+        db.commit()
+        return {"message": "Riwayat Pengujian berhasil ditambahkan"}
+    except SQLAlchemyError as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
-#  Update riwayat pengujian by ID
+# Update riwayat pengujian by ID
 @riwayat_router.put("/{id}", dependencies=[Depends(verify_token)])
-async def update_riwayat(id: int, data: RiwayatPengujian):
+async def update_riwayat(id: int, data: RiwayatPengujian, db: Session = Depends(get_db)):
-    query = update(riwayatPengujian).where(riwayatPengujian.c.id == id).values(
+    try:
-        id_kernel=data.id_kernel,
+        query = update(riwayatPengujian).where(riwayatPengujian.c.id == id).values(
-        tanggal=data.tanggal,
+            id_kernel=data.id_kernel,
-        infoHyperparameter=data.infoHyperparameter,
+            tanggal=data.tanggal,
-        MAE=data.MAE,
+            infoHyperparameter=data.infoHyperparameter,
-        RMSE=data.RMSE,
+            MAE=data.MAE,
-        MAPE=data.MAPE
+            RMSE=data.RMSE,
-    )
+            MAPE=data.MAPE
-    result = conn.execute(query)
+        )
-    conn.commit()
+        result = db.execute(query)
-    
+        db.commit()
-    if result.rowcount == 0:
+        
-        raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
+        if result.rowcount == 0:
-    
+            raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
-    return {"message": "Riwayat Pengujian berhasil diperbarui"}
+        
+        return {"message": "Riwayat Pengujian berhasil diperbarui"}
+    except SQLAlchemyError as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
-#  Delete riwayat pengujian by ID
+# Delete riwayat pengujian by ID
 @riwayat_router.delete("/{id}", dependencies=[Depends(verify_token)])
-async def delete_riwayat(id: int):
+async def delete_riwayat(id: int, db: Session = Depends(get_db)):
-    query = delete(riwayatPengujian).where(riwayatPengujian.c.id == id)
+    try:
-    result = conn.execute(query)
+        query = delete(riwayatPengujian).where(riwayatPengujian.c.id == id)
-    conn.commit()
+        result = db.execute(query)
-    
+        db.commit()
-    if result.rowcount == 0:
+        
-        raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
+        if result.rowcount == 0:
-    
+            raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
-    return {"message": "Riwayat Pengujian berhasil dihapus"}
+        
+        return {"message": "Riwayat Pengujian berhasil dihapus"}
+    except SQLAlchemyError as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")

backend/routes/settingPredict.py

@@ -36,17 +36,17 @@ DEFAULT_VALUES = [
 ]
 
 @settingPredict_router.post("/seed",dependencies=[Depends(verify_token)])
-async def seed_database():
+async def seed_database(db: Session = Depends(get_db)):
     """Endpoint untuk menjalankan seeder secara manual via API."""
     query = select(settingPredict)
-    result = conn.execute(query).fetchall()
+    result = db.execute(query).fetchall()
 
     if result:
         raise HTTPException(status_code=400, detail="Seeder sudah dijalankan, data sudah ada.")
 
     query = insert(settingPredict).values(DEFAULT_VALUES)
-    conn.execute(query)
+    db.execute(query)
-    conn.commit()
+    db.commit()
     
     return {"message": " Seeder berhasil dijalankan: Data setting_predict sudah diisi."}
 
@@ -68,11 +68,11 @@ async def update_setting(
     nilai_epsilon: str = Query(None),
     nilai_degree: str = Query(None),
     nilai_coef: str = Query(None),
-    
+    db: Session = Depends(get_db)
 ):
     # Cek apakah setting dengan ID tersebut ada
     query = select(settingPredict.c.nama_kernel).where(settingPredict.c.id == setting_id)
-    result = conn.execute(query).fetchone()
+    result = db.execute(query).fetchone()
     
     if not result:
         raise HTTPException(status_code=404, detail="Setting not found")
@@ -98,32 +98,33 @@ async def update_setting(
 
     # Buat query update berdasarkan field yang diperbolehkan
     query = update(settingPredict).where(settingPredict.c.id == setting_id).values(**update_data)
-    result = conn.execute(query)
+    result = db.execute(query)
 
     if result.rowcount == 0:
         raise HTTPException(status_code=404, detail="Failed to update setting")
 
-    conn.commit()
+    db.commit()
     return {"message": "Setting updated successfully", "updated_fields": update_data}
 
 @settingPredict_router.put("/update-status/{setting_id}", dependencies=[Depends(verify_token)])
 async def update_status_setting(
     setting_id: int,
-    status: bool = Query(...)
+    status: bool = Query(...),
+    db: Session = Depends(get_db)
 ):
     # Cek apakah setting dengan ID tersebut ada
     query = select(settingPredict.c.id).where(settingPredict.c.id == setting_id)
-    result = conn.execute(query).fetchone()
+    result = db.execute(query).fetchone()
 
     if not result:
         raise HTTPException(status_code=404, detail="Setting not found")
 
     # Update hanya status
     query = update(settingPredict).where(settingPredict.c.id == setting_id).values(status=status)
-    result = conn.execute(query)
+    result = db.execute(query)
 
     if result.rowcount == 0:
         raise HTTPException(status_code=400, detail="Failed to update status")
 
-    conn.commit()
+    db.commit()
     return {"message": "Status updated successfully", "updated_status": status}

backend/routes/user.py

@@ -1,9 +1,10 @@
 import bcrypt
 from fastapi import APIRouter, HTTPException, Depends
-from config.db import conn
+from config.db import conn, get_db
 from models.index import users
 from schemas.index import User
 from middleware.index import verify_token
+from sqlalchemy.orm import Session
 
 # #  Seeder untuk Admin
 # def seed_admin():
@@ -40,18 +41,18 @@ user_router = APIRouter(
 
 #  READ ALL USERS
 @user_router.get("/",dependencies=[Depends(verify_token)])
-async def read_data():
+async def read_data(db: Session = Depends(get_db)):
     try:
-        result = conn.execute(users.select()).fetchall()
+        result = db.execute(users.select()).fetchall()
         return [dict(row._mapping) for row in result]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 #  READ USER BY ID
 @user_router.get("/{id}",dependencies=[Depends(verify_token)])
-async def read_data(id: int):
+async def read_data(id: int, db: Session = Depends(get_db)):
     try:
-        result = conn.execute(users.select().where(users.c.id == id)).fetchone()
+        result = db.execute(users.select().where(users.c.id == id)).fetchone()
         if result is None:
             raise HTTPException(status_code=404, detail="User not found")
         return dict(result._mapping)
@@ -60,42 +61,42 @@ async def read_data(id: int):
 
 #  CREATE USER
 @user_router.post("/",dependencies=[Depends(verify_token)])
-async def write_data(user: User):
+async def write_data(user: User, db: Session = Depends(get_db)):
     try:
         new_user = {"email": user.email, "password": user.password}
-        conn.execute(users.insert().values(new_user))
+        db.execute(users.insert().values(new_user))
-        conn.commit()
+        db.commit()
         return {"message": "User created successfully"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 #  UPDATE USER
 @user_router.put("/{id}",dependencies=[Depends(verify_token)])
-async def update_data(id: int, user: User):
+async def update_data(id: int, user: User, db: Session = Depends(get_db)):
     try:
-        result = conn.execute(users.select().where(users.c.id == id)).fetchone()
+        result = db.execute(users.select().where(users.c.id == id)).fetchone()
         if result is None:
             raise HTTPException(status_code=404, detail="User not found")
         
-        conn.execute(users.update().where(users.c.id == id).values(
+        db.execute(users.update().where(users.c.id == id).values(
             email=user.email,
             password=user.password
         ))
-        conn.commit()
+        db.commit()
         return {"message": "User updated successfully"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 #  DELETE USER
 @user_router.delete("/{id}",dependencies=[Depends(verify_token)])
-async def delete_data(id: int):
+async def delete_data(id: int, db: Session = Depends(get_db)):
     try:
-        result = conn.execute(users.select().where(users.c.id == id)).fetchone()
+        result = db.execute(users.select().where(users.c.id == id)).fetchone()
         if result is None:
             raise HTTPException(status_code=404, detail="User not found")
         
-        conn.execute(users.delete().where(users.c.id == id))
+        db.execute(users.delete().where(users.c.id == id))
-        conn.commit()
+        db.commit()
         return {"message": "User deleted successfully"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))