def delete_books_from_wish_list(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, ADD_SCHEMA_PATH) 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 add(db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, PERSON_ADD_SCHEMA_PATH) cell_no = data.get('cell_no') if cell_no and person_cell_exists(db_session, cell_no): logger.error(LogMsg.PERSON_EXISTS, {'cell_no': cell_no}) raise Http_error(409, Message.ALREADY_EXISTS) email = data.get('email') if email and person_mail_exists(db_session, email): logger.error(LogMsg.PERSON_EXISTS, {'email': email}) raise Http_error(409, Message.ALREADY_EXISTS) logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, data) model_instance = Person() populate_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.name = data.get('name') model_instance.last_name = data.get('last_name') model_instance.full_name = full_name(model_instance.name, model_instance.last_name) model_instance.address = data.get('address') model_instance.phone = data.get('phone') model_instance.email = data.get('email') model_instance.cell_no = data.get('cell_no') model_instance.bio = data.get('bio') model_instance.image = data.get('image') model_instance.is_legal = data.get('is_legal', False) db_session.add(model_instance) logger.info(LogMsg.END) return model_instance
def add(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data,ITEM_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) book_id = data.get('book_id') person_id = data.get('person_id') if person_id is None: logger.error(LogMsg.DATA_MISSING, 'person_id') if is_book_in_library(person_id, book_id, db_session): logger.error(LogMsg.ALREADY_IS_IN_LIBRARY, {'book_id': book_id}) raise Http_error(409, Message.ALREADY_EXISTS) 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) if book.type.name in ONLINE_BOOK_TYPES : if data.get('count') > 1: logger.error(LogMsg.BOOK_ONLINE_TYPE_COUNT_LIMITATION) raise Http_error(400, Message.ONLINE_BOOK_COUNT_LIMITATION) content_id = book_has_content(book_id,'Original',db_session) if not content_id: logger.error(LogMsg.CONTENT_NOT_FOUND,{'book_id':book_id}) raise Http_error(404,Message.BOOK_HAS_NO_CONTENT) if not is_generated(content_id): logger.error(LogMsg.CONTENT_NOT_GENERATED, {'content_id': content_id}) raise Http_error(404, Message.BOOK_NOT_GENERATED) model_instance = OrderItem() populate_basic_data(model_instance, username) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.order_id = data.get('order_id') model_instance.book_id = book_id model_instance.count = data.get('count') # TODO discount not imposed yet model_instance.discount = data.get('discount', 0.0) model_instance.description = data.get('description') model_instance.price_detail = data.get('price_detail') model_instance.unit_price = get_book_price_internal(model_instance.book_id, db_session) logger.debug(LogMsg.ORDER_ITEM_UNIT_PRICE, model_instance.unit_price) model_instance.net_price = calc_net_price(model_instance.unit_price, model_instance.count, model_instance.discount) logger.debug(LogMsg.ORDER_ITEM_NET_PRICE, model_instance.net_price) db_session.add(model_instance) logger.info(LogMsg.END) return model_instance
def add(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, RATING_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) user = check_user(username, db_session) rated = internal_get(user.person_id, data.get('movie_id'), db_session) if rated is not None: result = edit(rated.id, data, db_session, username) return result model_instance = Rating() populate_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.movie_id = data.get('movie_id') model_instance.person_id = user.person_id model_instance.comment = data.get('comment') model_instance.overall_rate = data.get('overall_rate') model_instance.novel = data.get('novel') model_instance.character = data.get('character') model_instance.reason = data.get('reason') model_instance.directing = data.get('directing') model_instance.true_vision_of_enemy = data.get('true_vision_of_enemy') model_instance.iranian_life_style = data.get('iranian_life_style') model_instance.hope = data.get('hope') model_instance.bright_future_exposure = data.get('bright_future_exposure') model_instance.theism = data.get('theism') model_instance.justice_seeking = data.get('justice_seeking') model_instance.feminism_exposure = data.get('feminism_exposure') model_instance.individual_social_behavior = data.get('individual_social_behavior') model_instance.family_subject = data.get('family_subject') model_instance.alcoholic_promotion = data.get('alcoholic_promotion') model_instance.gambling_promotion = data.get('gambling_promotion') model_instance.breaking_law_encouragement = data.get('breaking_law_encouragement') model_instance.suicide_encouragement = data.get('suicide_encouragement') model_instance.horror_content = data.get('horror_content') model_instance.addiction_promotion = data.get('addiction_promotion') model_instance.unsuitable_wearing = data.get('unsuitable_wearing') model_instance.sexual_content = data.get('sexual_content') model_instance.insulting_range = data.get('insulting_range') model_instance.violence_range = data.get('violence_range') model_instance.music = data.get('music') model_instance.sound = data.get('sound') model_instance.visualization = data.get('visualization') model_instance.editing = data.get('editing') model_instance.acting = data.get('acting') model_instance.true_historiography = data.get('true_historiography') model_instance.question_1 = data.get('question_1') model_instance.question_2 = data.get('question_2') model_instance.question_3 = data.get('question_3') model_instance.question_4 = data.get('question_4') model_instance.question_5 = data.get('question_5') model_instance.question_6 = data.get('question_6') model_instance.question_7 = data.get('question_7') model_instance.question_8 = data.get('question_8') model_instance.question_9 = data.get('question_9') model_instance.question_10 = data.get('question_10') db_session.add(model_instance) logger.debug(LogMsg.DB_ADD) return model_instance
def delete_permissions_of_groups(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, GROUP_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) permissions = set(data.get('permissions')) groups = set(data.get('groups')) validate_permissions(permissions, db_session) validate_groups(groups, db_session) for group_id in groups: group = get_group(group_id, db_session, username) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'GROUP_PERMISSION_DELETE', model=group, access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) for permission_id in permissions: if not group_has_permission(permission_id, group_id, db_session): logger.error(LogMsg.PERMISSION_NOT_HAS_GROUP, { 'permission_id': permission_id, 'group_id': group_id }) raise Http_error(404, Message.PERMISSION_NOT_FOUND) delete_permission_for_group(permission_id, group_id, db_session) logger.info(LogMsg.END) return {'result': 'successful'}
def add_permissions_to_groups(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, GROUP_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) permissions = set(data.get('permissions')) groups = set(data.get('groups')) validate_permissions(permissions, db_session) validate_groups(groups, db_session) final_res = {} for group_id in groups: result = [] for permission_id in permissions: if group_has_permission(permission_id, group_id, db_session): logger.error(LogMsg.PERMISSION_GROUP_ALREADY_HAS, { 'permission_id': permission_id, 'group_id': group_id }) raise Http_error(409, Message.ALREADY_EXISTS) result.append( group_permission_to_dict( add(permission_id, group_id, db_session, username))) final_res.update({group_id: result}) logger.info(LogMsg.END) return final_res
def edit(id, db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, USER_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) old_pass = data.get('old_password', None) if old_pass is not None: user = check_user(username, db_session) if user.password != old_pass: logger.error(LogMsg.INVALID_USER, {'old_password': '******'}) raise Http_error(403, Message.INVALID_PASSWORD) logger.debug(LogMsg.EDIT_REQUST, {'user_id': id, 'data': data}) model_instance = check_by_id(id, db_session) if model_instance: logger.debug(LogMsg.MODEL_GETTING, {'user_id': id}) else: logger.debug(LogMsg.NOT_FOUND, {'user_id': id}) raise Http_error(404, Message.NOT_FOUND) if model_instance.username == username: password = data.get('old_password') if model_instance.password != password: logger.error(LogMsg.INVALID_USER, {'password': '******'}) raise Http_error(403, Message.INVALID_PASSWORD) for key, value in data.items(): setattr(model_instance, key, value) edit_basic_data(model_instance, username, data.get('tags')) user_dict = user_to_dict(model_instance) logger.debug(LogMsg.EDIT_SUCCESS, user_dict) logger.info(LogMsg.END) return user_dict
def delete_group_permissions(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, A_GROUP_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) group_id = data.get('group_id') permissions = data.get('permissions') group = get_group(group_id, db_session, username) if group is None: logger.error(LogMsg.NOT_FOUND, {'group_id': group_id}) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'GROUP_PERMISSION_DELETE', model=group, access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) result = [] for permission_id in permissions: if not group_has_permission(permission_id, group_id, db_session): logger.error(LogMsg.PERMISSION_NOT_HAS_GROUP, { 'permission_id': permission_id, 'group_id': group_id }) raise Http_error(404, Message.PERMISSION_NOT_FOUND) delete_permission_for_group(permission_id, group_id, db_session, username) logger.info(LogMsg.END) return result
def checkout(order_id, data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data,CHECKOUT_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) preferred_account = data.get('preferred_account', 'Main') person_id = data.get('person_id') logger.debug(LogMsg.ORDER_CHECKOUT_REQUEST, order_id) order = get_order(order_id, db_session) if order is None: logger.error(LogMsg.NOT_FOUND, {'order_id': order_id}) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.ORDER_EXISTS, order_id) if order.status==OrderStatus.Invoiced: logger.debug(LogMsg.ORDER_NOT_EDITABLE,order_id) raise Http_error(409,Message.ORDER_INVOICED) # CHECK PERMISSION logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'ORDER_CHECKOUT',model=order) logger.debug(LogMsg.PERMISSION_VERIFIED, username) logger.debug(LogMsg.GETTING_ACCOUNT_PERSON, {'person_id': order.person_id}) account = get_account(order.person_id, preferred_account, db_session) if account is None: logger.error(LogMsg.USER_HAS_NO_ACCOUNT, {'person_id': order.person_id, 'type': preferred_account}) raise Http_error(404, Message.USER_HAS_NO_ACCOUNT) logger.debug(LogMsg.ORDER_CALC_PRICE,{'order_id',order_id}) order_price = recalc_order_price(order_id, db_session) logger.debug(LogMsg.ORDER_CHECK_ACCOUNT_VALUE) if account.value < order_price: logger.error(LogMsg.ORDER_LOW_BALANCE,{'order_price':order_price,'account_value':account.value}) raise Http_error(402, Message.INSUFFICIANT_BALANCE) account.value -= order_price transaction_data = {'account_id': account.id, 'debit': order_price} add_transaction(transaction_data, db_session) order.status = OrderStatus.Invoiced logger.debug(LogMsg.ORDER_INVOICED,order_id) edit_basic_data(order,username) order_items = get_orders_items_internal(order_id, db_session) logger.debug(LogMsg.ORDER_GETTING_ITEMS,{'order_id':order_id}) book_list = [] for item in order_items: book_list.append(item.book_id) add_books_to_library(order.person_id, book_list, db_session) data.update({'order_price': order_price}) logger.debug(LogMsg.ORDER_ITEMS_ADDED_TO_LIB) logger.info(LogMsg.END) return data
def add(db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, ADD_SCHEMA_PATH) logger.debug(LogMsg.CHECKING_VALID_TOKEN, username) current_token = get_current_token(db_session, username) if current_token is not None and \ current_token.expiration_date > (Now()): logger.debug(LogMsg.USER_HAS_VALID_TOKEN, current_token.id) return current_token model_instance = APP_Token() model_instance.id = str(uuid4()) model_instance.username = username model_instance.expiration_date = Now() + int(token_expiration_interval) logger.debug(LogMsg.DATA_ADDITION, data) db_session.add(model_instance) logger.debug(LogMsg.TOKEN_CREATED) logger.info(LogMsg.END) return model_instance
def add(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, GROUP_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) user = check_user(username, db_session) if user is None: logger.error(LogMsg.INVALID_USER, username) model_instance = DiscussionGroup() populate_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.title = data.get('title') model_instance.description = data.get('description') model_instance.image = data.get('image') model_instance.status = 'Created' db_session.add(model_instance) result = model_to_dict(model_instance) logger.debug(LogMsg.DISCUSSION_GROUP_ADD, result) members = data.get('members', []) if members is not None: members.append({'person_id': user.person_id, 'type': 'Admin'}) member_data = {'group_id': model_instance.id, 'members': members} discuss_members = add_disscussuion_members(member_data, db_session, username) logger.debug(LogMsg.DISCUSSION_GROUP_MEMBERS_ADDED, members) result['members'] = discuss_members logger.info(LogMsg.END) return result
def add_payment(data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, CHECKOUT_ADD_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'CHECKOUT_PAYMENT_ADD', access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) model_instance = CheckoutPressAccount() populate_basic_data(model_instance, username) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.amount = data.get('amount') model_instance.payer_id = data.get('payer_id') model_instance.receiver_id = data.get('receiver_id') model_instance.receiver_account_id = data.get('receiver_account_id') model_instance.payment_details = data.get('payment_details') db_session.add(model_instance) logger.debug(LogMsg.DB_ADD, model_to_dict(model_instance)) logger.info(LogMsg.END) return model_instance
def edit(id, db_session, data, username): logger.info(LogMsg.START, username) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'PERMISSION_EDIT', access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) logger.debug(LogMsg.EDIT_REQUST, {'permission_id': id, 'data': data}) schema_validate(data, PERMISSION_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) model_instance = db_session.query(Permission).filter( Permission.id == id).first() if model_instance: logger.debug(LogMsg.MODEL_GETTING) else: logger.debug(LogMsg.MODEL_GETTING_FAILED, {'permission_id': id}) raise Http_error(404, Message.NOT_FOUND) try: for key, value in data.items(): setattr(model_instance, key, value) edit_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.MODEL_ALTERED, model_to_dict(model_instance)) except: logger.exception(LogMsg.EDIT_FAILED, exc_info=True) raise Http_error(409, Message.ALREADY_EXISTS) logger.info(LogMsg.END) return model_instance
def add(db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, ROLE_ADD_SCHEMA_PATH) logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, data) unique_code = add_uniquecode(data, db_session) model_instance = BookRole() logger.debug(LogMsg.POPULATING_BASIC_DATA) populate_basic_data(model_instance, username, data.get('tags')) model_instance.person_id = data.get('person_id') model_instance.book_id = data.get('book_id') model_instance.role = data.get('role') logger.debug(LogMsg.DATA_ADDITION, book_role_to_dict(model_instance)) db_session.add(model_instance) logger.debug(LogMsg.DB_ADD) add_connector(model_instance.id, unique_code.UniqueCode, db_session) logger.debug( LogMsg.UNIQUE_CONNECTOR_ADDED, { 'book_role_id': model_instance.id, 'unique_constraint': unique_code.UniqueCode }) logger.info(LogMsg.END) return model_instance
def reset_pass(data, db_session): logger.info(LogMsg.START, data) schema_validate(data, RESET_PASS_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) cell_no = data.get('cell_no') redis_key = 'PASS_{}'.format(cell_no) code = redis.get(redis_key) if code is None: logger.error(LogMsg.REGISTER_KEY_DOESNT_EXIST) raise Http_error(404, Message.INVALID_CODE) code = code.decode("utf-8") if (code is None) or (code != data.get('code')): logger.error(LogMsg.REGISTER_KEY_INVALID) raise Http_error(409, Message.INVALID_CODE) user = check_by_cell_no(cell_no, db_session) if user: user.password = data.get('password') logger.debug(LogMsg.USER_PASSWORD_RESET, user_to_dict(user)) logger.info(LogMsg.END) return data logger.error(LogMsg.NOT_FOUND, data) raise Http_error(404, Message.INVALID_USER)
def edit(id, data, db_session, username): logger.info(LogMsg.START, username) schema_validate(data, MEMBER_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) group_member = get_model(id, db_session) if group_member is None: logger.error(LogMsg.NOT_FOUND, {'discussion_group_member': id}) raise Http_error(404, Message.NOT_FOUND) user = check_user(username, db_session) per_data = {} if is_admin_member(user.person_id, group_member.group_id, db_session): per_data.update({Permissions.IS_OWNER.value: True}) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'DISCUSSION_MEMBER', per_data) logger.debug(LogMsg.PERMISSION_VERIFIED, username) for key, value in data.items(): setattr(group_member, key, value) edit_basic_data(group_member, username, data.get('tags')) logger.debug(LogMsg.DISCUSSION_GROUP_OLD_MEMBERS_DELETED) return discussion_member_to_dict(group_member)
def edit(id, data, db_session, username): logger.info(LogMsg.START) permission_data = {} schema_validate(data, EDIT_SCHEMA_PATH) user = check_user(username, db_session) logger.debug(LogMsg.RATE_CHECK, {'rate_id': id}) model_instance = db_session.query(Rate).filter( Rate.id == id, Rate.person_id == user.person_id).first() if model_instance: logger.debug(LogMsg.RATE_EXISTS, model_to_dict(model_instance)) else: logger.error(LogMsg.RATE_NOT_EXISTS, {'rate_id': id}) raise Http_error(404, Message.NOT_FOUND) model_instance.rate = data.get('rate') edit_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.RATE_CHANGED, model_to_dict(model_instance)) logger.info(LogMsg.END) return model_instance
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 register(data, db_session): logger.info(LogMsg.START, data) schema_validate(data, REGISTER_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) cell_no = data.get('cell_no') logger.debug(LogMsg.CHECK_USER_EXISTANCE) if check_by_cell_no(cell_no, db_session): logger.error(LogMsg.USER_XISTS) raise Http_error(409, Message.USER_ALREADY_EXISTS) logger.debug(LogMsg.CHECK_REDIS_FOR_EXISTANCE) cell_data = redis.get(cell_no) if cell_data: logger.error(LogMsg.REGISTER_XISTS) activation_code = (json.loads(cell_data.decode('utf-8'))).get( 'activation_code', None) if activation_code: logger.error(LogMsg.USER_HAS_ACTIVATION_CODE) raise Http_error(403, { 'msg': Message.ALREADY_HAS_VALID_KEY, 'time': redis.ttl(cell_no) }) else: logger.error(LogMsg.USER_HAS_SIGNUP_TOKEN) redis.delete(cell_no) logger.debug(LogMsg.GENERATING_REGISTERY_CODE, cell_no) password = str(random.randint(1000, 9999)) data = { 'receptor': cell_no, 'token': password, 'type': 'sms', 'template': 'ratingregister' } logger.debug(LogMsg.SEND_CODE_BY_SMS.format(cell_no)) sent_data = send_message(data) redis.set(cell_no, json.dumps({'activation_code': password}), ex=valid_registering_intervall) result = { 'msg': Message.MESSAGE_SENT, 'cell_no': cell_no, 'time': redis.ttl(cell_no) } logger.debug(LogMsg.SMS_SENT, result) logger.info(LogMsg.END) return result
def generate_book( data,db_session,username): logger.info(LogMsg.START,username) schema_validate(data,GENERATE_BOOK_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) content_id = data.get('content_id') content = get_content(content_id, db_session) if content is None: logger.error(LogMsg.NOT_FOUND,{'book_content_id':content_id}) raise Http_error(404,Message.NOT_FOUND) book = get_book(content.book_id,db_session) if book is None: logger.error(LogMsg.NOT_FOUND,{'book_id':content.book_id}) raise Http_error(404,Message.NOT_FOUND) logger.debug(LogMsg.PERMISSION_CHECK, username) per_data ={} if book.creator==username: per_data.update({Permissions.IS_OWNER.value:True}) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'BOOK_CONTENT_ADD', model=content) logger.debug(LogMsg.PERMISSION_VERIFIED) if content.content_generated: logger.error(LogMsg.CONTENT_ALREADY_GENERATED) raise Http_error(409,Message.ALREADY_EXISTS) elif content.celery_task_id is not None: task_status = check_status(content.celery_task_id) status=task_status.get('inquiry_result') if status=='SUCCESS': book.size = content_size(content_id) content.content_generated = True logger.error(LogMsg.CONTENT_ALREADY_GENERATED) db_session.commit() raise Http_error(409,Message.ALREADY_EXISTS) elif status=='PENDING': logger.error(LogMsg.CONTENT_GENERATING) raise Http_error(409, Message.IN_PROCESS) content_data = return_content_full_path(content.content) content_data.update({'content_id':content_id}) result = generate_book_content.apply_async(args=[content_data], routing_key='book_generate') content.celery_task_id=result.task_id print(result.task_id) # result.get() return {'inquiry_id':result.task_id}
def signup(data, db_session, *args, **kwargs): logger.info(LogMsg.START, data) schema_validate(data, SIGN_UP_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) cell_no = data.get('cell_no') logger.debug(LogMsg.SIGNUP_GETTING_TOKEN_FROM_REDIS, cell_no) signup_token = redis.get(cell_no) if signup_token is None: logger.error(LogMsg.SIGNUP_TOKEN_NOT_IN_REDIS, cell_no) raise Http_error(404, Message.SIGNUP_TOKEN_NOT_EXISTS) signup_token = json.loads(signup_token.decode("utf-8")).get( 'signup_token', None) if (signup_token is None) or (signup_token != data.get('signup_token')): logger.error( LogMsg.SIGNUP_TOKEN_INVALID, { 'redis_signup_token': signup_token, 'data_token': data.get('signup_token') }) raise Http_error(404, Message.INVALID_SIGNUP_TOKEN) user_data = { k: v for k, v in data.items() if k in ['username', 'password'] } person_data = {k: v for k, v in data.items() if k not in user_data.keys()} del person_data['signup_token'] logger.debug(LogMsg.PERSON_GENERATING, person_data) person = add_person(db_session, person_data, SIGNUP_USER) if user_data: user_data.update({'person_id': person.id}) logger.debug(LogMsg.USER_GENERATING, user_data) user = add_user(db_session, user_data, SIGNUP_USER) full_name = '{} {}'.format(data.get('last_name', ''), data.get('name', '')) user_welcoming_data = { 'receptor': cell_no, 'token': full_name, 'type': 'sms', 'template': 'fajrwelcoming' } send_message(user_welcoming_data) logger.debug(LogMsg.SMS_SENT, user_welcoming_data) result = {'user': user_to_dict(user), 'person': model_to_dict(person)} logger.debug(LogMsg.SIGNUP_SUCCESS, result) logger.info(LogMsg.END) return result
def edit(id, db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, USER_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) old_pass = data.get('old_password', None) if old_pass is not None: user = check_user(username, db_session) if user.password != old_pass: logger.error(LogMsg.INVALID_USER, {'old_password': '******'}) raise Http_error(403, Message.INVALID_PASSWORD) logger.debug(LogMsg.EDIT_REQUST, {'user_id': id, 'data': data}) model_instance = check_by_id(id, db_session) if model_instance: logger.debug(LogMsg.MODEL_GETTING, {'user_id': id}) else: logger.debug(LogMsg.NOT_FOUND, {'user_id': id}) raise Http_error(404, Message.NOT_FOUND) per_data = {} permissions, presses = get_user_permissions(username, db_session) if model_instance.username == username: password = data.get('old_password') if model_instance.password != password: logger.error(LogMsg.INVALID_USER, {'password': '******'}) raise Http_error(403, Message.INVALID_PASSWORD) per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.USER_EDIT_PREMIUM], permissions, None, per_data) logger.debug(LogMsg.PERMISSION_VERIFIED) if not has_permission_or_not([Permissions.USER_EDIT_PREMIUM], permissions): if "person_id" in data: del data["person_id"] # if "person_id" in data: # user_by_person = db_session.query(User).filter( # User.person_id == data.get('person_id')).first() # if user_by_person is not None and user_by_person.id != model_instance.id: # raise Http_error(409,Message.USER_ALREADY_EXISTS) 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')) user_dict = user_to_dict(model_instance) logger.debug(LogMsg.EDIT_SUCCESS, user_dict) logger.info(LogMsg.END) return user_dict
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 edit(id, db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data, GROUP_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) logger.debug(LogMsg.EDIT_REQUST, {'discuss_group_id': id, 'data': data}) user = check_user(username, db_session) per_data = {} if is_admin_member(user.person_id, id, db_session): per_data.update({Permissions.IS_OWNER.value: True}) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'DISCUSSION_GROUP', per_data) logger.debug(LogMsg.PERMISSION_VERIFIED, username) model_instance = db_session.query(DiscussionGroup).filter( DiscussionGroup.id == id).first() if model_instance: logger.debug(LogMsg.MODEL_GETTING) else: logger.debug(LogMsg.MODEL_GETTING_FAILED, {'discussion_group_id': id}) raise Http_error(404, Message.NOT_FOUND) try: 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')) if 'members' in data: members = data.get('members', []) members.append({'person_id': user.person_id, 'type': 'Admin'}) delete_group_members(model_instance.id, db_session, username) logger.debug(LogMsg.DISCUSSION_GROUP_OLD_MEMBERS_DELETED) member_data = {'group_id': model_instance.id, 'members': members} add_disscussuion_members(member_data, db_session, username) logger.debug(LogMsg.DISCUSSION_GROUP_MEMBERS_ADDED, members) result = discuss_group_to_dict(model_instance, db_session) logger.debug(LogMsg.MODEL_ALTERED, result) except: logger.exception(LogMsg.EDIT_FAILED, exc_info=True) raise Http_error(500, Message.EDIT_FAILED) 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 add(db_session, data, username): logger.info(LogMsg.START, username) schema_validate(data,PERSON_ADD_SCHEMA_PATH) if username is not None and username != SIGNUP_USER: permissions, presses = get_user_permissions(username, db_session) has_permission([Permissions.PERSON_ADD_PREMIUM], permissions) logger.debug(LogMsg.PERMISSION_VERIFIED) cell_no = data.get('cell_no') if cell_no and person_cell_exists(db_session, cell_no): logger.error(LogMsg.PERSON_EXISTS, {'cell_no': cell_no}) raise Http_error(409, Message.ALREADY_EXISTS) email = data.get('email') if email and person_mail_exists(db_session, email): logger.error(LogMsg.PERSON_EXISTS, {'email': email}) raise Http_error(409, Message.ALREADY_EXISTS) logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, data) model_instance = Person() populate_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.name = data.get('name') model_instance.last_name = data.get('last_name') model_instance.full_name = full_name(model_instance.name,model_instance.last_name) model_instance.address = data.get('address') model_instance.phone = data.get('phone') model_instance.email = data.get('email') model_instance.cell_no = data.get('cell_no') model_instance.bio = data.get('bio') model_instance.image = data.get('image') model_instance.is_legal = data.get('is_legal', False) unique_code = add_uniquecode(model_instance, db_session) db_session.add(model_instance) db_session.flush() logger.debug(LogMsg.DB_ADD) add_initial_account(model_instance.id, db_session, username) logger.debug(LogMsg.PERSON_ADD_ACCOUNT, {'person_id': model_instance.id}) add_connector(model_instance.id, unique_code.UniqueCode, db_session) logger.debug(LogMsg.UNIQUE_CONNECTOR_ADDED, {'person_id': model_instance.id, 'unique_constraint': unique_code.UniqueCode}) logger.info(LogMsg.END) return model_instance
def edit(id, data, db_session, username=None): logger.info(LogMsg.START, username) schema_validate(data, ORDER_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) model_instance = internal_get(id, db_session) logger.debug(LogMsg.ORDER_CHECK, {'order_id': id}) if model_instance is None: logger.error(LogMsg.NOT_FOUND, {'order_id': id}) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'ORDER_EDIT', model=model_instance, access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) if model_instance.status == OrderStatus.Invoiced: logger.error(LogMsg.ORDER_NOT_EDITABLE, {'order_id': id}) raise Http_error(403, Message.ORDER_INVOICED) 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) for key, value in data.items(): setattr(model_instance, key, value) if 'items' in data: item_data = {} item_data['items'] = data.get('items') if 'person_id' in data: item_data['person_id'] = data.get('person_id') else: item_data['person_id'] = user.person_id logger.debug(LogMsg.ORDER_ITEMS_DELETE, {'order_id': id}) delete_orders_items_internal(model_instance.id, db_session) logger.debug(LogMsg.ORDER_ADD_ITEMS, {'order_id': id}) model_instance.total_price = add_orders_items(model_instance.id , item_data, db_session, username) edit_basic_data(model_instance, username) order_dict = order_to_dict(model_instance, db_session, username) logger.debug(LogMsg.MODEL_ALTERED, order_dict) logger.info(LogMsg.END) return order_dict
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 edit(id, db_session, data, username): logger.info(LogMsg.START, username) user = check_user(username, db_session) logger.debug(LogMsg.EDIT_REQUST, {'group_id': id, 'data': data}) schema_validate(data, GROUP_EDIT_SCHEMA_PATH) logger.debug(LogMsg.SCHEMA_CHECKED) model_instance = db_session.query(Group).filter(Group.id == id).first() if model_instance: logger.debug(LogMsg.MODEL_GETTING) else: logger.debug(LogMsg.MODEL_GETTING_FAILED, {'group_id': id}) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'PERMISSION_GROUP_EDIT', model=model_instance) logger.debug(LogMsg.PERMISSION_VERIFIED, username) person_id = data.get('person_id', None) if person_id is not None: owner_person = get_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) try: for key, value in data.items(): setattr(model_instance, key, value) edit_basic_data(model_instance, username, data.get('tags')) logger.debug(LogMsg.MODEL_ALTERED, model_to_dict(model_instance)) except: logger.exception(LogMsg.EDIT_FAILED, exc_info=True) raise Http_error(409, Message.ALREADY_EXISTS) logger.info(LogMsg.END) return model_instance
def upload_files(data, **kwargs): schema_validate(data, UPLOAD_SCHEMA_PATH) try: files_list = data.get('files') model_files = [] if files_list and len(files_list) > 0: for file in files_list: if file: file.filename = str(uuid4()) model_files.append(file.filename) file.save(save_path) return model_files except: logger.exception(LogMsg.UPLOAD_FAILED, exc_info=True) raise Http_error(405, Message.UPLOAD_FAILED)