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 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 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) )