MuhamadFaisAizat
/
MIF_E31220954
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix:memperbaiki koneksi database

This commit is contained in:
muhamad fais aizat 2025-05-16 23:35:48 +07:00
parent 7807f426c7
commit 3ff9446d54
4 changed files with 106 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
backend/routes/auth.py
View File

@ -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))
conn.commit()
db.execute(users.update().where(users.c.email == data.email).values(password=hashed_password))
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)}")

120
backend/routes/riwayatPengujian.py
View File

@ -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):
query = select(riwayatPengujian).where(riwayatPengujian.c.id == id)
result = conn.execute(query).fetchone()
if result:
return dict(result._mapping)
raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
async def get_riwayat_by_id(id: int, db: Session = Depends(get_db)):
try:
query = select(riwayatPengujian).where(riwayatPengujian.c.id == id)
result = db.execute(query).fetchone()
if result:
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):
query = insert(riwayatPengujian).values(
id_kernel=data.id_kernel,
tanggal=data.tanggal,
infoHyperparameter=data.infoHyperparameter,
MAE=data.MAE,
RMSE=data.RMSE,
MAPE=data.MAPE
)
conn.execute(query)
conn.commit()
return {"message": "Riwayat Pengujian berhasil ditambahkan"}
async def create_riwayat(data: RiwayatPengujian, db: Session = Depends(get_db)):
try:
query = insert(riwayatPengujian).values(
id_kernel=data.id_kernel,
tanggal=data.tanggal,
infoHyperparameter=data.infoHyperparameter,
MAE=data.MAE,
RMSE=data.RMSE,
MAPE=data.MAPE
)
db.execute(query)
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):
query = update(riwayatPengujian).where(riwayatPengujian.c.id == id).values(
id_kernel=data.id_kernel,
tanggal=data.tanggal,
infoHyperparameter=data.infoHyperparameter,
MAE=data.MAE,
RMSE=data.RMSE,
MAPE=data.MAPE
)
result = conn.execute(query)
conn.commit()
if result.rowcount == 0:
raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
return {"message": "Riwayat Pengujian berhasil diperbarui"}
async def update_riwayat(id: int, data: RiwayatPengujian, db: Session = Depends(get_db)):
try:
query = update(riwayatPengujian).where(riwayatPengujian.c.id == id).values(
id_kernel=data.id_kernel,
tanggal=data.tanggal,
infoHyperparameter=data.infoHyperparameter,
MAE=data.MAE,
RMSE=data.RMSE,
MAPE=data.MAPE
)
result = db.execute(query)
db.commit()
if result.rowcount == 0:
raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
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):
query = delete(riwayatPengujian).where(riwayatPengujian.c.id == id)
result = conn.execute(query)
conn.commit()
if result.rowcount == 0:
raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
return {"message": "Riwayat Pengujian berhasil dihapus"}
async def delete_riwayat(id: int, db: Session = Depends(get_db)):
try:
query = delete(riwayatPengujian).where(riwayatPengujian.c.id == id)
result = db.execute(query)
db.commit()
if result.rowcount == 0:
raise HTTPException(status_code=404, detail="Riwayat Pengujian tidak ditemukan")
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)}")

25
backend/routes/settingPredict.py
View File

@ -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)
conn.commit()
db.execute(query)
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}

33
backend/routes/user.py
View File

@ -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))
conn.commit()
db.execute(users.insert().values(new_user))
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))
conn.commit()
db.execute(users.delete().where(users.c.id == id))
db.commit()
return {"message": "User deleted successfully"}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))