def create_new_model(self, *args, **kwargs) -> Model:
new_meeting = super(MeetingEmailApprovalCreateDecorator, self).create_new_model(*args, **kwargs)
if new_meeting:
# if meeting is created in a location that no need for approval from admin, send request email is not
# necessary.
if not new_meeting.is_approval:
self._add_executor(task=RequestApprovalEmailTask(),
delay_arguments={
'meeting_id': new_meeting.id,
'received_email': new_meeting.location.manager.email
})
else:
# else, send email to all attendees and use coordinator access_token to create Google calendar event
attendee_service = AttendeeFormService()
coordinator = attendee_service.get_meeting_coordinator(meeting_id=new_meeting.id)
for attendee in new_meeting.associate_users:
if attendee.user_id is not coordinator.user_id:
self._add_executor(task=InvitedEmailTask(),
delay_arguments={
'meeting_id': new_meeting.id,
'received_email': attendee.user.email
})
self._add_executor(task=CreateEventTask(),
delay_arguments={
'meeting_id': new_meeting.id,
'user_id': coordinator.user_id
})
self._execute()
return new_meeting
def _check_authorization(self, meeting_id: int) -> bool:
"""
Check only the coordinator can update the meeting
:return:
"""
attendee_service = AttendeeFormService()
coordinator = attendee_service.get_meeting_coordinator(meeting_id)
if isinstance(coordinator, MeetingUser):
auth_user = self.get_authenticated_user()
return coordinator.user_id == auth_user.id
return False
def update_model(self, *args, **kwargs) -> bool:
updated = super(BaseApprovalEmailUpdateDecorator, self).update_model(*args, **kwargs)
if updated:
meeting = self.get_model(_id=kwargs['_id'])
if not isinstance(meeting, Meeting):
raise InvalidMeetingIdException()
attendee_service = AttendeeFormService()
coordinator = attendee_service.get_meeting_coordinator(meeting_id=meeting.id)
if meeting.is_approval:
self._add_approval_tasks(meeting=meeting, coordinator=coordinator)
self._execute()
return updated
def __check_coordinator_permission(self, meeting_id: int):
"""
Check coordinator permission. Only coordinator can synchronize
:param meeting_id: meeting_id to find coordinator
:return:True if self.auth_user is coordinator, otherwise, return False
"""
attendee_service = AttendeeFormService()
auth_user = self.get_authenticated_user()
coordinator = attendee_service.get_meeting_coordinator(
meeting_id=meeting_id)
if coordinator.user_id == auth_user.id:
return True
return False
def update_model(self, *args, **kwargs) -> bool:
"""
After service that is created by self._create_service use update_model, add an celery task to interact with
Google calendar
:param args:
:param kwargs:
:return: true if Meeting is update successfully, otherwise, return false
"""
updated = super(BaseCalendarUpdateDecorator,
self).update_model(*args, **kwargs)
meeting_id = kwargs['_id']
meeting = self.get_model(_id=meeting_id)
if not isinstance(meeting, Meeting):
raise InvalidMeetingIdException()
# retrieve coordinator to use its access token (auth user is not always coordinator :( )
attendee_service = AttendeeFormService()
coordinator = attendee_service.get_meeting_coordinator(
meeting_id=meeting_id)
coordinator = coordinator.user
# check valid google calendar id
if meeting.google_calendar_id:
# check meeting state,
# if true send celery update task,
# else send celery delete task
if meeting.state:
self._add_executor(
task=UpdateEventTask(),
delay_arguments={
'meeting_id': meeting_id,
'user_id': coordinator.id
},
async_options={'countdown': self.__DELAY_UPDATED_TIME})
else:
self._add_executor(task=DeleteEventTask(),
delay_arguments={
'meeting_id': meeting_id,
'user_id': coordinator.id
})
else:
self._add_executor(task=CreateEventTask(),
delay_arguments={
'meeting_id': meeting_id,
'user_id': coordinator.id
})
self._execute()
return updated
def update_model(self, *args, **kwargs) -> bool:
meeting_id = kwargs['meeting_id']
auth_user = self.get_authenticated_user()
# update confirm meeting to database
self.__confirm_decorator.set_authenticated_user(
auth_user_id=auth_user.id)
updated = self.__confirm_decorator.update_model(*args, **kwargs)
# set calendar celery task
self._add_executor(task=ConfirmEventTask(),
delay_arguments={
'meeting_id': meeting_id,
'user_id': auth_user.id
})
# set email celery task
meeting_coordinator = AttendeeFormService().get_meeting_coordinator(
meeting_id)
self._add_executor(task=ConfirmEmailTask(),
delay_arguments={
'meeting_id':
meeting_id,
'received_email':
meeting_coordinator.user.email,
'confirm_name':
auth_user.name,
'confirm_email':
auth_user.email,
'confirm_status':
self.__confirm_decorator.get_email_status()
})
self._execute()
return updated
def get_all(self, *args, **kwargs):
attendee_service = AttendeeFormService()
auth_user = self.get_authenticated_user()
# pop sort parameters, because we not sort MeetingUser, we sort Meeting from MeetingUser
sort = kwargs.pop('sort', None)
order = kwargs.pop('order', None)
attendees = attendee_service.get_user_meetings(user_id=auth_user.id,
**kwargs)
sorted_attendees = [
attendee.serialize(inclusion_rs=['meeting'])
for attendee in attendees
]
sorted_attendees.sort(key=lambda n: n['meeting'][sort],
reverse=self.__create_order(order))
return sorted_attendees
def _add_calendar_task(self, meeting_id: int, google_id: None):
if google_id:
if not self.__coordinator:
# if admin use this module, use admin access_token to activate DeleteEvenTask
auth_user = self.get_authenticated_user()
for role in auth_user.roles:
if role == 'admin':
self.__coordinator = auth_user
if not self.__coordinator:
# retrieve coordinator to use its access token (auth user is not always coordinator :( )
attendee_service = AttendeeFormService()
coordinator = attendee_service.get_meeting_coordinator(
meeting_id=meeting_id)
self.__coordinator = coordinator.user
# execute delete google calendar event celery task
self._add_executor(task=DeleteEventTask(),
delay_arguments={
'meeting_id': meeting_id,
'user_id': self.__coordinator.id
})
def update_model(self, *args, **kwargs) -> bool:
"""
Update is_accepted, may_join on MeetingUser table.
:param args:
:param kwargs:
:return:
"""
meeting_id = kwargs.get('meeting_id', 0)
auth_user = self.get_authenticated_user()
attendee_service = AttendeeFormService()
attendee = attendee_service.get_meeting_user(meeting_id=meeting_id,
user_id=auth_user.id)
if isinstance(attendee, MeetingUser):
attendee.note = kwargs.get('note', '')
attendee = self._modify_attendee(attendee)
if super().update_model(updated_model=attendee):
self.commit()
return True
else:
self.rollback()
raise InvalidMeetingIdException()
def update_model(self, *args, **kwargs) -> bool:
"""
Update is_coordinator fields on MeetingUser table
:param args:
:param kwargs:
:return:
"""
meeting_id = kwargs['meeting_id']
coordinator_id = kwargs['coordinator_id']
attendee_service = AttendeeFormService()
current_coordinator = attendee_service.get_meeting_coordinator(
meeting_id=meeting_id)
# check valid meeting id
if current_coordinator:
if self.__check_valid_coordinator_permission(current_coordinator):
# set current meeting coordinator to normal meeting attendee
current_coordinator.is_coordinator = False
if super().update_model(updated_model=current_coordinator):
# update new coordinator
new_coordinator = attendee_service.get_meeting_user(
meeting_id=meeting_id, user_id=coordinator_id)
# check valid new coordinator
if self.__check_activated_coordinator(new_coordinator):
new_coordinator.is_coordinator = True
if super().update_model(updated_model=new_coordinator):
self.commit()
return True
else:
self.rollback()
else:
raise InvalidCoordinatorException()
else:
raise InvalidMeetingPermissionException()
else:
raise InvalidMeetingIdException()