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)