def test_comment_field_created(self):
user = User(username='******',
password='******',
number='+16666666666')
user.save()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user[u'username'],
})
event.save()
comment = 'the test comment'
post = self.post('/events/%s/comments/' % event[u'id'],
{'comment': comment})
self.assertEqual(post.status, 200, 'comment POST 200')
comment = Comment(user=self.get_user()[u'id'], event=event[u'id'])
self.assertTrue(u'created' in comment, 'comment has created')
get = self.get('/events/%s/comments/' % event[u'id'])
self.assertEqual(get.status, 200, 'got comment')
got_comment = json.loads(get.read())['comments'][0]
self.assertTrue(u'created' in got_comment, 'comment has created')
def test_attendants_with_event(self):
event = Event(broadcast=True,
what='This is a test',
creator=self.get_user()[u'username'])
event.save()
att_user = self.make_user('att_user')
Attendant(**{
u'status': status.ATTENDING,
u'timestamp': timestamp(),
u'event': event[u'id'],
u'user': att_user[u'id'],
}).save()
response = self.get('/events/%s/?attendants=true' % event[u'revision'])
self.assertEqual(response.status, 200, 'event get success')
body = json.loads(response.read())
self.assertTrue(u'attendants' in body, 'response has attendants')
self.assertEqual(len(body['attendants']), 1, 'event has 1 attendant')
self.assertTrue(u'username' in body['attendants'][0], 'att has username')
self.assertTrue(u'user' in body['attendants'][0], 'att has user id')
self.assertTrue(u'event' in body['attendants'][0], 'att has event')
self.assertTrue(u'status' in body['attendants'][0], 'att has status')
self.assertTrue(u'timestamp' in body['attendants'][0], 'att has timestamp')
for k, v in body['attendants'][0].iteritems():
self.assertTrue(v is not None, '%s is not None' % k)
def prep_for_response_sms(self):
user = User(username='******',
password='******',
number='+16666666666')
user.save()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user[u'username'],
})
event.save()
smsuser = User(number='+16475555555', display_name='Testy Smoth')
smsuser.save()
Attendant(user=user[u'id'], event=event[u'id']).save()
SMSRegister(contact_number=smsuser[u'number'],
twilio_number=settings.TWILIO_NUMBERS[0],
event=event[u'id'],
expires=event[u'when'],
user=user[u'id']).save()
return user, event, smsuser
def test_sms_notification_comment(self):
if not settings.TEST_SMS: return
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': self.get_user()[u'username'],
})
event.save()
number = '+16475551234'
name = 'Testy Smoth'
reg, out, is_user = SMS.register(event, [{u'number':number,
u'name':name}])
self.assertEqual(len(reg), 1, 'correct ammout registered')
result = notifications.send(reg[0][u'id'],
{u'type': 'comment',
u'event_revision': event[u'revision'],
u'event_id': event[u'id'],
u'comment': 'my awesome comment',
u'commenter': self.make_user()})
self.assertEqual(len(result), 1, 'the correct number of notifications '
'were sent')
self.assertTrue(result[0], 'the notification was sent correctly')
def test_event_new_notification(self):
to_invite = self.make_user(username='******')
self.register_for_notifications(user=to_invite)
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': self.get_user()[u'username'],
})
event.save()
response = self.post('/events/%s/invites/' % event[u'id'],
{'users': [to_invite[u'username']]})
self.assertEqual(response.status, 200, 'user invited')
nots = self.get_new_notifications(user=to_invite)
self.assertEqual(len(nots), 1, 'one new notification')
notification = nots[0]
self.assertTrue(u'event_revision' in notification,
'poll response has event rev')
self.assertEqual(notification[u'event_revision'], event[u'revision'],
'event has the corrrect revision')
def test_event_comment_notification(self):
to_notify = self.make_user(username='******')
self.register_for_notifications(user=to_notify)
self.register_for_notifications()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': self.get_user()[u'username'],
})
event.save()
Attendant(**{
u'status': status.ATTENDING,
u'timestamp': timestamp(),
u'event': event[u'id'],
u'user': to_notify[u'id'],
}).save()
comment = 'the test comment'
response = self.post('/events/%s/comments/' % event[u'id'],
{'comment': comment})
self.assertEqual(response.status, 200, 'comments POST 200')
nots = self.get_new_notifications(user=to_notify)
self.assertEqual(len(nots), 1, 'one new notification')
notification = nots[0]
self.assertTrue(u'type' in notification,
'poll response has type')
self.assertEqual(notification[u'type'], 'comment',
'event has the correct type')
self.assertTrue(u'event_revision' in notification,
'poll response has event rev')
self.assertEqual(notification[u'event_revision'], event[u'revision'],
'event has the correct revision')
self.assertTrue(u'comment' in notification,
'poll response has comment')
self.assertEqual(notification[u'comment'], comment,
'event has the correct comment')
self.assertTrue(u'commenter' in notification,
'poll response has commenter')
self.assertEqual(notification[u'commenter'], self.get_user()[u'username'],
'event has the correct commenter')
nots = self.get_new_notifications()
self.assertEqual(len(nots), 0, 'no notification for the poster')
def post(self):
'''
Creates a new event
'''
req_body = self.body_dict()
event = Event(creator=self.get_session()[u'username'])
#grab data from the user-supplied dict
what = req_body.get(u'what')
if what is None:
self.output({'error': 'MISSING_FIELDS',
'field': 'what'}, 400)
return
elif len(what) > 140:
self.output({'error': 'FIELD_LENGTH',
'field': 'what'}, 400)
return
event[u'what'] = what
where = req_body.get(u'where')
if where is not None and len(where) > 25:
self.output({'error': 'FIELD_LENGTH',
'field': 'where'}, 400)
return
event[u'where'] = where
#optional:
event[u'broadcast'] = req_body.get(u'broadcast', True)
event[u'when'] = req_body.get(u'when')
event[u'posted_from'] = req_body.get(u'posted_from')
event[u'location'] = req_body.get(u'location')
event[u'category'] = req_body.get(u'category')
event[u'client'] = req_body.get(u'client')
event.save()
resp = dict()
resp_status = 201
if event[u'broadcast']:
usernames = self.get_user().followers()
else:
usernames = req_body.get(u'users', list())
tz = req_body.get(u'timezone', 'America/Toronto')
out_of_numbers = event.invite(usernames=usernames,
contacts=req_body.get(u'contacts'),
tz=tz)
if out_of_numbers is not None:
resp = {'error': 'OUT_OF_NUMBERS',
'contacts': out_of_numbers,
'event_revision': event[u'revision']}
resp_status = 409
resp[u'revision'] = event[u'revision']
resp[u'id'] = event[u'id']
self.output(resp, resp_status)
def test_comment_validation(self):
event = Event(**{
u'what': 'test',
u'broadcast': True,
u'creator': self.get_user()[u'username'],
})
event.save()
response = self.post('/events/%s/comments/' % event[u'id'],
{'comment': ''})
self.assertEqual(response.status, 400, 'comment POST 200')
def test_event_notification_attending_creator(self):
to_attend = self.make_user(username='******')
self.register_for_notifications(user=self.get_user())
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': self.get_user()[u'username'],
})
event.save()
# this attendant will trigger the notification
Attendant(**{
u'status': status.INVITED,
u'timestamp': timestamp(),
u'event': event[u'id'],
u'user': to_attend[u'id'],
}).save()
response = self.post('/events/%s/attendants/' % event[u'id'],
{u'status': status.ATTENDING},
auth_user=to_attend)
self.assertEqual(response.status, 200, 'attendants POST 200')
nots = self.get_new_notifications(user=self.get_user())
self.assertEqual(len(nots), 1, 'one new notification')
notification = nots[0]
self.assertTrue(u'type' in notification,
'poll response has type')
self.assertEqual(notification[u'type'], 'attendant',
'event has the correct type')
self.assertTrue(u'event_revision' in notification,
'poll response has event rev')
self.assertEqual(notification[u'event_revision'], event[u'revision'],
'event has the corrrect revision')
self.assertTrue(u'attendant' in notification,
'poll response has attendant')
self.assertEqual(notification[u'attendant'], to_attend[u'username'],
'event has the corrrect attendant')
def create_event(self):
"""
Returns an instance of Event class
:return:
"""
center_location = self.test_data["events"]["centerLocation"]
coords = [center_location["lat"], center_location["long"]]
event_data = json.loads(
self.test_data["events"]["eventData"]["eventData"])
e = Event(
category=event_data["category"],
datetime=time.time() * 1000,
description=event_data["description"],
local_assistance=event_data["local_assistance"],
location={
u'coords':
GeoPoint(event_data["location"]["coords"]["latitude"],
event_data["location"]["coords"]["longitude"]),
u"geohash":
encode(coords),
},
public={
'share': event_data["public"]["share"],
'view': event_data["public"]["view"]
},
reported_by={'original': {
'anonymous': event_data["anonymous"]
}},
title=event_data["title"],
images=[{
'isNsfw': False,
'isTrusted': True,
'uuid': 'images__image__uuid'
}])
return e
def test_get_none(self):
"""
Tests boundary condition when a Event does not exists in the DB
:return:
"""
_e = Event.get('dne', db)
self.assertEqual(_e, None)
def post(self, event_id):
#grab the event from the db
event = Event.get(event_id)
#make sure the event exists
if event is None:
raise HTTPError(404)
#make sure the client is the event's owner
if not event[u'creator'] == self.get_session()[u'username']:
raise HTTPError(403)
#make sure the request has the correct info in the body
body = self.body_dict()
if not body or (not u'users' in body and not u'contacts' in body):
raise HTTPError(400)
if u'users' in body or u'contacts' in body:
users = body.get(u'users')
#friends is a special case
if users == u'friends':
users = self.get_user().friends()
out_of_numbers = event.invite(usernames=users,
contacts=body.get(u'contacts'))
if out_of_numbers is not None:
self.write(json.dumps({'error': 'OUT_OF_NUMBERS',
'contacts': out_of_numbers,
'event_revision': event[u'revision']}))
self.set_status(409)
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 test_event_revisioning(self):
e = Event(broadcast=True,
what='This is a test',
creator=self.get_user()[u'username'])
self.assertEqual(e[u'revision'], None, 'unsaved event has no revision')
e.save()
self.assertTrue(e[u'revision'] is not None, 'saving creates revision')
old_rev = e[u'revision']
e[u'what'] = 'This is an edit'
e.save()
self.assertTrue(e[u'revision'] != old_rev, 'edits create new revisions')
def test_sms_comment(self):
display_name = 'Test User display'
user = User(number='+16666666666',
display_name=display_name)
user.save()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user[u'username'],
})
event.save()
comment = 'the test comment'
Comment(**{
u'comment': comment,
u'event': event[u'id'],
u'user': user[u'id']
}).save()
get = self.get('/events/%s/comments/' % event[u'id'])
self.assertEqual(get.status, 200, 'comment GET 200')
try:
get = json.loads(get.read())
except ValueError:
self.assertTrue(False, 'comment GET not JSON')
self.assertTrue('comments' in get,
'comments returned')
self.assertEqual(len(get['comments']), 1,
'correct number of comments')
self.assertFalse('username' in get['comments'][0],
'username field unavailable')
self.assertTrue('display_name' in get['comments'][0],
'display_name field available')
self.assertEqual(get['comments'][0]['display_name'], display_name,
'display_name field set correctly')
def test_new_comment(self):
user = User(username='******',
password='******',
number='+16666666666')
user.save()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user[u'username'],
})
event.save()
comment = 'the test comment'
post = self.post('/events/%s/comments/' % event[u'id'],
{'comment': comment})
self.assertEqual(post.status, 200, 'comment POST 200')
get = self.get('/events/%s/comments/' % event[u'id'])
self.assertEqual(get.status, 200, 'comment GET 200')
try:
get = json.loads(get.read())
except ValueError:
self.assertTrue(False, 'comment GET not JSON')
self.assertTrue('comments' in get, 'comment GET has comments')
self.assertEqual(len(get['comments']), 1, 'comment GET return 1 '
'comment')
self.assertTrue('comment' in get['comments'][0], 'comment GET has '
'comments')
self.assertEqual(get['comments'][0]['comment'], comment, 'comment GET '
'returned the right comment')
self.assertTrue('username' in get['comments'][0],
'comment GET has username')
self.assertFalse('display_name' in get['comments'][0],
'comment GET does not have display_name')
def test_get(self):
"""
Creates, saves a test Event data. Then fetches it from DB and asserts
that both should be key-value pairwise exactly the same
:return:
"""
e = self.create_event()
key = e.save(db)
_e = Event.get(key, db)
self.assertEqual(e.to_dict(), _e.to_dict())
def test_sms_notification_creation(self):
if not settings.TEST_SMS: return
user = User(username='******',
password='******',
number='+16666666666')
user.save()
event = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'test',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user[u'username'],
})
event.save()
number = '+16475551234'
name = 'Testy Smoth'
reg, out, is_user = SMS.register(event, [{u'number':number, u'name':name},
{u'number':user[u'number'],
u'name':name}])
self.assertEqual(len(reg), 1, 'correct ammout registered')
self.assertEqual(len(out), 0, 'correct ammout out of numbers')
self.assertEqual(len(is_user), 1, 'correct ammout are already users')
reged = reg[0]
self.assertEqual(reged.__class__, User)
self.assertTrue(u'id' in reged)
result = notifications.send(reged[u'id'],
{u'type': 'invite',
u'event_revision': event[u'revision'],
u'event_id': event[u'id']})
self.assertEqual(len(result), 1, 'the correct number of notifications '
'were sent')
self.assertTrue(result[0], 'the notification was sent correctly')
def send(self, user, client_id, message):
from api.events.models import Event
if message[u'type'] not in (u'invite', u'comment'):
return False
smsee = SMSRegister.get({u'event': message[u'event_id'],
u'contact_number': client_id})
if smsee is None: return False
event = Event.get(message[u'event_id'])
if event is None: return False
account = twilio.Account(settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN)
texts = list()
if message[u'type'] == u'invite':
tz = smsee[u'tz'] or 'America/Toronto'
t2 = ('%s shared a plan with you on '
'Connectsy. ' % event[u'creator'])
if event[u'where'] is not None:
t2 += 'Where: %s' % event[u'where']
if event[u'when'] is not None and event[u'when'] != 0:
t2 += ", "
else:
t2 += ". "
if event[u'when'] is not None and event[u'when'] != 0:
t2 += 'When: %s. ' % format_date(event[u'when'], tz=tz)
t2 += 'Reply to send a comment, include #in to join.'
texts.append(t2)
texts.append('What\'s the plan: %(what)s' %
{'username': event[u'creator'],
'what': event[u'what']})
elif message[u'type'] == u'comment':
texts.append('%(commenter)s commented: %(comment)s' % message)
if len(texts[-1]) > 160:
texts[-1] = texts[-1][:157]+"..."
try:
for text in texts:
account.request(SMS_OUTPUT_URL, 'POST', {
'To': smsee[u'contact_number'],
'Body': text,
'From': smsee[u'twilio_number'],
})
return True
except HTTPError, e:
print e.read()
return False
def delete(self, revision):
'''
Deletes an event, if the current user it that event's owner.
TODO - remove associated attendance
'''
event = Event.get({u'revision': revision})
if event is None:
raise HTTPError(404)
if event[u'creator'] != self.get_user()[u'username']:
raise HTTPError(403)
db.objects.event.remove(event[u'id'], safe=True)
self.finish()
def test_event_list_auth(self):
user = self.get_user()
user2 = self.make_user()
event1 = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'user2 created',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user2[u'username'],
})
event1.save()
Attendant(user=user[u'id'], event=event1[u'id']).save()
event2 = Event(**{
u'where': 'test',
u'what': 'user3 created',
u'broadcast': False,
u'creator': user2[u'username'],
})
event2.save()
event3 = Event(**{
u'where': 'test',
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user2[u'username'],
})
event3.save()
response = self.get('/events/?filter=creator'
'&username=%s' % user2[u'username'])
self.assertEqual(response.status, 200, 'response OK')
events = json.loads(response.read())[u'events']
self.assertTrue(event1[u'revision'] in events, 'invited returned')
self.assertTrue(event3[u'revision'] in events, 'broadcast returned')
self.assertEqual(len(events), 2, 'correct number of events returned')
def test_save(self):
"""
Saves the test image in the database and checks if the process is
successful by comparing the dictionaries
:return:
"""
e = self.create_event()
incident_id = e.save(db)
i = create_image(uuid='image uuid', name='image.png')
i.save(incident_id, db)
e.images.append(i.to_dict())
_e = Event.get(incident_id, db)
self.assertEqual(e.to_dict(), _e.to_dict())
def test_geo_queries(self):
"""
Tests the nearby geo spatial query
:return:
"""
coords = {
"latitude": self.test_data["events"]["centerLocation"]["lat"],
"longitude": self.test_data["events"]["centerLocation"]["long"]
}
max_distance = 2000
events = Event.get_events_around(center=coords,
max_distance=max_distance,
cluster_threshold=100.0,
db=db,
collection_name=Event.collection_name)
self.assertTrue(isinstance(events, list))
def test_event_new_created(self):
response = self.post('/events/', {
u'broadcast': True,
u'what': 'Testin event creation',
})
self.assertEqual(response.status, 201, 'new event 201')
response = self.post('/events/', {
u'broadcast': True,
u'what': 'Testin event creation',
})
self.assertEqual(response.status, 201, 'new event 201')
events = Event.find({u'creator': self.get_user()[u'username']})
self.assertEqual(len(events), 2, '2 events created')
self.assertNotEqual(events[0][u'created'], events[1][u'created'],
'created times are different')
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):
'''
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 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, event_id):
'''
Gets all comments for a given event.
'''
#make sure the event exists
if not Event.get(event_id): raise HTTPError(404)
#show them comments!
comments = Comment.find({u'event': event_id})
comments.sort(u'timestamp', pymongo.ASCENDING)
ret_coms = []
for c in comments:
user = User.get(c[u'user'])
ret = c.__data__
ret[u'username'] = user.__data__.get(u'username', None)
if ret[u'username'] is None:
del ret[u'username']
ret[u'display_name'] = user.__data__.get(u'display_name', None)
if ret[u'display_name'] is None:
del ret[u'display_name']
ret_coms.append(ret)
self.output({u'comments': ret_coms})
def handle(self, *args, **options):
# Event.objects.all().delete()
# Match.objects.all().delete()
# return
client = GraphQLClient('https://vk-hackathon-gateway.trbna.com/ru/graphql/')
for match_id in match_ids:
query = base_query % (match_id, 'match_started', 'statMatchStarted')
response = client.execute(query)
print(response)
response = json.loads(response)
match_data = response.get('data', {}).get('stat_match')
home_team_data = match_data.get('home')
away_team_data = match_data.get('away')
start_time = match_data.get('scheduledAt')
status = match_data.get('status')
minute = match_data.get('currentMinute')
home_team, created = Team.objects.update_or_create(
global_id=home_team_data.get('team', {}).get('id'),
defaults=dict(
name=home_team_data.get('team', {}).get('name'),
logo = home_team_data.get('team', {}).get('logo').get('url'),
)
)
away_team, created = Team.objects.update_or_create(
global_id=away_team_data.get('team', {}).get('id'),
defaults=dict(
name=away_team_data.get('team', {}).get('name'),
logo = away_team_data.get('team', {}).get('logo').get('url'),
)
)
match, created = Match.objects.update_or_create(
global_id=match_id,
defaults=dict(
start_datetime=start_time, status=status, minute=minute,
home_team_score = home_team_data.get('score'),
away_team_score = away_team_data.get('score'),
home_team=home_team,
away_team=away_team
)
)
for event_type in event_types:
query = base_query % (match_id, event_type['code'], event_type['model'])
result = client.execute(query)
print(result)
data = json.loads(result)
events = data.get('data', {}).get('stat_match').get('events', [])
for event_data in events:
time = event_data.get('time')
code = event_type['code']
if code is 'match_started':
match.real_start_datetime = time
match.save()
continue
try:
event = Event.objects.get(global_id=event_data.get('id'))
except Event.DoesNotExist:
event = Event(global_id=event_data.get('id'))
event.type = code
event.time = time
event.team = event_data.get('team')
event.match = match
event.match_time = event_data.get('value', {}).get('matchTime')
event.player_name = event_data.get('value', {}).get('player', {}).get('lastName')
event.player_avatar = event_data.get('value', {}).get('player', {}).get('avatar', {}).get('main')
event.home_score = event_data.get('value', {}).get('homeScore')
event.away_score = event_data.get('value', {}).get('awayScore')
event.method_score = event_data.get('value', {}).get('methodScore')
event.save()
def test_event_list_sort(self):
t1 = timestamp()
t2 = timestamp()
t3 = timestamp()
e1 = Event(**{
u'when': t1,
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'creator': self.get_user()[u'username'],
u'created': t1,
})
e1.save()
e2 = Event(**{
u'when': t2,
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'creator': self.get_user()[u'username'],
u'created': t3,
})
e2.save()
e3 = Event(**{
u'when': t2,
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'creator': self.get_user()[u'username'],
u'created': t2,
})
e3.save()
e4 = Event(**{
u'when': t3,
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'creator': self.get_user()[u'username'],
u'created': t1,
})
e4.save()
response = self.get('/events/?sort=soon&filter=creator&'
'username=%s' % self.get_user()[u'username'])
self.assertEqual(response.status, 200, 'response OK')
events = json.loads(response.read())[u'events']
self.assertEqual(len(events), 4, 'correct number of events returned')
self.assertEqual(events[0], e1[u'revision'],
'event 1 when correct, primary sort')
#unconnect to test secondary sort
# self.assertEqual(events[1], e3[u'revision'],
# 'event 3 when correct, secondary sort')
# self.assertEqual(events[2], e2[u'revision'],
# 'event 2 when correct, secondary sort')
self.assertEqual(events[3], e4[u'revision'],
'event 4 when correct, primary sort')
def test_event_list_invited(self):
user = self.get_user()
user2 = self.make_user(username='******')
user3 = self.make_user(username='******')
self.follow(user, user2, reciprocal=True)
self.follow(user3, user, reciprocal=True)
event1 = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'user2 created',
u'broadcast': False,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user2[u'username'],
})
event1.save()
Attendant(user=user[u'id'], event=event1[u'id']).save()
event2 = Event(**{
u'where': 'test',
u'what': 'user3 created',
u'broadcast': False,
u'creator': user3[u'username'],
})
event2.save()
Attendant(user=user[u'id'], event=event2[u'id'],
status=status.ATTENDING).save()
event3 = Event(**{
u'where': 'test',
u'what': 'user2 created, broadcast',
u'broadcast': True,
u'posted_from': [37.422834216666665, -122.08536667833332],
u'creator': user2[u'username'],
})
event3.save()
event4 = Event(**{
u'where': 'test',
u'when': timestamp(),
u'what': 'user3 created',
u'broadcast': False,
u'creator': user3[u'username'],
})
event4.save()
response = self.get('/events/?filter=invited')
self.assertEqual(response.status, 200, 'response OK')
events = json.loads(response.read())[u'events']
self.assertEqual(len(events), 3, 'correct number of events returned')
self.assertTrue(event1[u'revision'] in events, 'event 1 returned')
self.assertTrue(event2[u'revision'] in events, 'event 2 returned')
self.assertTrue(event3[u'revision'] in events, 'event 3 returned')