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 get_all(data, db_session, username, **kwargs):
logger.info(LogMsg.START, username)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
permissions, presses = get_user_permissions(username, db_session)
has_permission_or_not([Permissions.COMMENT_GET_PREMIUM], permissions)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
res = Comment.mongoquery(
db_session.query(Comment)).query(**data).end().all()
result = []
for item in res:
comment = comment_to_dict(db_session, item, username)
book = get_book(item.book_id, db_session)
comment['book'] = book
result.append(comment)
except:
logger.exception(LogMsg.GET_FAILED, exc_info=True)
raise Http_error(404, Message.NOT_FOUND)
logger.info(LogMsg.END)
return result
def get_wish_list(data, db_session, username):
logger.info(LogMsg.START)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
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)
result = []
if data['filter'] is None:
data.update({'filter': {'person_id': user.person_id}})
else:
data['filter'].update({'person_id': user.person_id})
book_ids = WishList.mongoquery(
db_session.query(WishList)).query(**data).end().all()
for item in book_ids:
logger.debug(LogMsg.BOOK_CHECKING_IF_EXISTS, item)
book = get_book(item.book_id, db_session)
result.append(book)
logger.debug(LogMsg.WISH_GET, result)
logger.info(LogMsg.END)
return result
def add(db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, COMMENT_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
book_id = data.get('book_id')
logger.debug(LogMsg.COMMENT_VALIDATING_BOOK, book_id)
book = get_book(book_id, db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': book_id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.CHECK_USER_EXISTANCE, username)
user = check_user(username, db_session)
if user is None:
logger.error(LogMsg.INVALID_USER, username)
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)
logger.debug(LogMsg.COMMENT_CHECK_FOR_PARENT)
parent_id = data.get('parent_id', None)
if parent_id:
logger.debug(LogMsg.COMMENT_GETTING_PARENT, parent_id)
parent_comment = get_comment(parent_id, db_session)
if parent_comment is None:
logger.error(LogMsg.COMMENT_PARENT_NOT_FOUND, parent_id)
raise Http_error(404, Message.PARENT_NOT_FOUND)
if parent_comment.book_id != book_id:
logger.error(
LogMsg.COMMENT_PARENT_NOT_MATCH, {
'book_id': book_id,
'parent': comment_to_dict(db_session, parent_comment)
})
raise Http_error(400, Message.ACCESS_DENIED)
model_instance = Comment()
logger.debug(LogMsg.POPULATING_BASIC_DATA)
populate_basic_data(model_instance, username, data.get('tags'))
model_instance.person_id = user.person_id
model_instance.book_id = book_id
model_instance.body = data.get('body')
model_instance.parent_id = data.get('parent_id')
logger.debug(LogMsg.DATA_ADDITION)
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD)
logger.info(LogMsg.END)
return comment_to_dict(db_session, model_instance, username)
def add(db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, ADD_SCHEMA_PATH)
user = check_user(username, db_session)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(400, Message.Invalid_persons)
book_id = data.get('book_id')
book = get_book(book_id, db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': book_id})
raise Http_error(400, Message.NOT_FOUND)
logger.debug(LogMsg.RATE_CHECK, {
'book_id': book_id,
'person_id': user.person_id
})
rate = get(book_id, user.person_id, db_session)
if rate:
logger.debug(LogMsg.RATE_EXISTS, {
'book_id': book_id,
'person_id': user.person_id,
'rate': rate.rate
})
rate.rate = data.get('rate')
logger.debug(LogMsg.RATE_CHANGED, {
'book_id': book_id,
'person_id': user.person_id,
'rate': rate.rate
})
return rate
else:
logger.debug(LogMsg.RATE_IS_NEW, {
'book_id': book_id,
'person_id': user.person_id
})
model_instance = Rate()
populate_basic_data(model_instance, username, data.get('tags'))
model_instance.person_id = user.person_id
model_instance.rate = data.get('rate')
model_instance.book_id = book_id
db_session.add(model_instance)
logger.debug(LogMsg.RATE_ADDED)
logger.info(LogMsg.END)
return model_instance
def internal_wish_list(db_session, person_id):
logger.info(LogMsg.START, person_id)
result = []
book_ids = db_session.query(WishList).filter(
WishList.person_id == person_id).all()
for item in book_ids:
logger.debug(LogMsg.BOOK_CHECKING_IF_EXISTS, item)
book = get_book(item.book_id, db_session)
result.append(book)
logger.debug(LogMsg.WISH_GET, result)
logger.info(LogMsg.END)
return result
def add(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, ADD_SCHEMA_PATH)
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, username)
book_ids = data.get('books')
for item in book_ids:
logger.debug(LogMsg.BOOK_CHECKING_IF_EXISTS, {'id': item})
book = get_book(item, db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': item})
raise Http_error(400, Message.NOT_FOUND)
logger.debug(LogMsg.WISH_CHECK_IF_IN_LIST, {
'person_id': user.person_id,
'book_id': item
})
wish = get(item, user.person_id, db_session)
if wish is not None:
logger.error(LogMsg.WISH_ALREADY_EXISTS, {
'person_id': user.person_id,
'book_id': item
})
raise Http_error(409, Message.ALREADY_EXISTS)
model_instance = WishList()
populate_basic_data(model_instance, username, data.get('tags'))
model_instance.person_id = user.person_id
model_instance.book_id = item
logger.debug(LogMsg.WISH_ADD, {
'person_id': user.person_id,
'book_id': item
})
db_session.add(model_instance)
logger.info(LogMsg.END)
return data
def get_all_collections(data, db_session, username):
logger.info(LogMsg.START, username)
if data.get('sort') is None:
data['sort'] = ['title+']
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)
if data.get('filter') is None:
data.update({'filter': {'person_id': user.person_id}})
else:
data['filter'].update({'person_id': user.person_id})
logger.debug(LogMsg.QUERY_OBJECT, data)
collection_items = Collection.mongoquery(
db_session.query(Collection)).query(**data).end().all()
collections, titles = arrange_collections(collection_items)
logger.debug(LogMsg.COLLECTION_ARRANGE_BY_TITLE)
result = []
for title, book_ids in collections.items():
books = []
for item in book_ids:
if item is None:
pass
else:
book = get_book(item, db_session)
books.append(book)
result.append({'title': title, 'books': books})
return result
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)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': book_id})
raise Http_error(404, Message.NOT_FOUND)
press = book.get('press', None)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'COMMENT_DELETE',
model=book)
logger.debug(LogMsg.PERMISSION_VERIFIED)
# 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 get_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)
if 'person_id' in data.keys() and username in ADMINISTRATORS:
person_id = data.get('person_id')
else:
person_id = user.person_id
collection_items = db_session.query(Collection).filter(
and_(Collection.person_id == person_id,
Collection.title == title)).order_by(
Collection.creation_date.desc()).all()
result = []
for item in collection_items:
if item.book_id is None:
book = {}
else:
book = get_book(item.book_id, db_session)
result.append(book)
logger.info(LogMsg.END)
return result