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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_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)
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_detail_list(request, employee_id, subcategory_id):
"""
Returns stars list detail from employee divided by subcategory
---
serializer: stars.serializers.StarSmallSerializer
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)
subcategory = get_object_or_404(Subcategory, pk=subcategory_id)
stars = Star.objects.filter(to_user=employee, subcategory=subcategory).order_by('-date')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(stars, request)
serializer = StarSmallSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get_messages_from_all(request):
"""
Get all messages sent
---
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':
messages = Message.objects.all()
paginator = PageNumberPagination()
results = paginator.paginate_queryset(messages, request)
serializer = MessageSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def employee_skills(request, employee_id):
"""
Get employee skills
---
response_serializer: employees.serializers.EmployeeSkillsSerializer
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)
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 participant_list(request):
"""
Returns the full participant list or result list if you use ?search=
---
serializer: events.serializers.ParticipantSerializer
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]
participant_list = Participant.objects.filter(
Q(fullname__icontains=initial_term) |
Q(email__icontains=initial_term))
if len(search_terms_array) > 1:
for term in range(1, len(search_terms_array)):
participant_list = participant_list.filter(Q(fullname__icontains=search_terms_array[term]) |
Q(email__icontains=search_terms_array[term]))
else:
participant_list = get_list_or_404(Participant)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(participant_list, request)
serializer = ParticipantSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def users_groups_posts_list(self, request):
users_groups = Group.objects.filter(
members=request.user) | Group.objects.filter(owner=request.user)
if len(users_groups) == 0:
return Response(data={'message': 'Your groups were not found'},
status=status.HTTP_406_NOT_ACCEPTABLE)
groups_posts = Post.objects.none()
for group in users_groups:
groups_posts = groups_posts | Post.objects.filter(group=group)
groups_posts = sorted(groups_posts,
key=attrgetter('date_posted'),
reverse=True)
if len(groups_posts) == 0:
return Response(data={'message': 'Your posts were not found'},
status=status.HTTP_406_NOT_ACCEPTABLE)
users_posts = PostSerializer(groups_posts,
context={
"host": request.get_host()
},
many=True).data
paginator = PageNumberPagination()
data = paginator.paginate_queryset(users_posts, request)
return paginator.get_paginated_response(data=data)
def showSearch(request):
# get the word/letter given by the user from the parameter of url, q (?q='searchedword')
title = request.GET['q']
# Check if the users choose any way of sorting from the parameter of url, gen (?gen='Action')
# and order it accordingly.
# Ordered in movieid by default.
if 'orderby' in request.GET:
orderby = request.GET['orderby']
else:
orderby = 'movieid'
# Check if the ordering of movies chosen by the user is from highest average rating to the lowest
if orderby == '-avg_rating':
# Retrieve title, genre and tmdbid of the movies
# from the Titles Model join the Ratings and Links Model
# where the title of movies contain the given word/letter and
# the movies have at least 50 ratings and in the descending order of average rating
queryset = Titles.objects.annotate(
avg_rating=Avg('ratings__rating'),
count_rating=Count('ratings__movieid')).filter(
title__icontains=title,
count_rating__gte=50).values('title', 'genre',
'links__tmdbid').order_by(orderby)
else:
# Retrieve title, genre and tmdbid of the movies
# from the Titles Model join the Ratings and Links Model
# where the title of the movies contain the given word/letter
# and in the given order the users preferred besides average rating
queryset = Titles.objects.annotate(
avg_rating=Avg('ratings__rating')).filter(
title__icontains=title).values(
'title', 'genre', 'links__tmdbid').order_by(orderby)
paginator = PageNumberPagination()
paginator.page_size = 7
result_page = paginator.paginate_queryset(queryset, request)
serializer = SearchSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def products_list(request):
if request.method == 'GET':
skin_type = request.GET.get('skin_type')
if not skin_type or not skin_type in ['oily', 'dry', 'sensitive']:
return empty_view()
category = request.GET.get('category')
exclude_ingredient = request.GET.get('exclude_ingredient')
include_ingredient = request.GET.get('include_ingredient')
kwargs = {} # filter의 조건 ( 카테고리, 필수 포함 성분들 )
exclude = {} # exclude의 조건 ( 배제 대상 성분들 )
having = 1 # include_ingredient의 개수
if category:
kwargs['category'] = category
if include_ingredient:
kwargs['ingredients__in'] = list(include_ingredient.split(','))
having = len(kwargs['ingredients__in'])
if exclude_ingredient:
exclude['ingredients__in'] = list(exclude_ingredient.split(','))
queryset = Item.objects\
.filter(**kwargs)\
.exclude(**exclude)\
.order_by('-'+skin_type, 'price')\
.annotate(count=Count('id'))\
.filter(count=having) # 같은 id의 개수가 필수 성분 개수와 같을 때, include_ingredient 조건 충족
paginator = PageNumberPagination() # pagination
paginator.page_size = 50 # 50개마다
page = paginator.paginate_queryset(queryset, request)
if page is not None:
serializer = ProductsSerializer(page, many=True)
return paginator.get_paginated_response(serializer.data)
serializer = ProductsSerializer(queryset, many=True)
return Response(serializer.data)
def tutorials(request):
"""
get: Return all tutorials
post: submit a tutorial
"""
if request.method == 'GET':
paginator = PageNumberPagination()
tutorials = Tutorial.objects.all().order_by('id').filter(publish=True)
context = paginator.paginate_queryset(tutorials, request)
serializer = TutorialSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
elif request.method == 'POST':
postserializer = TutorialPOST(data=request.data)
if postserializer.is_valid():
link_count = Tutorial.objects.filter(
link=request.data['link']).count()
if link_count == 0:
tags, title = generate_tags(request.data['link'])
if 'other' in tags:
return JSONResponse({"message ": "Not a Tutorial link"},
status=status.HTTP_406_NOT_ACCEPTABLE)
else:
tutorial_object = Tutorial.objects.create(
title=title,
link=request.data['link'],
category=request.data['category'])
for tag in tags:
obj, created = Tag.objects.get_or_create(name=tag)
tag_obj_list = Tag.objects.filter(name__in=tags)
tutorial_object.tags.set(tag_obj_list)
return JSONResponse({"message ": "Created, Thanks"},
status=status.HTTP_201_CREATED)
return JSONResponse({"message ": "Created, Thanks"},
status=status.HTTP_201_CREATED)
return JSONResponse({"message": "Not Valid, Try Again"},
status=status.HTTP_406_NOT_ACCEPTABLE)
def list(self, request):
date = request.GET.get(date_parameter.name, None)
start_date = request.GET.get(start_date_parameter.name, None)
open_cases = request.GET.get(open_cases_parameter.name, None)
team = request.GET.get(team_parameter.name, None)
reason = request.GET.get(reason_parameter.name, None)
open_status = request.GET.get(open_status_parameter.name, None)
no_pagination = request.GET.get(no_pagination_parameter.name, None)
queryset = self.get_queryset()
if date:
queryset = queryset.filter(start_date=date)
if start_date:
queryset = queryset.filter(start_date__gte=start_date)
if open_cases:
open_cases = open_cases == "true"
queryset = queryset.filter(end_date__isnull=open_cases)
if team:
queryset = queryset.filter(team=team)
if reason:
queryset = queryset.filter(reason=reason)
if open_status:
queryset = queryset.filter(
case_states__end_date__isnull=True,
case_states__status__name=open_status,
)
if no_pagination == "true":
serializer = CaseSerializer(queryset, many=True)
return Response(serializer.data)
paginator = PageNumberPagination()
context = paginator.paginate_queryset(queryset, request)
serializer = CaseSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def search(self, request):
postal_code = request.GET.get(postal_code_parameter.name, None)
street_name = request.GET.get(street_name_parameter.name, None)
number = request.GET.get(street_number_parameter.name, None)
suffix = request.GET.get(suffix_parameter.name, None)
team = request.GET.get(team_parameter.name, None)
if postal_code is None and street_name is None:
return HttpResponseBadRequest(
"A postal_code or street_name queryparameter should be provided"
)
if postal_code is not None and number is None:
return HttpResponseBadRequest("number queryparameter is required")
if street_name is not None and number is None:
return HttpResponseBadRequest("number queryparameter is required")
address_queryset = search(
street_name=street_name,
postal_code=postal_code,
number=number,
suffix=suffix,
)
cases = Case.objects.none()
for address in address_queryset:
cases = cases | address.cases.all()
cases = cases.filter(end_date=None)
if team:
cases = cases.filter(team=team)
paginator = PageNumberPagination()
context = paginator.paginate_queryset(cases, request)
serializer = CaseSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def room_search(request):
# 아래 두줄을 paginator = OwnPagination() 으로 줄여줄수 있지만
# Custom pagination 사용하지 않을때도 알아야하니깐 나두자
max_price = request.GET.get("max_price", None)
min_price = request.GET.get("min_price", None)
beds = request.GET.get("beds", None)
bedrooms = request.GET.get("bedrooms", None)
bathrooms = request.GET.get("bathrooms", None)
lat = request.GET.get("lat", None)
lng = request.GET.get("lng", None)
filter_kwargs = {}
if max_price is not None:
filter_kwargs["price__lte"] = max_price
if min_price is not None:
filter_kwargs["price__gte"] = min_price
if beds is not None:
filter_kwargs["beds__gte"] = beds
if bedrooms is not None:
filter_kwargs["beds__gte"] = bedrooms
if bathrooms is not None:
filter_kwargs["beds__gte"] = bathrooms
if lat is not None and lng is not None:
filter_kwargs["lat__gte"] = float(lat) - 0.005
filter_kwargs["lat__lte"] = float(lat) + 0.005
filter_kwargs["lng__gte"] = float(lng) - 0.005
filter_kwargs["lng__lte"] = float(lng) + 0.005
paginator = PageNumberPagination()
paginator.page_size = 10
try:
rooms = Room.objects.filter(**filter_kwargs)
except ValueError:
rooms = Room.objects.all()
results = paginator.paginate_queryset(rooms, request)
serializer = RoomSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, uid, format=None):
# print("product", uid)
if uid is "0":
getqueryset = Product.objects.all()
filter_word = request.query_params.get('search', '') #search
if filter_word: #search filter
getqueryset_productname = getqueryset.filter(productName__icontains=filter_word) #search by productname
getqueryset_productdescription = getqueryset.filter(productDescription__icontains=filter_word) #search by productdescription
getqueryset = getqueryset_productname | getqueryset_productdescription
sortby_list = request.query_params.getlist("sortby") #Sorting # (-word) for descending and (word) for ascending
if sortby_list:
for word in sortby_list:
getqueryset = getqueryset.order_by(word)
page_number = request.query_params.get('page','') #pagination setup
if page_number:
paginator = PageNumberPagination()
paginator.page_size = 1
result_page = paginator.paginate_queryset(getqueryset, request)
getserializer = productSerializer(result_page, many=True)
return paginator.get_paginated_response(getserializer.data)
getProductForOrder = request.query_params.getlist("fororder")
print(getProductForOrder)
if getProductForOrder:
emptyqueryset = Product.objects.none()
for productid in getProductForOrder:
queryset_temp = getqueryset.filter(productID=productid)
emptyqueryset = emptyqueryset | queryset_temp
getqueryset = emptyqueryset
getserializer = productSerializer(getqueryset, many=True)
else:
getqueryset = Product.objects.get(productID = uid) ##GET request for a specific ProductID
getserializer = productSerializer(getqueryset, many=False)
return Response(data=getserializer.data, status=status.HTTP_200_OK)
def challenge_phase_list(request, challenge_pk):
try:
challenge = Challenge.objects.get(pk=challenge_pk)
except Challenge.DoesNotExist:
response_data = {'error': 'Challenge does not exist'}
return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
if request.method == 'GET':
challenge_phase = ChallengePhase.objects.filter(challenge=challenge)
paginator = PageNumberPagination()
paginator.page_size = settings.REST_FRAMEWORK['PAGE_SIZE']
result_page = paginator.paginate_queryset(challenge_phase, request)
serializer = ChallengePhaseSerializer(result_page, many=True)
response_data = serializer.data
return paginator.get_paginated_response(response_data)
elif request.method == 'POST':
serializer = ChallengePhaseSerializer(data=request.data,
context={'challenge': challenge})
if serializer.is_valid():
serializer.save()
response_data = serializer.data
return Response(response_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
paginator = PageNumberPagination()
paginator.page_size = 10
activityControlQueryset = ActivityControl.objects.filter(
is_saved=True, auth_user=request.user)
activity_data = Activity.objects.filter(
pk__in=[x.activity.pk for x in activityControlQueryset
]).prefetch_related('activity_attachment')
if 'search' in request.GET:
activity_data = activity_data.filter(
content__contains=request.GET.get('search', None))
if activity_data:
result_page = paginator.paginate_queryset(activity_data, request)
data = ActivitySerializer(instance=result_page,
many=True,
context={
'request': request
}).data
return paginator.get_paginated_response(data)
else:
raise DataNotFoundException
return Response(status=HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, slug, formate=None):
paginator = PageNumberPagination()
paginator.page_size = 10
profile = get_object_or_404(UsersProfile, slug=slug)
bookmarked_activity = ActivityControl.objects.filter(
auth_user=profile.auth_user, is_saved=True).values('activity_id')
bookmarked_activity.exclude(is_hidden=True)
bookmarked_activity.exclude(is_reported=False)
bookmarked_activity = bookmarked_activity.values('activity_id')
activity_data = Activity.objects.filter(
pk__in=[bookmarked_activity]).prefetch_related(
'activity_attachment')
if activity_data:
result_page = paginator.paginate_queryset(activity_data, request)
data = ActivitySerializer(instance=result_page,
many=True,
context={
'request': request
}).data
return paginator.get_paginated_response(data)
else:
raise DataNotFoundException
return Response(status=HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, **kwargs):
flat_id = kwargs['flat_id']
component_id = kwargs['component_id']
type = request.data.pop("type", None)
paginator = PageNumberPagination()
paginator.page_size = 10
if type == 'pending':
tasks = Tasks.objects.annotate(
name=F('building_component__component__name'),
description=F('building_component__description')
).filter(building_component__flat_id=flat_id).filter(
Q(
Q(building_component__component__parent_id=component_id)
| Q(building_component__component_id=component_id))
).exclude(status='done')
elif type == 'done':
tasks = Tasks.objects.annotate(
name=F('building_component__component__name'),
description=F('building_component__description')
).filter(
building_component__flat_id=flat_id, status='done'
).filter(
Q(
Q(building_component__component__parent_id=component_id)
| Q(building_component__component_id=component_id)))
else:
tasks = Tasks.objects.annotate(
name=F('building_component__component__name'),
description=F('building_component__description')
).filter(building_component__flat_id=flat_id).filter(
Q(
Q(building_component__component__parent_id=component_id)
| Q(building_component__component_id=component_id)))
result_page = paginator.paginate_queryset(tasks, request)
serializer = TaskSerializer(result_page, many=True)
return paginator.get_paginated_response(data=serializer.data)
def get(
request,
slug,
):
paginator = PageNumberPagination()
paginator.page_size = 10
profile = get_object_or_404(UsersProfile, slug=slug)
friends = Friend.objects.friends(profile.auth_user)
if 'query' in request.GET and len(request.GET['query']) > 3:
friends = [
x for x in friends
if request.GET['query'] in x.first_name + ' ' + x.last_name
]
if friends:
result_page = paginator.paginate_queryset(friends, request)
data = AuthUserSerializerLogin(instance=result_page,
many=True,
context={
'request': request
}).data
return paginator.get_paginated_response(data)
else:
raise DataNotFoundException
return Response(status=HTTP_500_INTERNAL_SERVER_ERROR)
def room_serach(request):
max_price = request.GET.get("max_price", None)
min_price = request.GET.get("min_price", None)
beds = request.GET.get("beds", None)
bedrooms = request.GET.get("bedrooms", None)
bathrooms = request.GET.get("bathrooms", None)
lat = request.GET.get("lat", None)
lng = request.GET.get("lng", None)
filter_kwargs = {}
if max_price is not None:
filter_kwargs["price__lte"] = max_price
if min_price is not None:
filter_kwargs["price__gte"] = min_price
if beds is not None:
filter_kwargs["beds__gte"] = beds
if bedrooms is not None:
filter_kwargs["bedrooms__gte"] = bedrooms
if bathrooms is not None:
filter_kwargs["bathrooms__gte"] = bathrooms
paginator = PageNumberPagination()
paginator.page_size = 10
if lat is not None and lng is not None:
filter_kwargs["lat__gte"] = float(lat) - 0.005
filter_kwargs["lat__lte"] = float(lat) + 0.005
filter_kwargs["lng__gte"] = float(lng) - 0.005
filter_kwargs["lng__lte"] = float(lng) + 0.005
try:
rooms = Room.objects.filter(**filter_kwargs)
# **filter_kwargs(unpacking) :
# * 을 할경우 dict 의 모든 key 값을 반환한다
# ** 을 할 경우 key = "value" 값으로 반환해준다
except ValueError:
rooms = Room.objects.all()
results = paginator.paginate_queryset(rooms, request)
serializer = RoomSerializer(results, many=True).data
return paginator.get_paginated_response(serializer)
def all_objects(request, object):
serializer_class, model = get_serializer_and_model_or_404(object)
paginator = PageNumberPagination()
# must be Json array having 'n' strings
raw_fields = request.GET.get(EXTRA_PARAMS['FIELDS'], None)
try:
fields = process_fields_query(raw_fields)
except JSONDecodeError:
return Response({
"errors": {
"fields": ['Value must be valid JSON.']
}
}, status=status.HTTP_400_BAD_REQUEST)
sort_query = request.GET.get(EXTRA_PARAMS['SORT'], None)
sort = process_sort_query(sort_query, model)
query_set = model.objects.all().order_by(sort)
page = paginator.paginate_queryset(query_set, request)
serializer = serializer_class(
page, many=True, fields=fields, context={'request': request})
return paginator.get_paginated_response(serializer.data)
def get_posts(request):
text = request.data['text']
try:
social_media = request.data['social_media']
except:
social_media = None
if text == '':
queryset = Post.objects.filter(content=None, social_media=social_media)
else:
queryset = Post.objects.filter(Q(content__icontains=text)
| Q(title__icontains=text),
social_media=social_media)
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(queryset, request)
serializer = PostSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def products_list(request):
if request.method == 'GET':
search = request.GET.get('search', '')
order = request.GET.get('order', '')
per_page = request.GET.get('per_page', 5)
products = Product.objects.search_products(search, order)
paginator = PageNumberPagination()
paginator.page_size = per_page
result_page = paginator.paginate_queryset(products, request)
serializer = ProductSerializerGET(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
elif request.method == 'POST':
product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(data=product_data)
if product_serializer.is_valid():
product_serializer.save()
return JsonResponse(product_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(product_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 get_paginated_queryset_response(qs, request):
paginator = PageNumberPagination()
paginator.page_size = 20
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = TweetSerializer(paginated_qs, many=True)
return paginator.get_paginated_response(serializer.data) # Response( serializer.data, status=200)
def ordenes_toma_muestra(request):
"""
Lista las ordenes que vienen de recepcion y son enviadas al area de toma de muestra.
Aqui empieza el proceso de trazabilidad de un laboratorio.
"""
args = tuple()
kwargs = {}
empleado = request.user.empleado
class OrdenSerializerTomaMuestra(OrdenSerializer):
def to_representation(self, obj):
representacion = super(OrdenSerializerTomaMuestra, self).to_representation(obj)
representacion['toma_muestra'] = getattr(obj, 'recepcion', None) is not None
return representacion
if request.method == 'GET':
param = request.GET.get('param', '')
fecha = request.GET.get('fecha', '')
hoy = timezone.now().date()
servicios = Laboratorio.objects.all().values_list('servicio_id', flat=True)
querys = (
Q(paciente__pnombre__icontains=param) | Q(paciente__papellido__icontains=param) |
Q(paciente__cedula__icontains=param) | Q(id__icontains=param)
)
ordenes = Orden.objects.filter(
id__in=OrdenProducto.objects.filter(
servicio__nombre__id__in=servicios
).values_list('orden_id', flat=True).distinct(),
institucion__id=1
).exclude(anulada=True).order_by('fecha').select_related('paciente')
if param:
ordenes = ordenes.filter(querys)
elif fecha:
year, month, day = fecha.split('-')
fecha_filter = datetime.date(year=int(year), month=int(month), day=int(day))
ordenes = ordenes.filter(fecha__range=(fecha_filter, fecha_filter + datetime.timedelta(days=1)))
else:
hoy = datetime.date.today()
ordenes = ordenes.filter(fecha__range=(hoy, hoy + datetime.timedelta(days=1)))
pagination = PageNumberPagination()
pagination.page_size = 100
result_pagination = pagination.paginate_queryset(ordenes, request)
serializer = OrdenSerializerTomaMuestra(result_pagination, many=True)
return pagination.get_paginated_response(serializer.data)
else:
serializer = RecepcionSerializer(data=request.data)
if 'hoja_gasto' in request.data:
serializer_hoja_gasto = HojaGastoSerializer(data=request.data['hoja_gasto'], many=True)
valid_serializer = serializer.is_valid()
valid_hoja_gasto = serializer_hoja_gasto.is_valid()
if valid_hoja_gasto and valid_serializer:
serializer.save(estado=Recepcion.EN_CURSO, empleado=empleado)
recepcion = serializer_hoja_gasto.save()
recepcion.orden._save_status_if_need() # svorden
args = ([serializer.data, serializer_hoja_gasto.data], )
else:
args = ([getattr(serializer, 'errors', []), getattr(serializer_hoja_gasto, 'errors', [])], )
kwargs['status'] = status.HTTP_400_BAD_REQUEST
else:
if serializer.is_valid():
serializer.save(estado=Recepcion.EN_CURSO, empleado=empleado)
args = (serializer.data, )
else:
args = (serializer.errors, )
kwargs['status'] = status.HTTP_400_BAD_REQUEST
return Response(*args, **kwargs)
def get_paginated_queryset_response(qs, request):
paginator = PageNumberPagination()
paginator.page_size = 10
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = PostSerializer(paginated_qs, many=True , context={"request_user" : request.user})
return paginator.get_paginated_response(serializer.data) # Response( serializer.data, status=200)
def index(request):
paginator = PageNumberPagination()
movies = Movie.objects.all()
page = paginator.paginate_queryset(movies,request)
serializer = MovieListSerializer(page, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
paginator = PageNumberPagination()
obj = Shelter.objects.all()
context = paginator.paginate_queryset(obj, request)
serializer = ShelterSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, pk, format=None):
paginator = PageNumberPagination()
obj = Animal.objects.filter(shelter=pk)
context = paginator.paginate_queryset(obj, request)
serializer = AnimalSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get_paginated_queryset_response(querySet, request):
paginator = PageNumberPagination()
paginator.page_size = 20
paginated_querySet = paginator.paginate_queryset(querySet, request)
serializer = PostSerializer(paginated_querySet, many=True, context={"request": request})
return paginator.get_paginated_response(serializer.data)
def get_paginated_queryset_response(queryset, request):
paginator = PageNumberPagination()
paginator.page_size = 10
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = TweetSerializer(paginated_queryset, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
items = Colaborador.objects.all()
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(items, request)
serializer = ColaboradorSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def _paginate_response(data, request):
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(data, request)
return paginator.get_paginated_response(result_page)
def advance_search(self, request):
queryset = super().get_queryset()
filtros = request.data['filtros']
next_connector = None
apply_filters = Q()
people_search = PeopleFilterSearch()
for idx, f in enumerate(filtros):
data_key = f['data_key']
value = f['data_value']
condition = f['condition']
search_by = f['search_by']
check_attribute_type = 'USER'
if search_by == 'attribute':
attribute = Attribute.objects.get(pk=data_key)
is_exact = attribute.type in ['numeric', 'category']
# check if attribute belongs to user or instance, Priority to INSTANCES
if attribute.entity_set.filter(id__in=[1, 2]).exists():
check_attribute_type = 'INSTANCE'
if condition == 'is_set' or condition == 'not_set':
if condition == 'is_set':
# validar is set attribute
if check_attribute_type == 'USER':
users = User.objects.filter(
Q(userdata__attribute_id=data_key))
q = Q(instanceassociationuser__user_id__in=users)
apply_filters = people_search.apply_connector(
next_connector, apply_filters, q)
else:
q = Q(attributevalue__attribute_id=data_key)
apply_filters = people_search.apply_connector(
next_connector, apply_filters, q)
if condition == 'not_set':
# validar not set attribute
if check_attribute_type == 'USER':
users = User.objects.filter(~Q(
userdata__attribute_id=data_key))
q = Q(instanceassociationuser__user_id__in=users)
apply_filters = people_search.apply_connector(
next_connector, apply_filters, q)
else:
q = ~Q(attributevalue__attribute_id=data_key)
apply_filters = people_search.apply_connector(
next_connector, apply_filters, q)
else:
if check_attribute_type == 'USER':
# filter by attribute user
last_attributes = people_search.get_last_attributes(
data_key, model=UserData, type_id='user_id')
# query_search = list(User.objects.filter(userdata__id__in=last_attributes).values_list('id',flat=True))
s = Q(instanceassociationuser__user__userdata__id__in=
last_attributes)
val_field = 'userdata__data_value'
else:
# filter by attribute instance
last_attributes = people_search.get_last_attributes(
data_key,
model=models.AttributeValue,
type_id='instance_id')
s = Q(attributevalue__id__in=last_attributes)
val_field = 'attributevalue__value'
qs = models.Instance.objects.filter(s)
if attribute.type == 'numeric':
qs = qs.exclude(**{
f"{val_field}__isnull": True
}).exclude(**{f"{val_field}=": ""})
qs = qs.annotate(as_float=Cast(
Func(F(val_field),
Value('/[^0-9]/'),
Value(''),
function='regexp_replace'), FloatField()))
val_field = 'as_float'
s = people_search.apply_filter(val_field,
value,
condition,
exact=is_exact)
queryset = people_search.apply_connector(
next_connector, queryset, qs.filter(s))
elif search_by == 'bot':
condition = condition if condition == 'is' else 'is_not'
s = people_search.apply_filter('user__bot_id',
value,
condition,
exact=True)
qs = AssignationMessengerUser.objects.filter(s).values_list(
'user_id',
flat=True).exclude(user_id__isnull=True).distinct()
query = Q(instanceassociationuser__user_id__in=list(qs))
apply_filters = people_search.apply_connector(
next_connector, apply_filters, query)
elif search_by == 'channel':
# filter by channel
s = people_search.apply_filter('channel_id', value, condition)
qs = User.objects.filter(s).order_by('-id').values_list(
'id', flat=True)
query = Q(instanceassociationuser__user_id__in=list(qs))
apply_filters = people_search.apply_connector(
next_connector, apply_filters, query)
elif search_by == 'dates':
# filter by dates
date_from = datetime.combine(
datetime.strptime(f['date_from'], '%Y-%m-%d'),
time.min) - timedelta(days=1)
date_to = datetime.combine(
datetime.strptime(f['date_to'], '%Y-%m-%d'),
time.max) - timedelta(days=1)
if date_from and date_to:
if data_key == 'created_at':
queryset = queryset.filter(created_at__gte=date_from,
created_at__lte=date_to)
elif search_by == 'group':
# filter by group
s = people_search.apply_filter('group__id',
value,
condition,
exact=True)
qs = AssignationMessengerUser.objects.filter(s).values_list(
'user_id',
flat=True).exclude(user_id__isnull=True).distinct()
queryset = Q(instanceassociationuser__user_id__in=list(qs))
apply_filters = people_search.apply_connector(
next_connector, apply_filters, queryset)
elif search_by == 'program':
# filter by program
s = people_search.apply_filter('program__id',
value,
condition,
exact=True)
qs = ProgramAssignation.objects.filter(s).values_list(
'user_id', flat=True).exclude(user_id__isnull=True)
queryset = Q(instanceassociationuser__user_id__in=list(qs))
apply_filters = people_search.apply_connector(
next_connector, apply_filters, queryset)
elif search_by == 'sequence':
queryset = people_search.by_sequence(
models.Instance, 'instanceassociationuser__user__id',
next_connector, value, condition, queryset)
if isinstance(queryset, bool):
return Response({'message': 'subscribed API error'},
status=HTTP_500_INTERNAL_SERVER_ERROR)
next_connector = f['connector']
if request.query_params.get('search'):
# string search on datatable
filter_search = Q()
params = ['id', 'name']
for x in params:
filter_search |= Q(**{
f"{x}__icontains":
self.request.query_params.get('search')
})
queryset = queryset.filter(filter_search)
queryset = queryset.filter(apply_filters)
pagination = PageNumberPagination()
qs = pagination.paginate_queryset(queryset, request)
serializer = InstanceDetailSerializer(qs, many=True)
return pagination.get_paginated_response(serializer.data)
def get(self, request):
users = User.objects.all()
paginator = PageNumberPagination()
paginated_users = paginator.paginate_queryset(users, request)
serializer = UserListSerializer(paginated_users, many=True)
return paginator.get_paginated_response(serializer.data)
