def delete(id, db_session, username=None): logger.info(LogMsg.START, username) price = get_by_id(id, db_session) if price is None: logger.error(LogMsg.NOT_FOUND, {'book_price_id': id}) raise Http_error(404, Message.NOT_FOUND) book = get_book(price.book_id, db_session) if username is not None: per_data = {} permissions, presses = get_user_permissions(username, db_session) if book.creator == username: per_data.update({Permissions.IS_OWNER.value: True}) has_permit = has_permission_or_not([Permissions.PRICE_DELETE_PREMIUM], permissions, None, per_data) if not has_permit: if book.press in presses: has_permission([Permissions.PRICE_DELETE_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED, username) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED) try: db_session.delete(price) logger.debug(LogMsg.DELETE_SUCCESS, {'book_price_id': id}) 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_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 delete(id, db_session, username): logger.info(LogMsg.START, username) permissions, presses = get_user_permissions(username, db_session) has_permission([Permissions.ACCOUNT_DELETE_PREMIUM], permissions) 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_books_from_wish_list(data, db_session, username): logger.info(LogMsg.START, username) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS, username) book_ids = data.get('books') logger.debug(LogMsg.WISH_DELETE, book_ids) try: for id in book_ids: db_session.query(WishList).filter( and_(WishList.person_id == user.person_id, WishList.book_id == id)).delete() logger.debug(LogMsg.WISH_DELETE, id) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(502, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def delete_wish_list(db_session, username): logger.info(LogMsg.START, username) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS, username) try: logger.debug(LogMsg.WISH_DELETE_ALL, username) db_session.query(WishList).filter( WishList.person_id == user.person_id).delete() logger.debug(LogMsg.DELETE_SUCCESS, {'username': username}) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(502, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
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 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: user = check_user(username, db_session) per_data = {} permissions, presses = get_user_permissions(username, db_session) if order_item.creator == username or order.person_id == user.person_id: per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.ORDER_ITEM_GET_PREMIUM], permissions, None, per_data) logger.debug(LogMsg.PERMISSION_VERIFIED) 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) 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) 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) logger.debug(LogMsg.PERMISSION_CHECK, username) permission_data = {} if content.creator == username: permission_data = {Permissions.IS_OWNER.value: True} permissions, presses = get_user_permissions(username, db_session) has_permit = has_permission_or_not([Permissions.BOOK_DELETE_PREMIUM], permissions, None, permission_data) if not has_permit: if content.book_press in presses: has_permission([Permissions.BOOK_DELETE_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED, username) try: db_session.delete(content) 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) 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(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_DELETE', per_data, access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED) try: db_session.delete(model_instance) logger.debug(LogMsg.DELETE_SUCCESS, {'device_key_id': id}) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(500, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def delete(id, db_session, username): logger.info(LogMsg.START, username) user = check_user(username, db_session) logger.info(LogMsg.DELETE_REQUEST, {'group_user_id': id}) model_instance = db_session.query(GroupUser).filter( GroupUser.id == id).first() if model_instance is None: logger.error(LogMsg.NOT_FOUND, {'group_user_id': id}) raise Http_error(404, Message.NOT_FOUND) permissions, presses = get_user_permissions(username, db_session) permit = has_permission_or_not( [Permissions.PERMISSION_GROUP_USER_DELETE_PREMIUM], permissions) if not permit: press_permit = has_permission_or_not( [Permissions.PERMISSION_GROUP_USER_DELETE_PRESS], permissions) if not (press_permit and (model_instance.group.person_id == user.person_id)): logger.error(LogMsg.PERMISSION_DENIED, {'PERMISSION_GROUP_USER_DELETE': username}) raise Http_error(403, Message.ACCESS_DENIED) 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 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 = {} permissions, presses = get_user_permissions(username, db_session) if is_admin_member(user.person_id, id, db_session): per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.DISCUSSION_GROUP_PREMIUM], permissions, None, 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 delete(id, db_session, username): logger.info(LogMsg.START, username) logger.info(LogMsg.DELETE_REQUEST, id) logger.debug(LogMsg.MODEL_GETTING, id) model_instance = db_session.query(BookRole).filter( BookRole.id == id).first() if model_instance is None: logger.error(LogMsg.NOT_FOUND, id) raise Http_error(404, Message.NOT_FOUND) try: db_session.delete(model_instance) unique_connector = get_connector(id, db_session) if unique_connector: logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT) delete_uniquecode(unique_connector.UniqueCode, db_session) delete_connector(id, db_session) logger.debug(LogMsg.ENTITY_DELETED, id) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(500, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def dislike(db_session, comment_id, username): logger.info(LogMsg.START, username) logger.debug(LogMsg.ACTION_CHECK_COMMENT, comment_id) comment = get_comment(comment_id, db_session) if comment is None: logger.error(LogMsg.NOT_FOUND, {'comment_id': comment_id}) raise Http_error(404, Message.NOT_FOUND) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS) action = get_action_like(comment_id, user.person_id, db_session) if action is None: logger.error(LogMsg.ACTION_USER_CANT_DISLIKE) raise Http_error(404, Message.COMMENT_NOT_FOUND) if action.person_id != user.person_id: logger.error(LogMsg.NOT_ACCESSED, username) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.ACTION_DISLIKE_COMMENT, comment_id) delete(action.id, db_session, username) logger.info(LogMsg.END) return Http_response(204, True)
def delete_collection(data, db_session, username): title = data.get('title') logger.info(LogMsg.START, username) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS) try: if not collection_exists(title, user.person_id, db_session): logger.error(LogMsg.NOT_FOUND, { 'collection_title': title, 'person_id': user.person_id }) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.COLLECTION_DELETE, title) result = delete_collection_constraints(title, user.person_id, db_session) stmt = Collection.__table__.delete().where(Collection.id.in_(result)) db_session.execute(stmt) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(502, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def delete_comments(book_id, db_session, username, **kwargs): logger.info(LogMsg.START, username) logger.debug(LogMsg.COMMENT_DELETING_BOOK_COMMENTS, book_id) book = get_book(book_id, db_session) press = book.get('press', None) permissions, presses = get_user_permissions(username, db_session) has_permit = has_permission_or_not([Permissions.COMMENT_DELETE_PREMIUM], permissions) if not has_permit: if press in presses: has_permission([Permissions.COMMENT_DELETE_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED, username) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED, username) delete_book_comments(book_id, db_session) 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 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(self, id, db_session, username, permission_checked=False): logger.info(LogMsg.START, username) logger.info(LogMsg.DELETE_REQUEST, {'person_id': id}) # TODO library def change try: # TODO accounts delete_person_accounts(id, db_session) super(PersonController, self).delete(id, db_session, username, permission_checked) user_repository = UserRepository.generate(User, db_session, username) users = user_repository.get_all_by_person(id) if users is not None: for user in users: db_session.delete(user) except Exception as e: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(500, Message.DELETE_FAILED) 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 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): logger.info(LogMsg.START, username) logger.info(LogMsg.DELETE_REQUEST, {'group_id': id}) if username not in ADMINISTRATORS: logger.error(LogMsg.NOT_ACCESSED, {'username': username}) raise Http_error(403, Message.ACCESS_DENIED) 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) 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 delete(id, db_session, username): logger.info(LogMsg.START, username) logger.info(LogMsg.DELETING_BOOK, id) logger.debug(LogMsg.MODEL_GETTING, id) book = db_session.query(Book).filter(Book.id == id).first() if book is None: logger.error(LogMsg.NOT_FOUND, {'book_id': id}) raise Http_error(404, Message.NOT_FOUND) if book.images: logger.debug(LogMsg.DELETE_BOOK_IMAGES) delete_files(book.images) if book.files: logger.debug(LogMsg.DELETE_BOOK_FILES) delete_files(book.files) db_session.query(Book).filter(Book.id == id).delete() logger.debug(LogMsg.ENTITY_DELETED, {"Book.id": id}) unique_connector = get_connector(id, db_session) if unique_connector: logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT) delete_uniquecode(unique_connector.UniqueCode, db_session) delete_connector(id, db_session) logger.info(LogMsg.END) return Http_response(204, True)
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) permissions, presses = get_user_permissions(username, db_session) per_data = {} if order.creator == username: per_data.update({Permissions.IS_OWNER.value:True}) has_permission( [Permissions.ORDER_DELETE_PREMIUM], permissions,None,per_data) logger.debug(LogMsg.PERMISSION_VERIFIED) 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 delete_orders_items_internal(order_id, db_session): logger.info(LogMsg.START) try: logger.debug(LogMsg.ORDER_ITEMS_DELETE, {'order_id': order_id}) db_session.query(OrderItem).filter( OrderItem.order_id == order_id).delete() except: logger.exception(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): logger.info(LogMsg.START, username) logger.info(LogMsg.DELETE_REQUEST, {'person_id': id}) model_instance = db_session.query(Person).filter(Person.id == id).first() if model_instance is None: logger.error(LogMsg.NOT_FOUND, {'person_id': id}) raise Http_error(404, Message.NOT_FOUND) user = check_user(username, db_session) per_data = {} permissions, presses = get_user_permissions(username, db_session) if user.person_id == id: per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.PERSON_DELETE_PREMIUM], permissions, None, per_data) logger.debug(LogMsg.PERMISSION_VERIFIED) if person_has_books(id, db_session): logger.error(LogMsg.PERSON_HAS_BOOKS, {'person_id': id}) raise Http_error(403, Message.PERSON_HAS_BOOKS) try: delete_person_accounts(id, db_session) logger.debug(LogMsg.PERSON_ACCOUNTS_DELETED, {'person_id': id}) db_session.delete(model_instance) logger.debug(LogMsg.PERSON_DELETED, {'person_id': id}) users = db_session.query(User).filter(User.person_id == id).all() logger.debug(LogMsg.PERSON_USERS_GOT, id) if users is not None: for user in users: logger.debug(LogMsg.RELATED_USER_DELETE, {'person_id': id, 'user_id': user.id}) db_session.delete(user) logger.debug(LogMsg.ENTITY_DELETED) else: logger.debug(LogMsg.NOT_RELATED_USER_FOR_PERSON, {"Person.id {}": id}) unique_connector = get_connector(id, db_session) if unique_connector: logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT) delete_uniquecode(unique_connector.UniqueCode, db_session) delete_connector(id, db_session) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(500, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def delete(self, id, db_session, username=None, permission_checked=False): logger.info(LogMsg.START, username) try: super(ReceiptController, self).delete(id, db_session, username, permission_checked) except Exception as e: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(500, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def delete_book_comments(book_id,db_session): try: comments = db_session.query(Comment).filter(Comment.book_id == book_id).all() if comments is not None: for item in comments: logger.debug(LogMsg.COMMENT_DELETE_ACTIONS, item.id) delete_comment_actions_internal(db_session, item.id) db_session.delete(item) except: raise Http_error(404,Message.NOT_FOUND) return Http_response(204,True)
def delete_books_from_collection(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['title', 'book_ids'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS) book_ids = data.get('book_ids') ids = [] try: logger.debug(LogMsg.COLLECTION_DELETE_BOOK, { 'title': data.get('title'), 'books': book_ids }) result = db_session.query(Collection).filter( and_(Collection.person_id == user.person_id, Collection.title == data.get('title'), Collection.book_id.in_(book_ids))).all() for item in result: ids.append(item.id) unique_connector = get_connector(item.id, db_session) if unique_connector: logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT) delete_connector(item.id, db_session) new_connector = get_connector_by_unique( unique_connector.UniqueCode, db_session) if new_connector is None: delete_uniquecode(unique_connector.UniqueCode, db_session) stmt = Collection.__table__.delete().where(Collection.id.in_(ids)) db_session.execute(stmt) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(502, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)