def employee_list_group_by_badges_detail(request, badge_id):
"""
Returns employee list grouped by badge, you should provide badge_id
---
response_serializer: stars.serializers.EmployeeGroupedListSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
badge = get_object_or_404(Badge, pk=badge_id)
employee_list = EmployeeBadge.objects.filter(badge=badge).values(
'to_user__pk',
'to_user__username',
'to_user__first_name',
'to_user__last_name',
'to_user__level',
'to_user__avatar')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_list, request)
serializer = EmployeeGroupedListSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_keyword_list_detail(request, keyword_id):
"""
Returns stars list detail for keyword id.
---
response_serializer: stars.serializers.StarTopEmployeeLists
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
keyword = get_object_or_404(Keyword, pk=keyword_id)
stars = Star.objects.filter(keyword=keyword).values(
'to_user__pk',
'to_user__username',
'to_user__first_name',
'to_user__last_name',
'to_user__level',
'to_user__avatar').annotate(num_stars=Count('keyword')).order_by('-num_stars')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(stars, request)
serializer = StarTopEmployeeLists(results, many=True)
return paginator.get_paginated_response(serializer.data)
def other_location_events(request, employee_id):
"""
Returns the full upcoming events list for employee location
---
serializer: events.serializers.EventSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
events = []
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
events_list = Event.objects.filter(is_active=True)
for event in events_list:
if event.location != employee.location:
events.append(event)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(events, request)
serializer = EventSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def employee_skill_remove(request, employee_id):
"""
Remove employee skill
---
response_serializer: employees.serializers.EmployeeSkillsSerializer
parameters:
- name: skill
type: string
required: true
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'PATCH':
if 'skill' in request.data:
skill = request.data['skill'].upper()
keyword = get_object_or_404(Keyword, name=skill)
employee = get_object_or_404(Employee, pk=employee_id)
employee.skills.remove(keyword)
employee.save()
skills = employee.skills.all()
paginator = PageNumberPagination()
results = paginator.paginate_queryset(skills, request)
serializer = EmployeeSkillsSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_keyword_list(request):
"""
Returns stars list grouped by keyword or result list if you use ?search=
---
serializer: stars.serializers.StarKeywordList
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
if request.GET.get('search'):
search_term = request.GET.get('search')
star_list = Star.objects.filter(
Q(keyword__name__icontains=search_term)).values('keyword__pk',
'keyword__name').annotate(num_stars=Count('keyword')).order_by('-num_stars')
else:
star_list = Star.objects.all().values('keyword__pk', 'keyword__name').annotate(num_stars=Count('keyword')).order_by('-num_stars')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(star_list, request)
serializer = StarKeywordList(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get_notifications(request, employee_id):
"""
Get all notifications for employee id
---
response_serializer: activities.serializers.NotificationSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
activities = Activity.objects.annotate(
profile=F('to_user')).values('datetime',
'text',
'profile').filter(to_user=employee)
messages = Message.objects.annotate(
profile=F('from_user')).values('datetime',
'text',
'profile').filter(Q(to_user='******') |
Q(to_user=employee.location.name) |
Q(to_user=employee.username))
notifications = list(chain(activities, messages))
notifications = sorted(notifications, reverse=True)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(notifications, request)
serializer = NotificationSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get_messages(request, employee_id):
"""
Get all messages for employee id
---
response_serializer: activities.serializers.MessageSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
messages = Message.objects.filter(
Q(to_user='******') |
Q(to_user=employee.location.name) |
Q(to_user=employee.username))
paginator = PageNumberPagination()
results = paginator.paginate_queryset(messages, request)
serializer = MessageSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def employee_skills_search(request, terms):
"""
Returns the full employee list or result list from search skill terms
---
serializer: employees.serializers.EmployeeListSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal server error.
"""
if request.method == 'GET':
search_terms_array = terms.split()
initial_term = search_terms_array[0]
employee_list = Employee.objects.filter(skills__name__icontains=initial_term).annotate(Count('id'))
if len(search_terms_array) > 1:
for term in range(1, len(search_terms_array)):
employee_list = employee_list.filter(search_terms_array[term])
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_list, request)
serializer = EmployeeListSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def employee_list_group_by_badges(request):
"""
Returns badge list with employee counter or result list if you use ?search=
---
response_serializer: stars.serializers.EmployeeBadgeListSerializer
parameters:
- name: search
required: false
type: string
paramType: query
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
if request.GET.get('search'):
search_term = request.GET.get('search')
badge_list = EmployeeBadge.objects.filter(
Q(badge__name__icontains=search_term)).values(
'badge__pk',
'badge__name').annotate(num_employees=Count('to_user')).order_by('-num_employees')
else:
badge_list = EmployeeBadge.objects.all().values(
'badge__pk',
'badge__name').annotate(num_employees=Count('to_user')).order_by('-num_employees')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(badge_list, request)
serializer = EmployeeBadgeListSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def keyword_list(request):
"""
Returns full keyword list ordered by name
---
serializer: categories.serializers.KeywordSerializer
parameters:
- name: pagination
required: false
type: string
paramType: query
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
keywords = get_list_or_404(Keyword, is_active=True)
if request.GET.get('pagination'):
pagination = request.GET.get('pagination')
if pagination == 'true':
paginator = PageNumberPagination()
results = paginator.paginate_queryset(keywords, request)
serializer = KeywordSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
serializer = KeywordSerializer(keywords, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def person(request, pk=None, search=None, order=None):
if request.method == 'GET' and pk==None:
"""
Returns a JSON response with a listing of person objects
"""
search = request.query_params.get('search')
order = request.query_params.get('order')
if (search==None):
search = '';
if (order == None or order == ''):
order = 'name'
people = Person.objects.filter(name__istartswith=search).order_by(order).all()
paginator = PageNumberPagination()
# From the docs:
# The paginate_queryset method is passed the initial queryset
# and should return an iterable object that contains only the
# data in the requested page.
result_page = paginator.paginate_queryset(people, request)
# Now we just have to serialize the data
serializer = PersonSerializer(result_page, many=True)
# From the docs:
# The get_paginated_response method is passed the serialized page
# data and should return a Response instance.
return paginator.get_paginated_response(serializer.data)
elif request.method == 'POST':
serializer = PersonSerializer(data=request.data)
if serializer.is_valid():
serializer.save(photo = get_gravatar_url(serializer.data['email'], size=150))
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
try:
person = Person.objects.get(pk=pk)
except Person.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PersonSerializer(person)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = PersonSerializer(person, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serilizer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
person.delete()
serializer = PersonSerializer(person)
return Response(serializer.data)
def get_paginated_response(self):
paginator = PageNumberPagination()
page = paginator.paginate_queryset(self.queryset, self.request)
model_serializer = self.serializer_class(page, many=True, context={"request": self.request})
return paginator.get_paginated_response(model_serializer.data)
def list(self, request):
self.check_permissions(request)
paginator = PageNumberPagination()
users = User.objects.all()
paginator.paginate_queryset(users, request)
serializer = UserSerializer(users, many=True)
serializer_users = serializer.data
return paginator.get_paginated_response(serializer_users)
def paginated_queryset(queryset, request): """ Return a paginated queryset. """ paginator = PageNumberPagination() paginator.page_size = settings.REST_FRAMEWORK['PAGE_SIZE'] result_page = paginator.paginate_queryset(queryset, request) return (paginator, result_page)
def list(self, request):
self.check_permissions(request)
paginator = PageNumberPagination() #instanciar paginador
users = User.objects.all(
) # En users estará el queryset, no los objetos
paginator.paginate_queryset(users, request) #paginar el queryset
serializer = UserSerializer(
users,
many=True) #many es necesario para cuando pasas más de un objeto
serialized_users = serializer.data #lista de diccionarios
#devolver respuesta paginada
return paginator.get_paginated_response(serialized_users)
def get(self, request, format=None):
"""
get PeriodicTask list
"""
queryset = models.PeriodicTask.objects.filter(~Q(
name='celery.backend_cleanup'))
p = PageNumberPagination()
page = p.paginate_queryset(queryset=queryset,
request=request,
view=self)
s = serializers.PeriodicTaskSerializers(page, many=True)
return p.get_paginated_response(s.data)
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
queryset = models.DegreeCourse.objects.all()
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset, request, self)
ser = DegreeCourseModelSerializer(instance=course_list, many=True)
ret.data = ser.data
except Exception as e:
ret.code = 500
ret.error = '获取数据失败'
return Response(ret.dict)
def discussions(request):
query = request.query_params.get('q')
if query == None:
query = ''
# Q objects is used to make complex query to search in discussion content and headline
discussions = Discussion.objects.filter(
Q(content__icontains=query) | Q(headline__icontains=query))
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(discussions, request)
serializer = DiscussionSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def curso(self, request, *args, **kwargs):
user = request.user
perfil = Profile.objects.get(user=user)
catedratico = Catedratico.objects.get(perfil=perfil.id)
cursos = AsignacionCatedraticoCurso.objects.filter(
catedratico=catedratico.id, activo=True)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(cursos, request)
serializer = AsignacionCatedraticoSerializer(resultado_pagina,
many=True)
return paginador.get_paginated_response(serializer.data)
def product_home(request):
paginator = PageNumberPagination()
paginator.page_size = 15
try:
product = Product.objects.all().order_by('-id')
product = paginator.paginate_queryset(product, request)
serializer = ProductSerializer(product, many=True)
return paginator.get_paginated_response(serializer.data)
except:
return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def question_answers(request, uid):
"""Question answers by question id"""
answers = Answer.objects.filter(question__id=uid).select_related('author', 'author__profile')\
.order_by('-is_solution', 'created')
if not answers:
return HttpResponse(status=404)
if request.method == 'GET':
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(answers, request)
serializer = AnswerSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_interview(self, request, slug, job_slug, formate=None):
profile_in_session = ProfileSession(
request=request).is_authorized_company()
if not profile_in_session.user_profile.auth_user.username == request.user.username and \
profile_in_session.slug == slug:
raise exceptions.PermissionDenied('You are not authorize')
paginator = PageNumberPagination()
paginator.page_size = 10
applicants_list = get_list_or_404(JobSchedules, job__slug=job_slug)
result_page = paginator.paginate_queryset(applicants_list, request)
interview_serializer = InterviewSerializer(instance=result_page,
many=True)
return paginator.get_paginated_response(interview_serializer.data)
def StudentPagiantedData(request, page_size):
if request.method == 'GET':
if school_id:
student = Student.objects.filter(user=school_id)
serializer = StudentSerializer(student, many=True)
return Response(serializer.data)
paginator = PageNumberPagination()
paginator.page_size = page_size
person_objects = Person.objects.all()
result_page = paginator.paginate_queryset(person_objects, request)
serializer = PersonSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def list(self, request):
self.check_permissions(request)
# Instancio paginador
paginator = PageNumberPagination()
users = User.objects.all()
# paginamos el queryset
paginator.paginate_queryset(users, request)
serializer = UserSerializer(users, many=True)
serialized_users = serializer.data # lista de diccionarios
# Devolvemos respuesta paginada
return paginator.get_paginated_response(serialized_users)
def search(self, search_term):
photos = Photo.objects.filter(
Q(picture_id=search_term) | Q(author__contains=search_term)
| Q(camera__contains=search_term) | Q(tags__contains=search_term)
| Q(cropped_picture__contains=search_term)
| Q(full_picture__contains=search_term))
paginator = PageNumberPagination()
page = paginator.paginate_queryset(photos, self)
if page:
serializer = PhotoSerializer(page, many=True)
else:
serializer = PhotoSerializer(photos, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
if request.is_ajax():
apartments = self.get_queryset()
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(apartments, request)
apartments_serialized = ApartmentSerializer(result_page, many=True)
time.sleep(3)
return paginator.get_paginated_response(apartments_serialized.data)
else:
context = {}
context['username'] = username_generate(request)['username']
context['title'] = 'apartments'
return render(request, 'apartments.html', context)
def total_ventas(self, request):
user = request.user.id
ventas = Detalle_orden.objects.values(
'producto__descripcionCorta').annotate(total=Sum(
ExpressionWrapper(F('precio') * F('cantidad'),
output_field=DecimalField()))).filter(
producto__usuario=user)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(ventas, request)
serializer = resultado_pagina
return paginador.get_paginated_response(serializer)
def get(self, request, id, seachstring, format=None):
#id = request.data['id']
usuario = self.get_object(id)
try:
messages = WallMessages.objects.filter(
destination=usuario, message__contains=seachstring)
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(messages, request)
serializer = WallMessagesSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
except Exception as e:
print(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
queryset = Course.objects.filter(id=1)
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset, request, self)
ser = CourseSerializer6(instance=course_list, many=True)
ret.data = ser.data
except Exception as e:
ret.code = 1001
ret.error = '获取数据失败'
return Response(ret.dict)
def get(self, request, pk=False):
paginator = PageNumberPagination()
if pk:
try:
author = Author.objects.get(pk=pk)
except Author.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = AuthorSerializer(author)
else:
author = Author.objects.all()
result_page = paginator.paginate_queryset(author, request)
serializer = AuthorSerializer(result_page, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request, **kwargs):
queryset = CustomUser.objects.none()
name = self.request.query_params.get('name', None)
if name is not None:
queryset = CustomUser.objects.all()
queryset = queryset.filter(
Q(username__contains=name) | Q(email__contains=name)
| Q(nickname__contains=name)).distinct()
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(queryset, request)
serializer = UserSerializer(result_page, many=True)
return Response(serializer.data)
def category_product(request, slug):
paginator = PageNumberPagination()
paginator.page_size = 15
try:
category_product = Product.objects.filter(product_type=slug)
category_product = paginator.paginate_queryset(category_product,
request)
serializer = ProductSerializer(category_product, many=True)
return paginator.get_paginated_response(serializer.data)
except:
return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def get(self, request, *args, **kwargs):
category_pk = request.GET.get('category')
category_queryset = models.Category.objects.all()
article_queryset = models.Article.objects.filter(category=category_pk)
page_object = PageNumberPagination()
article_result = page_object.paginate_queryset(article_queryset,
request, self)
ser_category = HomePageCategory(instance=category_queryset, many=True)
ser_article = HomePageArticle(instance=article_result, many=True)
return Response({
"category": ser_category.data,
"article": ser_article.data
})
def tweet_feed_view(request, *args, **kwargs):
panigator = PageNumberPagination()
panigator.page_size = 20
user = request.user
profiles = user.following.all()
followed_users_id = []
if profiles.exists():
followed_users_id = [x.user.id for x in profiles]
followed_users_id.append(user.id)
qs = Tweet.objects.filter(user__id__in=followed_users_id)
panigator_qs = panigator.paginate_queryset(qs, request)
serializer = TweetSerializer(panigator_qs, many=True)
return panigator.get_paginated_response(serializer.data)
def get_page_response(self, query_set, request, serializer_class):
"""
simple function to convert query set to rest framework paginated
response,
:param query_set: query set
:param request: wsgi request
:param serializer_class: serialzer for query set
:return: paginated response.
"""
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(query_set, request)
serializer = serializer_class(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_items(request):
psize = -1
items = Item.objects.all()
ordered = sorted(items,
key=lambda item: datetime.strptime(
item.published_date, '%Y-%m-%d %H:%M:%S'),
reverse=True)
# ordered = sorted(items, key=operator.attrgetter('last_name'), reverse=True)
paginator = PageNumberPagination()
paginator.page_size = psize
result_page = paginator.paginate_queryset(ordered, request)
item_ser = ItemReadSerializer(result_page, many=True)
return paginator.get_paginated_response(item_ser.data)
def get(self, request):
queryset = Product.objects.all()
# 分页查询，需要在settings.py设置REST_FRAMEWORK属性
pg = PageNumberPagination()
page_roles = pg.paginate_queryset(queryset=queryset,
request=request,
view=self)
serializer = ProductSerializer(instance=page_roles, many=True)
# serializer = ProductSerializer(instance=queryset, many=True) # 全表查询
# 还可以使用MySerializer加载模型Product
# serializer = MySerializer(instance=page_roles, many=True)
# 返回对象Response由Django Rest Framework实现
return Response(serializer.data)
def order_details(request):
paginator = PageNumberPagination()
paginator.page_size = 4
try:
order_details = OrderItem.objects.filter(
order__customer=request.user).order_by('-id')
order_details = paginator.paginate_queryset(order_details, request)
serializer = orderitemSerializer(order_details, many=True)
return paginator.get_paginated_response(serializer.data)
except:
return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def users(request):
query = request.query_params.get('q')
if query == None:
query = ''
users = User.objects.filter(
Q(userprofile__name__icontains=query) |
Q(userprofile__username__icontains=query)
).order_by('-userprofile__followers_count')
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(users,request)
serializer = UserSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_page_response(self, query_set, request, serializer_class):
"""
simple function to convert query set to rest framework paginated
response,
:param query_set: query set
:param request: wsgi request
:param serializer_class: serialzer for query set
:return: paginated response.
"""
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(query_set, request)
serializer = serializer_class(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def api_division_post(request, slug):
paginator = PageNumberPagination()
paginator.page_size = 7
try:
division_post = blogPost.objects.filter(division=slug).order_by('-id')
post = paginator.paginate_queryset(division_post, request)
serializer = blogPostSerializer(post, many=True)
return paginator.get_paginated_response(serializer.data)
except:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
# url 最後面加入?page=1 or 2 ...就可以換分頁資料。
pg_obj = PageNumberPagination() # 實例化分頁類。
# 取得分頁資料，參數1 分頁的資料，Queryset類型，請求request，分頁的視圖，self代表自己
pg_res = pg_obj.paginate_queryset(queryset=self.queryset,
request=request,
view=self)
# 報錯訊息提示要加入 context={'request': request}，好像因為有關連的關係所以要加。
res = UserSerializer(instance=pg_res,
many=True,
context={'request': request})
# return Response(res.data)
return pg_obj.get_paginated_response(res.data)
def list(self, request):
if request.GET:
query = request.GET.get('q')
page = request.GET.get('page')
if query:
queryset = App.objects.filter(
Q(name__icontains=query)
| Q(abstract__icontains=query))
app_release = Release.objects.filter(
app__in=queryset).order_by('-version')
if page is not None:
paginator = PageNumberPagination()
context = paginator.paginate_queryset(app_release, request)
serializer = AppReleaseSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
else:
serializer = AppReleaseSerializer(app_release, many=True)
if len(serializer.data):
return Response(serializer.data, 200)
else:
return Response(serializer.data, 404)
elif query is None and page is not None:
queryset = App.objects.all()
paginator = PageNumberPagination()
context = paginator.paginate_queryset(queryset, request)
serializer = AppSearchSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
else:
return Response([], 404)
else:
queryset = App.objects.all()
serializer = AppSearchSerializer(queryset, many=True)
return Response(serializer.data, 200)
def list(self, request):
self.check_permissions(request)
# Instanciar el paginador
paginator = PageNumberPagination()
users = User.objects.all()
# Pagina el Queryset
paginator.paginate_queryset(users, request)
serializer = UserSerializer(users, many=True)
serialized_users = serializer.data #Lista de diccionarios
#renderer = JSONRenderer()
#json_users = renderer.render(serialized_users) # Lista de diccionarios --> JSON
# Devolver respuesta paginada
return paginator.get_paginated_response(serialized_users)
def car_list_view(request, *args, **kwargs):
search_str = request.GET.get('search') or ''
qs = Car.objects.filter(
Q(car_model__name__icontains=search_str)
| Q(car_model__brand__name__icontains=search_str)).order_by('-id')
paginator = PageNumberPagination()
paginator.page_size = 20
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = CarSerializer(paginated_qs, many=True)
return paginator.get_paginated_response(serializer.data)
def TeacherSubject(request):
teacher = TeacherProfile.objects.get(user_id=request.user.id)
subject = Subject.objects.filter(author=teacher).order_by('-id')
print(subject)
filterset = SubjectFilter(request.GET, queryset=subject)
if filterset.is_valid():
queryset = filterset.qs
paginator = PageNumberPagination()
paginator.page_size = 5
result_page = paginator.paginate_queryset(queryset, request)
serializer = SubjectSerializer(result_page, many=True)
for i in range(len(serializer.data)):
serializer.data[i]['author']['user'].pop('password')
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
"""
Returns a JSON response with a listing of course objects
"""
paginator = PageNumberPagination()
# From the docs:
# The paginate_queryset method is passed the initial queryset
# and should return an iterable object that contains only the
# data in the requested page.
result_page = paginator.paginate_queryset(self.get_queryset(), request)
# Now we just have to serialize the data.
serializer = CommunityPostSerializer(result_page, many=True, context={'request': request})
# From the docs:
# The get_paginated_response method is passed the serialized page
# data and should return a Response instance.
return paginator.get_paginated_response(serializer.data)
def diffs(request, doctype_name, dataset_name):
queryset = TreeNode.objects.select_related(
'dataset', 'tree2_diffs'
).filter(
dataset__doctype__name=doctype_name,
dataset__name=dataset_name,
tree2_diffs__isnull=False
)
paginator = PageNumberPagination()
paginator.page_size = 1
result_page = paginator.paginate_queryset(queryset, request)
serializer = KeySerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def blogs_list(request):
"GET: displays all the blogs POST: take a new blog as I/P (or) modified text"
if request.method == 'GET':
blogs = Blog.objects.all()
pages = PageNumberPagination()
page_data = pages.paginate_queryset(blogs, request)
serializer = BlogSerializer(page_data, many=True)
return pages.get_paginated_response(serializer.data)
elif request.method == 'POST':
data = request.data
title = data.pop('title')
text = data.pop('text')
try:
blog_exists = Blog.objects.filter(title=title)
if blog_exists:
para_list = text.split('\n\n')
para_text = Paragraph.objects.filter(blog=blog_exists)
dummy = json.loads(blog_exists[0].seq)
para_delete = para_text.exclude(text__in = para_list)
if para_delete:
comm_delete = Comment.objects.filter(paragraph__in=para_delete).delete()
for i in para_delete:
dummy.remove(i.id)
para_delete.delete()
para_text = para_text.filter().values_list('text', flat=True)
for i in range(0, len(para_list)):
if para_list[i] not in para_text:
para_save = Paragraph(blog=blog_exists[0], text=para_list[i])
para_save.save()
dummy = dummy[:i] + [para_save.id] + dummy[i:]
blog_exists[0].seq = json.dumps(dummy)
blog_exists[0].save()
return Response({"status":"success", "message":"Text is updated"}, status=status.HTTP_201_CREATED)
else:
blog_save = Blog(title=title)
blog_save.save()
paragraphs = text.split('\n\n')
para_list = [Paragraph(blog=blog_save, text=t) for t in paragraphs]
Paragraph.objects.bulk_create(para_list)
if para_list:
blog_save.seq = json.dumps(list(Paragraph.objects.filter(blog=blog_save).order_by('id').values_list('id', flat=True)), cls=DjangoJSONEncoder)
else:
blog_save.seq = json.dumps(list())
blog_save.save()
return Response({"status":"success", "message":"New Blog created"}, status=status.HTTP_201_CREATED)
except Exception as ex:
return Response({"status":"fail", 'message':str(ex)}, status=status.HTTP_400_BAD_REQUEST)
def search(request, query):
"""
Lista resultados de búsqueda de palabra clave. Usa paginación y muestra
hasta 20 resultados por página.
Además muestra links para páginas previas y siguientes.
# Puedes obtener los resultados en archivo TSV
Este archivo contiene la información en campos separados por tabs
(fácil de importar a MS Excel)
Solo es necesario usar la dirección `search.tsv`:
* <http://manolo.rocks/api/search.tsv/romulo/>
---
type:
query:
required: true
type: string
parameters:
- name: query
description: nombre o palabra clave a busar, por ejemplo Romulo
type: string
paramType: path
required: true
"""
query_request = QueryDict('q={}'.format(query))
form = ApiForm(query_request)
if request.user.is_authenticated():
all_items = form.search(premium=True)
else:
all_items = form.search(premium=False)
pagination = PageNumberPagination()
paginated_results = pagination.paginate_queryset(all_items, request)
paginated_results = [i.object for i in paginated_results]
serializer = ManoloSerializer(paginated_results, many=True)
data = {
'count': pagination.page.paginator.count,
'next': pagination.get_next_link(),
'previous': pagination.get_previous_link(),
'results': serializer.data,
}
return JSONResponse(data)
def get_nearest(self, request, *args, **kwargs):
#-82.1013183593750000 40.1766586303710014
logger.error('NearestUserViewSet: ' +kwargs['latitude']+' '+kwargs['longitude'])
current_user = request.user
pref_qs = Preferences.objects.all()
preferences = get_object_or_404(pref_qs, user=current_user)
# Get the current date
now = date.today()
min_date = now - relativedelta(years=preferences.max_age)
max_date = now - relativedelta(years=preferences.min_age)
logger.error('min_date ' + str(min_date))
logger.error('max_date ' + str(max_date))
distance_pref = preferences.distance
gender_pref = preferences.gender_pref
logger.error('Preferences: Gender ' + gender_pref + ' distance ' + str(distance_pref))
# Filter for all prospects already processed by user
match_set = Match.objects.filter(Q(source=current_user) | Q(target=current_user)).all()
#for prospect in match_set:
email_set = set()
for x in match_set:
logger.error('Matched emails ' + x.source.email +' and ' + x.target.email)
email_set.add(x.source.email)
email_set.add(x.target.email)
#email_set = {y.email for x in match_set for y in x.users.all()} #set()
# Exclude login user
'''email_set.add(current_user.email)
for match in match_set:
email_set.add(match.)'''
gps_reading = fromstr('POINT('+kwargs['latitude']+' '+kwargs['longitude']+')', srid=4326)
nearest_users = User.geo.exclude(email__in=email_set).exclude(preferences__hidden=True).filter(Q(date_of_birth__gte=min_date) & Q(date_of_birth__lte=max_date))
nearest_users = nearest_users.filter(gender=gender_pref).filter(location__distance_lte=(gps_reading, D(mi=distance_pref))).distance(gps_reading).order_by('distance')
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(nearest_users.all(), request)
serializer = UserSerializer(result_page , many=True)
return paginator.get_paginated_response(serializer.data)
def _get(self,request,*args,**kwargs):
"""
自己重写get() ,以上定义的Name些 xxx_class全部失效，完全自己处理数据返回
自定义的 {status,errcode,errmsg,result} 就在这里自行添加了
所以基本上从APIView继承就可以了,如果需要分页处理，看看ListViewAPI
"""
# if request.user.is_authenticated:
# return Response({'status':0}) #这里直接拒绝掉了
ser = SerializerDBTable( self.get_queryset(),many=True)
data = ser.data
return Response(data)
#手动控制分页
page = PageNumberPagination()
page.paginate_queryset(self.queryset.all()[:200],request)
return page.get_paginated_response(ser.data)
return Response({'result':data})
def employee_deactivated_list(request):
"""
Returns the full employee deactivated list
---
serializer: employees.serializers.EmployeeListSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
employee_list = get_list_or_404(Employee, is_active=False)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_list, request)
serializer = EmployeeListSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def comment_list(request):
response = {}
result = {}
if request.method == "POST":
member_id = request.data["memberId"]
board_id = request.data["boardId"]
comment = request.data["comment"]
if member_id is None or comment is None:
response["STS"] = ERR_USER_PARAM
response["MSG"] = MSG[ERR_USER_PARAM]
return Response(response)
comment = Comment(board_id=board_id, member_id=member_id, comment=comment)
comment.save()
result["id"] = comment.id
result["comment"] = comment.comment
result["regdt"] = comment.regdt
response["STS"] = SUCCESS
response["MSG"] = MSG[SUCCESS]
response["DAT"] = result
return Response(response)
if request.method == "GET":
paginator = PageNumberPagination()
board_list = Comment.objects.order_by("-id").all()
result_page = paginator.paginate_queryset(board_list, request)
comment_list_serializer = CommentListSerializer(result_page, many=True)
result["comment_list"] = comment_list_serializer.data
result["total_cnt"] = len(board_list)
response["STS"] = SUCCESS
response["MSG"] = MSG[SUCCESS]
response["DAT"] = result
return Response(response)
def event_list(request):
"""
Returns the full events list or result list if you use ?search=
---
serializer: events.serializers.EventSerializer
parameters:
- name: search
required: false
type: string
paramType: query
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'GET':
if request.GET.get('search'):
request_terms = request.GET.get('search')
search_terms_array = request_terms.split()
initial_term = search_terms_array[0]
event_list = Event.objects.annotate(
num_participants=Count('participants', distinct=True),
num_collaborators=Count('collaborators', distinct=True)).filter(
Q(title__icontains=initial_term) |
Q(description__icontains=initial_term))
if len(search_terms_array) > 1:
for term in range(1, len(search_terms_array)):
event_list = event_list.filter(Q(title__icontains=search_terms_array[term]) |
Q(description__icontains=search_terms_array[term]))
else:
event_list = Event.objects.annotate(
num_participants=Count('participants', distinct=True),
num_collaborators=Count('collaborators', distinct=True)).all()
paginator = PageNumberPagination()
results = paginator.paginate_queryset(event_list, request)
serializer = EventSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def feeds_to_user(request):
# load = json.loads(request.body)
# device = load.get('device_id')
device = request.GET['device_id']
print"===========DEvice Id====",device
if not device:
return HttpBadRequest("Enter device id")
user_obj=UserProfile.objects.get(device_id = device)
user_interests = user_obj.interests_category.all()
user_languages = user_obj.user_languages.all()
paginator = PageNumberPagination()
interest_list=[]
language_list=[]
for interest in user_interests:
interest_list.append(interest)
for language in user_languages:
language_list.append(language)
newsfeeds_objs1 = NewsFeedItems.objects.filter(category__in=interest_list)\
.filter(language__in=language_list)\
.order_by('-pubdate')
newsfeeds_objs = paginator.paginate_queryset(newsfeeds_objs1, request)
feed_item=[]
for newsfeeds_obj in newsfeeds_objs:
user_feeds={}
user_feeds['title']=newsfeeds_obj.title
user_feeds['descrption']=newsfeeds_obj.content
user_feeds['image_url']=newsfeeds_obj.image_url
news_pubdate = datetime.datetime.strftime(newsfeeds_obj.pubdate,'%a, %d %b %Y %I:%M:%S')
user_feeds['pubdate']=str(news_pubdate)
user_feeds['link']=newsfeeds_obj.link
user_feeds['category']=newsfeeds_obj.category
user_feeds['language']=newsfeeds_obj.language
user_feeds['source']=newsfeeds_obj.source
feed_item.append(user_feeds)
data = {'status_code':200,'feeds_details': feed_item}
return Response(data, status=status.HTTP_200_OK)
def employee_list(request, format=None):
"""
Returns the full employee list or result list if you use ?search=
---
serializer: employees.serializers.EmployeeListSerializer
parameters:
- name: search
required: false
type: string
paramType: query
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
if request.GET.get('search'):
request_terms = request.GET.get('search')
search_terms_array = request_terms.split()
initial_term = search_terms_array[0]
employee_list = Employee.objects.filter(
Q(first_name__icontains=initial_term) |
Q(last_name__icontains=initial_term) |
Q(username__icontains=initial_term)).filter(is_active=True, is_base_profile_complete=True)
if len(search_terms_array) > 1:
for term in range(1, len(search_terms_array)):
employee_list = employee_list.filter(
Q(first_name__icontains=search_terms_array[term]) |
Q(last_name__icontains=search_terms_array[term]) |
Q(username__icontains=search_terms_array[term])).filter(
is_active=True,
is_base_profile_complete=True)
else:
employee_list = get_list_or_404(Employee, is_active=True, is_base_profile_complete=True)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_list, request)
serializer = EmployeeListSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_employee_list(request, employee_id):
"""
Returns stars list from employee
---
serializer: stars.serializers.StarSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
employee_stars = Star.objects.filter(to_user=employee)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_stars, request)
serializer = StarSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_employee_subcategory_list(request, employee_id):
"""
Returns stars list from employee grouped by subcategories
---
serializer: stars.serializers.StarEmployeesSubcategoriesSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
employee_stars = Star.objects.filter(to_user=employee).values('subcategory__pk', 'subcategory__name').annotate(num_stars=Count('subcategory')).order_by('-num_stars', 'subcategory__name')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_stars, request)
serializer = StarEmployeesSubcategoriesSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def event_activities(request, event_id):
"""
Returns activity list for event
---
serializer: events.serializers.EventActivitySerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
event = get_object_or_404(Event, pk=event_id)
activities = EventActivity.objects.filter(event=event)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(activities, request)
serializer = EventActivitySerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
