def execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id)
else:
invite_attendee = InviteAttendee(unique_id=guid())
invite_attendee.name = self.name
invite_attendee.email = self.email
invite_attendee.phone = self.phone
contact = None
if self.user and self.unique_id:
contact = Contact.get_by_unique_id(self.unique_id)
elif self.user:
contact = Contact(unique_id=guid(), user=self.user)
# Here we update the contact with the appropiate Data
if contact:
invite_attendee.contact = contact.key
contact.name = self.name
contact.email = self.email
contact.phone = self.phone
contact.put()
invite = Invite.get_by_unique_id(self.invite_id)
invite_attendee.invite = invite.key
invite_attendee.put()
return invite_attendee.unique_id
def execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id
)
invite = Invite.get_by_unique_id(self.invite_unique_id)
if invite is None:
raise InviteNotFoundException()
author = None
if invite_attendee is not None:
author = invite_attendee.name or invite_attendee.email or invite_attendee.phone
if invite.comments is None:
invite.comments = []
comment = Comment()
comment.author = author
comment.comment = self.comment
comment.commented_on = datetime.datetime.now()
invite.comments.append(comment)
invite.put()
return comment
def query(self):
"""
Returns an Attendee on the Invite containing the parameter user
"""
if not self.invite_attendee:
self.invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id)
invite_attendee_contact = None
if self.invite_attendee.contact:
invite_attendee_contact = self.invite_attendee.contact.get()
return {
'unique_id':
invite_attendee_contact.unique_id
if invite_attendee_contact else '',
'invite_attendee_id':
self.invite_attendee.unique_id,
'user':
self.invite_attendee.user.urlsafe()
if self.invite_attendee.user else None,
'name':
self.invite_attendee.name,
'phone':
self.invite_attendee.phone,
'email':
self.invite_attendee.email,
'status':
self.invite_attendee.attendee_status,
'response_on':
self.invite_attendee.last_response_on
}
def execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(
self.invite_attendee_id)
invite = Invite.get_by_unique_id(self.invite_unique_id)
if invite is None:
raise InviteNotFoundException()
author = None
if invite_attendee is not None:
author = invite_attendee.name or invite_attendee.email or invite_attendee.phone
if invite.comments is None:
invite.comments = []
comment = Comment()
comment.author = author
comment.comment = self.comment
comment.commented_on = datetime.datetime.now()
invite.comments.append(comment)
invite.put()
return comment
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 execute(self):
invite_attendee = None
if self.invite_attendee_id:
invite_attendee = InviteAttendee.get_by_unique_id(self.invite_attendee_id)
else:
invite_attendee = InviteAttendee(
unique_id=guid()
)
invite_attendee.name = self.name
invite_attendee.email = self.email
invite_attendee.phone = self.phone
contact = None
if self.user and self.unique_id:
contact = Contact.get_by_unique_id(
self.unique_id
)
elif self.user:
contact = Contact(
unique_id=guid(),
user=self.user
)
# Here we update the contact with the appropiate Data
if contact:
invite_attendee.contact = contact.key
contact.name = self.name
contact.email = self.email
contact.phone = self.phone
contact.put()
invite = Invite.get_by_unique_id(self.invite_id)
invite_attendee.invite = invite.key
invite_attendee.put()
return invite_attendee.unique_id
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):
attendee = InviteAttendee.get_by_unique_id(self.invite_attendee_id)
ack = InviteAttendeeAcknowledge()
ack.response = self.attending
ack.responded_on = datetime.datetime.now()
ack.channel = self.channel
ack.attendee = attendee.key
ack.invite = attendee.invite
if 'yes' in self.attending.lower():
attendee.attendee_status = AttendeeStatus.YES
elif 'no' in self.attending.lower():
attendee.attendee_status = AttendeeStatus.NO
attendee.last_response_on = datetime.datetime.now()
ack.put()
attendee.put()
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 execute(self):
invite_attendee = None
invite_attendee = InviteAttendee(
unique_id=guid()
)
invite_attendee.name = self.name
invite_attendee.email = self.email
if self.status:
invite_attendee.attendee_status = self.status
invite_attendee.phone = self.phone
if self.contact_unique_id:
contact = Contact.get_by_unique_id(
self.contact_unique_id
)
if contact:
invite_attendee.contact = contact.key
if not self.invite:
self.invite = Invite.get_by_unique_id(self.invite_unique_id)
invite_attendee.invite = self.invite.key
invite_attendee.is_organizer = self.is_organizer
if self.user:
UpdateUserOnAttendeesCommand.update_user_on_attendee(self.user, invite_attendee)
elif invite_attendee.email: # We can only correlate by email now
user = self.user_from_email(invite_attendee.email)
if user:
UpdateUserOnAttendeesCommand.update_user_on_attendee(user, invite_attendee)
invite_attendee.put()
return invite_attendee.unique_id
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
def execute(self):
invite_attendee = InviteAttendee.get_by_unique_id(
self.attendee_unique_id
)
invite_attendee.attendee_status = AttendeeStatus.DELETED
invite_attendee.put()