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 edit_status_internal(id, status, db_session, username=None):
logger.info(LogMsg.START, username)
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)
if username is not None:
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)
try:
model_instance.status = status
edit_basic_data(model_instance, username)
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
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 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):
logger.info(LogMsg.START, '--INTERNAL--')
logger.debug(LogMsg.SCHEMA_CHECKED)
seen = get_internal(data.get('receptor_id'), data.get('sender_id'),
data.get('group_id'), db_session)
if seen is not None:
seen.last_seen = data.get('last_seen')
edit_basic_data(seen, 'INTERNAL')
logger.debug(LogMsg.LAST_SEEN_UPDATE,data)
return seen
model_instance = LastSeen()
logger.debug(LogMsg.POPULATING_BASIC_DATA)
populate_basic_data(model_instance, 'INTERNAL', data.get('tags'))
model_instance.sender_id = data.get('sender_id')
model_instance.receptor_id = data.get('receptor_id')
model_instance.group_id = data.get('group_id', None)
model_instance.last_seen = data.get('last_seen')
db_session.add(model_instance)
logger.debug(LogMsg.LAST_SEEN_ADD,data)
logger.info(LogMsg.END)
return model_instance
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 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 = {}
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)
logger.debug(LogMsg.RATE_CHECK,{'rate_id':id})
model_instance = db_session.query(Rate).filter(Rate.id == 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)
if model_instance.person_id == user.person_id:
permission_data = {Permissions.IS_OWNER.value:True}
permissions,presses = get_user_permissions(username, db_session)
has_permission([Permissions.RATE_EDIT_PREMIUM], permissions,None,permission_data)
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 edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.EDIT_REQUST, {'permission_id': id, 'data': data})
if username not in ADMINISTRATORS:
logger.error(LogMsg.NOT_ACCESSED, {'username': username})
raise Http_error(403, Message.ACCESS_DENIED)
if "id" in data.keys():
del data["id"]
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():
# TODO if key is valid attribute of class
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(500, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.EDIT_REQUST, {'book_id': id})
model_instance = db_session.query(Book).filter(Book.id == id).first()
if model_instance is None:
logger.debug(LogMsg.NOT_FOUND, {'book_id': id})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'LIBRARY_EDIT',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
logger.debug(LogMsg.EDITING_BOOK, id)
files = data.get('files', None)
images = data.get('images', None)
if files:
logger.debug(LogMsg.DELETE_BOOK_FILES, id)
delete_files(model_instance.files)
if images:
logger.debug(LogMsg.DELETE_BOOK_IMAGES)
delete_files(model_instance.images)
for key, value in data.items():
setattr(model_instance, key, value)
edit_basic_data(model_instance, username, data.get('tags'))
price = data.get('price', None)
if price is not None:
edit_price(model_instance.id, price, db_session)
logger.debug(LogMsg.MODEL_ALTERED)
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
unique_data = book_to_dict(db_session, model_instance)
del unique_data['roles']
unique_data['roles'] = data['roles']
unique_connector = get_connector(id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
logger.debug(LogMsg.GENERATE_UNIQUE_CONSTRAINT, unique_data)
code = add_uniquecode(unique_data, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
logger.debug(LogMsg.EDIT_SUCCESS, book_to_dict(db_session, model_instance))
logger.info(LogMsg.END)
return book_to_dict(db_session, model_instance)
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
# TODO: you never checked version of passed data, we have version field in our
# records, to prevent conflict when we received two different edit request
# concurrently. check KAVEH codes (edit functions) to better understanding
# version field usage
logger.debug(LogMsg.EDIT_REQUST, {'discuss_group_id': id, 'data': data})
user = check_user(username, db_session)
per_data = {}
permissions, presses = get_user_permissions(username, db_session)
if is_admin_member(user.person_id, id, db_session):
per_data.update({Permissions.IS_OWNER.value: True})
has_permission([Permissions.DISCUSSION_GROUP_PREMIUM], permissions, None,
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if "id" in data.keys():
del data["id"]
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 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 edit(id, data, db_session, username=None):
logger.info(LogMsg.START, username)
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)
permissions, presses = get_user_permissions(username, db_session)
per_data = {}
if model_instance.creator == username:
per_data.update({Permissions.IS_OWNER.value: True})
has_permission(
[Permissions.ORDER_EDIT_PREMIUM], permissions, None, per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED)
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)
if 'id' in data:
del data['id']
if 'status' in data:
del data['status']
for key, value in data.items():
# TODO if key is valid attribute of class
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 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 edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
if "id" in data.keys():
del data["id"]
logger.debug(LogMsg.EDIT_REQUST)
logger.debug(LogMsg.MODEL_GETTING, id)
model_instance = db_session.query(Comment).filter(Comment.id == id).first()
if model_instance is None:
logger.error(LogMsg.GET_FAILED, id)
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
if user is None:
raise Http_error(400, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(400, Message.Invalid_persons)
permissions, presses = get_user_permissions(username, db_session)
per_data = {}
if model_instance.person_id == user.person_id:
per_data.update({Permissions.IS_OWNER.value: True})
has_permission([Permissions.COMMENT_EDIT_PREMIUM], permissions, None,
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if 'person_id' in data:
del data['person_id']
if 'book_id' in data:
del data['book_id']
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'))
logger.debug(LogMsg.MODEL_ALTERED, id)
result = comment_to_dict(db_session, model_instance, username)
logger.debug(LogMsg.EDIT_SUCCESS, result)
logger.info(LogMsg.END)
return result
def edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
content = get_internal(id, db_session)
if content is None:
logger.error(LogMsg.NOT_FOUND, {'content_id': id})
raise Http_error(404, Message.NOT_FOUND)
book = get_book(content.book_id, db_session)
if 'book_id' in data.keys():
book = get_book(data.get('book_id'), db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': data.get('book_id')})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
permission_data = {}
if content.creator == username:
permission_data = {Permissions.IS_OWNER.value: True}
permissions, presses = get_user_permissions(username, db_session)
has_permit = has_permission_or_not([Permissions.BOOK_EDIT_PREMIUM],
permissions, None, permission_data)
if not has_permit:
if book.get('press') in presses:
has_permission([Permissions.BOOK_EDIT_PRESS], permissions)
else:
logger.error(LogMsg.PERMISSION_DENIED)
raise Http_error(403, Message.ACCESS_DENIED)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
try:
for key, value in data.items():
# TODO if key is valid attribute of class
setattr(content, key, value)
new_content = get_be_data(content.book_id, content.type, db_session)
if new_content is not None and new_content.id != content.id:
logger.error(LogMsg.BOOK_CONTENT_ALREADY_EXISTS,
content_to_dict(new_content, db_session))
raise Http_error(409, Message.ALREADY_EXISTS)
edit_basic_data(content, username, data.get('tags'))
content.book_press = book.press
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.ALREADY_EXISTS)
logger.debug(LogMsg.EDIT_SUCCESS, model_to_dict(content))
logger.info(LogMsg.END)
return content_to_dict(content, db_session)
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 edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
logger.debug(LogMsg.EDIT_REQUST)
if "id" in data.keys():
del data["id"]
logger.debug(LogMsg.MODEL_GETTING, id)
model_instance = db_session.query(ChatMessage).filter(
ChatMessage.id == id).first()
if model_instance is None:
logger.error(LogMsg.GET_FAILED, id)
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
if user is None:
raise Http_error(400, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(400, Message.Invalid_persons)
permissions, presses = get_user_permissions(username, db_session)
per_data = {}
if model_instance.sender_id == user.person_id or (
model_instance.group_id is not None and is_admin_member(
user.person_id, model_instance.group_id, db_session)):
per_data.update({Permissions.IS_OWNER.value: True})
has_permission([Permissions.CHAT_EDIT_PREMIUM], permissions, None,
per_data)
logger.debug(LogMsg.PERMISSION_VERIFIED, username)
if 'sender_id' in data:
del data['sender_id']
if 'group_id' in data:
del data['group_id']
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, id)
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 edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, CONTENT_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
content = get_internal(id, db_session)
if content is None:
logger.error(LogMsg.NOT_FOUND, {'content_id': id})
raise Http_error(404, Message.NOT_FOUND)
book = get_book(content.book_id, db_session)
if 'book_id' in data.keys():
book = get_book(data.get('book_id'), db_session)
if book is None:
logger.error(LogMsg.NOT_FOUND, {'book_id': data.get('book_id')})
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'BOOK_EDIT',
model=content)
logger.debug(LogMsg.PERMISSION_VERIFIED)
try:
for key, value in data.items():
setattr(content, key, value)
new_content = get_be_data(content.book_id, content.type, db_session)
if new_content is not None and new_content.id != content.id:
logger.error(LogMsg.BOOK_CONTENT_ALREADY_EXISTS,
content_to_dict(new_content, db_session))
raise Http_error(409, Message.ALREADY_EXISTS)
edit_basic_data(content, username, data.get('tags'))
content.book_press = book.press
if data.get('content') is not None:
content.celery_task_id = None
content.content_generated = False
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.ALREADY_EXISTS)
logger.debug(LogMsg.EDIT_SUCCESS, model_to_dict(content))
logger.info(LogMsg.END)
return content_to_dict(content, db_session)
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
schema_validate(data, PERSON_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
logger.debug(LogMsg.EDIT_REQUST, {'person_id': id, 'data': data})
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)
model_instance = db_session.query(Person).filter(Person.id == id).first()
if model_instance:
logger.debug(LogMsg.MODEL_GETTING)
else:
logger.debug(LogMsg.MODEL_GETTING_FAILED, {'person_id': id})
raise Http_error(404, Message.NOT_FOUND)
if 'cell_no' in data.keys():
cell_person = person_cell_exists(db_session, data.get('cell_no'))
if cell_person is not None:
if cell_person.id != model_instance.id:
logger.error(LogMsg.ANOTHER_PERSON_BY_CELL)
raise Http_error(403, Message.CELL_EXISTS)
try:
for key, value in data.items():
setattr(model_instance, key, value)
model_instance.full_name = full_name(model_instance.name,
model_instance.last_name)
edit_basic_data(model_instance, username, data.get('tags'))
db_session.flush()
logger.debug(LogMsg.MODEL_ALTERED,
person_to_dict(model_instance, db_session))
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(500, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
if "id" in data.keys():
del data["id"]
if 'username' in data.keys():
logger.error(LogMsg.NOT_EDITABLE, 'username')
raise Http_error(400, Message.NOT_EDITABLE)
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:
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 edit_status(id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, EDIT_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)
status = data.get('status', {})
model_instance = db_session.query(Library).filter(Library.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, id)
raise Http_error(404, Message.NOT_FOUND)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'LIBRARY_EDIT',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
if status.get('reading_started'):
model_instance.status['reading_started'] = status.get(
'reading_started')
if status.get('read_pages'):
model_instance.status['read_pages'] = status.get('read_pages')
if status.get('read_duration'):
model_instance.status['read_duration'] = status.get('read_duration')
if status.get('status'):
model_instance.status['status'] = status.get('status')
if status.get('is_read'):
model_instance.status['is_read'] = status.get('is_read')
if 'progress' in data:
model_instance.progress = data.get('progress')
edit_basic_data(model_instance, username)
logger.debug(LogMsg.MODEL_ALTERED, data)
logger.info(LogMsg.END)
return lib_to_dict(model_instance, db_session)
def edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, MOVIE_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
model_instance = db_session.query(Movie).filter(Movie.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'movie_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'))
logger.debug(LogMsg.EDIT_SUCCESS, model_to_dict(model_instance))
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.EDIT_FAILED)
logger.info(LogMsg.END)
return model_to_dict(model_instance)
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
if "id" in data.keys():
del data["id"]
logger.debug(LogMsg.EDIT_REQUST, id)
logger.debug(LogMsg.MODEL_GETTING, id)
model_instance = db_session.query(BookRole).filter(
BookRole.id == id).first()
if model_instance:
logger.debug(LogMsg.GET_SUCCESS, book_role_to_dict(model_instance))
else:
logger.debug(LogMsg.GET_FAILED, id)
raise Http_error(404, Message.NOT_FOUND)
for key, value in data.items():
# TODO if key is valid attribute of class
setattr(model_instance, key, value)
logger.debug(LogMsg.EDITING_BASIC_DATA, id)
edit_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.MODEL_ALTERED, id)
logger.debug(LogMsg.UNIQUE_CONSTRAINT_IS_CHANGING)
unique_connector = get_connector(id, db_session)
if unique_connector:
logger.debug(LogMsg.DELETE_UNIQUE_CONSTRAINT)
delete_uniquecode(unique_connector.UniqueCode, db_session)
logger.debug(LogMsg.GENERATE_UNIQUE_CONSTRAINT, data)
code = add_uniquecode(data, db_session)
delete_connector(id, db_session)
add_connector(id, code.UniqueCode, db_session)
logger.debug(LogMsg.EDIT_SUCCESS, book_role_to_dict(model_instance))
logger.info(LogMsg.END)
return model_instance
def edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
schema_validate(data, COMMENT_EDIT_SCHEMA_PATH)
logger.debug(LogMsg.SCHEMA_CHECKED)
logger.debug(LogMsg.MODEL_GETTING, id)
model_instance = db_session.query(Comment).filter(Comment.id == id).first()
if model_instance is None:
logger.error(LogMsg.GET_FAILED, id)
raise Http_error(404, Message.NOT_FOUND)
user = check_user(username, db_session)
if user is None:
raise Http_error(400, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(400, Message.Invalid_persons)
logger.debug(LogMsg.PERMISSION_CHECK, username)
validate_permissions_and_access(username,
db_session,
'COMMENT_EDIT',
model=model_instance)
logger.debug(LogMsg.PERMISSION_VERIFIED)
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'))
logger.debug(LogMsg.MODEL_ALTERED, id)
result = comment_to_dict(db_session, model_instance, username)
logger.debug(LogMsg.EDIT_SUCCESS, result)
logger.info(LogMsg.END)
return result
def edit_status(id, data, db_session, username):
logger.info(LogMsg.START, username)
permissions, presses = get_user_permissions(username, db_session)
has_permission([Permissions.LIBRARY_GET_PREMIUM], permissions, None,
{Permissions.IS_OWNER.value: True})
user = check_user(username, db_session)
if user is None:
raise Http_error(400, Message.INVALID_USER)
if user.person_id is None:
logger.error(LogMsg.USER_HAS_NO_PERSON, username)
raise Http_error(400, Message.Invalid_persons)
validate_person(user.person_id, db_session)
logger.debug(LogMsg.PERSON_EXISTS)
status = data.get('status', {})
model_instance = db_session.query(Library).filter(Library.id == id).first()
if status.get('reading_started'):
model_instance.status['reading_started'] = status.get(
'reading_started')
if status.get('read_pages'):
model_instance.status['read_pages'] = status.get('read_pages')
if status.get('read_duration'):
model_instance.status['read_duration'] = status.get('read_duration')
if status.get('status'):
model_instance.status['status'] = status.get('status')
if status.get('is_read'):
model_instance.status['is_read'] = status.get('is_read')
if 'progress' in data:
model_instance.progress = data.get('progress')
edit_basic_data(model_instance, username)
logger.debug(LogMsg.MODEL_ALTERED, data)
logger.info(LogMsg.END)
return lib_to_dict(model_instance, db_session)
def edit(id, data, db_session, username):
logger.info(LogMsg.START, username)
# schema_validate(data, RATING_EDIT_SCHEMA_PATH)
# logger.debug(LogMsg.SCHEMA_CHECKED)
user = check_user(username, db_session)
model_instance = db_session.query(Rating).filter(Rating.id == id).first()
if model_instance is None:
logger.error(LogMsg.NOT_FOUND, {'Rating_id': id})
raise Http_error(404, Message.NOT_FOUND)
if model_instance.person_id != user.person_id:
logger.error(LogMsg.NOT_ACCESSED, username)
raise Http_error(403, Message.ACCESS_DENIED)
try:
for key, value in data.items():
setattr(model_instance, key, value)
edit_basic_data(model_instance, username, data.get('tags'))
logger.debug(LogMsg.EDIT_SUCCESS, rating_to_dict(model_instance))
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(409, Message.EDIT_FAILED)
logger.info(LogMsg.END)
return rating_to_dict(model_instance)
def edit(id, db_session, data, username):
logger.info(LogMsg.START, username)
# TODO: you never checked version of passed data, we have version field in our
# records, to prevent conflict when we received two different edit request
# concurrently. check KAVEH codes (edit functions) to better understanding
# version field usage
logger.debug(LogMsg.EDIT_REQUST, {'group_id': id, 'data': data})
if username not in ADMINISTRATORS:
logger.error(LogMsg.NOT_ACCESSED, {'username': username})
raise Http_error(403, Message.ACCESS_DENIED)
if "id" in data.keys():
del data["id"]
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)
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'))
logger.debug(LogMsg.MODEL_ALTERED, model_to_dict(model_instance))
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(500, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
def edit_status_internal(id, status, db_session, username=None):
logger.info(LogMsg.START, username)
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)
if username is not None:
permissions, presses = get_user_permissions(username, db_session)
has_permission([Permissions.ORDER_EDIT_PREMIUM], permissions)
logger.debug(LogMsg.PERMISSION_VERIFIED)
try:
model_instance.status = status
edit_basic_data(model_instance, username)
except:
logger.exception(LogMsg.EDIT_FAILED, exc_info=True)
raise Http_error(404, Message.DELETE_FAILED)
logger.info(LogMsg.END)
return model_instance
