def test_sms_reply_in(self):
if not settings.TEST_SMS: return
user, event, smsuser = self.prep_for_response_sms()
att = Attendant.get({u'user': user[u'id'], u'event': event[u'id']})
self.assertEqual(att[u'status'], status.INVITED, 'user is invited')
response = self.post('/extras/SMS/', args={'From': smsuser[u'number'],
'To': settings.TWILIO_NUMBERS[0],
'Body': '#in'})
self.assertEqual(response.status, 200)
att = Attendant.get({u'user': user[u'id'], u'event': event[u'id']})
self.assertEqual(att[u'status'], status.ATTENDING, 'user is attending')
def get(self, event_id):
event = Event.get({u'id': event_id})
if not event: raise HTTPError(404)
if not event.user_can_access(self.get_user()):
raise HTTPError(401)
self.output({u'attendants': Attendant.find({u'event':
event_id}).serializable(name=True)})
def user_can_access(self, user):
if user[u'username'] == self[u'creator']:
return True
if not self[u'broadcast']:
att = Attendant.get({u'event': self[u'id'],
u'user': user[u'id']})
return att is not None
return True
def post(self, event_id):
'''
Updates an invitee's attendance
'''
body = self.body_dict()
username = self.get_session()[u'username']
user = User.get({u'username': username})
#make sure the event exists
event = Event.get(event_id)
if not event: raise HTTPError(404)
#try to grab the user's existing attendance status
att = Attendant.get({u'event': event[u'id'],
u'user': user[u'id']})
#if the user isn't invited, we need to error out if broadcast is off
if att is None:
if event[u'broadcast']:
att = Attendant(user=user[u'id'], event=event[u'id'])
else:
raise HTTPError(403)
# create a list of acceptable statuses
valid_statuses = [v for k, v in status.__dict__.iteritems() if k[0] != '_']
#make sure status is present and a correct value
if body.get(u'status') not in valid_statuses:
raise HTTPError(400)
notify = (att[u'status'] == status.INVITED
and body[u'status'] == status.ATTENDING)
att[u'status'] = body[u'status']
att.save()
if notify:
#Send out the attendant notifications
for uname in Attendant.to_notify(event, skip=[username]):
notifications.send(uname, {u'type': 'attendant',
u'event_revision': event[u'revision'],
u'event_id': event[u'id'],
u'attendant': username})
def test_auto_invite(self):
user = self.get_user()
user2 = self.make_user()
self.follow(user2, user)
response = self.post('/events/', {
u'broadcast': True,
u'what': 'Testin event creation',
})
self.assertEqual(response.status, 201, 'new event 201')
event = json.loads(response.read())
att = Attendant.get({u'event': event[u'id'], u'user': user2[u'id']})
self.assertNotEqual(att, None, 'user auto-invited')
def get(self, revision):
'''
TODO - enforce user restrictions
'''
#grab the event from the database
event = Event.get({u'revision': revision})
if event is None: raise HTTPError(404)
if not event.user_can_access(self.get_user()):
raise HTTPError(401)
response = {'event': event.serializable()}
#give the user the attendance info if they asked for it
if self.request.arguments.get('attendants'):
response['attendants'] = Attendant.find({u'event':
event[u'id']}).serializable(name=True)
self.output(response)
def post(self, event_id):
#make sure the event exists
event = Event.get(event_id)
if not event: raise HTTPError(404)
#grab the data
body = self.body_dict()
#comment body is required, and must have content
if not u'comment' in body or len(body[u'comment']) == 0:
raise HTTPError(400)
#nonce is optional
if u'nonce' in body:
#if another comment exists with this nonce, it's a double-post
if Comment.get({u'nonce': body[u'nonce'],
u'event': event[u'id'],
u'user': self.get_session()[u'username']}):
raise HTTPError(409)
commenter = self.get_session()[u'username']
#create the comment
Comment(**{
u'comment': body[u'comment'],
u'event': event[u'id'],
u'username': commenter,
}).save()
#Send out the comment notifications
usernames = Attendant.to_notify(event, skip=[commenter])
for username in usernames:
notifications.send(username, {u'type': 'comment',
u'event_revision': event[u'revision'],
u'event_id': event[u'id'],
u'comment': body[u'comment'],
u'commenter': commenter})
def get(self):
'''
Gets a list of events
'''
#store username for later use
username = self.get_session()[u'username']
user = User.get({u'username': username})
#grab the sorting/filtering types from the args
#funky names avoid conflict with python builtins
q_sort = self.get_argument(u'sort', u'soon')
q_filter = self.get_argument(u'filter', u'invited')
category = self.get_argument(u'category', None)
if not q_filter in (u'invited', u'creator', u'public'):
raise HTTPError(404)
#prep the geospatial info
lat = self.get_argument('lat', None)
lng = self.get_argument('lng', None)
if lat is not None and lng is not None:
where = [float(lat), float(lng)]
elif q_sort == u'nearby':
raise HTTPError(403)
events_invited = [ObjectId(att[u'event']) for att in
Attendant.find({u'user': user[u'id']})]
#prep filtering
if q_filter == 'invited':
q_filter = {'$or': [
{u'creator': username},
{u'_id': {'$in': events_invited}},
{
u'broadcast': True,
u'creator': {'$in': user.following()}
}
]}
elif q_filter == u'creator':
q_filter = {u'creator': self.get_argument(u'username', username),
u'$or': [{u'_id': {'$in': events_invited}},
{u'broadcast': True},
{u'broadcast': False, u'creator': username}]}
elif q_filter == u'public':
q_filter = {u'broadcast': True}
if category is not None:
q_filter[u'category'] = category
# This can be uncommented when mongogb gets support for $and
# # Limit to nearby times
# q_filter.update({'$or': [{u'when': {u'$lt': timestamp() + UNTIL_LIMIT,
# u'$gt': timestamp() - SINCE_LIMIT}},
# {u'when': None}]})
# Handle geo sorting
if q_sort == u'nearby':
#set the sort
q_filter.update({u'posted_from': {u'$near': where}})
#use 'soon' as a secondary sort
q_sort = u'soon'
# Run the query
events = db.objects.event.find(q_filter, limit=30)
#perform the required sorting
if q_sort == u'created':
events.sort(u'created', direction=DESCENDING)
elif q_sort == u'soon':
events.sort(u'when', direction=DESCENDING)
events.sort(u'created', direction=DESCENDING)
#output the results
result = {u'events': [e[u'revision'] for e in events]}
self.write(result)
