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