Commit 7cdb26db authored by Pratik Shrivastava's avatar Pratik Shrivastava

feat: add address with CRUD operations

parent 5621cfc2
......@@ -4,3 +4,4 @@ from app.orm.role_type_orm import *
from app.orm.role_orm import *
from app.orm.user_role_map_orm import *
from app.orm.role_api_map_orm import *
from app.orm.address_orm import *
from datetime import datetime
from app import db
from app.utils.serializer import CustomSerializerMixin
class Address(db.Model, CustomSerializerMixin):
__tablename__ = 'address'
id = db.Column(
db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False
)
user_id = db.Column(db.BigInteger, db.ForeignKey('webomagic_user.id'), nullable=False)
name = db.Column(db.String(80), nullable=False)
phone_number = db.Column(db.String(20), nullable=False)
alternate_phone_number = db.Column(db.String(20), nullable=True)
address_line_1 = db.Column(db.String(100), nullable=False)
address_line_2 = db.Column(db.String(100), nullable=True)
landmark = db.Column(db.String(100), nullable=True)
city = db.Column(db.String(100), nullable=False)
state = db.Column(db.String(100), nullable=False)
pincode = db.Column(db.String(10), nullable=False)
is_default = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DATETIME, default=datetime.now, nullable=False)
updated_at = db.Column(db.DATETIME, onupdate=datetime.now)
created_by = db.Column(db.BigInteger, db.ForeignKey('webomagic_user.id'), nullable=False)
updated_by = db.Column(db.BigInteger, db.ForeignKey('webomagic_user.id'))
serialize_rules = ('-created_by', '-updated_by', '-created_at', '-updated_at')
import os
import traceback
from flask import request
from flask_restx import Resource
from marshmallow import ValidationError
from app.app_config.config import get_logger
from app.app_config.response_code import *
from app.app_config.response_message import *
from app.app_config.swagger_config import SECURITY
from app.decorators.sanitizer import sanitized
from app.decorators.user_fetcher import fetch_user
from app.routes import api
from app.utils.api_response import prepare_api_response
from app.routes.address.address_payload import *
from app.routes.address.address_response import *
from app.routes.address.address_dao_service import *
from app.routes.address.address_validator import *
logger = get_logger(__name__)
ns = api.namespace(
name=os.path.dirname(__file__).split(os.sep)[-1].replace('_', '-'),
description='API connected to address module',
ordered=False
)
@ns.route('/add', methods=['POST'])
class AddAddress(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*add_address_payload())
@ns.response(*add_address_response())
@sanitized()
@fetch_user()
def post(self, user_id: int):
try:
validator = AddAddressValidator()
payload: dict = validator.load(request.get_json())
payload['created_by'] = user_id
address_id: int = add_address(payload)
return prepare_api_response(SUCCESS_CODE, INSERT_SUCCESS_MESSAGE, data={'id': address_id})
except ValidationError as e:
return prepare_api_response(
VALIDATION_ERROR_CODE,
VALIDATION_ERROR_MESSAGE,
error=e.normalized_messages()
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/update', methods=['PATCH'])
class UpdateAddress(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*update_address_payload())
@ns.response(*update_address_response())
@sanitized()
@fetch_user()
def patch(self, user_id: int):
try:
validator = UpdateAddressValidator()
payload: dict = validator.load(request.get_json())
payload['updated_by'] = user_id
updated: bool = update_address(payload)
if not updated:
return prepare_api_response(
VALIDATION_ERROR_CODE, UPDATE_ERROR_MESSAGE)
return prepare_api_response(SUCCESS_CODE, UPDATE_SUCCESS_MESSAGE)
except ValidationError as e:
return prepare_api_response(
VALIDATION_ERROR_CODE,
VALIDATION_ERROR_MESSAGE,
error=e.normalized_messages()
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/get', methods=['GET'])
class GetAddress(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*get_address_payload())
@ns.response(*get_address_response())
@sanitized()
def get(self):
try:
validator = GetAddressValidator()
arguments: dict = validator.load(request.args)
address_info: ORM.Address | None = get_address_by_id(arguments['id'])
if address_info is None:
return prepare_api_response(404, 'Address not found')
return prepare_api_response(
SUCCESS_CODE,
GET_SUCCESS_MESSAGE,
data=address_info.to_dict()
)
except ValidationError as e:
return prepare_api_response(
VALIDATION_ERROR_CODE,
VALIDATION_ERROR_MESSAGE,
error=e.normalized_messages()
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/get-all', methods=['GET'])
class GetAllAddresses(Resource):
@ns.doc(security=SECURITY)
@ns.response(*get_address_list_response())
def get(self):
try:
addresses_list = get_address_list()
return prepare_api_response(
SUCCESS_CODE,
GET_ALL_SUCCESS_MESSAGE,
data=[address.to_dict() for address in addresses_list]
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/delete', methods=['DELETE'])
class DeleteAddress(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*delete_address_payload())
@ns.response(*delete_address_response())
@sanitized()
def delete(self):
try:
validator = DeleteAddressValidator()
payload: dict = validator.load(request.get_json())
deleted: bool = delete_address(payload['id'])
if not deleted:
return prepare_api_response(
VALIDATION_ERROR_CODE, DELETE_ERROR_MESSAGE)
return prepare_api_response(SUCCESS_CODE, DELETE_SUCCESS_MESSAGE)
except ValidationError as e:
return prepare_api_response(
VALIDATION_ERROR_CODE,
VALIDATION_ERROR_MESSAGE,
error=e.normalized_messages()
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
from typing import List
from app import orm as ORM
from app import db
def get_address_by_id(address_id: int) -> ORM.Address | None:
return ORM.Address.query.filter_by(id=address_id).first()
def get_addresses_by_user_id(user_id: int) -> List[ORM.Address]:
return ORM.Address.query.filter_by(user_id=user_id).all()
def get_addresses_by_user_id_and_name(user_id: int, name: str) -> List[ORM.Address]:
return ORM.Address.query.filter_by(user_id=user_id, name=name).first()
def add_address(payload: dict) -> int:
try:
existing_address: ORM.Address | None = \
get_addresses_by_user_id_and_name(payload.get('user_id'), payload.get('name'))
if existing_address:
raise Exception('address already exists')
address_model = ORM.Address(
user_id=payload['user_id'],
name=payload['name'],
phone_number=payload['phone_number'],
alternate_phone_number=payload.get('alternate_phone_number'),
address_line_1=payload['address_line_1'],
address_line_2=payload.get('address_line_2'),
landmark=payload.get('landmark'),
city=payload['city'],
state=payload['state'],
pincode=payload['pincode'],
is_default=payload.get('is_default', False),
created_by=payload['created_by']
)
db.session.add(address_model)
db.session.flush([address_model])
db.session.commit()
return address_model.id
except Exception as e:
db.session.rollback()
raise e
def update_address(payload: dict) -> bool:
try:
address: ORM.Address | None = get_address_by_id(payload.get('id'))
if not address:
raise Exception ('address does not exist')
address.name = payload.get('name', address.name)
address.phone_number = payload.get('phone_number', address.phone_number)
address.alternate_phone_number = payload.get('alternate_phone_number', address.alternate_phone_number)
address.address_line_1 = payload.get('address_line_1', address.address_line_1)
address.address_line_2 = payload.get('address_line_2', address.address_line_2)
address.landmark = payload.get('landmark', address.landmark)
address.city = payload.get('city', address.city)
address.state = payload.get('state', address.state)
address.pincode = payload.get('pincode', address.pincode)
address.is_default = payload.get('is_default', address.is_default)
address.updated_by = payload['updated_by']
db.session.commit()
return True
except Exception as e:
db.session.rollback()
raise e
def delete_address(address_id: int) -> bool:
address: ORM.Address | None = get_address_by_id(address_id)
if not address:
return False
db.session.delete(address)
db.session.commit()
return True
def get_address_list() -> List[ORM.Address]:
return ORM.Address.query.all()
from flask_restx import fields
from app.routes import api
def add_address_payload() -> list:
payload = api.model(
'AddAddress Payload',
{
'user_id': fields.Integer(required=True, description='User ID'),
'name': fields.String(required=True, description='Name'),
'phone_number': fields.String(required=True, description='Phone Number'),
'alternate_phone_number': fields.String(description='Alternate Phone Number'),
'address_line_1': fields.String(required=True, description='Address Line 1'),
'address_line_2': fields.String(description='Address Line 2'),
'landmark': fields.String(description='Landmark'),
'city': fields.String(required=True, description='City'),
'state': fields.String(required=True, description='State'),
'pincode': fields.String(required=True, description='Pincode'),
'is_default': fields.Boolean(description='Is Default Address')
}
)
return [payload]
def update_address_payload() -> list:
payload = api.model(
'UpdateAddress Payload',
{
'id': fields.Integer(required=True, description='Address ID'),
'name': fields.String(description='Name'),
'phone_number': fields.String(description='Phone Number'),
'alternate_phone_number': fields.String(description='Alternate Phone Number'),
'address_line_1': fields.String(description='Address Line 1'),
'address_line_2': fields.String(description='Address Line 2'),
'landmark': fields.String(description='Landmark'),
'city': fields.String(description='City'),
'state': fields.String(description='State'),
'pincode': fields.String(description='Pincode'),
'is_default': fields.Boolean(description='Is Default Address')
}
)
return [payload]
def get_address_payload() -> list:
parser = api.parser()
parser.add_argument('id', required=True, type=int, location='args')
return [parser]
def delete_address_payload() -> list:
payload = api.model(
'DeleteAddress Payload',
{
'id': fields.Integer(required=True, description='Address ID')
}
)
return [payload]
from app.app_config.response_code import SUCCESS_CODE
from app.app_config.response_message import *
from app.routes import api
from flask_restx import fields
from app.utils.api_response import prepare_swagger_response
ADDRESS_RESPONSE_MODEL: any = api.model(
'address',
{
'id': fields.Integer,
'user_id': fields.Integer,
'name': fields.String,
'phone_number': fields.String,
'alternate_phone_number': fields.String,
'address_line_1': fields.String,
'address_line_2': fields.String,
'landmark': fields.String,
'city': fields.String,
'state': fields.String,
'pincode': fields.String,
'is_default': fields.Boolean,
'created_at': fields.DateTime,
'created_by': fields.Integer,
'updated_at': fields.DateTime,
'updated_by': fields.Integer,
},
)
def add_address_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=INSERT_SUCCESS_MESSAGE,
model_name='Add Address Response',
data=fields.Nested(ADDRESS_RESPONSE_MODEL),
)
def update_address_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=UPDATE_SUCCESS_MESSAGE,
model_name='Update Address Response',
data=fields.Nested(ADDRESS_RESPONSE_MODEL),
)
def get_address_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=GET_SUCCESS_MESSAGE,
model_name='Get Address Response',
data=fields.Nested(ADDRESS_RESPONSE_MODEL),
)
def get_address_list_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=GET_ALL_SUCCESS_MESSAGE,
model_name='Get Address List Response',
data=fields.List(fields.Nested(ADDRESS_RESPONSE_MODEL)),
)
def delete_address_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=DELETE_SUCCESS_MESSAGE,
model_name='Delete Address Response',
)
from marshmallow import Schema, fields, validate
class AddAddressValidator(Schema):
user_id = fields.Integer(required=True, validate=validate.Range(min=1))
name = fields.String(required=True)
phone_number = fields.String(required=True)
alternate_phone_number = fields.String()
address_line_1 = fields.String(required=True)
address_line_2 = fields.String()
landmark = fields.String()
city = fields.String(required=True)
state = fields.String(required=True)
pincode = fields.String(required=True)
is_default = fields.Boolean()
class UpdateAddressValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
name = fields.String()
phone_number = fields.String()
alternate_phone_number = fields.String()
address_line_1 = fields.String()
address_line_2 = fields.String()
landmark = fields.String()
city = fields.String()
state = fields.String()
pincode = fields.String()
is_default = fields.Boolean()
class GetAddressValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
class DeleteAddressValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
......@@ -96,7 +96,7 @@ CREATE TABLE IF NOT EXISTS address (
alternate_phone_number VARCHAR(20),
address_line_1 VARCHAR(100) NOT NULL,
address_line_2 VARCHAR(100),
lankdmark VARCHAR(100),
landmark VARCHAR(100),
city VARCHAR(100) NOT NULL,
state VARCHAR(100) NOT NULL,
pincode VARCHAR(10) NOT NULL,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment