def _complete_meal_session_construction_and_save(self, meal_sessions, date_time_to_use):
"""
Complete the contruction of the meal sessions
and save if they do not already exist
:param meal_sessions (dict): A dictionary with incomplete meal session data
:param date_time_to_use (datetime): A datetime object to use
:return:
"""
meal_session_date = date(year=date_time_to_use.year,
month=date_time_to_use.month,
day=date_time_to_use.day)
meal_sessions['breakfast']['date'] = meal_session_date
meal_sessions['lunch']['date'] = meal_session_date
for meal_session in meal_sessions.values():
# Ignore creation of meal session if one with in the specified
# time already exists
if MealSessionLogic.validate_meal_session_times(
**{
"name": meal_session.get('name'),
"date_sent": meal_session.get('date'),
"location_id": meal_session.get('location_id'),
"start_time": meal_session.get('start_time'),
"end_time": meal_session.get('stop_time'),
}
):
continue
MealSession(**meal_session).save()
def test_create_session_method_succeeds(self, mock_request_params):
with self.app.app_context():
new_location = LocationFactory.create(id=1, name="Lagos")
tz = pytz.timezone("Africa/Lagos")
self.current_date = datetime.now(tz)
mock_request_params_return_value = [
"lunch", "13:10", "14:45", "".join([
MealSessionLogic.format_preceding(self.current_date.year),
"-",
MealSessionLogic.format_preceding(self.current_date.month),
"-",
MealSessionLogic.format_preceding(self.current_date.day)
]), new_location.id
]
mock_request_params.return_value = mock_request_params_return_value
meal_session_controller = MealSessionController(
self.request_context)
response = meal_session_controller.create_session()
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_json['msg'], 'OK')
self.assertEqual(response_json['payload']['mealSession']['name'],
mock_request_params_return_value[0])
self.assertEqual(
(response_json['payload']['mealSession']['startTime'])[:-3],
mock_request_params_return_value[1])
self.assertEqual(
(response_json['payload']['mealSession']['stopTime'])[:-3],
mock_request_params_return_value[2])
self.assertEqual(response_json['payload']['mealSession']['date'],
mock_request_params_return_value[3])
self.assertEqual(
response_json['payload']['mealSession']['locationId'],
mock_request_params_return_value[4])
def setUp(self):
self.BaseSetUp()
self.logic = MealSessionLogic()
self.base_logic = BaseLogic()
class TestMealSessionLogic(BaseTestCase):
def setUp(self):
self.BaseSetUp()
self.logic = MealSessionLogic()
self.base_logic = BaseLogic()
def tearDown(self):
self.BaseTearDown()
def test_check_two_values_are_greater_method_returns_true(self):
return_value = self.logic.check_two_values_are_greater(2, 1)
self.assertEqual(return_value, True)
def test_check_two_values_are_greater_returns_false(self):
return_value = self.logic.check_two_values_are_greater(1, 2)
self.assertEqual(return_value, False)
def test_check_two_values_are_greater_method_returns_false(self):
return_value = self.logic.check_two_values_are_greater(1, 2)
self.assertEqual(return_value, False)
def test_format_preceding_returns_correct_formatting(self):
return_value = self.logic.format_preceding(2)
self.assertEqual(return_value, "02")
def test_get_location_time_zone_raises_attribute_error(self):
return_value = self.base_logic.get_location_time_zone(2)
self.assertEqual(AttributeError, return_value)
def test_get_location_time_zone_raises_unknownTimeZoneError(self):
LocationFactory.create(id=2, name="Uganda")
return_value = self.base_logic.get_location_time_zone(2)
self.assertEqual(pytz.exceptions.UnknownTimeZoneError, return_value)
def test_check_meal_session_exists_in_specified_time_method_returns_true(
self):
new_location = LocationFactory.create(name="Lagos")
tz = pytz.timezone("Africa/Lagos")
current_date = datetime.now(tz)
first_meal_session = {
"name":
"lunch",
"start_time":
time(hour=13, minute=10),
"end_time":
time(hour=14, minute=40),
"date_sent":
datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
"location_id":
new_location.id
}
MealSessionFactory.create(name="lunch",
start_time=time(hour=13, minute=0),
stop_time=time(hour=14, minute=0),
date=datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
location=new_location)
return_value = self.logic.check_meal_session_exists_in_specified_time(
**first_meal_session)
self.assertEqual(return_value, True)
def test_check_meal_session_exists_in_specified_time_method_returns_false(
self):
new_location = LocationFactory.create(name="Lagos")
tz = pytz.timezone("Africa/Lagos")
current_date = datetime.now(tz)
first_meal_session = {
"name":
"lunch",
"start_time":
time(hour=12, minute=10),
"end_time":
time(hour=12, minute=40),
"date_sent":
datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
"location_id":
new_location.id
}
MealSessionFactory.create(name="lunch",
start_time=time(hour=13, minute=0),
stop_time=time(hour=14, minute=0),
date=datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
location_id=new_location.id)
return_value = self.logic.check_meal_session_exists_in_specified_time(
**first_meal_session)
self.assertEqual(return_value, False)
def test_check_encloses_already_existing_meal_sessions_returns_true(self):
new_location = LocationFactory.create(name="Lagos")
tz = pytz.timezone("Africa/Lagos")
current_date = datetime.now(tz)
first_meal_session = {
"name":
"lunch",
"start_time":
time(hour=12, minute=10),
"end_time":
time(hour=14, minute=40),
"date_sent":
datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
"location_id":
new_location.id
}
MealSessionFactory.create(name="lunch",
start_time=time(hour=13, minute=0),
stop_time=time(hour=14, minute=0),
date=datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
location=new_location)
return_value = self.logic.check_encloses_already_existing_meal_sessions(
**first_meal_session)
self.assertEqual(return_value, True)
def test_check_encloses_already_existing_meal_sessions_returns_false(self):
new_location = LocationFactory.create(name="Lagos")
tz = pytz.timezone("Africa/Lagos")
current_date = datetime.now(tz)
first_meal_session = {
"name":
"lunch",
"start_time":
time(hour=12, minute=10),
"end_time":
time(hour=12, minute=40),
"date_sent":
datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
"location_id":
new_location.id
}
MealSessionFactory.create(name="lunch",
start_time=time(hour=13, minute=0),
stop_time=time(hour=14, minute=0),
date=datetime(year=current_date.year,
month=current_date.month,
day=current_date.day),
location=new_location)
return_value = self.logic.check_encloses_already_existing_meal_sessions(
**first_meal_session)
self.assertEqual(return_value, False)
def __init__(self, request):
BaseController.__init__(self, request)
self.meal_session_repo = MealSessionRepo()
self.meal_service_repo = MealServiceRepo()
self.business_logic = MealSessionLogic()
class MealSessionController(BaseController):
def __init__(self, request):
BaseController.__init__(self, request)
self.meal_session_repo = MealSessionRepo()
self.meal_service_repo = MealServiceRepo()
self.business_logic = MealSessionLogic()
def create_session(self):
"""
Creates a meal session if all data sent meets specified requirements
:return: Json Response
"""
name, start_time, end_time, date, location_id = self.request_params(
'name', 'startTime', 'endTime', 'date', 'locationId')
error_message, data = self.business_logic.validate_meal_session_details(
**{
"name": name,
"date": date,
"location_id": location_id,
"start_time": start_time,
"end_time": end_time,
})
if error_message:
return make_response(jsonify({'msg': error_message}), 400)
new_meal_session = self.meal_session_repo.new_meal_session(
name=data['name'],
start_time=data['start_time'],
stop_time=data['end_time'],
date=data['date_sent'],
location_id=data['location_id'])
new_meal_session.date = new_meal_session.date.strftime("%Y-%m-%d")
return self.handle_response(
'OK',
payload={'mealSession': new_meal_session.serialize()},
status_code=201)
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 list_meal_sessions(self):
"""
List all meal-sessions in the application, based on provided query
"""
options = self.get_params_dict()
options['is_deleted'] = False
sessions = self.meal_session_repo.filter_by(**options)
if sessions.items:
session_list = [session.serialize() for session in sessions.items]
return self.handle_response('OK',
payload={
'MealSessions': session_list,
'meta':
self.pagination_meta(sessions)
})
return self.handle_response('No meal sessions found', status_code=404)
def delete_session(self, meal_session_id):
"""
Deletes a meal session if correct meal_session_id is sent
:return: Json Response
"""
meal_session = self.meal_session_repo.get(meal_session_id)
if meal_session and not meal_session.is_deleted:
meal_session = self.meal_session_repo.update(
meal_session, **dict(is_deleted=True))
meal_session.name = meal_session.name.value
meal_session.start_time = self.business_logic.get_time_as_string(
meal_session.start_time.hour, meal_session.start_time.minute)
meal_session.stop_time = self.business_logic.get_time_as_string(
meal_session.stop_time.hour, meal_session.stop_time.minute)
meal_session.date = meal_session.date.strftime("%Y-%m-%d")
return self.handle_response(
'Meal session deleted successfully',
payload={'mealSession': meal_session.serialize()},
status_code=200)
return self.handle_response('Meal Session Not Found', status_code=404)