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 get_personal_library(data, db_session, username):
logger.info(LogMsg.START, username)
#
# logger.debug(LogMsg.PERMISSION_CHECK, username)
# validate_permissions_and_access(username, db_session, 'LIBRARY_DELETE',{Permissions.IS_OWNER.value: True})
# logger.debug(LogMsg.PERMISSION_VERIFIED)
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)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
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.LIBRARY_GET_PERSON_LIBRARY, username)
result = Library.mongoquery(
db_session.query(Library)).query(**data).end().all()
logger.info(LogMsg.END)
return lib_to_dictlist(result, db_session)
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_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 get_follower_list(data, username, db_session):
logger.info(LogMsg.START, username)
result = []
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('sort') is None:
data['sort'] = ['creation_date-']
if data.get('filter') is None:
data.update({'filter': {'following_id': user.person_id}})
else:
data['filter'].update({'following_id': user.person_id})
res = Follow.mongoquery(db_session.query(Follow)).query(**data).end().all()
for item in res:
result.append(follow_to_dict(item))
logger.debug(LogMsg.FOLLOWER_LIST, result)
logger.info(LogMsg.END)
return result
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(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_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 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 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 get_by_id(id, db_session, username):
logger.info(LogMsg.START, username)
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.GETTING_ACCOUNT_BY_ID, id)
result = db_session.query(Account).filter(
and_(Account.person_id == user.person_id, Account.id == id)).first()
if result is None:
logger.debug(LogMsg.ACCOUNT_BY_ID_IS_NOT_FOR_PERSON,
{'account_id': id, 'person_id': user.person_id})
except:
logger.error(LogMsg.GET_FAILED, exc_info=True)
raise Http_error(404, Message.NOT_FOUND)
logger.info(LogMsg.END)
return account_to_dict(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(data, db_session, username):
logger.debug(LogMsg.START, username)
permissions, presses = get_user_permissions(username, db_session)
has_permission([Permissions.ACCOUNT_ADD_PREMIUM], permissions)
check_schema(['person_id', 'type'], data.keys())
logger.debug(LogMsg.SCHEMA_CHECKED)
check_enum(data.get('type'), AccountTypes)
logger.debug(LogMsg.ENUM_CHECK, {
'enum': data.get('type'),
'reference_enum': 'AccountTypes'
})
user = check_user(username, db_session)
logger.debug(LogMsg.USER_CHECKING, username)
if user is None:
logger.error(LogMsg.INVALID_USER, username)
raise Http_error(404, Message.INVALID_USER)
logger.info(LogMsg.USER_XISTS, username)
if user.person_id is None:
logger.info(LogMsg.PERSON_NOT_EXISTS, username)
raise Http_error(404, Message.Invalid_persons)
validate_person(user.person_id, db_session)
logger.info(LogMsg.PERSON_EXISTS, username)
type = data.get('type', 'Main')
value = data.get('value', 0.0)
person_id = data.get('person_id')
logger.info(LogMsg.GETTING_USER_ACCOUNTS, type)
account = get(person_id, type, db_session)
if account is not None:
logger.error(LogMsg.ACCOUNT_BY_TYPE_EXISTS, type)
raise Http_error(409, Message.ALREADY_EXISTS)
model_instance = Account()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.type = type
model_instance.person_id = person_id
model_instance.value = value
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD, account_to_dict(model_instance))
logger.info(LogMsg.END)
return account_to_dict(model_instance)
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 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 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 add(db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
following_id = data.get('following_id')
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)
validate_person(following_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
if following_id == user.person_id:
logger.error(LogMsg.FOLLOW_SELF_DENIED)
raise Http_error(400, Message.FOLLOW_DENIED)
logger.debug(LogMsg.FOLLOW_CHECK, data)
follow = get(user.person_id, following_id, db_session)
if follow is not None:
logger.error(LogMsg.FOLLOW_EXISTS, data)
raise Http_error(409, Message.ALREADY_FOLLOWS)
model_instance = Follow()
model_instance.id = str(uuid4())
model_instance.creation_date = Now()
model_instance.creator = username
model_instance.version = 1
model_instance.tags = data.get('tags')
model_instance.following_id = following_id
model_instance.follower_id = user.person_id
db_session.add(model_instance)
logger.debug(LogMsg.FOLLOW_ADD, follow_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def delete(id, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.MODEL_GETTING, {'comment_action_id': id})
action = db_session.query(CommentAction).filter(
CommentAction.id == id).first()
if action is None:
logger.debug(LogMsg.NOT_FOUND)
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON)
raise Http_error(400, Message.INVALID_USER)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
logger.debug(LogMsg.PERMISSION_CHECK, username)
permission_data = {}
if action.person_id == user.person_id:
permission_data = {Permissions.IS_OWNER.value: True}
permissions, presses = get_user_permissions(username, db_session)
has_permission([
Permissions.COMMENT_ACTION_DELETE_PREMIUM,
Permissions.COMMENT_ACTION_DELETE_PRESS
], permissions, None, permission_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if action.person_id != user.person_id:
logger.error(LogMsg.NOT_ACCESSED, username)
raise Http_error(403, Message.ACCESS_DENIED)
try:
db_session.delete(action)
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 get_user_accounts(username, db_session, data):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.PERMISSION_CHECK,username)
validate_permissions_and_access(username, db_session, 'ACCOUNT_GET')
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)
if data.get('sort') is None:
data['sort'] = ['creation_date-']
if data.get('filter') is None:
data.update({'filter': {'person_id': user.person_id}})
else:
data['filter'].update({'person_id': user.person_id})
try:
result = Account.mongoquery(
db_session.query(Account)).query(
**data).end().all()
final_res = []
for account in result:
final_res.append(account_to_dict(account))
logger.debug(LogMsg.GET_SUCCESS, final_res)
except:
logger.error(LogMsg.GET_FAILED,
exc_info=True)
raise Http_error(404, Message.GET_FAILED)
logger.info(LogMsg.END)
return final_res
def report(db_session, comment_id, data, 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)
logger.debug(LogMsg.ACTION_CHECK_USER_REPORTED, comment_id)
action = get_action_report(comment_id, user.person_id, db_session)
if action is not None:
logger.error(LogMsg.ACTION_ALREADY_REPORTED, comment_id)
raise Http_error(409, Message.ALREADY_REPORTED)
report = data.get('report', None)
if report:
logger.debug(LogMsg.ENUM_CHECK, {'report': report})
check_enum(report, ReportComment)
model_instance = CommentAction()
populate_basic_data(model_instance, username, None)
model_instance.comment_id = comment_id
model_instance.person_id = user.person_id
model_instance.report = report
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD)
logger.info(LogMsg.END)
return model_instance
def add(db_session, data, 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)
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 edit_status(id, data, db_session, username):
logger.info(LogMsg.START, username)
permissions, presses = get_user_permissions(username, db_session)
has_permission([Permissions.LIBRARY_GET_PREMIUM], permissions, None,
{Permissions.IS_OWNER.value: True})
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)
status = data.get('status', {})
model_instance = db_session.query(Library).filter(Library.id == id).first()
if status.get('reading_started'):
model_instance.status['reading_started'] = status.get(
'reading_started')
if status.get('read_pages'):
model_instance.status['read_pages'] = status.get('read_pages')
if status.get('read_duration'):
model_instance.status['read_duration'] = status.get('read_duration')
if status.get('status'):
model_instance.status['status'] = status.get('status')
if status.get('is_read'):
model_instance.status['is_read'] = status.get('is_read')
if 'progress' in data:
model_instance.progress = data.get('progress')
edit_basic_data(model_instance, username)
logger.debug(LogMsg.MODEL_ALTERED, data)
logger.info(LogMsg.END)
return lib_to_dict(model_instance, db_session)
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 add(db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, ACTION_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
report = data.get('report', None)
if report:
logger.debug(LogMsg.ENUM_CHECK, {'report_comment': report})
check_enum(report, ReportComment)
comment_id = data.get('comment_id')
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)
logger.debug(LogMsg.CHECK_USER_EXISTANCE)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
model_instance = CommentAction()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.comment_id = comment_id
model_instance.person_id = user.person_id
model_instance.like = data.get('like')
model_instance.report = report
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD)
logger.info(LogMsg.END)
return model_instance
def like(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)
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)
logger.debug(LogMsg.ACTION_CHECK_USER_LIKED, comment_id)
action = get_action_like(comment_id, user.person_id, db_session)
if action is not None:
logger.error(LogMsg.ACTION_ALREADY_LIKED)
raise Http_error(409, Message.ALREADY_LIKED)
logger.debug(LogMsg.ACTION_LIKE_COMMENT, comment_id)
model_instance = CommentAction()
populate_basic_data(model_instance, username, None)
model_instance.comment_id = comment_id
model_instance.person_id = user.person_id
model_instance.like = True
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD)
logger.info(LogMsg.END)
return model_instance
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
def add(data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, GROUP_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
person_id = data.get('person_id', None)
if person_id is not None:
owner_person = validate_person(person_id, db_session)
if owner_person is not None and not owner_person.is_legal:
logger.error(LogMsg.PERSON_IS_NOT_LEGAL, username)
raise Http_error(400, Message.PERSON_IS_NOT_LEGAL)
owner_user = get_by_person(person_id, db_session)
if owner_user is None:
logger.error(LogMsg.PERSON_MUST_HAVE_USER, person_id)
raise Http_error(404, Message.PERSON_MUST_HAVE_USER)
user = check_user(username, db_session)
if username not in ADMINISTRATORS:
permissions, presses = get_user_permissions(username, db_session)
permit = has_permission_or_not(
[Permissions.PERMISSION_GROUP_ADD_PREMIUM], permissions)
if not permit:
press_permit = has_permission_or_not(
[Permissions.PERMISSION_GROUP_ADD_PRESS], permissions)
if not (press_permit and (person_id == user.person_id)):
logger.error(LogMsg.PERMISSION_DENIED,
{'PERMISSION_GROUP_ADD': username})
raise Http_error(403, Message.ACCESS_DENIED)
if check_group_title_exists(data.get('title', None), db_session):
logger.error(LogMsg.GROUP_EXISTS)
raise Http_error(409, Message.ALREADY_EXISTS)
model_instance = Group()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.title = data.get('title')
model_instance.person_id = data.get('person_id')
db_session.add(model_instance)
# db_session.flush()
add_owner_to_group_users(model_instance.id, owner_user.id, db_session,
username)
logger.info(LogMsg.END)
return model_instance
def add(data, db_session, username):
logger.debug(LogMsg.START, username)
schema_validate(data, ADD_SCHEMA_PATH)
validate_permissions_and_access(username, db_session, 'ACCOUNT_ADD',
access_level=Access_level.Premium)
logger.debug(LogMsg.SCHEMA_CHECKED)
check_enum(data.get('type'), AccountTypes)
logger.debug(LogMsg.ENUM_CHECK,
{'enum': data.get('type'), 'reference_enum': 'AccountTypes'})
logger.debug(LogMsg.USER_CHECKING, username)
type = data.get('type', 'Main')
value = data.get('value', 0.0)
person_id = data.get('person_id')
person = validate_person(person_id, db_session)
if person is None:
logger.error(LogMsg.NOT_FOUND, {'person_id': person_id})
raise Http_error(404, Message.Invalid_persons)
logger.info(LogMsg.GETTING_USER_ACCOUNTS, type)
account = get(person_id, type, db_session)
if account is not None:
logger.error(LogMsg.ACCOUNT_BY_TYPE_EXISTS, type)
raise Http_error(409, Message.ALREADY_EXISTS)
model_instance = Account()
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
model_instance.type = type
model_instance.person_id = person_id
model_instance.value = value
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD, account_to_dict(model_instance))
logger.info(LogMsg.END)
return account_to_dict(model_instance)
def add(db_session, data, username):
logger.info(LogMsg.START)
schema_validate(data, USER_ADD_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
new_username = data.get('username')
# adder = check_user(username,db_session)
user = check_by_username(new_username, db_session)
if user:
logger.error(LogMsg.USER_XISTS, new_username)
raise Http_error(409, Message.USERNAME_EXISTS)
logger.debug(LogMsg.USR_ADDING)
model_instance = User()
model_instance.username = new_username
model_instance.password = data.get('password')
populate_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.POPULATING_BASIC_DATA)
person_id = data.get('person_id')
if person_id:
person_is_valid = validate_person(person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS, {'person_id': person_id})
if person_is_valid:
if person_is_valid.is_legal:
person_user = get_by_person(person_id, db_session)
if person_user is not None:
logger.error(LogMsg.LEGAL_PERSON_USER_RESTRICTION)
raise Http_error(409, Message.LEGAL_PERSON_USER_RESTRICTION)
model_instance.person_id = person_id
else:
logger.error(LogMsg.INVALID_USER, {'person_id': person_id})
raise Http_error(404, Message.INVALID_USER)
db_session.add(model_instance)
logger.debug(LogMsg.DB_ADD, model_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def forget_pass(data, db_session):
logger.info(LogMsg.START, data)
schema_validate(data, FORGET_PASS_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
reset_password_interval = value('reset_password_interval', 120)
username = data.get('username')
cell_no = data.get('cell_no')
user = None
if username:
user = check_by_username(username, db_session)
elif cell_no:
user = check_by_cell_no(cell_no, db_session)
else:
logger.error(LogMsg.INVALID_USER, data)
raise Http_error(400, Message.USERNAME_CELLNO_REQUIRED)
if user:
person = validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS, username)
password = str(random.randint(1000, 9999))
sending_data = {
'receptor': person.cell_no,
'token': user.username,
'token2': password,
'type': 'sms',
'template': 'fajrresetPassword'
}
send_message(sending_data)
logger.debug(LogMsg.SMS_SENT, sending_data)
redis_key = 'PASS_{}'.format(person.cell_no)
redis.set(redis_key, password, ex=reset_password_interval)
logger.debug(LogMsg.REDIS_SET, redis_key)
logger.info(LogMsg.END)
return data
logger.error(LogMsg.INVALID_USER, data)
raise Http_error(404, Message.INVALID_USER)
