Merge pull request #75 from TebogoYungMercykay/development

Returning a Well Structured JSON Response

Author: TebogoYungMercykay

app/main.py

@@ -3,7 +3,7 @@
 
 from . import models
 from .database import engine
-from .routers import post, user, auth, vote, consultations, disease_prediction, chats
+from .routers import post, user, auth, consultations, disease_prediction, chats
 from .config import settings
 
 models.Base.metadata.create_all(bind=engine)
@@ -23,7 +23,6 @@
 app.include_router(post.router)
 app.include_router(user.router)
 app.include_router(auth.router)
-app.include_router(vote.router)
 app.include_router(consultations.router)
 app.include_router(disease_prediction.router)
 app.include_router(chats.router)

app/models.py

@@ -84,10 +84,10 @@ class Doctor(Base):
     address = Column(String(100), nullable=False)
     mobile_no = Column(String(15), nullable=True)
     gender = Column(String(10), nullable=False)
-    qualification = Column(String(20), nullable=False)
+    qualification = Column(String(50), nullable=False)
     registration_no = Column(String(20), nullable=False)
     year_of_registration = Column(DateTime, nullable=False)
-    state_medical_council = Column(String(30), nullable=False)
+    state_medical_council = Column(String(50), nullable=False)
     specialization = Column(String(30), nullable=False)
     rating = Column(Integer, server_default='0')
     is_patient = Column(Boolean, server_default='FALSE')

app/routers/auth.py

@@ -1,45 +1,69 @@
 from fastapi import APIRouter, Depends, status, HTTPException, Response
 from fastapi.security.oauth2 import OAuth2PasswordRequestForm
 from sqlalchemy.orm import Session
+from fastapi.responses import JSONResponse
 
 from .. import database, schemas, models, utils, oauth2
 
-router = APIRouter(tags=['Authentication'])
+router = APIRouter(
+    prefix="/auth",
+    tags=['Authentication']
+)
 
+MESSAGE_INVALID = "Invalid user Credentials."
 
-@router.post('/login', response_model=schemas.Token)
+@router.post('/login', response_model=schemas.JSONToken)
 def login(user_credentials: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(database.get_db)):
 
     user_query = db.query(models.User).filter(models.User.email == user_credentials.username)
     user = user_query.first()
 
     if not user:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN, detail=f"Invalid Credentials")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": MESSAGE_INVALID
+        }
+        return JSONResponse(content=error_response, status_code=403)
 
     if not utils.verify(user_credentials.password, user.password):
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN, detail=f"Invalid Credentials")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": MESSAGE_INVALID
+        }
+        return JSONResponse(content=error_response, status_code=403)
 
     access_token = oauth2.create_access_token(data={"user_id": user.id})
     user_query.update({ "is_active": True, "last_login": utils.get_current_time() })
     db.commit()
 
-    return { "access_token": access_token, "token_type": "bearer" }
+    response_obj = { "access_token": access_token, "token_type": "bearer" }
+    return schemas.JSONToken(status="success", id=user.id, data=response_obj)
 
 @router.post('/logout/{id}')
 def logout(id: int, db: Session = Depends(database.get_db), current_user: int = Depends(oauth2.get_current_user)):
     if current_user.id != id:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
-                            detail="You are not authorized to perform this action.")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": "You are not authorized to perform this action."
+        }
+        return JSONResponse(content=error_response, status_code=401)
 
     logout_query = db.query(models.User).filter(models.User.id == current_user.id)
     logout = logout_query.first()
     if not logout:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN, detail=f"Invalid Credentials")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": MESSAGE_INVALID
+        }
+        return JSONResponse(content=error_response, status_code=403)
+
     logout_query.update({ "is_active": False })
     db.commit()
 
-    return { "status":"success", "message": "User Successfully Logged Out." }
+    response_obj = { "status":"success", "id": current_user.id, "data": "User Successfully Logged Out." }
+    return response_obj
 

app/routers/chats.py

@@ -1,6 +1,7 @@
 from fastapi import FastAPI, Response, status, HTTPException, Depends, APIRouter
 from sqlalchemy.orm import Session
 from typing import List, Optional
+from fastapi.responses import JSONResponse
 
 from sqlalchemy import func
 from .. import models, schemas, oauth2
@@ -14,77 +15,103 @@
     tags=['Chats & Feedback']
 )
 
-@router.post('/chat_messages/{id}', response_model=schemas.ChatList)
+@router.post('/chat_messages/{id}', response_model=schemas.JSONChatList)
 def chat_messages(id: int, db: Session = Depends(get_db), current_user: int = Depends(oauth2.get_current_user)):
     chats = db.query(models.Chat).filter(models.Chat.consultation_id == id).all()
     if not chats:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                            detail=f"Chat with id {id} not found")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": f"Chat with id {id} not found"
+        }
+        return JSONResponse(content=error_response, status_code=404)
 
-    return schemas.ChatList(consultation_id=id, chats=chats)
+    response_obj = schemas.ChatList(consultation_id=id, chats=chats)
+    return schemas.JSONChatList(status="success", id=current_user.id, data=response_obj)
 
 
-@router.post('/create_chat/{id}', response_model=schemas.ChatOut)
+@router.post('/create_chat/{id}', response_model=schemas.JSONChatOut)
 def create_message(id: int, message: schemas.Chat, db: Session = Depends(get_db), current_user: int = Depends(oauth2.get_current_user)):
     consultation = db.query(models.Consultation).filter(models.Consultation.id == id).first()
     if not consultation:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                            detail=f"Consultation with id {id} not found")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": f"Consultation with id {id} not found"
+        }
+        return JSONResponse(content=error_response, status_code=404)
 
     new_message = models.Chat(sender_id=current_user.id, consultation_id=id, **message.dict())
     db.add(new_message)
     db.commit()
     db.refresh(new_message)
 
-    return new_message
+    return schemas.JSONChatOut(status="success", id=current_user.id, data=new_message)
 
 
-@router.post('/user_feedback/{id}', response_model=schemas.FeedbackResponse)
+@router.post('/user_feedback/{id}', response_model=schemas.JSONFeedbackResponse)
 def get_feedback(id: int, db: Session = Depends(get_db), current_user: int = Depends(oauth2.get_current_user)):
     doctor = db.query(models.Doctor).filter(models.Doctor.doctor_id == id).first()
     if not doctor:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                            detail=f"There is Currently no Feedback from Doctors for user, id: {id}")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": f"There is Currently no Feedback from Doctors for user, id: {id}"
+        }
+        return JSONResponse(content=error_response, status_code=404)
 
     reviews = db.query(models.Feedback).filter(models.Feedback.receiver_id == id).all()
     if not reviews:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                            detail=f"There is Currently no Feedback with id: {id}")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": f"There is Currently no Feedback with id: {id}"
+        }
+        return JSONResponse(content=error_response, status_code=404)
 
     list_feedback = []
     for single_feedback in reviews:
         feedback_sender = db.query(models.Patient).filter(models.Patient.patient_id == single_feedback.sender_id).first()
         if not feedback_sender:
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                                detail=f"Feedback Sender with id {single_feedback.sender_id} not found")
+            error_response = {
+                "status": "error",
+                "id": -1,
+                "data": f"Feedback Sender with id {single_feedback.sender_id} not found"
+            }
+            return JSONResponse(content=error_response, status_code=404)
 
         list_feedback.append(schemas.FeedbackOut(created_at=single_feedback.created_at, feedback=single_feedback.feedback, sender=feedback_sender))
-        
-    return schemas.FeedbackResponse(doctor_id=id, FeedBacks=list_feedback)
+    
+    response_obj = schemas.FeedbackResponse(doctor_id=id, FeedBacks=list_feedback)
+    return schemas.JSONFeedbackResponse(status="success", id=current_user.id, data=response_obj)
 
 
-@router.post('/post_feedback/{id}', response_model=schemas.FeedbackOutput)
+@router.post('/post_feedback/{id}', response_model=schemas.JSONFeedbackOutput)
 def post_feedback(id: int, message: schemas.FeedbackCreate, db: Session = Depends(get_db), current_user: int = Depends(oauth2.get_current_user)):
     doctor = db.query(models.Doctor).filter(models.Doctor.doctor_id == id).first()
     if not doctor:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
-                            detail=f"Doctor with id {id} not found")
+        error_response = {
+            "status": "error",
+            "id": -1,
+            "data": f"Doctor with id {id} not found"
+        }
+        return JSONResponse(content=error_response, status_code=404)
 
     new_feedback = models.Feedback(sender_id=current_user.id, receiver_id=id, **message.dict())
 
     db.add(new_feedback)
     db.commit()
     db.refresh(new_feedback)
 
-    return new_feedback
+    return schemas.JSONFeedbackOutput(status="success", id=current_user.id, data=new_feedback)
 
 
 @router.post('/whatsapp')
 def whatsapp():
-    return { "status":"pending", "message": MESSAGE_UNDER_CONSTRUCTION }
+    return { "status":"pending", "id": -1, "data": MESSAGE_UNDER_CONSTRUCTION }
 
 
 @router.post('/meeting')
 def meeting():
-    return { "status":"pending", "message": MESSAGE_UNDER_CONSTRUCTION }
+    return { "status":"pending", "id": -1, "data": MESSAGE_UNDER_CONSTRUCTION }