def group_permission_to_dict(model_instance):
result = {
'group_id': model_instance.group_id,
'permission_id': model_instance.permission_id,
'permission': model_to_dict(model_instance.permission)
}
primary_data = model_basic_dict(model_instance)
result.update(primary_data)
return result
def group_user_to_dict(model_instance):
result = {
'group_id': model_instance.group_id,
'user_id': model_instance.user_id,
'group': model_to_dict(model_instance.group)
}
primary_data = model_basic_dict(model_instance)
result.update(primary_data)
return result
def library_to_dict(library,db_session):
result =[]
for item in library:
lib_item = model_basic_dict(item)
lib_attrs = {'status':item.status,
'book':book_to_dict(db_session,item.book)
}
lib_item.update(lib_attrs)
result.append(lib_item)
return result
def lib_to_dict(item, db_session):
res = model_basic_dict(item)
item_dict = {
'book_id': item.book_id,
'person_id': item.person_id,
'status': item.status,
'progress': item.progress,
'book': book_to_dict(db_session, item.book)
}
item_dict.update(res)
return item_dict
def pay_model_to_dict(model):
result = model_basic_dict(model)
result.update({
'amount': model.amount,
'payer_id': model.payer_id,
'receiver_id': model.receiver_id,
'receiver_account_id': model.receiver_account_id,
'payment_details': model.payment_details,
'receiver': person_to_dict(model.receiver)
})
return result
def rating_to_dict(model):
if model is None:
logger.error(LogMsg.NOT_FOUND)
return {}
result = {
'movie_id': model.movie_id,
'person_id': model.person_id,
'comment': model.comment,
'overall_rate': model.overall_rate,
'novel': model.novel,
'character': model.character,
'reason': model.reason,
'directing': model.directing,
'true_vision_of_enemy': model.true_vision_of_enemy,
'iranian_life_style': model.iranian_life_style,
'hope': model.hope,
'bright_future_exposure': model.bright_future_exposure,
'theism': model.theism,
'justice_seeking': model.justice_seeking,
'feminism_exposure': model.feminism_exposure,
'individual_social_behavior': model.individual_social_behavior,
'family_subject': model.family_subject,
'alcoholic_promotion': model.alcoholic_promotion,
'gambling_promotion': model.gambling_promotion,
'breaking_law_encouragement': model.breaking_law_encouragement,
'suicide_encouragement': model.suicide_encouragement,
'horror_content': model.horror_content,
'addiction_promotion': model.addiction_promotion,
'unsuitable_wearing': model.unsuitable_wearing,
'sexual_content': model.sexual_content,
'insulting_range': model.insulting_range,
'violence_range': model.violence_range,
'music': model.music,
'sound': model.sound,
'visualization': model.visualization,
'editing': model.editing,
'acting': model.acting,
'true_historiography': model.true_historiography,
'question_1': model.question_1,
'question_2': model.question_2,
'question_3': model.question_3,
'question_4': model.question_4,
'question_5': model.question_5,
'question_6': model.question_6,
'question_7': model.question_7,
'question_8': model.question_8,
'question_9': model.question_9,
'question_10': model.question_10,
'person': person_to_dict(model.person),
'movie': model_to_dict(model.movie)}
basic_attrs = model_basic_dict(model)
result.update(basic_attrs)
return result
def account_to_dict(account):
if not isinstance(account, Account):
raise Http_error(404, Message.INVALID_ENTITY)
result = model_basic_dict(account)
model_properties = {
'person_id': account.person_id,
'value': account.value,
'type': str_account_type(account.type)
}
result.update(model_properties)
return result
def lib_to_dictlist(library, db_session):
result = []
for item in library:
res = model_basic_dict(item)
item_dict = {
'book_id': item.book_id,
'person_id': item.person_id,
'status': item.status,
'progress': item.progress,
'book': book_to_dict(db_session, item.book)
}
item_dict.update(res)
result.append(item_dict)
return result
def get_groups_by_list(group_ids, db_session):
groups = db_session.query(DiscussionGroup).filter(
DiscussionGroup.id.in_(group_ids)).all()
result = []
for group in groups:
group_dict = {
'title': group.title,
'description': group.description,
'status': group.status,
'image': group.image
}
basics = model_basic_dict(group)
group_dict.update(basics)
result.append(group_dict)
return result
def order_to_dict(order, db_session, username=None):
if not isinstance(order, Order):
raise Http_error(404, Message.INVALID_ENTITY)
result = model_basic_dict(order)
model_props = {
'person_id': order.person_id,
'price_detail': order.price_detail,
'description': order.description,
'total_price': order.total_price,
'status': order.status.name,
'person': get_person(order.person_id, db_session, username)
}
result.update(model_props)
return result
def discussion_member_to_dict(member_model):
result = {
'group_id': member_model.group_id,
'person_id': member_model.person_id,
'type': member_model.type,
}
if member_model.group is not None:
result['group'] = {
'title': member_model.group.title,
'description': member_model.group.description,
'image': member_model.group.image,
'status': member_model.group.status
}
basic_attrs = model_basic_dict(member_model)
result.update(basic_attrs)
return result
def collection_to_dict(db_session, collection):
if not isinstance(collection, Collection):
raise Http_error(400, Message.INVALID_ENTITY)
basic_res = model_basic_dict(collection)
model_props = {
'book_id': collection.book_id,
'person_id': collection.person_id,
'title': collection.title,
'book': None
}
if collection.book_id is not None:
book = book_to_dict(db_session, collection.book)
model_props['book'] = book
model_props.update(basic_res)
logger.debug('*****coll is model_props: %s', model_props)
return model_props
def person_to_dict(person, db_session=None):
result = model_basic_dict(person)
model_attrs = {
'address': person.address,
'bio': person.bio,
'cell_no': person.cell_no,
'email': person.email,
'image': person.image,
'name': person.name,
'last_name': person.last_name,
'full_name': person.full_name,
'phone': person.phone
# 'library':library_to_dict(person.library,db_session)
}
if person.is_legal is None:
result['is_legal'] = False
else:
result['is_legal'] = person.is_legal
result.update(model_attrs)
return result
def item_to_dict(item, db_session):
if not isinstance(item, OrderItem):
raise Http_error(404, Message.INVALID_ENTITY)
result = model_basic_dict(item)
model_props = {
'book_id': item.book_id,
'order_id': item.order_id,
'description': item.description,
'unit_price': item.unit_price,
'discount': item.discount,
'net_price': item.net_price,
'count': item.count,
'price_detail': item.price_detail,
'book': get_book_dict(item.book_id, db_session),
'order': get_order_dict(item.order_id, db_session)
}
result.update(model_props)
return result
