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)
