sakhteman/core/utils/response.py

from fastapi import HTTPException
from fastapi.encoders import jsonable_encoder
from pydantic import ValidationError
from starlette.responses import JSONResponse

from core.exceptions import SoftDeletedException, RecordNotFoundException, ModifiedCountException, ValidationException


class ResponseModel:
    def __init__(self, data, code=200, message="ok"):
        self.data = data
        self.code = code
        self.message = message

    def __str__(self):
        return str(self.data)

    def __iter__(self):
        return {
            "data": self.data,
            "code": self.code,
            "message": self.message,
        }


class ResponseBadRequest(ResponseModel):
    def __init__(self, data, message="Bad Request"):
        super().__init__(data, 400, message)


class ResponseValidationRequest(ResponseModel):
    def __init__(self, data, message="Bad Request"):
        super().__init__(data, 422, message)


class ResponseWriteErrorRequest(ResponseModel):
    def __init__(self, data, message="Request write error"):
        super().__init__(data, 400, message)


class ResponseNotFound(ResponseModel):
    def __init__(self, data, message="Not Found"):
        super().__init__(data, 404, message)


class ResponseUnauthorized(ResponseModel):
    def __init__(self, data, message="Unauthorized"):
        super().__init__(data, 401, message)


class ResponseInternalServerError(ResponseModel):
    def __init__(self, data, message="Internal Server Error"):
        super().__init__(data, 500, message)


class ResponseOk(ResponseModel):
    def __init__(self, data, code=200, message="ok"):
        super().__init__(data, code, message)


class ResponseOkUpdate(ResponseOk):
    def __init__(self, data, message="update was successful"):
        super().__init__(data, 200, message)


class ResponseOkCreate(ResponseOk):
    def __init__(self, data, message="create was successful"):
        super().__init__(data, 201, message)


class Res:

    @staticmethod
    def json(object, status_code):
        return JSONResponse(content=jsonable_encoder(object), status_code=status_code)

    @staticmethod
    def create(data, message="create was successful"):
        return Res.json(ResponseOkCreate(data, message), 201)

    @staticmethod
    def fetch(data, message="fetch was successful"):
        return Res.json(ResponseOk(data, 200, message), 200)

    @staticmethod
    def update(data, message="update was successful"):
        return Res.json(ResponseOkUpdate(data, message), 200)

    @staticmethod
    def not_found(data, message="Not Found"):
        return Res.json(ResponseNotFound(data, message), 404)

    @staticmethod
    def unauthorized(data, message="Unauthorized"):
        return Res.json(ResponseUnauthorized(data, message), 401)

    @staticmethod
    def server_error(data, message="Internal Server Error"):
        return Res.json(ResponseInternalServerError(data, message), 500)

    @staticmethod
    def bad_request(data, message="Bad Request"):
        return Res.json(ResponseBadRequest(data, message), 400)

    @staticmethod
    def validation_error(data, message="data validation error"):
        return Res.json(ResponseValidationRequest(data, message), 422)

    @staticmethod
    def write_error(data, message="Request write error"):
        return Res.json(ResponseWriteErrorRequest(data, message), 400)

    @staticmethod
    def delete_error(data, message="Request delete error"):
        return Res.json(ResponseWriteErrorRequest(data, message), 400)


def to_http_res(res, _type, message=None):
    if _type == "create":
        return Res.create(res, "create was successful")
    elif _type == "fetch":
        return Res.fetch(res, "fetch was successful")
    elif _type == "update":
        return Res.update(res, "update was successful")
    elif _type == "delete":
        return Res.update(res, "delete was successful")
    elif _type == "get":
        return Res.fetch(res, "get was successful")
    elif _type == "upload":
        return Res.fetch(res, "upload complete")
    elif _type == "token":
        return Res.fetch(res, "token was generated")
    else:
        return Res.fetch(res, "response ok")


def http_exception(res):
    _return = None
    # if isinstance(res, ResponseBadRequest):
    #     _return = HTTPException(status_code=res.code, detail=res.message)
    # elif isinstance(res, ResponseNotFound):
    #     _return = HTTPException(status_code=res.code, detail=res.message)
    # elif isinstance(res, ResponseUnauthorized):
    #     _return = HTTPException(status_code=res.code, detail=res.message)
    # elif isinstance(res, ResponseInternalServerError):
    #     _return = HTTPException(status_code=res.code, detail=res.message)
    if isinstance(res, SoftDeletedException):
        _return = Res.delete_error(res, res.message)
    elif isinstance(res, RecordNotFoundException):
        _return = Res.not_found(res, res.message)
    elif isinstance(res, ModifiedCountException):
        _return = Res.write_error(res, res.message)
    elif isinstance(res, ValidationError):
        _return = Res.validation_error(res.errors())
    elif isinstance(res, AssertionError):
        _return = Res.validation_error(res, message=res)
    elif isinstance(res, ValidationException):
        _return = Res.validation_error(res.message, message=res.message)
    elif isinstance(res, HTTPException):
        _return = Res.bad_request(res.status_code, message=res.detail)
    else:
        _return = Res.server_error(res, f'unknown error: {str(res)} {type(res)}')
    return _return