Commit 9ff3a6b1 authored by deepdey's avatar deepdey

inititalize application

parent 733c6c69
.idea/
.venv*/
venv*/
.vscode*/
__pycache__/
dist/
.coverage*
htmlcov/
.tox/
docs/_build/
*.log
docker-compose.yml
*.tar.gz
\ No newline at end of file
from flask import Flask
from flask_cors import CORS
from flask_jwt_extended import JWTManager
from flask_bcrypt import Bcrypt
from flask_sqlalchemy import SQLAlchemy
from app.app_config.config import DB_URI, JWT_SECRET_KEY
# instantiating required classes
app: Flask = Flask(__name__)
cors: CORS = CORS(app, resources={r'/*': {'origins': '*'}})
# db configuration
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['JWT_SECRET_KEY'] = JWT_SECRET_KEY
app.config['JWT_TOKEN_LOCATION'] = ['headers']
app.config['JWT_HEADER_TYPE'] = 'Bearer'
db: SQLAlchemy = SQLAlchemy(app)
jwt = JWTManager(app)
# IMPORTANT: BCRYPT IS USED FOR HASHING THE PASSWORD ONLY AS IT IS CPU INTENSIVE
bcrypt = Bcrypt(app)
from app import routes
# registering routes for each sub-folder in routes
app.register_blueprint(routes.blueprint)
app.config['RESTX_MASK_SWAGGER'] = False
import urllib.parse
import logging
import os
from datetime import date
SERVER_HOST: str = os.environ.get('SERVER_HOST', '127.0.0.1')
SERVER_PORT: str = os.environ.get('SERVER_PORT', '5000')
POSTGRES: dict = {
'user': os.environ.get('POSTGRES_USER', 'postgres'),
'db': os.environ.get('POSTGRES_DB', 'user_db'),
'host': os.environ.get('POSTGRES_HOST', '127.0.0.1'),
'password': urllib.parse.quote(os.environ.get('POSTGRES_PASSWORD', '2580')),
'port': os.environ.get('POSTGRES_PORT', '5432')
}
DB_URI: str = 'postgresql://%(user)s:%(password)s@%(host)s:%(port)s/%(db)s' % POSTGRES
POSTGRES_DATE_FORMAT: str = '%Y-%m-%d'
POSTGRES_DT_FORMAT: str = '%Y-%m-%dT%H:%M:%S'
REDIS_HOST = os.environ.get('REDIS_HOST', '127.0.0.1')
REDIS_PORT = os.environ.get('REDIS_PORT', 6379)
REDIS_DATABASE = os.environ.get('REDIS_DATABASE', 0)
JWT_SECRET_KEY: str = os.environ.get(
'JWT_SECRET_KEY', 'f3bca1544d308741c9240f3b6ced1067513ce1351c9fd3971fdafbfe68fffc82'
)
LOGGER_PATH: str = os.environ.get(
'LOGGER_PATH', f'{os.getcwd()}{os.sep}logs{os.sep}')
# Sensetive fields to hide in audit log
SENSITIVE_FIELDS: list = os.environ.get(
'SENSITIVE_FIELDS',
['password', 'confirm_password']
)
def get_logger(__name__: str) -> logging.Logger:
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s:%(levelname)s:%(name)s:%(message)s')
file_handler = logging.FileHandler(f'{LOGGER_PATH}log-{date.today()}.log')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
print(f'LOGGER_PATH: {os.getcwd()}{os.sep}logs{os.sep}')
SUCCESS_CODE: int = 200
VALIDATION_ERROR_CODE: int = 403
EXCEPTION_CODE: int = 500
UN_AUTHORIZED_CODE: int = 401
\ No newline at end of file
SUCCESS_MESSAGE: str = 'Operation perofrmed successfully.'
ERROR_MESSAGE: str = 'Failed to perform operation.'
INSERT_SUCCESS_MESSAGE: str = 'Data inserted successfully.'
INSERT_ERROR_MESSAGE: str = 'Failed to insert data.'
UPDATE_SUCCESS_MESSAGE: str = 'Data updated successfully.'
UPDATE_ERROR_MESSAGE: str = 'Failed to update data.'
DELETE_SUCCESS_MESSAGE: str = 'Data deleted successfully.'
DELETE_ERROR_MESSAGE: str = 'Failed to delete data.'
GET_SUCCESS_MESSAGE: str = 'Data fetched successfully.'
GET_ERROR_MESSAGE: str = 'Failed to fetch data.'
GET_ALL_SUCCESS_MESSAGE: str = 'Data fetched successfully.'
GET_ALL_ERROR_MESSAGE: str = 'Failed to fetch data.'
UNAUTHORISED_MESSAGE: str = 'Unauthorised access.'
VALIDATION_ERROR_MESSAGE: str = 'Validation error.'
EXCEPTION_MESSAGE: str = 'Something went wrong.'
\ No newline at end of file
SWAG_AUTH: dict = {
'Authorization': {
'type': 'apiKey',
'in': 'header',
'name': 'apiKey'
}
}
SWAG_VERSION: str = '4.0'
SWAG_TITLE: str = 'WEBOMAGIC USER API'
SWAG_DESCRIPTION: str = 'Powered by Websofttechs'
SWAG_DOC_URL: str = '/swagger-ui/'
SWAG_BASE_URL: str = '/webomagic-user/v1'
SECURITY: list = ['apiKey']
from functools import wraps
from flask import request
from app.utils.sanitizer import sanitize
def sanitized():
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
arguments = request.args.to_dict()
request.args = sanitize(arguments)
try:
payload = request.get_json()
request.json = sanitize(payload)
except Exception as e:
payload = request.form.to_dict()
request.form = sanitize(payload)
return func(*args, **kwargs)
return wrapper
return decorator
\ No newline at end of file
from app.orm.user_orm import *
from app.orm.role_orm import *
from app.orm.role_type_orm import *
from datetime import datetime
from app import db
from sqlalchemy_serializer import SerializerMixin
class Role(db.Model, SerializerMixin):
'''
ORM class for Role
'''
__tablename__ = 'role'
id = db.Column(
db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False
)
role_type_id = db.Column(db.BigInteger, db.ForeignKey('role_type.id'))
role_name = db.Column(db.String(80), nullable=False)
project_id = db.Column(db.BigInteger, nullable=False)
created_at = db.Column(db.DATETIME, default=datetime.now)
created_by = db.Column(db.BigInteger, db.ForeignKey('temp_user.id'), nullable=False)
updated_at = db.Column(db.DATETIME, onupdate=datetime.now)
updated_by = db.Column(db.BigInteger, db.ForeignKey('temp_user.id'), nullable=False)
is_deleted = db.Column(db.Boolean, default=False)
# role = db.relationship('RoleType')
from datetime import datetime
from app import db
from sqlalchemy_serializer import SerializerMixin
class RoleType(db.Model, SerializerMixin):
'''
ORM class for RoleType
'''
__tablename__ = 'role_type'
id = db.Column(
db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False
)
role_name = db.Column(db.String(80), nullable=False)
created_at = db.Column(db.DATETIME, default=datetime.now)
updated_at = db.Column(db.DATETIME, onupdate=datetime.now)
is_deleted = db.Column(db.Boolean, default=False)
serialize_only = ('id', 'name')
from datetime import datetime
from app import db
from sqlalchemy_serializer import SerializerMixin
class User(db.Model, SerializerMixin):
'''
ORM class for temp User
'''
__tablename__ = 'webomagic_user'
id = db.Column(
db.BigInteger,
primary_key=True,
autoincrement=True,
nullable=False
)
username = db.Column(db.String(80), nullable=False)
first_name = db.Column(db.String(80), nullable=False)
last_name = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(80), nullable=False)
phone = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), nullable=False)
gender = db.Column(db.String(20), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
date_of_join = db.Column(db.BigInteger, nullable=False)
created_at = db.Column(db.DATETIME, default=datetime.now)
updated_at = db.Column(db.DATETIME, onupdate=datetime.now)
is_deleted = db.Column(db.Boolean, default=False)
# user_roles = db.relationship('Role')
serialize_rules = ('-password',)
from flask_restx import Api
import importlib
import werkzeug
import flask
import os
from app.app_config.swagger_config import *
werkzeug.cached_property = werkzeug.utils.cached_property
blueprint: flask.Blueprint = flask.Blueprint(
name='api',
import_name=__name__,
url_prefix=SWAG_BASE_URL
)
api: Api = Api(
app=blueprint,
version=SWAG_VERSION,
title=SWAG_TITLE,
description=SWAG_DESCRIPTION,
authorizations=SWAG_AUTH,
doc=SWAG_DOC_URL
)
# from app.routes.user import sub_routes
current_dir: str = os.path.dirname(__file__)
for subdir in os.listdir(current_dir):
if os.path.isdir(os.path.join(current_dir, subdir)) and not subdir.startswith('__'):
module_name: str = f'app.routes.{subdir}'
module = importlib.import_module(module_name)
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.routes import api
from app.routes.role.role_payload import *
from app.routes.role.role_response import *
from app.routes.role.role_dao_service import *
from app.routes.role.role_validator import *
from app.utils.api_response import prepare_api_response
logger = get_logger(__name__)
ns = api.namespace(
name=os.path.dirname(__file__).split(os.sep)[-1].replace('_', '-'),
description='API connected to role module',
ordered=False
)
@ns.route('/add', methods=['POST'])
class AddRole(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*add_role_payload())
@ns.response(*add_role_response())
@sanitized()
def post(self):
try:
validator = AddRoleValidator()
payload: dict = validator.load(request.get_json())
role_id: int = add_role(payload)
return prepare_api_response(SUCCESS_CODE, INSERT_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('/update', methods=['PATCH'])
class UpdateRole(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*update_role_payload())
@ns.response(*update_role_response())
@sanitized()
def patch(self):
try:
validator = UpdateRoleValidator()
payload: dict = validator.load(request.get_json())
updated: bool = update_role(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 GetRole(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*get_role_payload())
@ns.response(*get_role_response())
@sanitized()
def get(self):
try:
validator = GetRoleValidator()
arguments: dict = validator.load(request.args)
role_info: ORM.Role | None = get_role_by_id(arguments['id'])
if role_info is None:
return prepare_api_response(404, 'Role not found')
return prepare_api_response(
SUCCESS_CODE,
GET_SUCCESS_MESSAGE,
data=role_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 GetAllRole(Resource):
@ns.doc(security=SECURITY)
@ns.response(*get_role_list_response())
def get(self):
try:
roles_list = get_role_list()
return prepare_api_response(
SUCCESS_CODE,
GET_ALL_SUCCESS_MESSAGE,
data=[role.to_dict() for role in roles_list]
)
except Exception as e:
logger.error(traceback.format_exc())
return prepare_api_response(EXCEPTION_CODE, str(e))
@ns.route('/delete', methods=['DELETE'])
class DeleteRole(Resource):
@ns.doc(security=SECURITY)
@ns.expect(*delete_role_payload())
@ns.response(*delete_role_response())
@sanitized()
def delete(self):
try:
pass
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_role_by_rolename_and_roletype(
rolename: str,
roletype: int
) -> ORM.Role | None:
return ORM.Role.query.filter_by(
role_name=rolename, role_type=roletype, is_deleted=False).first()
def add_role(role: dict) -> int | None:
try:
existing_role: ORM.Role | None = get_role_by_rolename_and_roletype(
role.get('role_name'), role.get('role_type_id')
)
if existing_role:
raise Exception('role_name already exists')
role_model = ORM.Role(
role_type_id=role.get('role_type_id'),
role_name=role.get('role_name'),
project_id=role.get('project_id')
)
db.session.add(role_model)
db.session.flush([role_model])
db.session.commit()
return role_model.id
except Exception as e:
db.session.rollback()
raise e
def get_role_by_id(id: int) -> ORM.Role | None:
return ORM.Role.query.filter_by(id=id, is_deleted=False).first()
def get_role_list() -> List[ORM.Role] | list:
return ORM.Role.query.filter_by(is_deleted=False).all()
def update_role(role: dict) -> bool:
try:
role_info: ORM.Role = get_role_by_id(role.get('id'), is_deleted=False)
if role_info is None:
return False
existing_role: ORM.Role | None = get_role_by_rolename_and_roletype(
role.get('role_name'), role.get('role_type_id')
)
if existing_role and existing_role.id != role_info.id:
raise Exception('rolename already exists')
role_info.role_type_id = role.get('role_type_id')
role_info.role_name = role.get('role_name')
role_info.project_id = role.get('project_id')
db.session.commit()
return True
except Exception as e:
db.session.rollback()
raise e
from flask_restx import fields
from app.routes import api
def add_role_payload() -> list:
payload = api.model('addRole Payload', {
'role_type_id': fields.Integer,
'role_name': fields.String,
'project_id': fields.Integer
})
return [payload]
def update_role_payload() -> list:
payload = api.model('updateRole Payload', {
'id': fields.Integer,
'role_type_id': fields.Integer,
'role_name': fields.String,
'project_id': fields.Integer
})
return [payload]
def get_role_payload() -> list:
parser = api.parser()
parser.add_argument('id', type=int, location='args')
return [parser]
def delete_role_payload() -> list:
parser = api.parser()
parser.add_argument('id', type=int, location='args')
return [parser]
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
ROLE_RESPONSE_MODEL: any = api.model('role', {
'id': fields.Integer,
'role_type_id': fields.Integer,
'role_name': fields.String,
'project_id': fields.Integer
})
JWT_RESPONSE_MODEL: any = api.model('jwt Data', {
'jwt': fields.String
})
def add_role_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=INSERT_SUCCESS_MESSAGE,
model_name='addRole Response'
)
def update_role_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=UPDATE_SUCCESS_MESSAGE,
model_name='updateRole Response'
)
def get_role_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=GET_SUCCESS_MESSAGE,
model_name='getRole Response',
data=fields.Nested(ROLE_RESPONSE_MODEL)
)
def get_role_list_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=GET_ALL_SUCCESS_MESSAGE,
model_name='getRoleList Response',
data=fields.List(fields.Nested(ROLE_RESPONSE_MODEL))
)
def get_role_profile_response() -> any:
return get_role_response()
def delete_role_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=DELETE_SUCCESS_MESSAGE,
model_name='deleteRole Response'
)
from marshmallow import Schema, fields, validate
class AddRoleValidator(Schema):
role_name = fields.String(required=True, validate=validate.Length(min=1))
project_id = fields.Integer(required=True, validate=validate.Range(min=1))
class UpdateRoleValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
role_name = fields.String(required=True, validate=validate.Length(min=1))
project_id = fields.Integer(required=True, validate=validate.Range(min=1))
class GetRoleValidator(Schema):
id = fields.Integer(required=True, validate=validate.Range(min=1))
import os
import traceback
import secrets
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.decorators.sanitizer import sanitized
from app.routes import api
from app import bcrypt
from app.routes.user.user_payload import *
from app.routes.user.user_response import *
from app.routes.user.user_dao_service import *
from app.routes.user.user_validator import *
from app.utils.api_response import prepare_api_response
from app.utils.redis import set_value
logger = get_logger(__name__)
ns = api.namespace(
name=os.path.dirname(__file__).split(os.sep)[-1].replace('_', '-'),
description='API connected to user module',
ordered=False
)
@ns.route('/login', methods=['POST'])
class Login(Resource):
def generate_api_key(self) -> str:
return ''.join(secrets.choice('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz') for _ in range(18))
@ns.expect(*login_payload())
@ns.response(*login_response())
@sanitized()
def post(self):
try:
validator = LoginValidator()
payload: dict = validator.load(request.get_json())
email: str = payload['email']
password: str = payload['password']
user_info: ORM.User | None = get_user_by_email(email)
if (not user_info):
return prepare_api_response(401, 'Invalid Email')
if not bcrypt.check_password_hash(user_info.password, password):
return prepare_api_response(401, 'Invalid password')
api_key = self.generate_api_key()
if user_info.id:
set_value(api_key, user_info.id)
return prepare_api_response(
SUCCESS_CODE,
SUCCESS_MESSAGE,
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))
\ No newline at end of file
from typing import List
from app import orm as ORM
from app import db
def get_user_by_username(username: str) -> ORM.User | None:
return ORM.User.query.filter_by(
username=username, is_deleted=False).first()
def get_user_by_email(email: str) -> ORM.User | None:
return ORM.User.query.filter_by(
email=email, is_deleted=False).first()
from flask_restx import fields
from app.routes import api
def login_payload() -> list:
payload = api.model('login Payload', {
'email': fields.String,
'password': fields.String
})
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
USER_RESPONSE_MODEL: any = api.model('user', {
'id': fields.Integer,
'username': fields.String,
'first_name': fields.String,
'last_name': fields.String,
'password': fields.String,
'phone': fields.String,
'email': fields.String,
'gender': fields.String,
'active': fields.Boolean,
'date_of_join': fields.Integer(description='date in epoch format'),
})
JWT_RESPONSE_MODEL: any = api.model('jwt Data', {
'jwt': fields.String
})
def login_response() -> any:
return prepare_swagger_response(
code=SUCCESS_CODE,
message=SUCCESS_MESSAGE,
model_name='login Response',
data=fields.Nested(JWT_RESPONSE_MODEL)
)
# from app.enum.user_role_enum import USER_ROLE
from marshmallow import Schema, fields, validate
class LoginValidator(Schema):
email = fields.String(required=True)
password = fields.String(required=True)
# class AddUserValidator(Schema):
# username = fields.String(required=True)
# first_name = fields.String(required=True)
# last_name = fields.String(required=True)
# password = fields.String(required=True, validate=validate.Length(min=6, max=32))
# phone = fields.String(required=True, validate=validate.Regexp(r'^[0-9]{10}$'))
# email = fields.String(required=True, validate=validate.Email())
# gender = fields.String(required=True)
# active = fields.Boolean(required=True)
# date_of_join = fields.Integer(required=True)
# roles = fields.List(
# fields.String(
# required=True,
# validate=validate.OneOf(USER_ROLE.get_list()),
# ),
# required=True,
# validate=validate.Length(min=1),
# )
# class UpdateUserValidator(Schema):
# id = fields.Integer(required=True, validate=validate.Range(min=1))
# first_name = fields.String(required=True)
# last_name = fields.String(required=True)
# password = fields.String(required=True, validate=validate.Length(min=6, max=32))
# phone = fields.String(required=True, validate=validate.Regexp(r'^[0-9]{10}$'))
# gender = fields.String(required=True)
# active = fields.Boolean(required=True)
# date_of_join = fields.Integer(required=True)
# class GetUserValidator(Schema):
# id = fields.Integer(required=True, validate=validate.Range(min=1))
from app.routes import api
from flask_restx import fields
def prepare_swagger_response(
code: int,
message: str,
model_name: str = '',
data: any = None
) -> dict:
response: dict = {
'code': fields.Integer(default=code),
'message': fields.String(default=message)
}
if (data is not None):
response['data'] = data
return [code, message, api.model(model_name, response)]
def prepare_api_response(
code: int,
message: str,
data: any = None,
error: any = None
) -> dict:
response: dict = {
'code': int(code),
'message': str(message)
}
if (data is not None):
response['data'] = data
if (error is not None):
response['error'] = error
return response, code
from flask import Request
def get_my_ip(request: Request) -> str:
ip_address: str = request.environ.get('HTTP_X_FORWARDED_FOR')
if ip_address is None:
ip_address = request.environ['REMOTE_ADDR']
return ip_address
\ No newline at end of file
from datetime import datetime
from decimal import Decimal
def model_to_dict(self):
result: dict = {}
for column in self.__table__.columns:
value = getattr(self, column.name)
if isinstance(value, datetime):
value = value.isoformat()
if isinstance(value, Decimal):
value = float(value)
result[column.name] = value
return result
\ No newline at end of file
import redis
from app.app_config.config import REDIS_HOST, REDIS_PORT, REDIS_DATABASE
def get_client(host, port, password):
try:
redis_client = redis.Redis(host=host, port=port, db=REDIS_DATABASE)
return redis_client
except Exception as e:
print(e)
return None
def get_value(key):
try:
client = get_client(REDIS_HOST, REDIS_PORT, None)
val = client.get(str(key))
return val.decode() if val else None
except Exception as e:
print(e)
return None
def set_value(key,value):
try:
client = get_client(REDIS_HOST, REDIS_PORT, None)
client.set(key, value)
return True
except Exception as e:
print(e)
return None
\ No newline at end of file
import bleach
def sanitize(data: dict) -> dict:
if data:
for key, value in data.items():
if isinstance(value, str):
data[key] = bleach.clean(value)
elif isinstance(value, dict):
data[key] = sanitize(value)
return data
INSERT INTO
public.webomagic_user (
username,
first_name,
last_name,
"password",
phone,
email,
gender,
active,
date_of_join
)
VALUES
(
'deepdey',
'Deep',
'Dey',
'$2b$12$du0B3AlnD5wOYxt.ADYPwuaCFqF7R3XrLHDiNca4FvVtTGPIQVEu2',
'8697448896',
'deep.websofttechs@gmail.com',
'MALE',
true,
0
);
CREATE TABLE
IF NOT EXISTS api_authorization (
id BIGSERIAL PRIMARY KEY NOT NULL,
endpoint VARCHAR(255) NOT NULL,
associated_roles BIGINT[] NOT NULL
);
CREATE TABLE
IF NOT EXISTS role_type(
id BIGSERIAL PRIMARY KEY NOT NULL,
role_name VARCHAR(80) NOT NULL,
is_deleted BOOLEAN DEFAULT false,
created_at TIMESTAMP NOT NULL DEFAULT now (),
updated_at TIMESTAMP
);
CREATE TABLE
IF NOT EXISTS role (
id BIGSERIAL PRIMARY KEY NOT NULL,
role_type_id BIGINT NOT NULL,
role_name VARCHAR(80) NOT NULL,
project_id BIGINT NOT NULL,
is_deleted BOOLEAN DEFAULT false,
created_at TIMESTAMP NOT NULL DEFAULT now (),
created_by BIGINT NOT NULL,
updated_at TIMESTAMP
updated_by BIGINT,
FOREIGN KEY (role_type_id) REFERENCES role_type(id),
FOREIGN KEY (created_by) REFERENCES webomagic_user (id),
FOREIGN KEY (updated_by) REFERENCES webomagic_user (id)
);
CREATE TABLE
IF NOT EXISTS webomagic_user (
id BIGSERIAL PRIMARY KEY NOT NULL,
username VARCHAR(80) UNIQUE NOT NULL,
first_name VARCHAR(80) NOT NULL,
last_name VARCHAR(80) NOT NULL,
password VARCHAR(80) NOT NULL,
phone VARCHAR(20) UNIQUE NOT NULL,
email VARCHAR(120) UNIQUE NOT NULL,
gender VARCHAR(20) NOT NULL,
active BOOLEAN DEFAULT true,
date_of_join BIGINT NOT NULL,
is_deleted BOOLEAN DEFAULT false,
created_at TIMESTAMP NOT NULL DEFAULT now (),
updated_at TIMESTAMP
);
\ No newline at end of file
from app import app
from app.app_config.config import SERVER_HOST, SERVER_PORT, get_logger
logger = get_logger(__name__)
if __name__ == '__main__':
app.run(host = SERVER_HOST, debug = True, port=SERVER_PORT)
\ 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