def create_vendor(self):
location = Auth.get_location()
name, tel, address, is_active, contact_person = self.request_params(
'name', 'tel', 'address', 'isActive', 'contactPerson')
vendor = self.vendor_repo.new_vendor(name, address, tel, is_active, contact_person, location).serialize()
return self.handle_response('OK', payload={'vendor': vendor}, status_code=201)
def create_order(self):
"""
creates an order
:return: order object
"""
user_id = Auth.user('id')
location_id = Auth.get_location()
date_booked_for, channel, meal_period, meal_items, menu_id = self.request_params(
'dateBookedFor', 'channel', 'mealPeriod', 'mealItems', 'menuId'
)
if self.order_repo.user_has_order(user_id, date_booked_for, meal_period):
return self.handle_response('You have already booked for this meal period.', status_code=400)
location = LocationRepo().get(location_id)
current_time = current_time_by_zone(location.zone)
if datetime.strptime(date_booked_for, "%Y-%m-%d") < datetime.now():
return self.handle_response('You are not allowed to book for a date in the past', status_code=400)
if int(current_time_by_zone(location.zone).strftime('%H')) > 15:
if check_date_current_vs_date_for(current_time, datetime.strptime(date_booked_for, "%Y-%m-%d")):
return self.handle_response('It is too late to book a meal for the selected date ', status_code=400)
meal_object_items = self.meal_item_repo.get_meal_items_by_ids(meal_items)
new_order = self.order_repo.create_order(
user_id, date_booked_for, meal_object_items, location_id, menu_id, channel, meal_period).serialize()
new_order['mealItems'] = [
item.to_dict(only=OrderController.default_meal_item_return_fields)
for item in meal_object_items
]
return self.handle_response('OK', payload={'order': new_order}, status_code=201)
def test_get_location_header_returns_int_value_when_location_header_present(
self):
with self.app.test_request_context(path='/api/v1/vendors',
method='GET',
headers=self.headers()) as request:
location = Auth.get_location()
self.assertIsInstance(location, int)
self.assertIsNotNone(location)
# def test_has_permission_checks_valid_permissions(self):
# '''To test the has_permission method, We need to create a mock role, user role maping and role-permission mapping '''
#
#
# with self.app.test_request_context(path='/api/v1/vendors', method='GET', headers=self.headers()) as request:
# user_id = Auth.user('id')
#
# role = RoleFactory(id=1)
# user_role = UserRoleFactory(role_id=role.id, user_id=user_id)
# perm = PermissionFactory(id=1, role_id=role.id, keyword='login')
#
# r = Auth.has_permission('create_account')
#
#
# # print(user_id, role.id, role.name, user_role.role_id, user_role.user_id, perm.role_id, r.data.decode('utf-8'))
#
# assert False
def list_orders_date_range(self, start_date, end_date):
"""
List all orders for a particular date
:param start_date:
:param end_date:
:return:
"""
params = self.get_int_params()
location_id = Auth.get_location()
orders = self.order_repo.get_range_paginated_options_all(
start_date=start_date, end_date=end_date, location_id=location_id, **params)
order_list = []
if len(orders.items) > 0:
for order in orders.items:
meal_items = self.order_repo.get(order.id).meal_item_orders
try:
user = self.andela_service.get_user_by_email_or_id(order.user_id)
except Exception as e:
return str(e)
order_item = order.serialize()
order_item['mealItems'] = [
item.to_dict(only=OrderController.default_meal_item_return_fields)
for item in meal_items]
order_item['user'] = '******'.format(user['first_name'], user['last_name']) if user else None
rating = self.order_repo.get_rating(user['id'], 'order', order.id) if user else None
order_item['user_rating'] = rating
order_list.append(order_item)
return self.handle_response('OK', payload={'orders': order_list})
def create_user_role(self):
location = Auth.get_location()
role_id, email_address = self.request_params('roleId', 'emailAddress')
user = self.andela_service.get_user_by_email_or_id(email_address)
if user is None:
return self.handle_response('This user record does not exist',
status_code=400)
user_id = user['id']
user_role = self.user_role_repo.get_unpaginated(role_id=role_id,
user_id=user_id,
is_deleted=False)
if not user_role:
role = self.role_repo.get(role_id)
if role:
user_role = self.user_role_repo.new_user_role(
role_id=role_id,
user_id=user_id,
location_id=location,
email=email_address)
user_role_data = user_role.serialize()
user_role_data.update({'name': user.get('name')})
return self.handle_response(
'OK',
payload={'user_role': user_role_data},
status_code=201)
return self.handle_response('This role does not exist',
status_code=400)
return self.handle_response('This User has this Role already',
status_code=400)
def list_orders_date_range(self, start_date, end_date):
"""
List all orders for a particular date
:param start_date:
:param end_date:
:return:
"""
location_id = Auth.get_location()
orders = self.order_repo.get_range_paginated_options_all(
start_date=start_date, end_date=end_date, location_id=location_id)
order_list = []
if len(orders.items) > 0:
for order in orders.items:
meal_items = self.order_repo.get(order.id).meal_item_orders
user = self.andela_service.get_user_by_email_or_id(
order.user_id)
order_item = order.serialize()
order_item['mealItems'] = [{
'name': item.name,
'image': item.image,
'id': item.id
} for item in meal_items]
order_item['user'] = '******'.format(user['first_name'],
user['last_name'])
order_list.append(order_item)
return self.handle_response('OK', payload={'orders': order_list})
def list_orders(self):
"""
List all orders in the application: should rarely be should
:return:
"""
location_id = Auth.get_location()
current_date = datetime.now()
current_date += timedelta(days=1)
orders = self.order_repo.filter_by(
is_deleted=False,
date_booked_for=current_date.strftime('%Y-%m-%d'),
location_id=location_id)
order_list = []
if len(orders.items) > 0:
for order in orders.items:
meal_items = self.order_repo.get(order.id).meal_item_orders
user = self.andela_service.get_user_by_email_or_id(
order.user_id)
order_item = order.serialize()
order_item['mealItems'] = [{
'name': item.name,
'image': item.image,
'id': item.id
} for item in meal_items]
order_item['user'] = '******'.format(user['first_name'],
user['last_name'])
order_list.append(order_item)
return self.handle_response('OK',
payload={
'orders': order_list,
'meta': self.pagination_meta(orders)
})
def test_get_location_header_returns_int_value_when_location_header_present(
self):
with self.app.test_request_context(path='/api/v1/vendors',
method='GET',
headers=self.headers()) as request:
location = Auth.get_location()
self.assertIsInstance(location, int)
self.assertIsNotNone(location)
def list_vendors(self):
location = Auth.get_location()
vendors = self.vendor_repo.filter_by_asc(
self.vendor_repo._model.name,
is_deleted=False,
is_active=True,
location_id=location)
vendors_list = [vendor.serialize() for vendor in vendors.items]
return self.handle_response('OK', payload={'vendors': vendors_list, 'meta': self.pagination_meta(vendors)})
def validate_meal_session_details(self, **kwargs):
"""
Validate all data before creating a meal session
:return tuple:
"""
location_id = kwargs.get('location_id')
if not location_id:
location_id = Auth.get_location()
error_message_mapper = self.return_error_message_mapper()
tz = self.get_location_time_zone(location_id)
exception_message = error_message_mapper.get(tz)
if exception_message:
return exception_message, None
start_time = self.return_as_object(kwargs.get('start_time'), "time")
end_time = self.return_as_object(kwargs.get('end_time'), "time")
date_sent = self.return_as_object(kwargs.get('date'), "date")
current_date = datetime.now(tz)
message = self.validate_times_and_dates_not_greater_than_each_other(
start_time, end_time,
datetime(year=current_date.year,
month=current_date.month,
day=current_date.day), date_sent)
error_message = error_message_mapper.get(message)
if error_message:
return error_message, None
message = self.validate_meal_session_times(
**{
"name": kwargs.get('name'),
"date_sent": date_sent,
"location_id": location_id,
"start_time": start_time,
"end_time": end_time,
})
message = error_message_mapper.get(message)
if message:
return message, None
return None, {
"name": kwargs.get('name'),
"date_sent": date_sent,
"location_id": location_id,
"start_time": start_time,
"end_time": end_time,
}
def create(self):
location = Auth.get_location()
name, meal_period, description = self.request_params(
'name', 'mealPeriod', 'description')
# check unique together attirbutes
if self.repo.exists(name=name, location_id=location):
return self.handle_response('error', payload={
'message': "Meal Template with name exists in your center"}, status_code=400)
template = self.repo.create(
name, location, meal_period, description)
return self.handle_response('OK', payload=template.serialize(), status_code=201)
def upcoming_vendor_engagements(self):
location = Auth.get_location()
engagements = self.vendor_engagement_repo.get_engagement_by_date()
engagements_list = []
for e in engagements.items:
if e.location_id == location:
engagement = e.serialize()
engagement['vendor'] = e.vendor.serialize()
engagements_list.append(engagement)
return self.handle_response(
'OK', payload={'engagements': engagements_list, 'meta': self.pagination_meta(engagements)}
)
def list_vendor_engagements(self):
location = Auth.get_location()
engagements = self.vendor_engagement_repo.filter_by_desc(
self.vendor_engagement_repo._model.start_date,
is_deleted=False, location_id=location
)
engagements_list = []
for e in engagements.items:
engagement = e.serialize()
engagement['vendor'] = e.vendor.serialize()
engagements_list.append(engagement)
return self.handle_response(
'OK', payload={'engagements': engagements_list, 'meta': self.pagination_meta(engagements)}
)
def create_user(self):
push_id = PushID()
next_id = push_id.next_id()
user_info = self.request_params('firstName', 'lastName', 'imageUrl',
'slackId', 'userId', 'roleId')
first_name, last_name, image_url, slack_id, user_id, role_id = user_info
role = self.role_repo.find_first(id=role_id)
if not role:
return self.handle_response(
f"Role with userTypeId(roleId) {role_id} does not exist",
status_code=400)
if self.user_repo.exists(slack_id=slack_id):
return self.handle_response(
f"User with slackId '{slack_id}' already exists",
status_code=400)
if self.user_repo.exists(user_id=user_id) and user_id is not None:
return self.handle_response(
f"User with userId '{user_id}' already exists",
status_code=400)
slack_id = slack_id if slack_id else next_id
user_id = user_id if user_id else slack_id
user_type = self.user_role_repo.find_first(user_id=user_id) or \
self.user_role_repo.new_user_role(
role_id=role_id, user_id=user_id, location_id=Auth.get_location(),email=None)
user = self.user_repo.new_user(*user_info,
user_id=user_id,
slack_id=slack_id,
user_type=user_type).serialize()
user.__setitem__(
'userRoles',
[role.to_dict(only=['id', 'name', 'help', "timestamps"])])
user.pop('userTypeId')
return self.handle_response('OK',
payload={'user': user},
status_code=201)
def list_orders(self):
"""
List all orders in the application: should rarely be should
:return:
"""
location_id = Auth.get_location()
yesterday = date.today() - timedelta(days=1)
tomorrow = date.today() + timedelta(days=1)
orders = self.order_repo.get_range_paginated_options_all(
start_date=yesterday, end_date=tomorrow, location_id=location_id)
order_list = []
if len(orders.items) > 0:
for order in orders.items:
meal_items = self.order_repo.get(order.id).meal_item_orders
try:
user = self.andela_service.get_user_by_email_or_id(
order.user_id)
except Exception as e:
return str(e)
order_item = order.serialize()
order_item['mealItems'] = [
item.to_dict(
only=OrderController.default_meal_item_return_fields)
for item in meal_items
]
order_item['user'] = '******'.format(
user['first_name'], user['last_name']) if user else None
rating = self.order_repo.get_rating(user['id'], 'order',
order.id) if user else None
order_item['user_rating'] = rating
order_list.append(order_item)
return self.handle_response('OK',
payload={
'orders': order_list,
'meta': self.pagination_meta(orders)
})
def test_get_location_throws_exception_for_invalid_location_id(self):
try:
Auth.get_location('A')
assert False
except Exception as e:
assert True
def update_session(self, meal_session_id):
"""
Updates a meal session if all data sent meets specified requirements
:return: Json Response
"""
meal_session = self.meal_session_repo.get(meal_session_id)
if not meal_session:
return self.handle_response("Meal session Not Found",
status_code=404)
name, start_time, end_time, date, location_id = self.request_params(
'name', 'startTime', 'endTime', 'date', 'locationId')
if not location_id:
location_id = Auth.get_location()
meal_session_data = {
"name": name,
"start_time": start_time,
"end_time": end_time,
"date": date,
"location_id": location_id,
"meal_session_id": meal_session.id,
"meal_session": meal_session,
}
validated_data = self.business_logic.validate_update_of_meal_session(
**meal_session_data)
error_message = validated_data.get("error_message")
if error_message:
return make_response(jsonify({'msg': error_message}), 400)
meal_session_updated = self.meal_session_repo.update_meal_session(
meal_session,
name=validated_data.get("name"),
start_time=validated_data.get("start_time"),
stop_time=validated_data.get("end_time"),
date=validated_data.get("date"),
location_id=validated_data.get("location_id"))
meal_session_updated.name = meal_session_updated.name.value
meal_session_updated.start_time = self.business_logic.get_time_as_string(
meal_session_updated.start_time.hour,
meal_session_updated.start_time.minute)
meal_session_updated.stop_time = self.business_logic.get_time_as_string(
meal_session_updated.stop_time.hour,
meal_session_updated.stop_time.minute)
meal_session_updated.date = meal_session_updated.date.strftime(
"%Y-%m-%d")
return self.handle_response(
'OK',
payload={'mealSession': meal_session_updated.serialize()},
status_code=200)
def dashboard_summary(self):
params = self.get_params_dict()
location = Auth.get_location()
vendors = self.vendor_repo.get_unpaginated(is_deleted=False)
engagements = self.engagement_repo.get_unpaginated(
is_deleted=False, location_id=location)
if 'all_vendor_comparison' in params:
orders = self.order_repo.fetch_all()
vendor_orders = []
for vendor in vendors:
vendor_info = {}
vendor_info['id'] = vendor.id
vendor_info['name'] = vendor.name
vendor_info['collectedOrders'] = len([
order for order in orders.items
if order.order_status == 'collected' and Menu.query.get(
order.menu_id).vendor_engagement.vendor_id == vendor.id
])
vendor_info['uncollectedOrders'] = len([
order for order in orders.items
if order.order_status == 'booked' and Menu.query.get(
order.menu_id).vendor_engagement.vendor_id == vendor.id
])
vendor_info['cancelledOrders'] = len([
order for order in orders.items
if order.order_status == 'cancelled' and Menu.query.get(
order.menu_id).vendor_engagement.vendor_id == vendor.id
])
vendor_orders.append(vendor_info)
return self.handle_response('ok', payload=vendor_orders)
str_start_date = params.get('start_date', None)
start_date = datetime.now().date(
) if str_start_date is None else datetime.strptime(
str_start_date, '%Y-%m-%d').date()
str_end_date = params.get('end_date', None)
end_date = (
datetime.now().date() -
timedelta(14)) if str_end_date is None else datetime.strptime(
str_end_date, '%Y-%m-%d').date()
if start_date < end_date:
return self.handle_response(
'Start date must not be less than end date', status_code=400)
result = []
orders = Order.query.filter(
and_(Order.date_booked_for >= end_date,
Order.date_booked_for <= start_date))
if orders and vendors and engagements:
orders_collected = [
order for order in orders if order.order_status == 'collected'
]
orders_cancelled = [
order for order in orders if order.order_status == 'cancelled'
]
orders_uncollected = [
order for order in orders if order.order_status == 'booked'
]
dates = [
date.date() for date in pd.bdate_range(end_date, start_date)
]
for date in dates:
date_info = {
'date':
date,
'collectedOrders':
len([
order for order in orders_collected
if order.date_booked_for == date
]),
'uncollectedOrders':
len([
order for order in orders_uncollected
if order.date_booked_for == date
]),
'cancelledOrders':
len([
order for order in orders_cancelled
if order.date_booked_for == date
]),
'averageRating':
self.rating_repo.daily_average_rating(date),
'vendor':
self.engagement_repo.vendor_of_the_day(date)
}
result.append(date_info)
return self.handle_response('OK', payload=result)
def test_get_location_throws_exception_when_location_header_missing(self):
try:
Auth.get_location()
assert False
except Exception as e:
assert True
