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
