def test_retrieve_meeting(self):
"""
A meeting can be retrieved
"""
meeting_name = "A meeting"
meeting = MeetingService.create(self.team.id, meeting_name)
retrieved_meeting = MeetingService.get(meeting.id)
self.assertEqual(retrieved_meeting.id, meeting.id)
self.assertEqual(retrieved_meeting.name, meeting_name)
def test_create_meeting_without_venue(self):
"""
A meeting can be created without a venue being provided, defaulting to
an empty string
"""
meeting_name = "A meeting"
meeting = MeetingService.create(self.team.id, meeting_name)
self.assertEqual(meeting.name, meeting_name)
self.assertEqual(meeting.venue, "")
def test_create(self):
"""
A meeting can be created
"""
meeting_name = "A meeting"
meeting_venue = "A meeting venue"
meeting = MeetingService.create(self.team.id, meeting_name, meeting_venue)
self.assertEqual(meeting.name, meeting_name)
self.assertEqual(meeting.venue, meeting_venue)
def get_meetings_of_team(self, request):
"""
Gets the meetings of a given team.
"""
user = IdentityService.get_required_session_user(request)
team_id = re.match(r"/api/teams/([0-9]*)/meetings", request.path)[1]
if not PermissionsService.can_read_meetings_of_team(user.id, team_id):
raise ForbiddenException(
"You are not allowed to view this team's meetings")
meetings = MeetingService.get_meetings_of_team_with_id(team_id)
return JsonResponse(
{"meetings": [serialize_meeting(meeting) for meeting in meetings]},
status=200,
)
def get_items_of_meeting(self, request):
"""
Obtains the items of a meeting
"""
user = IdentityService.get_required_session_user(request)
meeting_id = int(
re.match(r"/api/meetings/([0-9]*)/items", request.path)[1])
meeting = MeetingService.get(meeting_id)
if not PermissionsService.can_write_meetings_of_team(
user.id, meeting.team.id):
raise ForbiddenException(
"You are not allowed to view the items of this meeting")
items = ItemService.get_items_of_meeting_with_id(meeting_id)
return JsonResponse(
{"items": [serialize_item(item) for item in items]}, status=200)
def create_meeting_for_team(self, request):
"""
Creates a meeting for the given team.
"""
user = IdentityService.get_required_session_user(request)
team_id = re.match(r"/api/teams/([0-9]*)/meetings", request.path)[1]
body = json.loads(request.body.decode("utf-8"))
name = body["name"]
venue = body["venue"] if "venue" in body else ""
if not PermissionsService.can_write_meetings_of_team(user.id, team_id):
raise ForbiddenException(
"You are not allowed to create a meeting for this team")
meeting = MeetingService.create(team_id, name, venue)
return JsonResponse({"meeting": serialize_meeting(meeting)},
status=201)
def post_item_to_meeting(self, request):
"""
Creates an item within a meeting.
"""
user = IdentityService.get_required_session_user(request)
meeting_id = int(
re.match(r"/api/meetings/([0-9]*)/items", request.path)[1])
body = json.loads(request.body.decode("utf-8"))
name = body["name"]
description = body["description"]
meeting = MeetingService.get(meeting_id)
if not PermissionsService.can_write_meetings_of_team(
user.id, meeting.team.id):
raise ForbiddenException(
"You are not allowed to create items for this meeting")
item = ItemService.create(meeting.id, name, description)
return JsonResponse({"item": serialize_item(item)}, status=201)
def get_meeting_by_id(self, request):
"""
Returns a given meeting and the team that held it, requires the session
user be a member of said team.
To check team membership (and thus permission to read meetings), it's
fine to get the team ID from the meeting itself for now, as retreiving
meetings is not a particularly expensive operation.
"""
user = IdentityService.get_required_session_user(request)
meeting_id = int(re.match(r"/api/meetings/([0-9]*)", request.path)[1])
meeting = MeetingService.get(meeting_id)
if not PermissionsService.can_read_meetings_of_team(
user.id, meeting.team.id):
raise ForbiddenException(
"You are not allowed to view this meeting")
return JsonResponse({"meeting": serialize_meeting(meeting)},
status=200)
def setUp(self):
self.user = UserService.create("*****@*****.**", "hunter2", "John",
"Doe")
self.team = TeamService.create_team_with_user_as_owner(
self.user, "John's team", "")
self.meeting = MeetingService.create(self.team.id, "A meeting")
def test_create_meeting_throws_if_empty_name(self):
"""
A meeting must have a name, an empty string is not accepted.
"""
with self.assertRaises(BadRequestException, msg="A meeting must have a name"):
MeetingService.create(self.team.id, "", "-")