def edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, MEMBER_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
group_member = get_model(id, db_session)
if group_member is None:
logger.error(LogMsg.NOT_FOUND, {'discussion_group_member': id})
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
per_data = {}
if is_admin_member(user.person_id, group_member.group_id, db_session):
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session, 'DISCUSSION_MEMBER',
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
for key, value in data.items():
setattr(group_member, key, value)
edit_basic_data(group_member, username, data.get('tags'))
logger.debug(LogMsg.DISCUSSION_GROUP_OLD_MEMBERS_DELETED)
return discussion_member_to_dict(group_member)
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
content = get_internal(id, db_session)
if content is None:
logger.error(LogMsg.NOT_FOUND, {'content_id': id})
raise Http_error(404, Message.NOT_FOUND)
book = get_book(content.book_id, db_session)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'BOOK_DELETE',
model=content)
logger.debug(LogMsg.PERMISSION_VERIFIED)
try:
db_session.delete(content)
book.size = None
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.DELETE_FAILED)
logger.debug(LogMsg.DELETE_SUCCESS, {'book_content_id': id})
logger.info(LogMsg.END)
return Http_response(204, True)
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
group_member = get_model(id, db_session)
if group_member is None:
logger.error(LogMsg.NOT_FOUND, {'discussion_group_member': id})
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
per_data = {}
if group_member.person_id == user.person_id or is_admin_member(
user.person_id, group_member.group_id, db_session):
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session, 'DISCUSSION_MEMBER',
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
db_session.query(DiscussionMember).filter(
DiscussionMember.id == id).delete()
logger.debug(LogMsg.DISCUSSION_GROUP_OLD_MEMBERS_DELETED)
return Http_response(204, True)
def get_person_accounts(person_id, db_session, username):
logger.info(LogMsg.START, username)
validate_permissions_and_access(username, db_session, 'ACCOUNT_GET',
access_level=Access_level.Premium)
logger.debug(LogMsg.SCHEMA_CHECKED)
rtn = []
try:
logger.debug(LogMsg.GETTING_PERSON_ALL_ACCOUNTS, person_id)
result = db_session.query(Account).filter(
Account.person_id == person_id).all()
for item in result:
rtn.append(account_to_dict(item))
logger.debug(LogMsg.GET_SUCCESS, rtn)
except:
logger.error(LogMsg.GET_FAILED,
{'person_id': person_id},
exc_info=True)
raise Http_error(404, Message.GET_FAILED)
logger.info(LogMsg.END)
return rtn
def delete(id, db_session, username=None):
logger.info(LogMsg.START)
order_item = get(id, db_session)
if order_item is None:
logger.error(LogMsg.NOT_FOUND, {'order_item_id': id})
raise Http_error(404, Message.NOT_FOUND)
order = get_order(order_item.order_id, db_session)
if order is None:
logger.error(LogMsg.NOT_FOUND, {'order_id': order_item.order_id})
raise Http_error(404, Message.NOT_FOUND)
if username is not None:
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_ITEM_GET', model=order_item,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
db_session.delete(order_item)
logger.debug(LogMsg.ORDER_ITEM_DELETED, id)
new_order = calc_total_price_order(order.id, db_session)
logger.debug(LogMsg.ORDER_CALC_PRICE,
order_to_dict(new_order, db_session, username))
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return Http_response(204, True)
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
logger.info(LogMsg.DELETE_REQUEST, {'group_permission_id': id})
model_instance = db_session.query(GroupPermission).filter(
GroupPermission.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'group_permission_id': id})
raise Http_error(404, Message.NOT_FOUND)
group = get_group(model_instance.group_id, db_session, username=None)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'GROUP_PERMISSION_DELETE',
model=group,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
db_session.delete(model_instance)
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(500, LogMsg.DELETE_FAILED)
logger.info(LogMsg.END)
return Http_response(204, True)
def add_payment(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, CHECKOUT_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'CHECKOUT_PAYMENT_ADD',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
model_instance = CheckoutPressAccount()
populate_basic_data(model_instance, username)
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.amount = data.get('amount')
model_instance.payer_id = data.get('payer_id')
model_instance.receiver_id = data.get('receiver_id')
model_instance.receiver_account_id = data.get('receiver_account_id')
model_instance.payment_details = data.get('payment_details')
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD, model_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'PERMISSION_EDIT',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
logger.debug(LogMsg.EDIT_REQUST, {'permission_id': id, 'data': data})
schema_validate(data, PERMISSION_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
model_instance = db_session.query(Permission).filter(
Permission.id == id).first()
if model_instance:
logger.debug(LogMsg.MODEL_GETTING)
else:
logger.debug(LogMsg.MODEL_GETTING_FAILED, {'permission_id': id})
raise Http_error(404, Message.NOT_FOUND)
try:
for key, value in data.items():
setattr(model_instance, key, value)
edit_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.MODEL_ALTERED, model_to_dict(model_instance))
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.ALREADY_EXISTS)
logger.info(LogMsg.END)
return model_instance
def checkout(order_id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data,CHECKOUT_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
preferred_account = data.get('preferred_account', 'Main')
person_id = data.get('person_id')
logger.debug(LogMsg.ORDER_CHECKOUT_REQUEST, order_id)
order = get_order(order_id, db_session)
if order is None:
logger.error(LogMsg.NOT_FOUND, {'order_id': order_id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.ORDER_EXISTS, order_id)
if order.status==OrderStatus.Invoiced:
logger.debug(LogMsg.ORDER_NOT_EDITABLE,order_id)
raise Http_error(409,Message.ORDER_INVOICED)
# CHECK PERMISSION
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_CHECKOUT',model=order)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
logger.debug(LogMsg.GETTING_ACCOUNT_PERSON, {'person_id': order.person_id})
account = get_account(order.person_id, preferred_account, db_session)
if account is None:
logger.error(LogMsg.USER_HAS_NO_ACCOUNT,
{'person_id': order.person_id, 'type': preferred_account})
raise Http_error(404, Message.USER_HAS_NO_ACCOUNT)
logger.debug(LogMsg.ORDER_CALC_PRICE,{'order_id',order_id})
order_price = recalc_order_price(order_id, db_session)
logger.debug(LogMsg.ORDER_CHECK_ACCOUNT_VALUE)
if account.value < order_price:
logger.error(LogMsg.ORDER_LOW_BALANCE,{'order_price':order_price,'account_value':account.value})
raise Http_error(402, Message.INSUFFICIANT_BALANCE)
account.value -= order_price
transaction_data = {'account_id': account.id, 'debit': order_price}
add_transaction(transaction_data, db_session)
order.status = OrderStatus.Invoiced
logger.debug(LogMsg.ORDER_INVOICED,order_id)
edit_basic_data(order,username)
order_items = get_orders_items_internal(order_id, db_session)
logger.debug(LogMsg.ORDER_GETTING_ITEMS,{'order_id':order_id})
book_list = []
for item in order_items:
book_list.append(item.book_id)
add_books_to_library(order.person_id, book_list, db_session)
data.update({'order_price': order_price})
logger.debug(LogMsg.ORDER_ITEMS_ADDED_TO_LIB)
logger.info(LogMsg.END)
return data
def delete_group_permissions(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, A_GROUP_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
group_id = data.get('group_id')
permissions = data.get('permissions')
group = get_group(group_id, db_session, username)
if group is None:
logger.error(LogMsg.NOT_FOUND, {'group_id': group_id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'GROUP_PERMISSION_DELETE',
model=group,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
result = []
for permission_id in permissions:
if not group_has_permission(permission_id, group_id, db_session):
logger.error(LogMsg.PERMISSION_NOT_HAS_GROUP, {
'permission_id': permission_id,
'group_id': group_id
})
raise Http_error(404, Message.PERMISSION_NOT_FOUND)
delete_permission_for_group(permission_id, group_id, db_session,
username)
logger.info(LogMsg.END)
return result
def get(id, db_session, username=None):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.MODEL_GETTING)
model_instance = db_session.query(GroupPermission).filter(
GroupPermission.id == id).first()
if model_instance:
logger.debug(LogMsg.GET_SUCCESS, model_to_dict(model_instance))
else:
logger.debug(LogMsg.MODEL_GETTING_FAILED)
raise Http_error(404, Message.NOT_FOUND)
if username is not None:
user = check_user(username, db_session)
per_data = {}
if user_is_in_group(user.id, model_instance.group_id, db_session):
per_data.update({Permissions.IS_MEMBER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'GROUP_PERMISSION_GET', per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
logger.info(LogMsg.END)
return group_permission_to_dict(model_instance)
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
logger.info(LogMsg.DELETE_REQUEST, {'group_id': id})
user = check_user(username, db_session)
per_data = {}
if is_admin_member(user.person_id, id, db_session):
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session, 'DISCUSSION_GROUP',
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
model_instance = db_session.query(DiscussionGroup).filter(
DiscussionGroup.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'group_id': id})
raise Http_error(404, Message.NOT_FOUND)
try:
delete_group_members(model_instance.id, db_session, username)
logger.debug(LogMsg.DISCUSSION_GROUP_OLD_MEMBERS_DELETED)
db_session.delete(model_instance)
logger.debug(LogMsg.DISCUSSION_GROUP_DELETE, id)
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(500, LogMsg.DELETE_FAILED)
logger.info(LogMsg.END)
return Http_response(204, True)
def get_all(data, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'GROUP_PERMISSION_GET',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
try:
result = GroupPermission.mongoquery(
db_session.query(GroupPermission)).query(**data).end().all()
logger.debug(LogMsg.GET_SUCCESS)
final_res = []
for item in result:
final_res.append(group_permission_to_dict(item))
except:
logger.error(LogMsg.GET_FAILED)
raise Http_error(500, LogMsg.GET_FAILED)
logger.info(LogMsg.END)
return final_res
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
logger.info(LogMsg.DELETE_REQUEST, {'group_id': id})
user = check_user(username, db_session)
model_instance = db_session.query(Group).filter(Group.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'group_id': id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'PERMISSION_GROUP_DELETE',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
logger.debug(LogMsg.DELETE_GROUP_USERS, {'group_id': id})
delete_group_users(model_instance.id, db_session)
logger.debug(LogMsg.GROUP_DELETE_PERMISSIONS, {'group_id': id})
delete_all_permissions_of_group(model_instance.id, db_session)
logger.debug(LogMsg.GROUP_DELETE, id)
db_session.delete(model_instance)
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(500, LogMsg.DELETE_FAILED)
logger.info(LogMsg.END)
return Http_response(204, True)
def search_group(data, db_session, username=None):
if username is not None:
user = check_user(username, db_session)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'PERMISSION_GROUP_GET')
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
result = []
groups = Group.mongoquery(
db_session.query(Group)).query(**data).end().all()
for group in groups:
result.append(model_to_dict(group))
if username is not None and not (user_is_in_group(
user.id, group.id, db_session)):
del result[-1]
logger.debug(LogMsg.GET_SUCCESS, result)
logger.info(LogMsg.END)
return result
def get_orders_items(order_id, db_session, username=None):
logger.info(LogMsg.START)
result = db_session.query(OrderItem).filter(
OrderItem.order_id == order_id).all()
order = get_order(order_id, db_session)
if order is None:
logger.error(LogMsg.NOT_FOUND, {'order_id': order_id})
raise Http_error(404, Message.NOT_FOUND)
if username is not None:
user = check_user(username, db_session)
per_data = {}
if order.person_id == user.person_id or (
result is not None and result[0].creator == username):
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_ITEM_GET',per_data, model=order,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
final_res = []
for item in result:
final_res.append(item_to_dict(item, db_session))
logger.debug(LogMsg.ORDERS_ITEMS, final_res)
logger.info(LogMsg.END)
return final_res
def edit_status_internal(id, status, db_session, username=None):
logger.info(LogMsg.START, username)
model_instance = internal_get(id, db_session)
logger.debug(LogMsg.ORDER_CHECK, {'order_id': id})
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'order_id': id})
raise Http_error(404, Message.NOT_FOUND)
if username is not None:
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_EDIT', model=model_instance,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
model_instance.status = status
edit_basic_data(model_instance, username)
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
def delete(id, db_session, username=None):
logger.info(LogMsg.START, username)
order = internal_get(id, db_session)
if order is None:
logger.error(LogMsg.NOT_FOUND, {'order_id': id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_DELETE', model=order,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if order.status == OrderStatus.Invoiced:
logger.error(LogMsg.ORDER_NOT_EDITABLE,
order_to_dict(order, db_session, username))
raise Http_error(403, Message.ORDER_INVOICED)
try:
logger.debug(LogMsg.ORDER_ITEMS_DELETE, {'order_id': id})
delete_orders_items_internal(order.id, db_session)
logger.debug(LogMsg.ORDER_DELETE, {'order_id': id})
db_session.delete(order)
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return Http_response(204, True)
def add(data, db_session, username=None):
logger.info(LogMsg.START, username)
# schema_validate(data,ADD_SCHEMA_PATH)
if username is not None:
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'TRANSACTION_ADD',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED)
account_id = data.get('account_id')
logger.debug(LogMsg.GETTING_ACCOUNT_BY_ID, account_id)
account = get_account(account_id, db_session)
if account is None:
logger.error(LogMsg.NOT_FOUND, {'account_id': account_id})
raise Http_error(404, Message.NOT_FOUND)
model_instance = Transaction()
populate_basic_data(model_instance, username)
model_instance.account_id = account_id
model_instance.credit = data.get('credit')
model_instance.debit = data.get('debit')
model_instance.payment_details = data.get('payment_details')
db_session.add(model_instance)
logger.debug(LogMsg.TRANSACTION_ADDED, model_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def delete_all(username, db_session):
logger.info(LogMsg.START, username)
validate_permissions_and_access(username, db_session, 'ACCOUNT_DELETE',
access_level=Access_level.Premium)
user = check_user(username, db_session)
if user.person_id is None:
logger.error(LogMsg.PERSON_NOT_EXISTS, username)
raise Http_error(404, Message.Invalid_persons)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS, username)
try:
logger.debug(LogMsg.DELETE_USER_ALL_ACCOUNTS, username)
db_session.query(Account).filter(
Account.person_id == user.person_id).delete()
except:
logger.error(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(404, Message.NOT_FOUND)
logger.info(LogMsg.END)
return Http_response(204, True)
def delete(id, db_session, username, **kwargs):
logger.info(LogMsg.START)
logger.debug(LogMsg.RATE_CHECK)
model_instance = db_session.query(Rate).filter(Rate.id == id).first()
if model_instance:
logger.debug(LogMsg.RATE_EXISTS, model_to_dict(model_instance))
else:
logger.debug(LogMsg.RATE_NOT_EXISTS, {'rate_id': id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'RATE_DELETE',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
try:
db_session.delete(model_instance)
logger.debug(LogMsg.RATE_DELETED, {'rate_id': id})
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return {}
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session, 'ACCOUNT_DELETE',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
user = check_user(username, db_session)
if user is None:
logger.error(LogMsg.INVALID_USER, username)
raise Http_error(404, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.PERSON_NOT_EXISTS, username)
raise Http_error(404, Message.Invalid_persons)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS, username)
try:
logger.debug(LogMsg.DELETE_ACCOUNT_BY_ID, id)
db_session.query(Account).filter(
and_(Account.person_id == user.person_id, Account.id == id)
).delete()
except:
logger.error(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(404, Message.NOT_FOUND)
logger.info(LogMsg.END)
return Http_response(204, True)
def delete_permissions_of_groups(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, GROUP_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
permissions = set(data.get('permissions'))
groups = set(data.get('groups'))
validate_permissions(permissions, db_session)
validate_groups(groups, db_session)
for group_id in groups:
group = get_group(group_id, db_session, username)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'GROUP_PERMISSION_DELETE',
model=group,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
for permission_id in permissions:
if not group_has_permission(permission_id, group_id, db_session):
logger.error(LogMsg.PERMISSION_NOT_HAS_GROUP, {
'permission_id': permission_id,
'group_id': group_id
})
raise Http_error(404, Message.PERMISSION_NOT_FOUND)
delete_permission_for_group(permission_id, group_id, db_session)
logger.info(LogMsg.END)
return {'result': 'successful'}
def get(id, db_session, username):
logger.info(LogMsg.START, username)
user = check_user(username, db_session)
model_instance = db_session.query(DeviceCode).filter(
DeviceCode.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'device_key': id})
raise Http_error(404, Message.NOT_FOUND)
result = model_to_dict(model_instance)
logger.debug(LogMsg.GET_SUCCESS, result)
per_data = {}
if model_instance.user_id == user.id:
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'DEVICE_KEY_GET',
per_data,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED)
logger.debug(LogMsg.PERMISSION_VERIFIED)
logger.info(LogMsg.END)
return result
def premium_permission_group(group_id, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'ASSIGN_PREMIUM_PERMISSION_GROUP',
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
permissions = permission_list(db_session, 'PREMIUM')
result = []
for permission_id in permissions:
if group_has_permission(permission_id, group_id, db_session):
logger.debug(LogMsg.PERMISSION_GROUP_ALREADY_HAS)
pass
else:
model_instance = GroupPermission()
populate_basic_data(model_instance, username)
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.group_id = group_id
model_instance.permission_id = permission_id
db_session.add(model_instance)
result.append(group_permission_to_dict(model_instance))
logger.info(LogMsg.END)
return result
def get_user_devices(user_id, db_session, username):
logger.info(LogMsg.START, username)
user = check_user(username, db_session)
logger.debug(LogMsg.PERMISSION_CHECK,
{username: Permissions.DEVICE_KEY_GET_PREMIUM})
per_data = {}
if user_id == user.id:
per_data.update({Permissions.IS_OWNER.value: True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'DEVICE_KEY_GET',
per_data,
access_level=Access_level.Premium)
logger.debug(LogMsg.PERMISSION_VERIFIED)
result = db_session.query(DeviceCode).filter(
DeviceCode.user_id == user_id).order_by(
DeviceCode.creation_date.desc()).all()
final_res = []
for item in result:
final_res.append(model_to_dict(item))
logger.debug(LogMsg.GET_SUCCESS, final_res)
logger.info(LogMsg.END)
return final_res
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.EDIT_REQUST, {'book_id': id})
model_instance = db_session.query(Book).filter(Book.id == id).first()
if model_instance is None:
logger.debug(LogMsg.NOT_FOUND, {'book_id': id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'LIBRARY_EDIT',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
logger.debug(LogMsg.EDITING_BOOK, id)
files = data.get('files', None)
images = data.get('images', None)
if files:
logger.debug(LogMsg.DELETE_BOOK_FILES, id)
delete_files(model_instance.files)
if images:
logger.debug(LogMsg.DELETE_BOOK_IMAGES)
delete_files(model_instance.images)
for key, value in data.items():
setattr(model_instance, key, value)
edit_basic_data(model_instance, username, data.get('tags'))
price = data.get('price', None)
if price is not None:
edit_price(model_instance.id, price, db_session)
logger.debug(LogMsg.MODEL_ALTERED)
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
unique_data = book_to_dict(db_session, model_instance)
del unique_data['roles']
unique_data['roles'] = data['roles']
unique_connector = get_connector(id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
logger.debug(LogMsg.GENERATE_UNIQUE_CONSTRAINT, unique_data)
code = add_uniquecode(unique_data, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
logger.debug(LogMsg.EDIT_SUCCESS, book_to_dict(db_session, model_instance))
logger.info(LogMsg.END)
return book_to_dict(db_session, model_instance)
def get(id, db_session, username=None):
logger.info(LogMsg.START, username)
result = db_session.query(Order).filter(Order.id == id).first()
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session,
'ORDER_GET', model=result)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
return order_to_dict(result, db_session, username)
def generate_book( data,db_session,username):
logger.info(LogMsg.START,username)
schema_validate(data,GENERATE_BOOK_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
content_id = data.get('content_id')
content = get_content(content_id, db_session)
if content is None:
logger.error(LogMsg.NOT_FOUND,{'book_content_id':content_id})
raise Http_error(404,Message.NOT_FOUND)
book = get_book(content.book_id,db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND,{'book_id':content.book_id})
raise Http_error(404,Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
per_data ={}
if book.creator==username:
per_data.update({Permissions.IS_OWNER.value:True})
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username, db_session, 'BOOK_CONTENT_ADD',
model=content)
logger.debug(LogMsg.PERMISSION_VERIFIED)
if content.content_generated:
logger.error(LogMsg.CONTENT_ALREADY_GENERATED)
raise Http_error(409,Message.ALREADY_EXISTS)
elif content.celery_task_id is not None:
task_status = check_status(content.celery_task_id)
status=task_status.get('inquiry_result')
if status=='SUCCESS':
book.size = content_size(content_id)
content.content_generated = True
logger.error(LogMsg.CONTENT_ALREADY_GENERATED)
db_session.commit()
raise Http_error(409,Message.ALREADY_EXISTS)
elif status=='PENDING':
logger.error(LogMsg.CONTENT_GENERATING)
raise Http_error(409, Message.IN_PROCESS)
content_data = return_content_full_path(content.content)
content_data.update({'content_id':content_id})
result = generate_book_content.apply_async(args=[content_data],
routing_key='book_generate')
content.celery_task_id=result.task_id
print(result.task_id)
# result.get()
return {'inquiry_id':result.task_id}
def add(db_session, data, username, **kwargs):
logger.debug(LogMsg.START, username)
genre = data.get('genre', [])
if genre and len(genre) > 0:
check_enums(genre, Genre)
logger.debug(LogMsg.ENUM_CHECK, {'genre': genre})
model_instance = Book()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.title = data.get('title')
model_instance.edition = data.get('edition')
model_instance.pub_year = data.get('pub_year')
model_instance.type = data.get('type')
model_instance.genre = genre
model_instance.images = data.get('images')
model_instance.files = data.get('files')
model_instance.language = data.get('language')
model_instance.rate = data.get('rate')
model_instance.description = data.get('description')
model_instance.pages = data.get('pages')
model_instance.duration = data.get('duration')
model_instance.size = data.get('size')
model_instance.isben = data.get('isben')
model_instance.description = data.get('description')
model_instance.from_editor = data.get('from_editor')
model_instance.press = data.get('press')
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'BOOK_ADD',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD)
add_connector(model_instance.id, data.get('unique_code'), db_session)
logger.debug(LogMsg.UNIQUE_CONNECTOR_ADDED, {
'book_id': model_instance.id,
'unique_constraint': data.get('unique_code')
})
price = data.get('price', None)
if price:
add_price_internal(price, model_instance.id, db_session, username)
logger.info(LogMsg.END)
return model_instance
