def get_food_and_store_by_id(food_id, is_dict_result=False):
"""Get food and store by id
:param is_dict_result: True return dict
:param food_id: food_id
:return: food
"""
result = db.session.query(Food, Store).join(Store, Food.restaurant_id == Store.restaurant_id) \
.filter(Food.id == food_id).first()
food, store = result
if is_dict_result:
return object_to_dict_utils(food), object_to_dict_utils(store)
return result
def get_list_allergy_by_uid_dao(uid,
is_list_result=False,
is_dict_result=False):
"""Get all allergy by uid
:param is_dict_result:
:param is_list_result: True return list
:param uid: uid
:return: allergy
"""
if is_dict_result and is_list_result:
return []
results = db.session.query(Allergy, MetaTag.v_name).join(
MetaTag,
MetaTag.id == Allergy.meta_tag_id).filter(Allergy.uid == uid).all()
if is_list_result:
result_list = []
for result in results:
result_list.append(result[1])
return result_list
if is_dict_result:
result_dict = []
for result in results:
data_dict = object_to_dict_utils(result[0])
data_dict['name'] = result[1]
result_dict.append(data_dict)
return result_dict
return results
def get_user_by_uid_dao(uid, is_dict_result=False):
"""Get user by uid
:param uid: uid of user
:param is_dict_result: True return dict, False return object
:return: user information
"""
user = User.query.filter_by(uid=uid).first()
if is_dict_result:
return object_to_dict_utils(user)
return user
def get_food_by_id(food_id, is_dict_result=False):
"""Get food by id
:param is_dict_result: True return dict
:param food_id: food_id
:return: food
"""
result = db.session.query(Food).filter(Food.id == food_id).first()
if is_dict_result:
return object_to_dict_utils(result)
return result
def update_user_dao(user_obj):
"""Update user
:param user_obj: user object
:return: True if update success
"""
try:
User.query.filter_by(uid=user_obj.uid).update(object_to_dict_utils(user_obj))
db.session.commit()
except Exception as e:
db.session.rollback()
logging.error(str(e))
return False
def get_store_by_id_dao(store_id, is_dict_result=False):
"""Get store by id
:param store_id: store_id
:param is_dict_result: True return dict
:return: store response
"""
result = Store.query.filter_by(restaurant_id=store_id).first()
if not result:
return None
if is_dict_result:
return object_to_dict_utils(result)
return result
def get_city_by_name(name, is_dict_result=False):
"""Get location by name
:param name: name of city
:param is_dict_result: True return dict, False return object
:return: city
"""
city = City.query.filter_by(name=name).first()
if city:
if is_dict_result:
return object_to_dict_utils(city)
return city
else:
return None
def get_list_histories_dao(uid, is_dict_result=False):
"""Get list history
:param uid: uid
:param is_dict_result:
:return:
"""
result_foods = db.session.query(History, Food.image, Food.name) \
.join(Food, Food.id == History.food_id).filter(History.uid == uid).all()
if is_dict_result:
list_result = []
for food in result_foods:
dict_result = object_to_dict_utils(food[0])
dict_result['image'] = food[1]
dict_result['food_name'] = food[2]
list_result.append(dict_result)
return list_result
return result_foods
def get_list_bookmarks_dao(uid, is_dict_result=False):
"""Get list bookmarks
:param uid: uid
:param is_dict_result: True return dict result
:return: list bookmarks
"""
results = db.session.query(Food, Store.address) \
.join(Bookmark, Food.id == Bookmark.food_id) \
.join(Store, Food.restaurant_id == Store.restaurant_id) \
.filter(Bookmark.uid == uid).all()
if is_dict_result:
results_list = []
for result in results:
results_dict = object_to_dict_utils(result[0])
results_dict['address'] = result[1]
results_list.append(results_dict)
return results_list
return results
def get_vegetarian_food_by_location_mealtoday(location, uid):
"""Get vegetarian food by location
:param location: location
:param uid: uid
:return: food
"""
location_format = "%{}".format(location)
get_vegetarian_food_script = db.session.query(Food).join(FoodTag, Food.food_id == FoodTag.food_id) \
.join(Tag, FoodTag.tag_id == Tag.id) \
.filter(Tag.name == 'chay')
get_food_by_location_script = db.session.query(Food).join(Store, Food.restaurant_id == Store.restaurant_id) \
.filter(Store.address.like(location_format))
results = get_vegetarian_food_script.intersect(
get_food_by_location_script).order_by(db.func.random()).first()
if results:
foods = object_to_dict_utils(results)
return foods
else:
return None
def search_limited_food_dao(keyword, limit, is_dict_result=False):
"""Search limited food dao
:param keyword: keyword
:param limit: limit
:param is_dict_result: True return dict
:return: limited foods
"""
escaped_keyword = '%{}%'.format(
keyword.replace('%', '/%').replace('_', '/_'))
result_foods = db.session.query(Food, Store.food_name) \
.join(Store, Store.restaurant_id == Food.restaurant_id) \
.order_by(Food.name).filter(Food.name.ilike(escaped_keyword)).limit(limit).all()
if is_dict_result:
result_foods_list = []
for result_food in result_foods:
result_foods_dict = object_to_dict_utils(result_food[0])
result_foods_dict['description'] = result_food[1]
result_foods_list.append(result_foods_dict)
return result_foods_list
return result_foods
def get_top_rating_dao(top, offset):
"""Get top rating dao
:param offset: offset
:param top: limit top foods
:return: top food dict
"""
results = db.session.query(Food, db.func.sum(Rating.rate), Store.food_name) \
.join(Rating, Food.food_id == Rating.food_id) \
.join(Store, Food.restaurant_id == Store.restaurant_id) \
.group_by(Food.id, Store.food_name).order_by(db.func.sum(Rating.rate).desc()).offset(
(offset - 1) * top).limit(top).all()
result_list = []
rank = 0
for result in results:
rank += 1
result_dict = object_to_dict_utils(result[0])
result_dict['rate'] = result[1]
result_dict['description'] = result[2]
result_dict['rank'] = rank
result_list.append(result_dict)
return result_list
def get_food_from_super_tag_name_and_location(super_tag_name, location):
"""Get food by super_tag
@param super_tag_name: name of meta tag
@param location: location of user
@return: List food corresponding of super tag
"""
location_format = "%{}".format(location)
get_food_by_super_tag_script = db.session.query(Food).join(FoodTag, Food.food_id == FoodTag.food_id) \
.join(Tag, Tag.id == FoodTag.tag_id) \
.join(TagMetaTag, Tag.id == TagMetaTag.tag_id) \
.join(MetaTag, MetaTag.id == TagMetaTag.meta_tag_id) \
.join(MetaTagSuperTag, MetaTag.id == MetaTagSuperTag.meta_tag_id) \
.join(SuperTag, SuperTag.id == MetaTagSuperTag.super_tag_id) \
.filter(SuperTag.name == super_tag_name)
get_food_by_location_script = db.session.query(Food).join(Store, Food.restaurant_id == Store.restaurant_id) \
.filter(Store.address.like(location_format))
results = get_food_by_super_tag_script.intersect(
get_food_by_location_script).order_by(db.func.random()).first()
if results is not None:
food = object_to_dict_utils(results)
return food
return None
