def get(self, request, *args, **kwargs): """Returns a user's profile.""" # Get user try: username = kwargs.get('username') user = DjangoDev.objects.get(username=username) except: return Http404('This user does not exist') # Serialize user user_fields = ['username', 'job_title', 'company', 'interests', 'email', 'website', 'image'] serialized_user = serialize(user, fields=user_fields) # Serialize attached posts # Check if logged in user is authorized to view these posts model_filters = {"user": user} if not ((request.user.is_authenticated()) and (user == request.user)): model_filters["is_draft"] = True posts = paginate(request=request, model=BlogPost, model_filters=model_filters) post_fields = ['title', 'caption', ('url', lambda obj: obj.get_url()), ] serialized_posts = serialize(posts.object_list, fields=post_fields) # Conjoin the two together serialized_user['posts'] = serialized_posts return Http200(serialized_user)
def get(self, request, *args, **kwargs): """Returns the main quote, and the latest meetups, jobs, and posts.""" # Posts{"is_draft": False} posts = BlogPost.objects.filter(**{"is_draft": False})[:5] post_fields = [ "title", "caption", ("url", lambda obj: obj.get_url()) ] # Jobs jobs = Job.objects.all()[:5] job_fields = ["title", "company", ("url", lambda obj: obj.get_url()) ] # Meetups meetups = Meetup.objects.all()[:5] meetup_fields = ["title", "event_url"] return_data = { "caption": HOME_CAPTION, "posts": serialize(posts, post_fields), "jobs": serialize(jobs, job_fields), "meetups": serialize(meetups, meetup_fields) } return Http200(return_data)
def post(self, request, format=None): print "User: "******"Data: ", request.POST # print "Method: ",request.method if request.method == "POST": print request.POST if "code" in request.POST: code = request.POST.get('code') print code ticket = get_object_or_404(EventTickets, code=code) print ticket.email, ticket dict_obj = { 'id': ticket.id, 'email': ticket.email, 'promocode_success': ticket.promocode_success, 'expire': ticket.expire, 'amount': ticket.amount, 'quantity': ticket.quantity, 'earlybird_ticket': ticket.earlybird_ticket, 'group_ticket': ticket.group_ticket, 'code': ticket.code, 'is_attended': ticket.is_attended, 'created_at': str(ticket.created_at), 'phone': ticket.phone, 'event': ticket.event.name, } print dict_obj return Http200(serialize(dict_obj)) elif "code_update" in request.POST: code = request.POST.get('code_update') print code ticket = get_object_or_404(EventTickets, code=code) ticket.is_attended = True ticket.save() dict_obj = { 'id': ticket.id, 'email': ticket.email, 'promocode_success': ticket.promocode_success, 'expire': ticket.expire, 'amount': ticket.amount, 'quantity': ticket.quantity, 'earlybird_ticket': ticket.earlybird_ticket, 'group_ticket': ticket.group_ticket, 'code': ticket.code, 'is_attended': ticket.is_attended, 'created_at': str(ticket.created_at), 'phone': ticket.phone, 'event': ticket.event.name, } print Http200(serialize(dict_obj)) return Http200(serialize(dict_obj)) print 'get' return HttpResponse("No such method available.")
def post(self, request): try: cluster = Cluster.objects.get(pk=request.data['uuid']) except Cluster.DoesNotExist: return Http404("That cluster does not exist.") form = ClusterForm(request.data, instance=cluster) if form.is_valid(): form.save() else: return serialize([(k, v[0]) for k, v in form.errors.items()]) return serialize(cluster)
def test_serialize_doesnt_mutate_fields(self): runs = [0] def accessor(obj): runs[0] += 1 return 'foo' # If fields are appended on, 'desc' will be twice in the list # for the second run, so in total the accessor function will be # run 3 instead of 2 times serialize([self.author, self.author], fields=['id'], include=[('desc', accessor)]) self.assertEqual(runs[0], 2)
def put(self, request, sensor_id): sensor = self.get_sensor(request, sensor_id) if not isinstance(sensor, Sensor): return sensor form = SensorForm(request.data, instance=sensor) if form.is_valid(): form.save() else: return serialize([(k, v[0]) for k, v in form.errors.items()]) return serialize(sensor)
def get(self, request, *args, **kwargs): """Returns a list of public or private posts, depending on whether or not the requested user is the one authenticated, """ username = kwargs.get('username') try: request_user = get_user_model().objects.get(username=username) except: return Http404("User, %s, does not exist" % username) if request.user.is_authenticated() and \ username == request.user.username: model_filters = {'user': request_user} else: model_filters = {'user': request_user, 'is_draft': False} posts = paginate(request=request, model=BlogPost, model_filters=model_filters) post_fields = ["title", "caption", ("last_updated", lambda obj: obj.last_updated.strftime( "%B %d, %Y")), ("url", lambda obj: obj.get_url()), ("user", dict(fields=[ "username", 'image', ("url", lambda obj: obj.get_url()) ])) ] serialized_data = { "posts": serialize(posts.object_list, post_fields), "page": posts.number, "count": posts.paginator.per_page } return Http200(serialized_data)
def get(self, request, *args, **kwargs): """Returns a list of paginated comments.""" try: # Check if Blog post exists, and return a list of related comments username = kwargs.get('username') user = get_user_model().objects.get(username=username) title_slug = kwargs.get('title_slug') post = BlogPost.objects.get(user=user, title_slug=title_slug) model_filters = {"post": post} comments = paginate(request=request, model=Comment, model_filters=model_filters) comment_fields = ['text', 'pk', ('date_created', lambda obj: obj.date_created.strftime( "%B %d, %Y")), ('date_updated', lambda obj: obj.date_updated.strftime( "%B %d, %Y")), ('user', dict(fields=[ 'username', 'image', ('url', lambda obj: obj.get_url()) ])) ] return_data = { "comments": serialize(comments.object_list, comment_fields), "page": comments.number, "count": comments.paginator.per_page } return Http200(return_data) except: return Http404("Blog post does not exist.")
def get(self, request, *args, **kwargs): """Returns the data for a full blog post, and a hyperlink for attached comments. """ try: # Check if blog post exists title = kwargs.get('title_slug') username = kwargs.get('username') user = get_user_model().objects.get(username=username) post = BlogPost.objects.get(title_slug=title, user=user) except: return Http404("This blog post does not exist.") if post.is_draft and request.user.username != user.username: return Http403("You are not authorized to view this post " "because you are not the owner, and it is not public yet.") post_fields = ['title', 'caption', 'text', 'pk', ('last_updated', lambda obj: obj.last_updated.strftime( "%B %d, %Y")), ('user', dict(fields=[ 'username', ('url', lambda obj: obj.get_url()) ])) ] if post.is_draft == False: post_fields.append(('date_published', lambda obj: obj.date_published.strftime("%B %d, %Y"))) return_data = serialize(post, fields=post_fields) return Http200(return_data)
def get(self, request): """ @query page Requested page number @query per_page Number of results per page """ objects = request.user.team.advisories \ .prefetch_related("sensor", "rule") \ .order_by("-created") # Parse Parameters per_page = safe_cast(request.GET.get("per_page"), int, default=100) page = safe_cast(request.GET.get("page"), int, default=1) pages = Paginator(objects, per_page) try: advisories = pages.page(page) except EmptyPage: return None return serialize({ "advisories": AdvisoryPresenter(advisories.object_list).serialized, "page": page, "num_pages": pages.num_pages, })
def iOSLoginBAWF(request): if request.method == "POST": print 'abcd' print request.POST print request.GET print request username = request.POST.get('username') password = request.POST.get('password') if not username and not password: print "response inside if" return Http400("failed") print 'ca', username print 'ca', password user_auth = authenticate(username=username, password=password) try: print 'auth', user_auth user_auth.backend = 'django.contrib.auth.backends.ModelBackend' auth_login(request, user_auth) print 'auth' if not user_auth.is_staff: return Http400("failed") token = Token.objects.get_or_create(user=user_auth)[0] # return HttpResponse(json.dumps({ # 'key':token.key, # })) return Http200(serialize({ 'key': token.key, })) except Exception as e: print e return Http400("failed")
def get(self, request, pk, *args, **kwargs): params = request.params fields = self.default_fields if 'fields' in params: fields = params.pop('fields').split(",") related, config = get_fields(self.serialize_config, fields=fields) self.start_debug() try: obj = self.model.objects.prefetch_related(*related).get(pk=pk) except ObjectDoesNotExist as e: raise HttpError(404, "Error: {}".format(e)) except Exception: raise HttpError(500, "Error: Something went wrong with your request") serialized = serialize(obj, **config) serialized['debug'] = self.get_debug() response = Http200(serialized) response['Access-Control-Allow-Origin'] = "*" return response
def post(self, request): form = AuthorForm(request.data) if form.is_valid(): author = form.save() return Http201(serialize(author)) else: return Http400(reason='invalid author data', details=form.errors)
def post(self, request): """Assign boat to timeslot.""" fields = ('timeslot_id', 'boat_id') ids = prepare_record(request.data, fields) ts = Timeslot.objects.get(pk=int(ids['timeslot_id'])) boat = Boat.objects.get(pk=int(ids['boat_id'])) return serialize(Assignment.objects.create(boat=boat, timeslot=ts))
def get(self, request): sensor_id = request.GET.get("sensor") param = Q() if sensor_id: param = Q(sensor=sensor_id) rules_count = request.user.team.advisories \ .filter(param) \ .prefetch_related("rule") \ .values("rule") \ .annotate(Count("rule")) \ .order_by() rule_map = {} for r in Rule.objects.values("id", "name").all(): rule_map[r["id"]] = r["name"] advisory_total = request.user.team.advisories \ .filter(param) \ .count() type_data = [] for a in rules_count: type_data.append({ "name": rule_map[a["rule"]], "count": a["rule__count"], }) return serialize({ "total": advisory_total, "types": type_data, })
def post(self, request): """Create a timeslot.""" fields = ('start_time', 'duration') rec = prepare_record(request.data, fields) rec['end_time'] = duration_to_timestamp(rec['duration'], rec['start_time']) del rec['duration'] return serialize(self._augment(Timeslot.objects.create(**rec)))
def get(self, request, sensor_id): sensor = self.get_sensor(request, sensor_id) if not isinstance(sensor, Sensor): return sensor objects = sensor.advisories.prefetch_related("rule") \ .order_by("-created") # Parse Parameters per_page = safe_cast(request.GET.get("per_page"), int, default=100) page = safe_cast(request.GET.get("page"), int, default=1) pages = Paginator(objects, per_page) try: advisories = pages.page(page) except EmptyPage: return None return serialize({ "advisories": AdvisoryPresenter(advisories.object_list).serialized, "page": page, "num_pages": pages.num_pages, })
def test_serialize_related_flatten(self): """Test injection of related models' fields into the serialized one""" b = self.books[0] s = serialize(b, fields=[('author', dict())], fixup=flatten('author')) self.assertEqual(s['name'], b.author.name)
def test_serialize_related_flatten(self): """Test injection of related models' fields into the serialized one""" b = self.books[0] s = serialize(b, related={ 'author': (None, None, True) }) self.assertEqual(s['name'], b.author.name)
def put(self, request, item_id): item = Item.objects.get(pk=item_id) if item.user != request.user: return HttpResponseForbidden() self.request_to_item(request, item) item.user = request.user item.save() return serialize(item)
def get(self, request, pk): pages = Page.objects.filter(course_id=pk) # on inclut le champs "order" pour mettre en évidence la page active dans le menu return serialize(pages, fields=[ 'name', 'order', ('sections', dict(fields=['name'])) ])
def get(self, request, *args, **kwargs): params = dict(request.GET) response = Http200(serialize( self.get_object(request, *args, **kwargs), **self.PUBLIC_SCHEMA)) response['Access-Control-Allow-Origin'] = "*" return response
def get(self, request, *args, **kwargs): params = dict(request.GET) response = Http200( serialize(self.get_object(request, *args, **kwargs), **self.PUBLIC_SCHEMA)) response['Access-Control-Allow-Origin'] = "*" return response
def get(self, request): from .update import apply_modeldiffs result = apply_modeldiffs() if len(result['rows_skipped']) > 0: mail_admins('Some modeldiffs failed to apply!', 'ERROR!') return serialize(result['qs'], exclude=('the_geom'))
def blog_detail(request, pk, *args, **kwargs): # were going to serialize the data into json and return it via the url # with this object using .get is not iterable because it only returns one item # post = Post.objects.get(pk=pk, published=True) soooo..you have to use post = Post.objects.filter(pk=pk, published=True) data = serialize(post) jsondata = json.dumps(data, cls=DjangoJSONEncoder) return HttpResponse(jsondata, mimetype="application/json")
def get(self, request): """List timeslots. ?date: YYYY-MM-DD format.""" try: dt = dateparser.parse(request.params.get('date')) except: return Http400("date param missing or invalid format") match = dict(zip(('start_time__gte', 'start_time__lt'), date_bounds(dt))) return serialize([self._augment(rec) for rec in Timeslot.objects.filter(**match)])
def test_serialize_related_partial(self): """Test serialization of some fields of related model""" s = serialize(self.author, related={'books': ('title', None, False)}) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue('isbn' not in b)
def get(self, request): venues_list = Place.objects.all().annotate( pic_count=Count('location__pic')).annotate( preview='location__pic').order_by('pic_count').reverse()[:10] fields = ('id', 'name', 'pic_count', ('foursq_primary_cat', dict(fields=[ 'name', ])), ('location', dict(fields=['lat', 'lon']))) return serialize(venues_list, fields)
def test_serialize_related_flatten(self): """Test injection of related models' fields into the serialized one""" b = self.books[0] s = serialize(b, fields=[ ('author', dict()) ], fixup=flatten('author')) self.assertEqual(s['name'], b.author.name)
def test_serialize_related(self): """Test serialization of related model""" s = serialize(self.author, related={'books': None}) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue(b['isbn'].startswith('123-1-12-123456-'))
def test_serialize_related(self): """Test serialization of related model""" s = serialize(self.author, include=[('books', dict())]) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue(b['isbn'].startswith('123-1-12-123456-'))
def test_serialize_related_partial(self): """Test serialization of some fields of related model""" s = serialize(self.author, include=[('books', dict(fields=['title']))]) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue('isbn' not in b)
def post(self, request, pk): comment_form = CommentForm(request.data) if comment_form.is_valid(): comment = comment_form.save(commit=False) comment.user = request.user comment.course_id = pk comment.save() return Http201(serialize(comment, include=[ ('user', lambda c: c.user.username) ]))
def test_serialize_related_deprecated(self): """Test serialization of related model""" with warnings.catch_warnings(record=True): s = serialize(self.author, related={'books': None}) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue(b['isbn'].startswith('123-1-12-123456-'))
def test_serialize_dict(self): """Test that dict serialization deep-serializes dict values""" Author.objects.all().delete() a1 = Author.objects.create(name="foo") a2 = Author.objects.create(name="bar") s = serialize({'a1': a1, 'a2': a2}) self.assertEqual(s['a1']['name'], a1.name) self.assertEqual(s['a2']['name'], a2.name)
def post(self, request): """Create a booking.""" fields = ('timeslot_id', 'size') rec = prepare_record(request.data, fields) tsid = int(rec['timeslot_id']) size = int(rec['size']) try: booking = Booking.book_for(tsid, size) except ValueError as err: return Http409(err.message) return serialize(booking)
def get(self, request): sensors = request.user.team.sensors.all() snapshot = SnapshotAPI(request.user.team.identifier) state = snapshot.state clusters = snapshot.clusters assets = snapshot.cloud_information cluster_counts = Counter() group_counts = Counter() hosts = Counter() # Populate cluster statistics for uuid, members in clusters.iteritems(): cluster, created = Cluster.objects.get_or_create(uuid=uuid, team=request.user.team) cluster_counts[cluster.name] += len(members) # Add AWS tag information to group list for key, asset in assets.iteritems(): for key, value in asset["tags"].iteritems(): if key != "Name": group = "AWS - %s" % value group_counts[group] += 1 hosts["monitored"] = 0 for s in sensors: hosts["monitored"] += 1 # Populate groups statistics if s.groups: for g in s.groups: group_counts[g] += 1 # Remove from asset list to prevent duplicate entry assets.pop(s.cloud_key, None) # Check online/offline status status = state.get(s.uuid, {}).get("activity", {}).get("is_connected") if status: hosts["active"] += 1 else: hosts["inactive"] += 1 # All remaining assets are "unmonitored" hosts["unmonitored"] = len(assets.keys()) hosts["total"] = hosts["monitored"] + hosts["unmonitored"] return serialize({ "hosts": hosts, "groups": [{"name": name, "count": count} for name, count in group_counts.iteritems()], "clusters": [{"name": name, "count": count} for name, count in cluster_counts.iteritems()] })
def test_serialize_related_partial(self): """Test serialization of some fields of related model""" s = serialize(self.author, related={ 'books': ('title', None, False) }) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue('isbn' not in b)
def get(self, request): groups = [] for sensor in request.user.team.sensors.all(): if sensor.group: for group in sensor.groups: groups.append(str(group)) else: groups.append('ungrouped') return serialize(set(groups))
def get(self, request): jobs = Job.objects.all() fields = [ "id", "locus", "analysis_type", "date", "status", ("url", lambda job: job.url) ] return serialize(jobs,fields)
def get(self, request): venues_list = Place.objects.filter( Q(foursq_primary_cat__name__contains='Bar') | Q(foursq_primary_cat__name__contains='Lounge') | Q(foursq_primary_cat__name__contains='Beer')).annotate( pic_count=Count('location__pic')).order_by( 'pic_count').reverse()[:10] fields = ('id', 'name', 'pic_count', ('foursq_primary_cat', dict(fields=[ 'name', ])), ('location', dict(fields=['lat', 'lon']))) return serialize(venues_list, fields)
def get(self, request, sensor_id): result = cache.get("%s.process_info" % sensor_id) if result: return result else: process_info = SnapshotAPI( request.user.team.identifier).sensor_process_tree(sensor_id) cache.set("%s.process_info" % sensor_id, process_info, 300) return serialize(process_info)
def test_serialize_related_deep(self): """Test serialization of twice-removed related model""" s = serialize(self.author, include=[('books', dict(include=[('publisher', dict())])) ]) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertEqual(b['publisher']['name'], 'Publisher')
def get(self, request, pk, *args, **kwargs): params = request.params fields = self.default_fields if 'fields' in params: fields = params.pop('fields').split(",") obj = self.model.objects.get(pk=pk) config = get_fields(self.serialize_config, fields=fields) response = Http200(serialize(obj, **config)) response['Access-Control-Allow-Origin'] = "*" return response
def put(self, request, author_id=None): author_id = int(author_id) try: author = Author.objects.get(id=author_id) except Author.DoesNotExist: return Http404(reason='no such author') form = AuthorForm(request.data, instance=author) if form.is_valid(): author = form.save() return serialize(author) else: return Http400(reason='invalid author data', details=form.errors)
def test_serialize_related_deep(self): """Test serialization of twice-removed related model""" s = serialize(self.author, related={'books': (None, { 'publisher': None, }, None)}) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertEqual(b['publisher']['name'], 'Publisher')
def get(self, request): user = request.user # Trie les cours par thème, sélectionne les cours favoris d'un utilisateur ou renvoie tous les cours # Retourne seulement les cours publiés if 'theme' in request.GET: courses = Course.objects.filter(chapter__theme__name=request.GET['theme'], published=True) elif 'favorite' in request.GET and user.is_authenticated() and user.is_active: courses = user.favorite_courses.filter(published=True) else: courses = Course.objects.filter(published=True) return serialize(courses, include=[ ('chapter', dict(fields=['name'])) ])
def get(self, request, pk): try: post = Post.objects.get(pk=pk) fields = [ 'id', ('url', lambda post: post.url), 'title', 'date_created', 'text' ] return serialize(post, fields) except Exception as e: return Http400(e)
def test_serialize_list(self): """Test list serialization""" Author.objects.all().delete() a1 = Author.objects.create(name="foo") a2 = Author.objects.create(name="bar") s = serialize(list(Author.objects.all())) self.assertEqual(s, [ {'name': a1.name, 'id': a1.id}, {'name': a2.name, 'id': a2.id}, ] )
def test_serialize_related_partial(self): """Test serialization of some fields of related model""" s = serialize(self.author, include=[ ('books', dict( fields=['title'] )) ]) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertTrue('isbn' not in b)
def test_serialize_related_deep(self): """Test serialization of twice-removed related model""" s = serialize(self.author, related={ 'books': (None, { 'publisher': None, }, None)}) self.assertEqual(s['name'], 'User Foo') self.assertEqual(len(s['books']), len(self.books)) for b in s['books']: self.assertTrue(b['title'].startswith('Book ')) self.assertEqual(b['publisher']['name'], 'Publisher')
def get(self, request): interval = request.GET.get("interval", "hour") series_type = request.GET.get("type", "histogram") team_id = request.user.team.identifier manager = TimeseriesManager(team_id, series_type) results = [] for rule in Rule.objects.all(): stat = manager.query(rule.slug, interval) results.append(tame_results(stat, rule.name)) return serialize(results)
def get(self, request): # Pull request information interval = request.GET.get("interval", "hour") series_type = request.GET.get("type", "histogram") team_id = request.user.team.identifier manager = TimeseriesManager(team_id, series_type) monitored = manager.query("monitored",interval) unmonitored = manager.query("unmonitored",interval) mon = tame_results(monitored, "monitored") unmon = tame_results(unmonitored, "unmonitored") return serialize([mon, unmon])
def get(self, request): interval = request.GET.get("interval", "hour") series_type = request.GET.get("type", "histogram") team_id = request.user.team.identifier clusters = request.user.team.clusters.all() manager = TimeseriesManager(team_id, series_type) results = [] for cluster in clusters: stat = manager.query(cluster.uuid, interval) results.append(tame_results(stat, cluster.name)) return serialize(results)
def verify_access_key(request, access_key): """ Verifies that an access_key is valid. Used inside of the sensor endpoint. """ try: apikey = APIKey.objects.get(access_key=access_key) except APIKey.DoesNotExist: return Http403("The access_key is not valid.") return JSONResponse( serialize(apikey, fields=[ 'secret_key', ('identifier', lambda a: a.team.identifier), ]))