def add(data, username, db_session): logging.info(Msg.START) required_data = ['action', 'target', 'entity_name', 'entity_id'] check_schema(required_data, data.keys()) logging.debug(Msg.SCHEMA_CHECKED) model_instance = Event() model_instance.creator = username model_instance.id = str(uuid4()) model_instance.creation_date = Now() model_instance.target = data.get('target') model_instance.action = data.get('action') model_instance.entity_id = data.get('entity_id') model_instance.entity_name = data.get('entity_name') model_instance.seen = False logging.debug(Msg.DATA_ADDITION + " || Data :" + json.dumps(data)) db_session.add(model_instance) logging.debug(Msg.DB_ADD) logging.info(Msg.END) return model_instance
def get_new_events(db_session, data, username): logging.info(Msg.START) required = ['scroll'] check_schema(required, data.keys()) if data.get('time') is None: data['time'] = Now() if data.get('count_number') is None: data['count_number'] = 50 logging.debug(Msg.GET_ALL_REQUEST + 'new unread Events...') if data.get('scroll') == 'down': result = db_session.query(Event).filter( and_(Event.target == username, Event.seen == False)).filter( Event.creation_date < data.get('time')).order_by( Event.creation_date.desc()).limit( data.get('count_number')).all() else: result = db_session.query(Event).filter( and_(Event.target == username, Event.seen == False)).filter( Event.creation_date > data.get('time')).order_by( Event.creation_date.desc()).limit( data.get('count_number')).all() logging.debug(Msg.GET_SUCCESS) logging.info(Msg.END) return result
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 signup(data, db_session, *args, **kwargs): logger.info(LogMsg.START, data) check_schema(['cell_no', 'signup_token', 'username', 'password'], data.keys()) 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()} 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': 'welcoming' } 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 add(db_session, data, username): logger.info(LogMsg.START, username) check_schema(['book_id', 'type', 'content'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) book_id = data.get('book_id') type = data.get('type') logger.debug(LogMsg.ENUM_CHECK, {'BOOK_CONTENT_TYpe': type}) check_enum(type, BookContentType) book = get_book(book_id, db_session) if not book: logger.error(LogMsg.NOT_FOUND, {'book_id': book_id}) raise Http_error(404, Message.NOT_FOUND) logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, data) content = get_be_data(book_id, type, db_session) if content is not None: logger.error(LogMsg.CONTENT_EXIST, data) raise Http_error(409, Message.ALREADY_EXISTS) logger.debug(LogMsg.PERMISSION_CHECK, username) permissions, presses = get_user_permissions(username, db_session) has_permit = has_permission_or_not([Permissions.BOOK_ADD_PREMIUM], permissions) if not has_permit: if book.press in presses: has_permission([Permissions.BOOK_ADD_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED, username) model_instance = BookContent() logger.debug(LogMsg.POPULATING_BASIC_DATA) populate_basic_data(model_instance, username, data.get('tags')) model_instance.content = data.get('content') model_instance.book_id = book_id model_instance.type = type model_instance.book_press = book.press db_session.add(model_instance) logger.info(LogMsg.END) return model_instance
def calc_price(data, db_session, username): logger.info(LogMsg.START, username) item_prices = [] total_price = 0.000 check_schema(['items'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) items = data.get('items') for item in items: book_id = item.get('book_id') count = item.get('count', 0) discount = item.get('discount', None) price_object = get_book_price_internal(book_id, db_session) if price_object is None: logger.error(LogMsg.PRICE_NOT_FOUND, {'book_id': book_id}) raise Http_error(404, Message.NO_PRICE_FOUND) book = get_book(book_id, db_session) if (book.type.name in ONLINE_BOOK_TYPES) and (count > 1): logger.error(LogMsg.BOOK_ONLINE_TYPE_COUNT_LIMITATION) raise Http_error(400, Message.ONLINE_BOOK_COUNT_LIMITATION) price = price_object * count net_price = price if discount: if isinstance(discount, float) and discount < 1: effect = 1.000 - discount net_price = price * effect else: logger.error(LogMsg.INVALID_ENTITY_TYPE, {'discount': discount}) raise Http_error(400, Message.DISCOUNT_IS_FLOAT) item_info = { 'book_id': book_id, 'unit_price': price_object, 'count': count, 'discount': discount, 'net_price': net_price } logger.debug(LogMsg.PRICE_ITEM_CALC, item_info) item_prices.append(item_info) total_price += net_price final_res = {'items': item_prices, 'total_price': total_price} logger.debug(LogMsg.PRICE_ALL_CALCED, final_res) logger.info(LogMsg.END) return final_res
def delete_books_from_collection(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['title', 'book_ids'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) user = check_user(username, db_session) if user is None: raise Http_error(400, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(400, Message.Invalid_persons) validate_person(user.person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS) book_ids = data.get('book_ids') ids = [] try: logger.debug(LogMsg.COLLECTION_DELETE_BOOK, { 'title': data.get('title'), 'books': book_ids }) result = db_session.query(Collection).filter( and_(Collection.person_id == user.person_id, Collection.title == data.get('title'), Collection.book_id.in_(book_ids))).all() for item in result: ids.append(item.id) unique_connector = get_connector(item.id, db_session) if unique_connector: logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT) delete_connector(item.id, db_session) new_connector = get_connector_by_unique( unique_connector.UniqueCode, db_session) if new_connector is None: delete_uniquecode(unique_connector.UniqueCode, db_session) stmt = Collection.__table__.delete().where(Collection.id.in_(ids)) db_session.execute(stmt) except: logger.exception(LogMsg.DELETE_FAILED, exc_info=True) raise Http_error(502, Message.DELETE_FAILED) logger.info(LogMsg.END) return Http_response(204, True)
def 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) check_schema(['book_id', 'count', 'order_id', 'person_id'], data.keys()) 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 and data.get('count') > 1: logger.error(LogMsg.BOOK_ONLINE_TYPE_COUNT_LIMITATION) raise Http_error(400, Message.ONLINE_BOOK_COUNT_LIMITATION) 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 get_messages_by_recipient(db_session, username, data): logging.info(Msg.START) required = ['recipient', 'scroll'] check_schema(required, data.keys()) recipient = data.get('recipient') if data.get('time') is None: data['time'] = Now() if data.get('count_number') is None: data['count_number'] = 50 logging.debug(Msg.GET_ALL_REQUEST + 'DirectMessages...') if data.get('scroll') == 'down': result = db_session.query(DirectMessage).filter( and_(DirectMessage.sender.in_((username, recipient)), DirectMessage.reciever.in_((username, recipient)))).filter( DirectMessage.creation_date < data.get('time')).order_by( DirectMessage.creation_date.desc()).limit( data.get('count_number')).all() else: result = db_session.query(DirectMessage).filter( and_(DirectMessage.sender.in_((username, recipient)), DirectMessage.reciever.in_(username, recipient))).filter( DirectMessage.creation_date > data.get('time')).order_by( DirectMessage.creation_date.desc()).limit( data.get('count_number')).all() final_result = [] for message in result: message.seen = True message_creator = get_profile(message.creator, db_session) creator = model_to_dict(message_creator) del creator['password'] new_message = model_to_dict(message) new_message['creator'] = creator final_result.append(new_message) logging.debug(Msg.GET_SUCCESS) logging.info(Msg.END) return final_result
def add(db_session, data, username): logger.info(LogMsg.START, username) check_schema(['following_id'], data.keys()) 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 add(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['price', 'book_id'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) book_id = data.get('book_id') book = get_book(book_id, db_session) if username is not None: per_data = {} permissions, presses = get_user_permissions(username, db_session) if book.creator == username: per_data.update({Permissions.IS_OWNER.value: True}) has_permit = has_permission_or_not([Permissions.PRICE_ADD_PREMIUM], permissions, None, per_data) if not has_permit: if book.press in presses: has_permission([Permissions.PRICE_ADD_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED, username) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED) logger.debug(LogMsg.CHECK_BOOK_PRICE_EXISTANCE, book_id) model_instance = get_by_book(book_id, db_session, username) if model_instance: logger.debug(LogMsg.BOOK_PRICE_EXISTS, book_id) logger.debug(LogMsg.EDIT_PRICE, book_id) model_instance.price = data.get('price') else: logger.debug(LogMsg.ADD_NEW_BOOK_PRICE, book_id) model_instance = Price() populate_basic_data(model_instance, username) model_instance.book_id = book_id model_instance.price = data.get('price') db_session.add(model_instance) logger.info(LogMsg.END) return model_instance
def edit(id, data, db_session, username): logger.info(LogMsg.START, username) permissions, presses = get_user_permissions(username, db_session) has_permission([Permissions.ACCOUNT_EDIT_PREMIUM], permissions) check_schema(['value'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) value = data.get('value') logger.debug(LogMsg.GETTING_ACCOUNT_BY_ID, id) account = db_session.query(Account).filter(Account.id == id).first() if account is None: logger.error(LogMsg.NOT_FOUND, {'account_id': id}) raise Http_error(404, Message.NOT_FOUND) account.value += value logger.debug(LogMsg.EDIT_SUCCESS) logger.info(LogMsg.END) return account_to_dict(account)
def add(data, db_session, username=None): logging.info(LogMsg.START) if username is not None: permissions, presses = get_user_permissions(username, db_session) has_permission([Permissions.LIBRARY_ADD_PREMIUM], permissions) check_schema(['book_id', 'person_id'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) book_id = data.get('book_id') person_id = data.get('person_id') logger.debug(LogMsg.LIBRARY_CHECK_BOOK_EXISTANCE, { 'book_id': book_id, 'person_id': 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.BOOK_IS_ALREADY_PURCHASED) book = get_book(book_id, db_session) if book.type.name not in ONLINE_BOOK_TYPES: logger.debug(LogMsg.LIBRARY_BOOK_TYPE_NOT_ADDABLE, book.type.name) return {} model_instance = Library() populate_basic_data(model_instance) logger.debug(LogMsg.POPULATING_BASIC_DATA) model_instance.person_id = person_id model_instance.book_id = book_id model_instance.progress = 0.00 model_instance.status = { 'status': 'buyed', 'reading_started': False, 'read_pages': 0, 'read_duration': 0.00, 'is_read': False } db_session.add(model_instance) logger.info(LogMsg.END) return model_instance
def add(db_session, data, username): logger.info(LogMsg.START, username) check_schema(['body'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) group_id = data.get('group_id', None) user = check_user(username, db_session) if group_id is not None and not is_group_member(user.person_id, group_id, db_session): logger.debug(LogMsg.CHAT_PERSON_NOT_IN_GROUP, { 'group_id': group_id, 'username': username }) raise Http_error(403, Message.PERSON_CANT_SENT_MESSAGE) logger.debug(LogMsg.PERMISSION_VERIFIED, username) parent_id = data.get('parent_id', None) if parent_id: logger.debug(LogMsg.CHAT_CHECK_FOR_PARENT) parent_message = get_internal(parent_id, db_session) if parent_message is None: logger.error(LogMsg.CHAT_PARENT_NOT_FOUND, parent_id) raise Http_error(404, Message.PARENT_NOT_FOUND) model_instance = ChatMessage() logger.debug(LogMsg.POPULATING_BASIC_DATA) populate_basic_data(model_instance, username, data.get('tags')) model_instance.sender_id = user.person_id model_instance.receptor_id = data.get('receptor_id') model_instance.group_id = group_id model_instance.body = data.get('body') model_instance.parent_id = data.get('parent_id') db_session.add(model_instance) logger.debug(LogMsg.DB_ADD) logger.info(LogMsg.END) return model_instance
def edit_by_person(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['person_id', 'value'], data.keys()) user = check_user(username, db_session) logger.debug(LogMsg.PERMISSION_CHECK, username) validate_permissions_and_access(username, db_session, 'ACCOUNT_EDIT', access_level=Access_level.Premium) logger.debug(LogMsg.PERMISSION_VERIFIED, username) logger.debug(LogMsg.SCHEMA_CHECKED) value = data.get('value') type = data.get('type', 'Main') person_id = data.get('person_id') logger.debug(LogMsg.GETTING_ACCOUNT_PERSON, data) account = db_session.query(Account).filter( and_(Account.person_id == person_id, Account.type == type)).first() if account is None: logger.error(LogMsg.NOT_FOUND, {'account_id': id}) raise Http_error(404, Message.NOT_FOUND) # special_data = {} # if user.person_id == account.person_id: # special_data.update({Permissions.IS_OWNER.value: True}) # logger.debug(LogMsg.PERMISSION_CHECK, username) # validate_permissions_and_access(username, db_session, 'ACCOUNT_EDIT', # special_data) # logger.debug(LogMsg.PERMISSION_VERIFIED, username) account.value += value logger.debug(LogMsg.EDIT_SUCCESS) logger.info(LogMsg.END) return account_to_dict(account)
def edit(id, data, db_session, username=None): logger.info(LogMsg.START, username) check_schema(['price'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) model_instance = get_by_id(id, db_session) if model_instance is None: logger.error(LogMsg.NOT_FOUND, {'book_price_id': id}) raise Http_error(404, Message.NOT_FOUND) book = get_book(model_instance.book_id, db_session) if username is not None: per_data = {} permissions, presses = get_user_permissions(username, db_session) if book.creator == username: per_data.update({Permissions.IS_OWNER.value: True}) has_permit = has_permission_or_not([Permissions.PRICE_EDIT_PREMIUM], permissions, None, per_data) if not has_permit: if book.press in presses: has_permission([Permissions.PRICE_EDIT_PRESS], permissions) else: logger.error(LogMsg.PERMISSION_DENIED, username) raise Http_error(403, Message.ACCESS_DENIED) logger.debug(LogMsg.PERMISSION_VERIFIED) try: model_instance.price = data.get('price') logger.debug(LogMsg.EDIT_SUCCESS, model_to_dict(model_instance)) except: logger.exception(LogMsg.EDIT_FAILED, exc_info=True) raise Http_error(404, Message.EDIT_FAILED) logger.info(LogMsg.END) return model_instance
def add(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['items'], data.keys()) 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_ACCOUNT, username) raise Http_error(400, Message.Invalid_persons) model_instance = Order() populate_basic_data(model_instance, username) if 'person_id' in data : permissions, presses = get_user_permissions(username, db_session) has_permission( [Permissions.ORDER_ADD_PREMIUM,Permissions.ORDER_ADD_PRESS], permissions) logger.debug(LogMsg.PERMISSION_VERIFIED) person_id = data.get('person_id') else: person_id = user.person_id model_instance.person_id = person_id db_session.add(model_instance) item_data = {} item_data['items']= data.get('items') item_data['person_id'] = person_id logger.debug(LogMsg.ORDER_ADD_ITEMS, data.get('items')) model_instance.total_price = add_orders_items(model_instance.id, item_data, db_session, username) order_dict = order_to_dict(model_instance, db_session, username) logger.debug(LogMsg.ORDER_ADD, order_dict) logger.info(LogMsg.END) return order_dict
def edit_by_person(data, db_session, username): logger.info(LogMsg.START, username) user = check_user(username, db_session) check_schema(['person_id', 'value'], data.keys()) permissions, presses = get_user_permissions(username, db_session) has_permission([Permissions.ACCOUNT_EDIT_PREMIUM], permissions) logger.debug(LogMsg.SCHEMA_CHECKED) value = data.get('value') type = data.get('type', 'Main') person_id = data.get('person_id') logger.debug(LogMsg.GETTING_ACCOUNT_PERSON, data) account = db_session.query(Account).filter( and_(Account.person_id == person_id, Account.type == type)).first() if account is None: logger.error(LogMsg.NOT_FOUND, {'account_id': id}) raise Http_error(404, Message.NOT_FOUND) permissions, presses = get_user_permissions(username, db_session) per_data = {} if user.person_id == account.person_id: per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.ACCOUNT_EDIT_PREMIUM], permissions, None, per_data) account.value += value logger.debug(LogMsg.EDIT_SUCCESS) logger.info(LogMsg.END) return account_to_dict(account)
def add(data, username, db_session): logging.info(Msg.START) required_data = ['message', 'reciever'] check_schema(required_data, data.keys()) reciever = get_profile(data['reciever'], db_session) logging.debug(Msg.SCHEMA_CHECKED) model_instance = DirectMessage() model_instance.sender = username model_instance.id = str(uuid4()) model_instance.creation_date = Now() model_instance.reciever = reciever.username model_instance.message = data.get('message') model_instance.seen = False logging.debug(Msg.DATA_ADDITION + " || Data :" + json.dumps(data)) db_session.add(model_instance) event_data = { 'entity_name': 'DirectMessage', 'entity_id': model_instance.id, 'action': 'ADD', 'target': model_instance.reciever, } add_event(event_data, username, db_session) logging.debug(Msg.DB_ADD) logging.info(Msg.END) return model_instance
def add_book_to_collections(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['book_ids', 'collections'], data.keys()) if 'person_id' in data: person_id = data.get('person_id') else: user = check_user(username, db_session) if user is None: raise Http_error(404, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(404, Message.INVALID_USER) person_id = user.person_id books_ids = data.get('book_ids') logger.debug(LogMsg.LIBRARY_CHECK_BOOK_EXISTANCE, books_ids) if not books_are_in_lib(person_id, books_ids, db_session): raise Http_error(404, Message.BOOK_NOT_IN_LIB) logger.debug(LogMsg.COLLECTION_ADD_BOOK_TO_MULTIPLE_COLLECTIONS, data) for collection_title in data.get('collections'): if not collection_exists(collection_title, person_id, db_session): logger.error(LogMsg.NOT_FOUND, { 'collection_tilte': collection_title, 'person_id': person_id }) addition_data = { 'book_ids': books_ids, 'title': collection_title, 'person_id': person_id } add(addition_data, db_session, 'internal') logger.info(LogMsg.END) return data
def add_disscussuion_members(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['group_id', 'members'], data.keys()) group_id = data.get('group_id') members = data.get('members') group = get_discussion_group(group_id, db_session) if group is None: logger.error(LogMsg.NOT_FOUND, {'discussion_group_id': group_id}) raise Http_error(404, Message.NOT_FOUND) user = check_user(username, db_session) is_admin = False for item in members: if item['person_id'] == user.person_id and item['type'] == 'Admin': is_admin = True per_data = {} permissions, presses = get_user_permissions(username, db_session) if is_admin or is_admin_member(user.person_id, group_id, db_session): per_data.update({Permissions.IS_OWNER.value: True}) has_permission([Permissions.DISCUSSION_MEMBER_PREMIUM], permissions, None, per_data) logger.debug(LogMsg.PERMISSION_VERIFIED, username) group_members = [] for item in members: member = add(group_id, item.get('person_id'), item.get('type'), db_session, username) group_members.append(discussion_member_to_dict(member)) logger.debug(LogMsg.DISCUSSION_GROUP_MEMBERS_ADDED) return group_members
def pay_by_kipo(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['amount'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) person_id = data.get('person_id') per_data = {} user = check_user(username, db_session) if user is None: logger.error(LogMsg.INVALID_USER, username) raise Http_error(404, Message.INVALID_USER) if person_id is None: person_id = user.person_id per_data.update({Permissions.IS_OWNER.value: True}) permissions, presses = get_user_permissions(username, db_session) has_permission( [Permissions.PAYMENT_ADD_PREMIUM, Permissions.PAYMENT_ADD_PRESS], permissions, None, per_data) logger.debug(LogMsg.PERMISSION_VERIFIED) from_bank_url = '{}/payment-receive'.format(base_url) logger.debug(LogMsg.CALL_BACK_FROM_BANK_URL, from_bank_url) kpg_initiate = kipo.kpg_initiate(data.get('amount'), from_bank_url) if kpg_initiate['status']: logger.debug(LogMsg.KIPO_PAYMENT_INITIATED, kpg_initiate) data.update({ 'agent': 'kipo', 'shopping_key': kpg_initiate.get('shopping_key'), 'reference_code': kipo.get_referent_code(), 'details': kpg_initiate, 'person_id': person_id }) logger.debug(LogMsg.ADDING_PAYMENT_ENTITY, data) payment = add_payment(data, db_session, username) logger.debug(LogMsg.PAYMENT_ADDED, model_to_dict(payment)) else: logger.error(LogMsg.PAYMENT_FAILED_KIPO, kpg_initiate) error = kipo_error_code(kpg_initiate['code']) raise Http_error(402, error) html_content = ''' <form id="kipopay-gateway" method="post" action="{url}" style="display: none;"> <input type="hidden" id="sk" name="sk" value="{shopping_key}"/> </form> <script language="javascript">document.forms['kipopay-gateway'].submit();</script> '''.format(url=kipo.kipo_webgate_url, shopping_key=kpg_initiate['shopping_key']) return HTTPResponse(body=html_content, status=200, headers=dict(content_type='text/html'))
def add(data, db_session, username): logger.info(LogMsg.START, username) check_schema(['title'], data.keys()) logger.debug(LogMsg.SCHEMA_CHECKED) title = data.get('title') if 'person_id' in data: person_id = data.get('person_id') else: user = check_user(username, db_session) if user is None: raise Http_error(404, Message.INVALID_USER) if user.person_id is None: logger.error(LogMsg.USER_HAS_NO_PERSON, username) raise Http_error(404, Message.Invalid_persons) person_id = user.person_id data['person_id'] = person_id validate_person(person_id, db_session) logger.debug(LogMsg.PERSON_EXISTS, person_id) logger.debug(LogMsg.CHECK_UNIQUE_EXISTANCE, data) unique_code = unique_code_exists(data, db_session) if unique_code is not None and username != 'internal': logger.error(LogMsg.COLLECTION_EXISTS, { 'collection_tilte': data.get('title'), 'person_id': person_id }) raise Http_error(409, Message.ALREADY_EXISTS) if unique_code is None: unique_code = add_uniquecode(data, db_session) db_session.flush() logger.debug(LogMsg.COLLECTION_ADD_NEW_COLLECTION, {'title': title}) book_ids = data.get('book_ids', None) if book_ids is None: logger.debug(LogMsg.COLLECTION_ADD_EMPTY_COLLECTION, {'title': title}) model_instance = Collection() logger.debug(LogMsg.POPULATING_BASIC_DATA) populate_basic_data(model_instance, username, data.get('tags')) model_instance.person_id = person_id model_instance.title = title db_session.add(model_instance) add_connector(model_instance.id, unique_code.UniqueCode, db_session) logger.debug( LogMsg.UNIQUE_CONNECTOR_ADDED, { 'collection_id': model_instance.id, 'unique_constraint': unique_code.UniqueCode }) logger.debug(LogMsg.DB_ADD) return data for item in book_ids: log_data = {'book_id': item, 'collection': title} logger.debug(LogMsg.COLLECTION_ADD_BOOKS_TO_COLLECTION, title) data['book_id'] = item collection_item = get(item, person_id, title, db_session) if collection_item is not None: logger.error(LogMsg.COLLECTION_BOOK_ALREADY_EXISTS, log_data) raise Http_error(409, Message.ALREADY_EXISTS) if not is_book_in_library(person_id, item, db_session): logger.error(LogMsg.COLLECTION_BOOK_IS_NOT_IN_LIBRARY, {'book_id': item}) raise Http_error(403, Message.BOOK_NOT_IN_LIB) logger.debug(LogMsg.COLLECTION_CHECK_BOOK_IS_IN_COLLECTION, log_data) model_instance = Collection() logger.debug(LogMsg.POPULATING_BASIC_DATA) populate_basic_data(model_instance, username, data.get('tags')) model_instance.person_id = person_id model_instance.book_id = item model_instance.title = title logger.debug(LogMsg.DB_ADD) db_session.add(model_instance) add_connector(model_instance.id, unique_code.UniqueCode, db_session) logger.debug( LogMsg.UNIQUE_CONNECTOR_ADDED, { 'collection_id': model_instance.id, 'unique_constraint': unique_code.UniqueCode }) logger.info(LogMsg.END) return data