Merge pull request #3 from crane-cloud/db-existing-endpoints

Db existing endpoints

Author: neelxie

app/core/database.py

@@ -1,18 +1,17 @@
 from sqlalchemy import create_engine
-import os
-from fastapi import Depends, HTTPException
-from sqlalchemy.orm import sessionmaker, Session
-from typing import List, Annotated
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
 from sqlalchemy_utils import create_database, database_exists
-from app.models import Base, Database
+from app.models import Base
+import os
 import settings
 
+
 DATABASE_URL = os.getenv('DATABASE_URI')
 
 if not database_exists(DATABASE_URL):
   create_database(DATABASE_URL)
 
+
 engine =  create_engine(DATABASE_URL, pool_pre_ping=True)
 
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

app/core/database_flavor.py

@@ -1,6 +1,7 @@
 import os
 from types import SimpleNamespace
 from app.core.database_service import MysqlDbService, PostgresqlDbService
+import settings
 
 db_flavors = {
     'postgres': {

app/models.py

@@ -25,11 +25,5 @@ class Database(Base):
     deleted = Column(Boolean, default=False)
     disabled = Column(Boolean, default=False)
     admin_disabled = Column(Boolean, default=False)
-    # TODO: make database_flavour_name nullable=false
-    # TODO: Implement the soft delete
-
-    # def password_is_valid(self, password):
-    #     """ checks the password against it's hash to validate the user's password """
-    #     return bcrypt.checkpw(password, self.password)
-    
-# Base.metadata.create_all(engine)
+    default_storage = Column(Integer, nullable=True)
+    allocated_size = Column(Integer, nullable=True)

app/routes/admin.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
-from app.schema import (DatabaseSchema)
+from app.schema import (DatabaseSchema, PasswordUpdate)
 from app.models import Database
 from app.core.config import get_db
 from typing import List
@@ -10,17 +10,17 @@
 router = APIRouter()
 
 @router.get("/admin/databases/")
-def get_all_databases(db: Session = Depends(get_db)):
+def admin_get_all_databases(db: Session = Depends(get_db)):
     databases = db.query(Database).all()
     return databases
 
 @router.get("/admin/mysql_databases/")
-def get_all_mysql_databases(db: Session = Depends(get_db)):
+def admin_get_all_mysql_databases(db: Session = Depends(get_db)):
     mysql_databases = db.query(Database).filter(Database.database_flavour_name == "mysql").all()
     return mysql_databases
 
 @router.get("/admin/postgresql_databases/")
-def get_all_postgresql_databases(db: Session = Depends(get_db)):
+def admin_get_all_postgresql_databases(db: Session = Depends(get_db)):
     postgresql_databases = db.query(Database).filter(Database.database_flavour_name == "postgres").all()
     return postgresql_databases
 
@@ -38,6 +38,40 @@ def get_single_databases(database_id:str, db: Session = Depends(get_db)):
     raise HTTPException(status_code=404, detail="Databases not found")
   return user_databases
 
+@router.get("/admin/databases/{database_id}/password")
+def admin_get_database_password(database_id:str, db: Session = Depends(get_db)):
+  db_exists = db.query(Database).filter(Database.id == database_id).first()
+  if not db_exists:
+    raise HTTPException(status_code=404, detail="Database not found")
+  return db_exists.password
+
+@router.post("/admin/databases/{database_id}/enable")
+def admin_enable_user_database(database_id:str, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if database is None:
+    raise HTTPException(status_code=404, detail="Databases not found")
+  
+  if (database.admin_disabled == False):
+    raise HTTPException(status_code=404, detail="Databases is already enabled.")
+  
+  database.admin_disabled = False
+  db.commit()
+  return {"message": "Database enabled successfully"}
+
+
+@router.post("/admin/databases/{database_id}/disable")
+def admin_disable_user_database(database_id:str, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if database is None:
+    raise HTTPException(status_code=404, detail="Databases not found")
+  
+  if database.admin_disabled:
+    raise HTTPException(status_code=404, detail="Databases is already disabled.")
+  
+  database.admin_disabled = True
+  db.commit()
+  return {"message": "Database disabled successfully"}
+
 @router.delete("/admin/databases/{database_id}")
 def delete_user_database(database_id:str, db: Session = Depends(get_db)):
   database = db.query(Database).filter(Database.id == database_id).first()
@@ -47,7 +81,7 @@ def delete_user_database(database_id:str, db: Session = Depends(get_db)):
   db.commit()
   return {"message": "Database deleted successfully"}
 
-@router.post("/admin/databases/reset/{database_id}")
+@router.post("/admin/databases/{database_id}/reset")
 def reset_user_database(database_id:str, db: Session = Depends(get_db)):
   database = db.query(Database).filter(Database.id == database_id).first()
   if database is None:
@@ -83,4 +117,47 @@ def reset_user_database(database_id:str, db: Session = Depends(get_db)):
         message=f"Unable to reset database"
     ), 500
 
-  return ({"status":'success', "message":"Database Reset Successfully"}), 200
+  return ({"status":'success', "message":"Database Reset Successfully"}), 200
+
+@router.post("/admin/databases/{database_id}/reset_password")
+def admin_password_reset_database(database_id:str, field_update:PasswordUpdate, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if not database:
+    raise HTTPException(status_code=404, detail="Databases not found")
+
+  db_flavour = get_db_flavour(database.database_flavour_name)
+
+  if not db_flavour:
+    return dict(
+        status="fail",
+        message=f"Database with flavour name {database.database_flavour_name} is not mysql or postgres."
+    ), 409
+
+  database_service = db_flavour['class']
+
+  database_connection = database_service.check_db_connection()
+
+  if not database_connection:
+
+    return dict(
+        status="fail",
+        message=f"Failed to connect to the database service"
+    ), 500
+
+  password_reset_database = database_service.reset_password(
+    
+    user=database.user,
+    password= field_update.password
+  )
+
+  if not password_reset_database:
+    return dict(
+        status="fail",
+        message=f"Unable to reset database password"
+    ), 500
+  
+  database.password = field_update.password
+
+  db.commit()
+
+  return ({"status":'success', "message":"Database Password Reset Successfully"}), 200

app/routes/userdb.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
-from app.schema import (DatabaseSchema, DatabaseFlavor)
+from app.schema import (DatabaseSchema, DatabaseFlavor, PasswordUpdate)
 import os
 import json
 from app.core.config import get_db
@@ -81,10 +81,10 @@ async def create_database(database: DatabaseFlavor, db: Session = Depends(get_db
       data=database
   ), 201
 
-@router.get("/admin/postgresql_databases/")
-def get_all_postgresql_databases(db: Session = Depends(get_db)):
-    postgresql_databases = db.query(Database).filter(Database.database_flavour_name == "postgres").all()
-    return postgresql_databases
+# @router.get("/admin/postgresql_databases/")
+# def get_all_postgresql_databases(db: Session = Depends(get_db)):
+#     postgresql_databases = db.query(Database).filter(Database.database_flavour_name == "postgres").all()
+#     return postgresql_databases
 
 @router.get("/user/databases")
 def get_user_databases(user_id:str, db: Session = Depends(get_db)):
@@ -114,16 +114,56 @@ def get_one_databases(database_id:str, db: Session = Depends(get_db)):
     raise HTTPException(status_code=404, detail="Databases not found")
   return user_databases
 
+@router.get("/user/databases/{database_id}/password")
+def get_database_password(database_id:str, db: Session = Depends(get_db)):
+  db_exists = db.query(Database).filter(Database.id == database_id).first()
+  if not db_exists:
+    raise HTTPException(status_code=404, detail="Database not found")
+  return db_exists.password
+
 @router.delete("/user/databases/{database_id}")
-def admin_delete_user_database(database_id:str, db: Session = Depends(get_db)):
+def delete_user_database(database_id:str, db: Session = Depends(get_db)):
   database = db.query(Database).filter(Database.id == database_id).first()
   if database is None:
     raise HTTPException(status_code=404, detail="Databases not found")
   database.deleted = True
   db.commit()
   return {"message": "Database deleted successfully"}
 
-@router.post("/user/databases/reset/{database_id}")
+@router.post("/user/databases/{database_id}/enable")
+def enable_user_database(database_id:str, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if database is None:
+    raise HTTPException(status_code=404, detail="Databases not found")
+  
+  if (database.disabled == False):
+    raise HTTPException(status_code=404, detail="Databases is already enabled.")
+  
+  if database.admin_disabled:
+    return {'You are not authorised to enable Database with id {database_id}, please contact an admin'}, 403
+  
+  database.disabled = False
+  db.commit()
+  return {"message": "Database enabled successfully"}
+
+
+@router.post("/user/databases/{database_id}/disable")
+def disable_user_database(database_id:str, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if database is None:
+    raise HTTPException(status_code=404, detail="Databases not found")
+  
+  if database.disabled:
+    raise HTTPException(status_code=404, detail="Databases is already disabled.")
+  
+  if database.admin_disabled:
+    return {'Database with id {database_id} is disabled, please contact an admin'}, 403
+  
+  database.disabled = True
+  db.commit()
+  return {"message": "Database disabled successfully"}
+
+@router.post("/user/databases/{database_id}/reset/")
 def reset_database(database_id:str, db: Session = Depends(get_db)):
   database = db.query(Database).filter(Database.id == database_id).first()
   if database is None:
@@ -162,6 +202,49 @@ def reset_database(database_id:str, db: Session = Depends(get_db)):
 
   return ({"status":'success', "message":"Database Reset Successfully"}), 200
 
+@router.post("/user/databases/{database_id}/reset_password")
+def password_reset_database(database_id:str, field_update:PasswordUpdate, db: Session = Depends(get_db)):
+  database = db.query(Database).filter(Database.id == database_id).first()
+  if not database:
+    raise HTTPException(status_code=404, detail="Databases not found")
+
+  db_flavour = get_db_flavour(database.database_flavour_name)
+
+  if not db_flavour:
+    return dict(
+        status="fail",
+        message=f"Database with flavour name {database.database_flavour_name} is not mysql or postgres."
+    ), 409
+
+  database_service = db_flavour['class']
+
+  database_connection = database_service.check_db_connection()
+
+  if not database_connection:
+
+    return dict(
+        status="fail",
+        message=f"Failed to connect to the database service"
+    ), 500
+
+  password_reset_database = database_service.reset_password(
+    
+    user=database.user,
+    password= field_update.password
+  )
+
+  if not password_reset_database:
+    return dict(
+        status="fail",
+        message=f"Unable to reset database password"
+    ), 500
+  
+  database.password = field_update.password
+
+  db.commit()
+
+  return ({"status":'success', "message":"Database Password Reset Successfully"}), 200
+
 @router.post("/user/databases")
 async def create_database(database: DatabaseFlavor, db: Session = Depends(get_db)):
 

app/schema.py

@@ -19,4 +19,8 @@ class DatabaseSchema(BaseModel):
 
 class DatabaseFlavor(BaseModel):
 
-    database_flavour_name: Optional[str]
+    database_flavour_name: Optional[str]
+
+class PasswordUpdate(BaseModel):
+    
+    password: str