def post(self, session):
"""
Post call to create Project with name and organization Id.
Args:
session(object): User session
Returns: Standard API Response with HTTP status code
"""
create_project_parser = reqparse.RequestParser(bundle_errors=True)
create_project_parser.add_argument(
'project_name',
help=APIMessages.PARSER_MESSAGE,
required=True, type=str, location='json')
create_project_parser.add_argument(
'project_description',
help=APIMessages.PARSER_MESSAGE,
required=True, type=str, location='json')
create_project_parser.add_argument(
'org_id',
help=APIMessages.PARSER_MESSAGE,
required=True, type=int, location='json')
create_project_data = create_project_parser.parse_args()
org_obj = Organization.query.filter_by(
org_id=create_project_data['org_id'],
is_deleted=False).first()
if not org_obj:
raise GenericBadRequestException(APIMessages.INVALID_ORG_ID)
check_permission(user_object=session.user,
list_of_permissions=PROJECT_POST,
org_id=create_project_data["org_id"])
create_project_data['project_name'] = create_project_data[
'project_name'].strip()
list_of_args = [arg.name for arg in create_project_parser.args]
request_data_validation = validate_empty_fields(
create_project_data,
list_of_args)
if request_data_validation:
return api_response(success=False,
message=request_data_validation,
http_status_code=STATUS_BAD_REQUEST,
data={})
new_project = Project(create_project_data['project_name'],
create_project_data['project_description'],
create_project_data['org_id'],
session.user_id)
new_project.save_to_db()
project_payload = {'project_name': new_project.project_name,
'project_id': new_project.project_id,
'project_description': new_project.project_description,
'org_id': new_project.org_id}
return api_response(True,
APIMessages.CREATE_RESOURCE.format('Project'),
STATUS_CREATED, project_payload)
def get_db_connection(project_id):
"""
Method to give list of db connection id and db connection name.
Args:
project_id(int):project id
Returns:
give all the db_connection_ids and db connection name
associated with the project_id which we will pass in the argument
"""
db_obj = DbConnection.query.filter(DbConnection.project_id == project_id,
DbConnection.is_deleted == False).all()
if not db_obj:
raise GenericBadRequestException(APIMessages.NO_DB_UNDER_PROJECT)
all_connection = [{
"db_connection_id": each_db_detail.db_connection_id,
"db_connection_name": each_db_detail.db_connection_name
} for each_db_detail in db_obj]
payload = {"all_connections": all_connection}
return payload
def post(self, session):
"""
Post to create UserProjectRole and UserOrgRole records.
Args:
session (object):
Returns: Standard API Response with HTTP status code
"""
parser = reqparse.RequestParser()
parser.add_argument('org_id',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=int,
location='json')
parser.add_argument('user_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=int,
location='json')
parser.add_argument('email_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=str,
location='json')
parser.add_argument('project_role_list',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=list,
location='json')
parser.add_argument('org_allowed_role_list',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=list,
location='json')
parser.add_argument('first_name',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=str,
location='json')
parser.add_argument('last_name',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=str,
location='json')
create_role_api_parser = parser.parse_args()
# check if user and org id is valid if user id is passed
if create_role_api_parser['user_id']:
check_valid_id_passed_by_user(
org_id=create_role_api_parser['org_id'],
user_id=create_role_api_parser['user_id'])
# Check if org id is valid if user id is not passed
if not create_role_api_parser['user_id']:
check_valid_id_passed_by_user(
org_id=create_role_api_parser['org_id'])
# TODO: Check if user management permission exists
# check if project ids passed are related to org
list_of_projects_passed = []
if create_role_api_parser['project_role_list']:
list_of_projects_passed = \
[each_project['project_id'] for each_project in
create_role_api_parser['project_role_list']]
projects_under_given_org = Project.query.filter_by(
org_id=create_role_api_parser['org_id'], is_deleted=False).all()
list_projects_under_org = \
[project.project_id for project in projects_under_given_org]
if not (set(list_of_projects_passed).issubset(
set(list_projects_under_org))):
raise GenericBadRequestException(APIMessages.PROJECT_NOT_UNDER_ORG)
# check if role Ids passed are related to passed org
passed_roles_list = list()
for each_project_and_role in create_role_api_parser[
'project_role_list']:
passed_roles_list.extend(
each_project_and_role['allowed_role_list'])
passed_roles_list.extend(
create_role_api_parser['org_allowed_role_list'])
# TODO: Need to enable & optimise check_permission
# check_permission(user_object=session.user,
# list_of_permissions=USER_ROLE_API_POST,
# org_id=create_role_api_parser["org_id"])
# get all roles under the given org
valid_roles_under_org = Role.query.filter_by(
org_id=create_role_api_parser['org_id']).all()
valid_role_ids_under_org = \
[each_role.role_id for each_role in valid_roles_under_org]
if not set(passed_roles_list).issubset(valid_role_ids_under_org):
raise GenericBadRequestException(APIMessages.ROLE_NOT_UNDER_ORG)
# check if email is passed in request
if create_role_api_parser['email_id'] and \
not create_role_api_parser['user_id']:
# get user_id based on email_id
get_user_record = User.query.filter(
User.email.ilike(create_role_api_parser['email_id']),
User.is_deleted == False).first()
if get_user_record:
# User record is present with given email id
user_id = get_user_record.user_id
else:
# User record is not present for given email id.
# Create a new user
if not (re.search(GenericStrings.EMAIL_FORMAT_REGEX,
create_role_api_parser['email_id'])):
raise GenericBadRequestException(APIMessages.VALID_EMAIL)
# First name and last name should not be None for New User.
if create_role_api_parser['first_name'] is None or \
create_role_api_parser['last_name'] is None:
raise GenericBadRequestException(
APIMessages.FIRST_LAST_NAME)
create_user_args = \
{'first_name': create_role_api_parser['first_name'],
'last_name': create_role_api_parser['last_name'],
'password': create_role_api_parser['email_id'],
'is_verified': True}
user_id = create_new_user(create_role_api_parser['email_id'],
**create_user_args)
if create_role_api_parser['user_id'] and \
not create_role_api_parser['email_id']:
user_id = create_role_api_parser['user_id']
# Deleting all UserProjectRole records with given User and Org Id
UserProjectRole.query.filter_by(
org_id=create_role_api_parser['org_id'], user_id=user_id).delete()
UserOrgRole.query.filter_by(org_id=create_role_api_parser['org_id'],
user_id=user_id).delete()
# add project roles
if create_role_api_parser['project_role_list']:
for each_project_role in \
create_role_api_parser['project_role_list']:
for each_roles_given in \
set(each_project_role['allowed_role_list']):
add_user_project_role = UserProjectRole(
user_id=user_id,
org_id=create_role_api_parser['org_id'],
project_id=each_project_role['project_id'],
role_id=each_roles_given,
owner_id=session.user_id)
add_user_project_role.save_to_db()
# Add Org Roles
if create_role_api_parser['org_allowed_role_list']:
for each_org_role in \
set(create_role_api_parser['org_allowed_role_list']):
new_user_org_role = UserOrgRole(
user_id=user_id,
org_id=create_role_api_parser['org_id'],
role_id=each_org_role,
owner_id=session.user_id)
new_user_org_role.save_to_db()
return api_response(True, APIMessages.ADD_ROLE, STATUS_CREATED)
def delete(self, session):
"""
DELETE call to delete UserProjectRole and UserOrgRole records.
Args:
session (object): User Session
Returns: Standard API Response with HTTP status code
"""
parser = reqparse.RequestParser()
parser.add_argument('org_id',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=int,
location='args')
parser.add_argument('user_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=int,
location='args')
parser.add_argument('email_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=str,
location='args')
delete_role_api_parser = parser.parse_args()
result_dict = {}
# Checking if User Id or Email Id is mandatorily passed
if not delete_role_api_parser['user_id'] and \
not delete_role_api_parser['email_id']:
return api_response(False, APIMessages.EMAIL_USER,
STATUS_BAD_REQUEST)
if delete_role_api_parser['user_id'] and delete_role_api_parser[
'email_id']:
raise GenericBadRequestException(APIMessages.ONLY_USER_OR_EMAIL)
# Storing user id if user id is passed
user_id = delete_role_api_parser['user_id'] \
if delete_role_api_parser['user_id'] else None
# checking if User Id is valid
if delete_role_api_parser['user_id']:
check_valid_id_passed_by_user(
org_id=delete_role_api_parser['org_id'],
user_id=delete_role_api_parser['user_id'])
check_permission(user_object=session.user,
list_of_permissions=USER_ROLE_API_DELETE,
org_id=delete_role_api_parser["org_id"])
# Get user Id based on email Id passed
if delete_role_api_parser['email_id'] and \
not delete_role_api_parser['user_id']:
check_valid_id_passed_by_user(
org_id=delete_role_api_parser['org_id'])
user_record = User.query.filter(
User.email.ilike(delete_role_api_parser['email_id']),
User.is_deleted == False).first()
if not user_record:
raise ResourceNotAvailableException("User")
user_id = user_record.user_id
result_dict['email_id'] = user_record.email
user_project_role_obj = UserProjectRole.query.filter(
UserProjectRole.org_id == delete_role_api_parser["org_id"],
UserProjectRole.user_id == user_id).all()
user_org_role_obj = UserOrgRole.query.filter(
UserOrgRole.org_id == delete_role_api_parser["org_id"],
UserOrgRole.user_id == user_id).all()
session_obj = Session.query.filter(Session.user_id == user_id).all()
for each_project_org_session_role in (user_project_role_obj,
user_org_role_obj, session_obj):
for each_role in each_project_org_session_role:
db.session.delete(each_role)
db.session.commit()
return api_response(
True,
APIMessages.USER_ROLE_DELETED.format(
delete_role_api_parser["org_id"]), STATUS_CREATED)
def get(self, session):
"""
GET call to retrieve UserProjectRole and UserOrgRole records.
Args:
session (object): User Session
Returns: Standard API Response with HTTP status code
"""
# TODO: Need to reduce DB hit
parser = reqparse.RequestParser()
parser.add_argument('org_id',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=int,
location='args')
parser.add_argument('user_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=int,
location='args')
parser.add_argument('email_id',
help=APIMessages.PARSER_MESSAGE,
required=False,
type=str,
location='args')
get_role_api_parser = parser.parse_args()
result_dict = {}
# Checking if User Id or Email Id is mandatorily passed
if not get_role_api_parser['user_id'] and \
not get_role_api_parser['email_id']:
return api_response(False, APIMessages.EMAIL_USER,
STATUS_BAD_REQUEST)
if get_role_api_parser['user_id'] and get_role_api_parser['email_id']:
raise GenericBadRequestException(APIMessages.ONLY_USER_OR_EMAIL)
# checking if User Id is valid
valid_org, valid_project, valid_user, valid_role = None, None, None, None
if get_role_api_parser['user_id']:
valid_org, valid_project, valid_user, valid_role = check_valid_id_passed_by_user(
org_id=get_role_api_parser['org_id'],
user_id=get_role_api_parser['user_id'])
check_permission(user_object=session.user,
list_of_permissions=USER_ROLE_API_GET,
org_id=get_role_api_parser["org_id"])
# Get user Id based on email Id passed
if get_role_api_parser['email_id'] and \
not get_role_api_parser['user_id']:
valid_org, valid_project, valid_user, valid_role = check_valid_id_passed_by_user(
org_id=get_role_api_parser['org_id'])
valid_user = User.query.filter(
User.email.ilike(get_role_api_parser['email_id']),
User.is_deleted == False).first()
if not valid_user:
return api_response(True, APIMessages.NO_ROLES, STATUS_OK)
if get_role_api_parser['org_id'] and valid_user.user_id:
# Get Project Role list
project_role_list = list()
temp_dict = {}
user_project_roles = UserProjectRole.query.filter_by(
org_id=get_role_api_parser['org_id'],
user_id=valid_user.user_id).all()
for each_project_role in user_project_roles:
if each_project_role.project_id not in temp_dict.keys():
# Add a key with value as role_id
temp_dict[each_project_role.project_id] = \
[each_project_role.role_id]
else:
temp_dict[each_project_role.project_id].append(
each_project_role.role_id)
for key, value in temp_dict.items():
project_role_list.append({
'project_id': key,
'allowed_role_list': value
})
result_dict['project_role_list'] = project_role_list
# Get Org Roles
user_org_roles = UserOrgRole.query.filter_by(
org_id=get_role_api_parser['org_id'],
user_id=valid_user.user_id).all()
result_dict['is_org_user'] = True if user_org_roles else False
result_dict['org_allowed_role_list'] = []
if user_org_roles:
for each_user_org_role in user_org_roles:
result_dict['org_allowed_role_list'].append(
each_user_org_role.role_id)
if not (result_dict['org_allowed_role_list']
or result_dict['project_role_list']):
return api_response(True, APIMessages.NO_ROLES, STATUS_OK)
result_dict['user_id'] = valid_user.user_id
result_dict['email_id'] = valid_user.email
result_dict['first_name'] = valid_user.first_name
result_dict['last_name'] = valid_user.last_name
result_dict['user_id'] = valid_user.user_id
result_dict['org_id'] = get_role_api_parser['org_id']
return api_response(True, APIMessages.SUCCESS, STATUS_OK,
result_dict)
def get(self, session):
project_dql_parser = reqparse.RequestParser()
project_dql_parser.add_argument(
'project_id',
help=APIMessages.PARSER_MESSAGE.format('project_id'),
required=True,
type=int,
location='args')
project_dql_parser.add_argument(
"start_date",
help=APIMessages.PARSER_MESSAGE.format('start_date'),
required=False,
type=str,
location='args')
project_dql_parser.add_argument(
"end_date",
help=APIMessages.PARSER_MESSAGE.format('end_date'),
required=False,
type=str,
location='args')
project_dql_args = project_dql_parser.parse_args()
# check if project Id exists
check_valid_project = Project.query.filter_by(
project_id=project_dql_args['project_id'],
is_deleted=False).first()
if not check_valid_project:
raise ResourceNotAvailableException("Project")
# checking if user is authorized to make this call
check_permission(session.user,
list_of_permissions=PROJECT_DQI_GET,
org_id=check_valid_project.org_id,
project_id=project_dql_args['project_id'])
# Check if both start and end date are passed instead either of them
if (project_dql_args['start_date']
and not project_dql_args['end_date']) or \
(not project_dql_args['start_date'] and
project_dql_args['end_date']):
raise GenericBadRequestException(APIMessages.START_END_DATE)
try:
# check if user passed dates in yyyy-mm-dd format
start_date, end_date = "", ""
if project_dql_args['start_date'] and project_dql_args['end_date']:
start_date = dt.strptime(
project_dql_args['start_date'] + " 00:00:00",
"%Y-%m-%d %H:%M:%S")
end_date = dt.strptime(
project_dql_args['end_date'] + " 23:59:59",
"%Y-%m-%d %H:%M:%S")
except ValueError:
raise GenericBadRequestException(APIMessages.DATE_FORMAT)
dqi_name_casting = OrderedDict([
(TestTypeDisplay.COMPLETENESS, TestClass.COUNT_CHECK),
(TestTypeDisplay.NULLS, TestClass.NULL_CHECK),
(TestTypeDisplay.DUPLICATES, TestClass.DUPLICATE_CHECK),
(TestTypeDisplay.CONSISTENCY, TestClass.DDL_CHECK),
(TestTypeDisplay.CORRECTNESS, TestClass.DATA_VALIDATION)
])
list_of_project_dqi, project_dqi_average, starting_date, \
ending_date = get_project_dqi(
project_dql_args['project_id'], start_date, end_date)
dqi_list = list()
for each_display_class in dqi_name_casting.keys():
if each_display_class in list_of_project_dqi.keys():
dqi_dict = dict()
dqi_dict['name'] = each_display_class
dqi_dict['value'] = list_of_project_dqi[each_display_class]
dqi_list.append(dqi_dict)
project_dql_data = dict()
project_dql_data['project_name'] = check_valid_project.project_name
project_dql_data['project_id'] = check_valid_project.project_id
project_dql_data['project_dqi_percentage'] = project_dqi_average
project_dql_data['project_dqi_detail'] = dqi_list
project_dql_data['start_date'] = str(starting_date)
project_dql_data['end_date'] = str(ending_date)
return api_response(True, APIMessages.SUCCESS, STATUS_OK,
project_dql_data)
def get(self, session):
dqi_history_parser = reqparse.RequestParser()
dqi_history_parser.add_argument(
'project_id',
help=APIMessages.PARSER_MESSAGE.format('org_id'),
required=True,
type=int,
location='args')
dqi_history_parser.add_argument(
"start_date",
help=APIMessages.PARSER_MESSAGE.format('start_date'),
required=False,
type=str,
location='args')
dqi_history_parser.add_argument(
"end_date",
help=APIMessages.PARSER_MESSAGE.format('end_date'),
required=False,
type=str,
location='args')
dqi_history_data = dqi_history_parser.parse_args()
# check if project Id exists
check_valid_project = Project.query.filter_by(
project_id=dqi_history_data['project_id'],
is_deleted=False).first()
if not check_valid_project:
raise ResourceNotAvailableException("Project")
# checking if user is authorized to make this call
check_permission(session.user,
list_of_permissions=PROJECT_DQI_HISTORY_GET,
org_id=check_valid_project.org_id,
project_id=dqi_history_data['project_id'])
# Check if both start and end date are passed instead either of them
if (dqi_history_data['start_date']
and not dqi_history_data['end_date']) or \
(not dqi_history_data['start_date'] and
dqi_history_data['end_date']):
raise GenericBadRequestException(APIMessages.START_END_DATE)
try:
# check if user passed dates in yyyy-mm-dd format
start_date, end_date = "", ""
if dqi_history_data['start_date'] and dqi_history_data['end_date']:
start_date = dt.strptime(
dqi_history_data['start_date'] + " 00:00:00",
"%Y-%m-%d %H:%M:%S")
end_date = dt.strptime(
dqi_history_data['end_date'] + " 23:59:59",
"%Y-%m-%d %H:%M:%S")
except ValueError:
raise GenericBadRequestException(APIMessages.DATE_FORMAT)
# calling get_project_dqi_history to get day wise data
daily_dqi = get_project_dqi_history(dqi_history_data['project_id'],
start_date=start_date,
end_date=end_date)
if not start_date and not end_date:
# If start and end date are not given, take current month range
current_day = dt.today()
current_month_first_day = date.today().replace(day=1)
start_date = current_month_first_day.strftime("%Y-%m-%d")
end_date = current_day.strftime("%Y-%m-%d")
dqi_response = OrderedDict()
dqi_response['project_id'] = dqi_history_data['project_id']
dqi_response['project_name'] = check_valid_project.project_name
dqi_response['dqi_history'] = daily_dqi
dqi_response['start_date'] = str(start_date)
dqi_response['end_date'] = str(end_date)
return api_response(True, APIMessages.SUCCESS, STATUS_OK, dqi_response)
def get(self, session):
org_dql_parser = reqparse.RequestParser()
org_dql_parser.add_argument(
'org_id',
help=APIMessages.PARSER_MESSAGE.format('org_id'),
required=True,
type=int,
location='args')
org_dql_parser.add_argument(
"start_date",
help=APIMessages.PARSER_MESSAGE.format('start_date'),
required=False,
type=str,
location='args')
org_dql_parser.add_argument(
"end_date",
help=APIMessages.PARSER_MESSAGE.format('end_date'),
required=False,
type=str,
location='args')
org_dql_args = org_dql_parser.parse_args()
valid_org = Organization.query.filter_by(org_id=org_dql_args["org_id"],
is_deleted=False).first()
if not valid_org:
raise ResourceNotAvailableException("Organization")
# checking if user is authorized to make this call
check_permission(session.user,
list_of_permissions=ORGANIZATION_DQI_GET,
org_id=org_dql_args['org_id'])
# Check if both start and end date are passed instead either of them
if (org_dql_args['start_date']
and not org_dql_args['end_date']) or \
(not org_dql_args['start_date'] and
org_dql_args['end_date']):
raise GenericBadRequestException(APIMessages.START_END_DATE)
try:
# check if user passed dates in yyyy-mm-dd format
start_date, end_date = "", ""
if org_dql_args['start_date'] and org_dql_args['end_date']:
start_date = dt.strptime(
org_dql_args['start_date'] + " 00:00:00",
"%Y-%m-%d %H:%M:%S")
end_date = dt.strptime(org_dql_args['end_date'] + " 23:59:59",
"%Y-%m-%d %H:%M:%S")
except ValueError:
raise GenericBadRequestException(APIMessages.DATE_FORMAT)
project_obj_list = Project.query.filter_by(org_id=valid_org.org_id,
is_deleted=False).all()
project_list = list()
for project_obj in project_obj_list:
project_dict = dict()
dqi_dict, project_dql_avg, starting_date, ending_date = \
get_project_dqi(project_obj.project_id, start_date, end_date)
project_dict['project_id'] = project_obj.project_id
project_dict['project_name'] = project_obj.project_name
project_dict['project_dqi_percentage'] = project_dql_avg
project_list.append(project_dict)
org_data = dict()
org_data['org_name'] = valid_org.org_name
org_data['org_id'] = valid_org.org_id
org_data['start_date'] = str(starting_date)
org_data['end_date'] = str(ending_date)
org_data['projects'] = project_list
return api_response(True, APIMessages.SUCCESS, STATUS_OK, org_data)
def post(self, session):
"""
POST call to Create a role.
Args:
session (object): User session
Returns: Standard API Response with HTTP status code
"""
create_role_parser = reqparse.RequestParser()
create_role_parser.add_argument('role_name',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=str,
location='json')
create_role_parser.add_argument('role_description',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=str,
location='json')
create_role_parser.add_argument('org_id',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=int,
location='json')
create_role_parser.add_argument('permission_id_list',
help=APIMessages.PARSER_MESSAGE,
required=True,
type=list,
location='json')
create_role_data = create_role_parser.parse_args()
create_role_data["role_name"] = create_role_data["role_name"].strip()
create_role_data["role_description"] = create_role_data[
"role_description"].strip()
list_of_args = [arg.name for arg in create_role_parser.args]
request_data_validation = validate_empty_fields(
create_role_data, list_of_args)
if request_data_validation:
return api_response(success=False,
message=request_data_validation,
http_status_code=STATUS_BAD_REQUEST,
data={})
# check if permission_id_list is not empty
if not create_role_data['permission_id_list']:
raise GenericBadRequestException(APIMessages.PERMISSION_LIST)
# TODO: Check User Management access
permission_id_given_by_user = set(
create_role_data['permission_id_list'])
# checking if permissions are valid
valid_permissions = check_permission_exists(
permission_id_given_by_user)
if isinstance(valid_permissions, tuple):
return api_response(
False, APIMessages.NO_RESOURCE.format('Permission'),
STATUS_BAD_REQUEST,
{'invalid_permissions': list(valid_permissions[0])})
check_valid_id_passed_by_user(org_id=create_role_data['org_id'])
# checking if role_name already exists with given org
get_role_details = Role.query.filter(
and_(Role.role_name.ilike(create_role_data['role_name']),
Role.org_id == create_role_data['org_id'])).first()
if get_role_details:
raise GenericBadRequestException(
APIMessages.RESOURCE_EXISTS.format('Role'))
check_permission(user_object=session.user,
list_of_permissions=ROLE_API_POST,
org_id=create_role_data["org_id"])
new_role = Role(role_name=create_role_data['role_name'],
org_id=create_role_data['org_id'],
owner_id=session.user_id,
description=create_role_data["role_description"])
new_role.save_to_db()
# add permission to role
for each_permission in set(create_role_data['permission_id_list']):
add_role_permission = RolePermission(
org_id=create_role_data['org_id'],
role_id=new_role.role_id,
permission_id=each_permission,
owner_id=session.user_id)
add_role_permission.save_to_db()
payload = {
'role_name': new_role.role_name,
'role_id': new_role.role_id,
'permissions_granted': valid_permissions
}
return api_response(True, APIMessages.CREATE_RESOURCE.format('Role'),
STATUS_CREATED, payload)
def put(self, session):
"""
PUT call to update role.
Args:
session (object): User session
Returns: Standard API Response with HTTP status code
"""
create_role_parser = reqparse.RequestParser()
create_role_parser.add_argument('role_id',
help=APIMessages.PARSER_MESSAGE,
type=str,
required=True,
location='json')
create_role_parser.add_argument('role_name', type=str, location='json')
create_role_parser.add_argument('role_description',
type=str,
location='json')
create_role_parser.add_argument('permission_id_list',
type=list,
location='json')
create_role_data = create_role_parser.parse_args()
keys = set()
for key, value in dict(create_role_data).items():
if value == None:
del create_role_data[key]
for key, value in dict(create_role_data).items():
keys.add(key)
role_obj = Role.query.filter(
Role.role_id == create_role_data["role_id"]).first()
if "role_name" in keys:
create_role_data["role_name"] = create_role_data[
"role_name"].strip()
# checking if role_name already exists in org
get_role_details = Role.query.filter(
and_(Role.role_name.ilike(create_role_data['role_name']),
Role.org_id == role_obj.org_id,
Role.role_id != role_obj.role_id)).first()
if get_role_details:
raise GenericBadRequestException(
APIMessages.RESOURCE_EXISTS.format('Role'))
if "role_description" in keys:
create_role_data["role_description"] = create_role_data[
"role_description"].strip()
# check if permission_id_list is not empty
if "permission_id_list" in keys:
if not create_role_data['permission_id_list']:
raise GenericBadRequestException(APIMessages.PERMISSION_LIST)
permission_id_given_by_user = set(
create_role_data['permission_id_list'])
# checking if permissions are valid
valid_permissions = check_permission_exists(
permission_id_given_by_user)
if isinstance(valid_permissions, tuple):
return api_response(
False, APIMessages.NO_RESOURCE.format('Permission'),
STATUS_BAD_REQUEST,
{'invalid_permissions': list(valid_permissions[0])})
check_permission(user_object=session.user,
list_of_permissions=ROLE_API_PUT,
org_id=role_obj.org_id)
role_permission = RolePermission.query.filter(
RolePermission.org_id == role_obj.org_id,
RolePermission.role_id == role_obj.role_id,
).all()
permission_id_in_table = set()
for each_role in role_permission:
permission_id_in_table.add(each_role.permission_id)
# role_permission.delete_from_db()
for key, value in create_role_data.items():
if key == 'role_name':
if value == "":
return APIMessages.ROLE_NAME_CANNOT_BLANK
role_obj.role_name = value
if key == 'role_description':
if value == "":
return APIMessages.ROLE_DESCRIPTION_CANNOT_BLANK
role_obj.description = value
if key == 'permission_id_list':
for each_permission_by_user in value:
if each_permission_by_user not in permission_id_in_table:
add_role_permission = RolePermission(
org_id=role_obj.org_id,
role_id=role_obj.role_id,
permission_id=each_permission_by_user,
owner_id=session.user_id)
add_role_permission.save_to_db()
for each_permission_in_table in permission_id_in_table:
if each_permission_in_table not in value:
# TODO: Delete the permission which is not given by user
role_permission_obj = RolePermission.query.filter_by(
org_id=role_obj.org_id,
role_id=role_obj.role_id,
permission_id=each_permission_in_table).first()
role_permission_obj.delete_from_db()
role_obj.save_to_db()
return api_response(True, APIMessages.ROLE_UPDATED, STATUS_CREATED)
def get(self, session):
"""
GET call to retrieve role information.
Args:
session (object): User session
Returns: Standard API Response with HTTP status code
"""
get_role_parser = reqparse.RequestParser()
get_role_parser.add_argument('org_id',
help=APIMessages.PARSER_MESSAGE,
type=str,
location='args')
get_role_parser.add_argument('project_id',
help=APIMessages.PARSER_MESSAGE,
type=str,
location='args')
get_role_parser.add_argument('role_id',
help=APIMessages.PARSER_MESSAGE,
type=str,
location='args')
get_role_data = get_role_parser.parse_args()
payload = None
# Check if either Org Id or Project Id or Role Id is passed
if not get_role_data['org_id'] and not get_role_data[
'project_id'] and not get_role_data['role_id']:
raise GenericBadRequestException(
APIMessages.ORG_PROJECT_ROLE_REQUIRED)
if get_role_data['org_id'] and get_role_data['project_id'] and \
get_role_data['role_id']:
raise GenericBadRequestException(
APIMessages.ONLY_ORG_OR_PROJECT_OR_ROLE)
if get_role_data['org_id'] and get_role_data['project_id']:
raise GenericBadRequestException(
APIMessages.ONLY_ORG_OR_PROJECT_OR_ROLE)
if get_role_data['org_id'] and get_role_data['role_id']:
raise GenericBadRequestException(
APIMessages.ONLY_ORG_OR_PROJECT_OR_ROLE)
if get_role_data['project_id'] and get_role_data['role_id']:
raise GenericBadRequestException(
APIMessages.ONLY_ORG_OR_PROJECT_OR_ROLE)
if get_role_data['org_id'] and not get_role_data['project_id'] and not \
get_role_data['role_id']:
# get all roles based on org_id
# TODO: Returns roles with permission not exceeding the User's
# permissions
check_valid_id_passed_by_user(org_id=get_role_data['org_id'])
check_permission(user_object=session.user,
list_of_permissions=ROLE_API_GET,
org_id=get_role_data["org_id"])
permissions = db.session.query(Permission.permission_id).join(
RolePermission,
Permission.permission_id == RolePermission.permission_id).join(
UserOrgRole,
RolePermission.role_id == UserOrgRole.role_id).filter(
UserOrgRole.user_id == session.user_id,
UserOrgRole.org_id ==
get_role_data["org_id"]).distinct().all()
permission_id_list = [permission for permission, in permissions]
payload = retrieve_roles_under_org(get_role_data['org_id'],
permission_id_list)
if get_role_data['project_id'] and not get_role_data['org_id'] and not \
get_role_data["role_id"]:
check_valid_id_passed_by_user(
project_id=get_role_data['project_id'])
project_obj = Project.query.filter(
Project.project_id == get_role_data["project_id"],
Project.is_deleted == False).first()
check_permission(user_object=session.user,
list_of_permissions=ROLE_API_GET,
project_id=get_role_data["project_id"],
org_id=project_obj.org_id)
permissions = db.session.query(Permission.permission_id).join(
RolePermission,
Permission.permission_id == RolePermission.permission_id).join(
UserOrgRole,
RolePermission.role_id == UserOrgRole.role_id).filter(
UserOrgRole.user_id == session.user_id,
UserOrgRole.org_id ==
project_obj.org_id).distinct().all()
permission_id_list = [permission for permission, in permissions]
payload = retrieve_roles_under_org(project_obj.org_id,
permission_id_list)
if get_role_data['role_id'] and not get_role_data['org_id'] and not \
get_role_data["project_id"]:
check_valid_id_passed_by_user(role_id=get_role_data['role_id'])
role_obj = Role.query.filter_by(
role_id=get_role_data["role_id"]).first()
check_permission(user_object=session.user,
list_of_permissions=ROLE_API_GET,
org_id=role_obj.org_id)
if not (session.user.is_super_admin or UserOrgRole.query.filter(
user_id=session.user_id, org_id=role_obj.org_id).first()
or UserProjectRole.query.filter(
user_id=session.user_id,
org_id=role_obj.org_id).first()):
return api_response(False, APIMessages.FORBIDDEN,
STATUS_FORBIDDEN)
payload = retrive_role_with_permissions_by_role_id(role_obj)
if payload:
return api_response(True, APIMessages.SUCCESS, STATUS_OK,
{'roles': payload})
raise GenericBadRequestException(APIMessages.NO_ROLES)