class TrendingScoreViewSet2(viewsets.GenericViewSet, mixins.ListModelMixin):
permission_classes = (permissions.IsAuthenticatedOrReadOnly,)
pagination_class = TrendingPagination
ordering_filter = filters.OrderingFilter()
queryset = Branch.objects.all()
def get_queryset(self):
last_day = datetime.today() - timedelta(days=1)
# branches = Branch.objects.filter(posts_from_all__spreads__updated__gte=last_day) \
# .aggregate(Sum('posts_from_all__spreads__times'))
branches = Branch.objects.filter(posts_from_all__spreads__updated__gte=last_day).distinct()
return branches
def filter_queryset(self, queryset):
queryset = super(TrendingScoreViewSet, self).filter_queryset(queryset)
queryset = queryset.annotate(num_spreads=Sum('posts_from_all__spreads__times')).order_by('-num_spreads')
for item in queryset:
print(item.num_spreads)
return queryset
def list(self, request, *args, **kwargs):
serializer = serializers.BranchSerializer(self.filter_queryset(self.get_queryset()), many=True)
'''filtered = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(filtered)
serializer = serializers.BranchSerializer(page, many=True)
return self.get_paginated_response(serializer.data)'''
page = self.paginate_queryset(self.filter_queryset(self.get_queryset()))
return Response(serializer.data)
def threads(self, request, slug=None):
forum = self.get_object()
filtered_queryset = filters.OrderingFilter().filter_queryset(
request,
forum.threads.all().order_by('-is_sticky', '-modified'), self)
page = self.paginate_queryset(filtered_queryset)
threads = {}
if page is not None:
serializer = serializers.FullThreadSerializer(
page, many=True, context={'request': request})
threads = self.get_paginated_response(serializer.data).data
else:
threads = serializers.FullThreadSerializer(
forum.threads.all().order_by('-modified'),
many=True,
context={
'request': request
}).data
return Response({
**{
'threads': threads
},
**serializers.BasicForumSerializer(forum,
context={
'request': request
}).data
})
def list(self, request, project_pk=None):
get_and_check_project(request, project_pk)
tasks = self.queryset.filter(project=project_pk)
tasks = filters.OrderingFilter().filter_queryset(
self.request, tasks, self)
serializer = TaskSerializer(tasks, many=True)
return Response(serializer.data)
def events(self, request, pk=None):
ip = self.get_object()
events = filters.OrderingFilter().filter_queryset(request, ip.events.all(), self)
page = self.paginate_queryset(events)
if page is not None:
serializers = EventIPSerializer(page, many=True, context={'request': request})
return self.get_paginated_response(serializers.data)
serializers = EventIPSerializer(events, many=True, context={'request': request})
return Response(serializers.data)
def filter_by_request_query_params_order(self, request, queryset=None):
"""
Would be useful if you call outside of rest framework ordering filters
Return QuerySet
"""
_queryset = self.queryset if queryset is None else queryset
return filters.OrderingFilter().filter_queryset(
request, _queryset, self)
def upvotes(self, request):
user = request.user
questions = self.get_queryset().filter(votequestion__up=True,
votequestion__user=user)
questions = filters.OrderingFilter().filter_queryset(
self.request, questions, self)
answered = request.GET.get('answered')
if answered is not None:
if answered == 'true':
questions = questions.exclude(answers=None)
if answered == 'false':
questions = questions.filter(answers=None)
return Response(self.get_serializer(questions, many=True).data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all HE InVisualizations
queryset = HistoricalEventsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(
self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(
self.request, queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByEventFilter(request.GET,
queryset=queryset)
# Set the pagination
# set defaul
page_size = 10
# get url param
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
eventsinvisualizations = paginator.page(page)
except PageNotAnInteger:
eventsinvisualizations = paginator.page(1)
except EmptyPage:
eventsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByEventSerializer(
eventsinvisualizations)
# log.info(paginator.page_range)
# return set_jsonschema_link_header(Response(serializer.data), 'visualization_collection', request)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all Datasets In Visualizations
# queryset = MetricsInVisualizations.objects.all()
queryset = DatasetsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(
self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(
self.request, queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByDatasetFilter(request.GET,
queryset=queryset)
# Set the pagination
page_size = 10
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
datasetsinvisualizations = paginator.page(page)
except PageNotAnInteger:
datasetsinvisualizations = paginator.page(1)
except EmptyPage:
datasetsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByDatasetSerializer(
datasetsinvisualizations)
return Response(serializer.data)
class ObjectJournalViewSet(XOSViewSet):
base_name = "object_journal"
method_name = "object_journal"
method_kind = "viewset"
serializer_class = JournalEntrySerializer
queryset = JournalEntry.objects.all()
ordering_filter = filters.OrderingFilter()
filter_backends = (filters.DjangoFilterBackend, )
filter_fields = ('id', 'objClassName', 'objId', 'objUnicode', 'operation',
'timestamp')
pagination_class = pagination.LimitOffsetPagination
@classmethod
def get_urlpatterns(self, api_path="^"):
patterns = super(ObjectJournalViewSet,
self).get_urlpatterns(api_path=api_path)
#patterns.append( self.list_url("html/$", {"get": "get_oj_html"}, "oj_html") )
return patterns
def filter_queryset(self, queryset):
queryset = super(ObjectJournalViewSet, self).filter_queryset(queryset)
return self.ordering_filter.filter_queryset(self.request, queryset,
self)
def list(self, request):
if hasattr(self.request, "query_params"):
format = self.request.query_params.get('output_format', "json")
limit = int(self.request.query_params.get('limit', 1000000))
else:
format = "json"
limit = 1000000
if format == "json":
return super(ObjectJournalViewSet, self).list(request)
if format == "html":
lines = []
for obj in self.filter_queryset(self.get_queryset()).all():
lines.append(
"<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td></TR>"
% (obj.id, obj.objClassName, obj.objId, obj.objUnicode,
obj.operation, obj.msg or ""))
lines = lines[:limit]
return HttpResponse(
"<html><head></head><body><table>%s</table></body></html>" %
"\n".join(lines),
content_type="text/html")
if format == "ascii":
lines = []
for obj in self.filter_queryset(self.get_queryset()).all():
lines.append(
"%-10s %-24s %-10s %-32s %-48s %s" %
(obj.id, obj.objClassName, obj.objId, str(
obj.objUnicode)[:32], obj.operation, obj.msg or ""))
lines = lines[:limit]
return HttpResponse("\n".join(lines), content_type="text/ascii")
return HttpResponse("unknown format")
