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 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 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 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 rename_collection(data, db_session, username):
logger.info(LogMsg.START, username)
check_schema(['title', 'new_title'], data.keys())
logger.debug(LogMsg.SCHEMA_CHECKED)
person_id = data.get('person_id')
if person_id is None:
user = check_user(username, db_session)
person_id = user.person_id
if person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(401, Message.INVALID_USER)
validate_person(person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
new_title = data.get('new_title')
# db_session.update(Collection).Where(Collection.title == title,
# Collection.person_id == person_id).values(
# title=new_title)
result = db_session.query(Collection).filter(
Collection.title == data.get('title'),
Collection.person_id == person_id).all()
final_res = []
for item in result:
item.title = new_title
unique_connector = get_connector(item.id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
delete_connector(item.id, db_session)
db_session.flush()
model_dict = collection_to_dict(db_session, item)
logger.debug(LogMsg.MODEL_ALTERED, model_dict)
print(model_dict)
logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, model_dict)
unique_code = unique_code_exists(model_dict, db_session)
if unique_code is None:
logger.debug(LogMsg.UNIQUE_NOT_EXISTS)
unique_code = add_uniquecode(model_dict, db_session)
db_session.flush()
add_connector(item.id, unique_code.UniqueCode, db_session)
logger.debug(LogMsg.UNIQUE_CONNECTOR_ADDED, {
'collection_id': item.id,
'unique_constraint': unique_code.UniqueCode
})
final_res.append(model_dict)
return final_res
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)
def delete_collection_constraints(title, person_id, db_session):
result = db_session.query(Collection).filter(
Collection.title == title, Collection.person_id == person_id).all()
ids = []
for item in result:
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)
ids.append(item.id)
return ids
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
if "id" in data.keys():
del data["id"]
logger.debug(LogMsg.EDIT_REQUST, id)
logger.debug(LogMsg.MODEL_GETTING, id)
model_instance = db_session.query(BookRole).filter(
BookRole.id == id).first()
if model_instance:
logger.debug(LogMsg.GET_SUCCESS, book_role_to_dict(model_instance))
else:
logger.debug(LogMsg.GET_FAILED, id)
raise Http_error(404, Message.NOT_FOUND)
for key, value in data.items():
# TODO if key is valid attribute of class
setattr(model_instance, key, value)
logger.debug(LogMsg.EDITING_BASIC_DATA, id)
edit_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.MODEL_ALTERED, id)
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
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, data)
code = add_uniquecode(data, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
logger.debug(LogMsg.EDIT_SUCCESS, book_role_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def delete_by_id(id, db_session, username):
logger.info(LogMsg.START, username)
try:
logger.debug(LogMsg.DELETE_REQUEST, {'collection_id': id})
db_session.query(Collection).filter(Collection.id == id).delete()
unique_connector = get_connector(id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_connector(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)
db_session.flush()
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)
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)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'LIBRARY_DELETE',
model=book)
logger.debug(LogMsg.PERMISSION_VERIFIED)
if book.images is not None:
logger.debug(LogMsg.DELETE_BOOK_IMAGES)
delete_files(book.images)
if book.files is not None:
logger.debug(LogMsg.DELETE_BOOK_FILES)
delete_files(book.files)
try:
db_session.query(Book).filter(Book.id == id).delete()
logger.debug(LogMsg.ENTITY_DELETED, {"Book.id": id})
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(403, Message.USED_SOMEWHERE)
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_book_roles(book_id, db_session):
logger.info(LogMsg.START)
logger.debug(LogMsg.DELETE_BOOK_ROLES, book_id)
try:
roles = db_session.query(BookRole).filter(
BookRole.book_id == book_id).all()
for role in roles:
unique_connector = get_connector(role.id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
delete_connector(role.id, db_session)
db_session.delete(role)
logger.debug(LogMsg.DELETE_SUCCESS)
except:
logger.exception(LogMsg.DELETE_FAILED, exc_info=True)
raise Http_error(500, Message.DELETE_FAILED)
logger.debug(LogMsg.END)
return Http_response(204, True)
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
if "id" in data.keys():
del data["id"]
logger.debug(LogMsg.EDIT_REQUST)
logger.debug(LogMsg.MODEL_GETTING, {'book_id': id})
model_instance = db_session.query(Book).filter(Book.id == id).first()
if model_instance:
logger.debug(LogMsg.GET_SUCCESS)
else:
logger.debug(LogMsg.NOT_FOUND, {'book_id': id})
raise Http_error(404, Message.NOT_FOUND)
# permission_data = {}
# if model_instance.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_EDIT_PREMIUM],
# permissions, None, permission_data)
# if not has_permit and model_instance.press in presses:
# has_permission([Permissions.BOOK_EDIT_PRESS], permissions)
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():
# TODO if key is valid attribute of class
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 edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data,PERSON_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
logger.debug(LogMsg.EDIT_REQUST, {'person_id': id, 'data': data})
user = check_user(username, db_session)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(404, Message.INVALID_USER)
model_instance = db_session.query(Person).filter(Person.id == id).first()
if model_instance:
logger.debug(LogMsg.MODEL_GETTING)
else:
logger.debug(LogMsg.MODEL_GETTING_FAILED, {'person_id': id})
raise Http_error(404, Message.NOT_FOUND)
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_EDIT_PREMIUM],
permissions, None, per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED)
if 'current_book_id' in data.keys():
if not is_book_in_library(model_instance.id, data.get('current_book_id'),
db_session):
logger.error(LogMsg.COLLECTION_BOOK_IS_NOT_IN_LIBRARY,
{'current_book_id': data.get('current_book_id')})
raise Http_error(404, Message.BOOK_NOT_IN_LIB)
if 'cell_no' in data.keys():
cell_person = person_cell_exists(db_session, data.get('cell_no'))
if cell_person is not None:
if cell_person.id != model_instance.id:
logger.error(LogMsg.ANOTHER_PERSON_BY_CELL)
raise Http_error(403, Message.CELL_EXISTS)
try:
for key, value in data.items():
# TODO if key is valid attribute of class
setattr(model_instance, key, value)
model_instance.full_name = full_name(model_instance.name,model_instance.last_name)
edit_basic_data(model_instance, username, data.get('tags'))
db_session.flush()
logger.debug(LogMsg.MODEL_ALTERED,
person_to_dict(model_instance, db_session))
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
unique_connector = get_connector(id, db_session)
if unique_connector:
if persons_code(model_instance) != unique_connector.UniqueCode:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
db_session.flush()
logger.debug(LogMsg.GENERATE_UNIQUE_CONSTRAINT, data)
code = add_uniquecode(model_instance, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(500, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
# TODO: you never checked version of passed data, we have version field in our
# records, to prevent conflict when we received two different edit request
# concurrently. check KAVEH codes (edit functions) to better understanding
# version field usage
logger.debug(LogMsg.EDIT_REQUST, {'person_id': id, 'data': data})
if "id" in data.keys():
del data["id"]
user = check_user(username,db_session)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON,username)
raise Http_error(404,Message.INVALID_USER)
model_instance = db_session.query(Person).filter(Person.id == id).first()
if model_instance:
logger.debug(LogMsg.MODEL_GETTING)
else:
logger.debug(LogMsg.MODEL_GETTING_FAILED, {'person_id': id})
raise Http_error(404, Message.NOT_FOUND)
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_EDIT_PREMIUM],
permissions, None, per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED)
if 'current_book' in data.keys():
if not is_book_in_library(model_instance.id, data.get('current_book'),
db_session):
logger.error(LogMsg.COLLECTION_BOOK_IS_NOT_IN_LIBRARY,
{'current_book_id': data.get('current_book')})
raise Http_error(404, Message.BOOK_NOT_IN_LIB)
if 'cell_no' in data.keys():
cell_person = person_cell_exists(db_session,data.get('cell_no'))
if cell_person is not None:
if cell_person.id !=model_instance.id:
logger.error(LogMsg.ANOTHER_PERSON_BY_CELL)
raise Http_error(403,Message.CELL_EXISTS)
try:
for key, value in data.items():
# TODO if key is valid attribute of class
setattr(model_instance, key, value)
model_instance.full_name ='{} {}'.format(model_instance.last_name or '',model_instance.name or '')
edit_basic_data(model_instance, username, data.get('tags'))
db_session.flush()
logger.debug(LogMsg.MODEL_ALTERED,
person_to_dict(model_instance, db_session))
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
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, data)
db_session.flush()
code = add_uniquecode(data, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
except:
logger.exception(LogMsg.EDIT_FAILED,exc_info=True)
raise Http_error(403,Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
