def upcoming_events(request):
# This gets the first x amount of events after now, x being based on the the url parameter 'numEvents'
context_dict = {
'events':Event.objects.filter(dateTime__gte=timezone.now())[:request.GET.get('numEvents')],
}
# If the request contains sports, then return an HTML segment because it is looking for filtered data
if(request.GET.getlist('sports')):
sports = Sport.objects.filter(sportType__in=request.GET.getlist('sports'))
courts = Court.objects.filter(sport__in=sports)
events = Event.objects.filter(court__in=courts, dateTime__gte=timezone.now())[:request.GET.get('numEvents')]
return render_to_response('events/events_segment.html', {'events':events}, RequestContext(request))
# Returns either a JSON payload or an HTML segment based on the request
if(request.GET.get('html')):
return render_to_response('events/events_segment.html', context_dict, RequestContext(request))
else:
# Creates a dictionary based on this, and then returns it as a JSON payload
jsonPayload = {}
for index, event in enumerate(context_dict['events']):
jsonPayload[index] = model_to_dict(event)
# Also returns a dateTimeStmp parameter as a timestamp in the form of a UTC timestamp
jsonPayload[index]['dateTimeStamp'] = int(time.mktime(jsonPayload[index]['dateTime'].timetuple()))
jsonPayload[index]['dateTime'] = unicode(jsonPayload[index]['dateTime'])
jsonPayload[index]['endTime'] = unicode(jsonPayload[index]['endTime'])
return HttpResponse(json.dumps(jsonPayload), content_type="application/json")
def setUp(self):
super(UserResourceTest, self).setUp()
# Create a user.
self.username = '******'
self.password = '******'
self.user = User.objects.create_user(
self.username, '*****@*****.**', self.password)
# Fetch the ``battleUser`` object we'll use in testing.
self.user_1 = Entry.objects.get(firstName='TestUser1')
# We also build a detail URI, since we will be using it all over.
# DRY, baby. DRY.
self.detail_url = '/api/v1/battleuser/{0}/'.format(self.user_1.pk)
# The data we'll send on POST requests. Again, because we'll use it
# frequently (enough).
self.post_data = {
'user': '******'.format(self.user.pk),
'firstName': 'TestUser1',
'lastName': 'TestUser1',
'nickName': 'TestUser1',
'wins': 3,
'losses': 4,
'winStreak': 2
'created': now()
'last_seen': now()
}
def test_now(self):
without_tz = datetime.datetime(2013, 8, 7, 22, 54, 52)
with_tz = without_tz.replace(tzinfo=Pacific)
with mock.patch('django.utils.timezone.now', return_value=with_tz):
self.assertEqual(now().isoformat(), '2013-08-08T00:54:52-05:00')
with mock.patch('django.utils.timezone.now', return_value=without_tz):
self.assertEqual(now().isoformat(), '2013-08-07T22:54:52')
def test_now(self):
without_tz = datetime.datetime(2013, 8, 7, 22, 54, 52)
with_tz = without_tz.replace(tzinfo=Pacific)
with mock.patch('django.utils.timezone.now', return_value=with_tz):
self.assertEqual(now().isoformat(), '2013-08-08T00:54:52-05:00')
with mock.patch('django.utils.timezone.now', return_value=without_tz):
self.assertEqual(now().isoformat(), '2013-08-07T22:54:52')
def leaderboard(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
if request.is_secure():
prefix = 'https://'
else:
prefix = 'http://'
response_data = {}
response_data['generated_date'] = timezone.now()
response_data['server'] = prefix + request.META['SERVER_NAME']
leaderboard = Points.get_leaderboard()
response_data['leaderboard'] = []
for idx, leader in enumerate(leaderboard):
leader_data = {}
leader_data['position'] = idx + 1
leader_data['username'] = leader.username
leader_data['first_name'] = leader.first_name
leader_data['last_name'] = leader.last_name
leader_data['points'] = leader.total
leader_data['badges'] = leader.badges
response_data['leaderboard'].append(leader_data)
return JsonResponse(response_data)
def leaderboard(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
if request.is_secure():
prefix = 'https://'
else:
prefix = 'http://'
response_data = {}
response_data['generated_date'] = timezone.now()
response_data['server'] = prefix + request.META['SERVER_NAME']
leaderboard = Points.get_leaderboard()
response_data['leaderboard'] = []
for idx, leader in enumerate(leaderboard):
leader_data = {}
leader_data['position'] = idx + 1
leader_data['username'] = leader.username
leader_data['first_name'] = leader.first_name
leader_data['last_name'] = leader.last_name
leader_data['points'] = leader.total
leader_data['badges'] = leader.badges
response_data['leaderboard'].append(leader_data)
return JsonResponse(response_data)
def index(request):
# This returns the first 10 events after the current time
context_dict = {
'events':Event.objects.filter(dateTime__gte=timezone.now())[:10],
'recent_activity': RecentActivity.objects.all().order_by('-id'),
}
return render_to_response('events/index.html',context_dict, RequestContext(request) )
def hydrate_tracker_date(self, bundle, request=None, **kwargs):
# Fix tracker date if date submitted is in the future
if 'tracker_date' in bundle.data:
tracker_date = dateparse.parse_datetime(bundle.data['tracker_date'])
if tracker_date > datetime.datetime.now():
bundle.data['tracker_date'] = timezone.now()
return bundle
def hydrate_tracker_date(self, bundle, request=None, **kwargs):
# Fix tracker date if date submitted is in the future
if 'tracker_date' in bundle.data:
tracker_date = dateparse.parse_datetime(bundle.data['tracker_date'])
if tracker_date > datetime.datetime.now():
bundle.data['tracker_date'] = timezone.now()
return bundle
def store_user_reviews(self, request, *args, **kwargs):
if request:
body = json.loads(request.body)
rating = body['rating']
review = body['review']
# print rating, review
review_object = Reviews.objects.create(review=review,
rating=rating,
time=now())
review_object.save()
return self.create_response(request, {'status': "success"})
def find_near_by_location(self, request, *args, **kwargs):
if request:
body = json.loads(request.body)
# print body
location = str(body['lat']) + ',' + str(body['lng'])
resp = near_by_places(location)
# print resp
if resp['status'] == u'OK':
result = resp['results']
# print result
locations = []
place_ids = []
custom_reviews = [
"Clean and Tidy", "Dirty and Unhygienic",
"Water supply is irregular", "Noisy Environment",
"Incomplete Construction", "Entire place smells bad",
"Ideal for everyone", "Not suitable for women",
"Excessive Charge", "Remotely located"
]
custom_ratings = [5, 1, 2.5, 3, 2.5, 3, 4, 3, 3.5, 3]
for i in range(10):
# print result[i]
place_id = result[i]['place_id']
address = result[i]['vicinity']
location = result[i]['geometry']['location']
try:
map_query = Map.objects.get(place_id=place_id)
except Map.DoesNotExist:
map_query = Map.objects.create(place_id=place_id,
address=address,
location=location)
map_query.save()
review_query = Reviews.objects.create(
place_id=map_query,
rating=custom_ratings[i],
review=custom_reviews[i],
user_locations=location,
time=now())
review_query.save()
locations.append(location)
place_ids.append(place_id)
# print location
# print locations
return self.create_response(
request, {
'status': "success",
'location': locations,
'place_id': place_ids
})
def leaderboard(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
if request.is_secure():
prefix = 'https://'
else:
prefix = 'http://'
response_data = {}
response_data['generated_date'] = timezone.now()
response_data['server'] = prefix + request.META['SERVER_NAME']
leaderboard = Points.get_leaderboard_filtered(request.user,
count_top=20,
above=20,
below=20)
response_data['leaderboard'] = leaderboard
return JsonResponse(response_data)
def lcia_dispatcher(product, method):
"""
same again
"""
uR, annot = random_result("float")
# save the result
R = RealResult(data_type = "float",
unit = uR.unit,
mean_value = uR.value,
st_dev = uR.stdev,
confidence_interval_5 = uR.conf5(),
confidence_interval_95 = uR.conf95())
R.save()
A=Annotation(uuid=R.uuid,relation=method.name,annotation=product.name + " | " + annot)
A.save()
Aa=Annotation(uuid=R.uuid,relation='created',annotation=now())
Aa.save()
return R
def module_dispatcher(prop, chemical, product=None):
"""
first argument is the property to be computed-- should be an instance of models.Property
second argument is the chemical the property is computed about-- instance of models.Chemica
third argument is the product system in scope-- instance of models.Product. not implemented.
This function is only called when a new result is required. Invoke the appropriate module
and return the result! make a random one for now.
"""
M = prop.module
# these should all return a ( uResult , annotation )
uR, annot = {
'Module 01': (None, 'dummy'),
'Module 02': (None, 'dummy'),
'ECHA CombinedTox': echa_tox_lookup(prop, chemical)
}.get(M.name,random_result(prop.data_type))
if uR is None:
return annot
# save the result
R = RealResult(data_type = prop.data_type,
unit = uR.unit,
mean_value = uR.value,
st_dev = uR.stdev,
confidence_interval_5 = uR.conf5(),
confidence_interval_95 = uR.conf95())
R.save()
A=Annotation(uuid=R.uuid,relation='result',annotation=annot)
A.save()
Aa=Annotation(uuid=R.uuid,relation='created',annotation=now())
Aa.save()
return R
def get_object_list(self, request):
return super(
ScheduledOverrideResource,
self).get_object_list(request).filter(end__gt=timezone.now())
def browse(request):
# This returns the first 10 events after the current time
context_dict = {'events':Event.objects.filter(dateTime__gte=timezone.now())[:15]}
context_dict['lastTime'] = int(time.mktime(context_dict['events'].reverse()[0].dateTime.timetuple()))
return render_to_response('events/browse.html',context_dict, context_instance=RequestContext(request) )
