Commit 804d9331 authored by Deep Dey's avatar Deep Dey

Merge branch 'master' into 'master'

User OTP Login, OTP verify and Address CRUD

See merge request deepdey/webomagic-auth!1
parents 497217c1 7cdb26db
from flask import Flask
from flask_cors import CORS
from flask_bcrypt import Bcrypt
from flask_mail import Mail
from flask_sqlalchemy import SQLAlchemy
from app.app_config.config import DB_URI
from app.app_config.config import DB_URI, MAIL_DEFAULT_SENDER, MAIL_PASSWORD, MAIL_PORT, MAIL_SERVER, MAIL_USERNAME
db: SQLAlchemy = SQLAlchemy()
bcrypt: Bcrypt = Bcrypt()
mail: Mail = Mail()
def create_app():
# instantiating required classes
......@@ -13,12 +15,23 @@ def create_app():
cors: CORS = CORS(app, resources={r'/*': {'origins': '*'}})
# mail configuration
app.config['MAIL_SERVER'] = MAIL_SERVER
app.config['MAIL_PORT'] = MAIL_PORT
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USE_SSL'] = False
app.config['MAIL_USERNAME'] = MAIL_USERNAME
app.config['MAIL_PASSWORD'] = MAIL_PASSWORD
app.config['MAIL_DEFAULT_SENDER'] = (MAIL_DEFAULT_SENDER, MAIL_USERNAME)
# db configuration
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
bcrypt.init_app(app)
mail.init_app(app)
from app import routes
......
......@@ -25,6 +25,13 @@ REDIS_PORT = os.environ.get('REDIS_PORT', 6379)
REDIS_DATABASE = os.environ.get('REDIS_DATABASE', 0)
MAIL_SERVER: str = os.environ.get('MAIL_SERVER', 'smtp.gmail.com')
MAIL_PORT: int = os.environ.get('MAIL_PORT', 587)
MAIL_USERNAME = os.environ.get('MAIL_USERNAME', 'shadowtitan3003@gmail.com')
MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD', 'extv zmvb ibln hquj')
MAIL_DEFAULT_SENDER = os.environ.get('MAIL_DEFAULT_SENDER', 'WEBOMAGIC-TEST')
LOGGER_PATH: str = os.environ.get('LOGGER_PATH', f'{os.getcwd()}{os.sep}logs{os.sep}')
print(LOGGER_PATH)
......
......@@ -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))
import os
import string
import traceback
import secrets
from flask import request
......@@ -20,6 +21,8 @@ from app.routes.user.user_dao_service import *
from app.routes.user.user_util import process_valid_loging
from app.routes.user.user_validator import *
from app.utils.api_response import prepare_api_response
from app.utils.mail_service import send_otp
from app.utils.redis import set_value, get_value
logger = get_logger(__name__)
......@@ -78,6 +81,103 @@ class Login(Resource):
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/login-otp', methods=['POST'])
class LoginOTP(Resource):
def generate_otp(self) -> str:
return ''.join(secrets.choice(string.digits) for _ in range(6))
@ns.expect(*otp_payload())
@ns.response(*otp_response())
@sanitized()
def post(self):
try:
validator = OtpValidator()
payload: dict = validator.load(request.get_json())
email: str = payload.get('email')
user_info: ORM.User | None = get_user_by_email(email)
if (not user_info):
return prepare_api_response(401, 'Invalid Email')
otp: int = self.generate_otp()
send_otp('shadowtitan3003@gmail.com', [email], otp)
redis_key: str = str(user_info.id) + '_' + 'otp' + str(otp)
set_value(redis_key, 1, 60 * 5)
return prepare_api_response(
SUCCESS_CODE,
'OTP generated successfully'
)
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('/login-otp-verify', methods=['POST'])
class LoginOTPVerify(Resource):
def generate_api_key(self) -> str:
return ''.join(secrets.choice(ALPHANUMARIC_STRING) for _ in range(18))
@ns.expect(*otp_verify_payload())
@ns.response(*otp_verify_response())
@sanitized()
def post(self):
try:
validator = OtpVerifyValidator()
payload: dict = validator.load(request.get_json())
email: str = payload['email']
provided_otp: str = str(payload['OTP'])
user_info: ORM.User | None = get_user_by_email(email)
if (not user_info):
return prepare_api_response(401, 'Invalid Email')
redis_key: str = str(user_info.id) + '_' + 'otp' + str(provided_otp)
redis_otp: int | None = get_value(redis_key)
if redis_otp is None:
raise Exception ('OTP is invalid.')
api_key = self.generate_api_key()
process_valid_loging(user_info, api_key)
return prepare_api_response(
SUCCESS_CODE,
'OTP Verified Successfully',
data={'apiKey': api_key}
)
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('/profile', methods=['GET'])
class GetProfile(Resource):
......
......@@ -10,6 +10,24 @@ def login_payload() -> list:
return [payload]
def otp_payload() -> list:
payload = api.model(
'OTP Payload', {'email': fields.String}
)
return [payload]
def otp_verify_payload() -> list:
payload = api.model(
'OTP Verify Payload', {'email': fields.String, 'OTP': fields.String}
)
return [payload]
def get_user_payload() -> list:
parser = api.parser()
......
......@@ -36,7 +36,22 @@ def login_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=SUCCESS_MESSAGE,
model_name='login Response',
model_name='login OTP Response',
data=fields.Nested(LOGIN_RESPONSE_MODEL),
)
def otp_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message='OTP generated successfully',
model_name='Verify OTP Response',
data=fields.Nested(LOGIN_RESPONSE_MODEL),
)
def otp_verify_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message='OTP Verified Successfully',
model_name='login OTP Verify Response',
data=fields.Nested(LOGIN_RESPONSE_MODEL),
)
......
......@@ -5,6 +5,12 @@ class LoginValidator(Schema):
email = fields.String(required=True)
password = fields.String(required=True)
class OtpValidator(Schema):
email = fields.String(required=True)
class OtpVerifyValidator(Schema):
email = fields.String(required=True)
OTP = fields.Integer(required=True)
class GetUserValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
\ No newline at end of file
from flask import render_template_string
from flask_mail import Message
from app import mail
def send_otp(sender: str, receiver: list, otp: int) -> None:
email_title = 'OTP for Login'
msg = Message(email_title, sender=sender, recipients=receiver)
# Define the OTP template
email_html = '''
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>OTP Template</title>
<link
href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600&display=swap"
rel="stylesheet"
/>
</head>
<body
style="
margin: 0;
font-family: 'Poppins', sans-serif;
background: #ffffff;
font-size: 14px;
"
>
<div
style="
max-width: 680px;
margin: 0 auto;
padding: 45px 30px 60px;
background: #f4f7ff;
font-size: 14px;
color: #434343;
"
>
<main>
<div
style="
margin: 0;
margin-top: 70px;
padding: 92px 30px 115px;
background: #ffffff;
border-radius: 30px;
text-align: center;
"
>
<div style="width: 100%; max-width: 489px; margin: 0 auto;">
<h1
style="
margin: 0;
font-size: 24px;
font-weight: 500;
color: #1f1f1f;
"
>
OTP Verification
</h1>
<p
style="
margin: 0;
margin-top: 17px;
font-size: 16px;
font-weight: 500;
"
>
Hey {{ user }},
</p>
<p
style="
margin: 0;
margin-top: 17px;
font-weight: 500;
letter-spacing: 0.56px;
"
>
Use the following OTP to login. OTP is valid for
<span style="font-weight: 600; color: #1f1f1f;">5 minutes</span>.
Do not share this code with others.
</p>
<p
style="
margin: 0;
margin-top: 60px;
font-size: 40px;
font-weight: 600;
letter-spacing: 25px;
color: #ba3d4f;
"
>
{{ otp }}
</p>
</div>
</div>
</main>
</div>
</body>
</html>
'''
email_html_rendered = render_template_string(email_html, user=receiver[0], otp=otp)
msg.html = email_html_rendered
msg.subject = 'OTP Verification for Login'
try:
mail.send(msg)
return 'Email sent!'
except Exception as e:
print(e)
return None
......@@ -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,
......
......@@ -12,3 +12,4 @@ bleach
flask_bcrypt
redis
python-dotenv
flask-mail
\ No newline at end of file
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