def get_invites_grouped_by_attendee(self):
invite_attendees = InviteAttendee.query(
InviteAttendee.user == self.user.key).fetch() or []
invite_attendees_table = {}
for x in invite_attendees:
invite_attendees_table[x.invite] = x
return invite_attendees_table
def get_invites_grouped_by_attendee(self):
invite_attendees = InviteAttendee.query(
InviteAttendee.user == self.user.key
).fetch() or []
invite_attendees_table = {}
for x in invite_attendees:
invite_attendees_table[x.invite] = x
return invite_attendees_table
def query(self):
"""
Returns an Attendee on the Invite containing the parameter user
"""
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_id)
invite_attendee = InviteAttendee.query(ndb.AND(
InviteAttendee.user == self.user.key,
InviteAttendee.invite == self.invite.key,
)).get()
if not invite_attendee:
return None
return InviteAttendeeQuery(invite_attendee).query()
def query(self):
"""
Returns an Attendee on the Invite containing the parameter user
"""
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_id)
invite_attendee = InviteAttendee.query(
ndb.AND(
InviteAttendee.user == self.user.key,
InviteAttendee.invite == self.invite.key,
)).get()
if not invite_attendee:
return None
return InviteAttendeeQuery(invite_attendee).query()
def execute(self):
query = None
if self.user.email:
query = InviteAttendee.query(
InviteAttendee.email == self.user.email
)
attendees = query.fetch()
# Eventually filter here also by phone
puts = []
for attendee in attendees:
if not attendee.user:
self.update_user_on_attendee(self.user, attendee, put=False)
puts.append(attendee)
ndb.put_multi(puts)
def query(self):
"""
Returns the invite organizer minimally formatted
This is a valid data-format:
{
'unique_id': '',
'name': u'',
'phone':
'email': '',
'status':,
'is_organizer':,
}
"""
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_unique_id)
invite_attendee = InviteAttendee.query(
ndb.AND(
InviteAttendee.invite == self.invite.key,
InviteAttendee.is_organizer == True
)
).get()
if not invite_attendee:
return None
attendee = {
'unique_id': invite_attendee.unique_id,
'invite_attendee_id': invite_attendee.unique_id,
'name': invite_attendee.name,
'phone': invite_attendee.phone,
'email': invite_attendee.email,
'user_id': invite_attendee.user.id() if invite_attendee.user else None,
'status': AttendeeStatus.ORGANIZER,
'notifications': [],
'acknowledges': []
}
return attendee
def query(self):
"""
Returns the invite organizer minimally formatted
This is a valid data-format:
{
'unique_id': '',
'name': u'',
'phone':
'email': '',
'status':,
'is_organizer':,
}
"""
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_unique_id)
invite_attendee = InviteAttendee.query(
ndb.AND(InviteAttendee.invite == self.invite.key,
InviteAttendee.is_organizer == True)).get()
if not invite_attendee:
return None
attendee = {
'unique_id': invite_attendee.unique_id,
'invite_attendee_id': invite_attendee.unique_id,
'name': invite_attendee.name,
'phone': invite_attendee.phone,
'email': invite_attendee.email,
'user_id':
invite_attendee.user.id() if invite_attendee.user else None,
'status': AttendeeStatus.ORGANIZER,
'notifications': [],
'acknowledges': []
}
return attendee
def execute(self):
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_unique_id)
invite_attendees = InviteAttendee.query(
InviteAttendee.unique_id.IN(self.attendees_unique_ids)
).fetch()
body = {
'invite_unique_id': self.invite.unique_id,
'uniquecall_id': guid(),
'attendees': []
}
bulk_notifications = []
for invite_attendee in invite_attendees:
if self._check_if_skip_attendee(invite_attendee):
continue
bulk_notifications += self.create_notification_records(invite_attendee)
body['attendees'].append(NotifyAttendeeQuery(
invite_attendee
).query())
group_id = EventQueue.get_group_id(self.invite.unique_id)
EventQueue.push_event(
endpoint=config.get('api_url') + "/attendees",
headers=get_voiceflows_headers(),
payload=body,
group_id=group_id, #Same Group as Invite Creation
priority=1 #Lower priority than Invite Creation
)
ndb.put_multi(bulk_notifications)
def query(self):
"""
Returns a dictionary for the Invite Attendee Notification
This is a valid data-format:
{
'unique_id': '',
'invite_attendee_id': '',
'name': u'',
'phone':
'email': '',
'status':,
'last_response_on':,
notifications: [
{
unique_id: '',
channel: '',
channel_type: '',
notified_on: '',
}
],
acknowledges: [
{
unique_id: '',
channel: '',
channel_type: '',
response: '',
responded_on: '',
}
]
}
"""
if not self.invite_attendee and self.invite_attendee_id:
self.invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id)
elif not self.invite_attendee and self.invite_attendee_email and self.invite:
self.invite_attendee = InviteAttendee.query(
ndb.AND(
InviteAttendee.invite == self.invite.key,
InviteAttendee.email == self.invite_attendee_email)).get()
if not self.invite_attendee:
raise InviteAttendeeNotFound()
notifications = self.invite_attendee.get_notifications()
acknowledges = self.invite_attendee.get_acknowledges()
attendee = {
'unique_id':
self.invite_attendee.contact.get().unique_id
if self.invite_attendee.contact else '',
'invite_attendee_id':
self.invite_attendee.unique_id,
'name':
self.invite_attendee.name,
'phone':
self.invite_attendee.phone,
'email':
self.invite_attendee.email,
'status':
self.invite_attendee.attendee_status,
'last_response_on':
self.invite_attendee.last_response_on,
'notifications': [],
'acknowledges': []
}
for x in notifications:
attendee['notifications'].append({
'unique_id': x.unique_id,
'channel': x.channel,
'channel_type': x.channel_type,
'notified_on': x.notified_on,
})
for x in acknowledges:
attendee['acknowledges'].append({
'unique_id': x.unique_id,
'channel': x.channel,
'responded_on': x.responded_on,
'response': x.response,
})
return attendee