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)
