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 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 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 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 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 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 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 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 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_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 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 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 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 _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 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(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 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 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 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 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_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 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 advance_search(self, request):
queryset = models.User.objects.all()
filtros = request.data['filtros']
next_connector = None
date_filter = Q()
filter_search = 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 = 'INSTANCE'
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 USER
if attribute.entity_set.filter(id__in=[4, 5]).exists():
check_attribute_type = 'USER'
if condition == 'is_set' or condition == 'not_set':
model_field = dict(
instanceassociationuser__instance__attributevalue__attribute_id
=data_key)
if check_attribute_type == 'USER':
model_field = dict(userdata__attribute_id=data_key)
if condition == 'is_set':
qs = models.User.objects.filter(**model_field)
else:
qs = models.User.objects.exclude(**model_field)
queryset = people_search.apply_connector(
next_connector, queryset, qs)
else:
if check_attribute_type == 'INSTANCE':
# filter by attribute instance
last_attributes = people_search.get_last_attributes(
data_key,
model=InstanceAttributeValue,
type_id='instance_id')
s = Q(
instanceassociationuser__instance__attributevalue__id__in
=last_attributes)
val_field = 'instanceassociationuser__instance__attributevalue__value'
else:
# filter by attribute user
last_attributes = people_search.get_last_attributes(
data_key, model=models.UserData, type_id='user_id')
s = Q(userdata__id__in=last_attributes)
val_field = 'userdata__data_value'
qs = models.User.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('bot_id',
value,
condition,
exact=True)
qs = models.User.objects.filter(s)
queryset = people_search.apply_connector(
next_connector, queryset, qs)
elif search_by == 'channel':
# filter by channel
s = people_search.apply_filter('userchannel__channel_id',
value,
condition,
exact=True)
qs = models.User.objects.filter(s)
queryset = people_search.apply_connector(
next_connector, queryset, qs)
elif search_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':
date_filter = Q(created_at__gte=date_from,
created_at__lte=date_to)
if data_key == 'last_seen':
date_filter = Q(
userchannel__interaction__created_at__gte=date_from,
userchannel__interaction__created_at__lte=date_to)
if data_key == 'last_user_message':
date_filter = Q(
userchannel__interaction__category=1,
userchannel__interaction__created_at__gte=date_from,
userchannel__interaction__created_at__lte=date_to)
if data_key == 'last_channel_interaction':
date_filter = Q(
userchannel__interaction__category=2,
userchannel__interaction__created_at__gte=date_from,
userchannel__interaction__created_at__lte=date_to)
if data_key == 'window':
date_filter = Q(
userchannel__interaction__category=1,
userchannel__interaction__created_at__gt=timezone.now(
) - timedelta(1))
elif search_by == 'group':
# filter by group and by parent group
s = people_search.apply_filter(
'assignationmessengeruser__group_id',
value,
condition,
exact=True)
s2 = people_search.apply_filter(
'assignationmessengeruser__group__parent_id',
value,
condition,
exact=True)
qs = models.User.objects.filter(s | s2)
queryset = people_search.apply_connector(
next_connector, queryset, qs)
elif search_by == 'program':
# filter by program
s = people_search.apply_filter(
'assignationmessengeruser__group__programassignation__program_id',
value,
condition,
exact=True)
qs = models.User.objects.filter(s)
queryset = people_search.apply_connector(
next_connector, queryset, qs)
elif search_by == 'sequence':
queryset = people_search.by_sequence(models.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'):
# search by queryparams
params = ['username', 'first_name', 'last_name', 'created_at']
for x in params:
filter_search |= Q(**{
f"{x}__icontains":
self.request.query_params.get('search')
})
if self.request.query_params.get('search').isnumeric():
filter_search |= Q(id=self.request.query_params.get('search'))
filter_search |= Q(
bot_id=self.request.query_params.get('search'))
filter_search |= Q(
channel_id=self.request.query_params.get('search'))
queryset = queryset.filter(date_filter).filter(
filter_search).distinct()
queryset = queryset.annotate(last_interaction=Max(
'userchannel__interaction__id')).order_by('-last_interaction')
pagination = PageNumberPagination()
qs = pagination.paginate_queryset(queryset, request)
serializer = serializers.UserSerializer(qs, many=True)
return pagination.get_paginated_response(serializer.data)
def get(self, request, format="JSON"):
user = request.user
try:
dept_id = user.dept.id
dept_arr = []
depts = Department.objects.all()
getDept(dept_id, depts, dept_arr).append(dept_id)
query_params = list(request.query_params.keys())
kwargs = {}
if 'name' in query_params:
kwargs['name__contains'] = request.query_params['name']
kwargs['user__dept_id__in'] = dept_arr
buidling_list = Buidling.objects.filter(
**kwargs).order_by('-addtime')
page = PageNumberPagination() # 生成分页器对象
page.page_size = 20 # 设置每页的条数
page.page_query_param = 'page' # url中查询第几页的key默认为'page
page.page_size_query_param = 'limit' # url中这一页数据的条数的key, 默认为None
# page.max_page_size = 5 # 每页的最大数据条数
page_list = page.paginate_queryset(buidling_list, request,
self) # 生成这一页的数据列表
# page_list.
# 将这一页的数据列表序列化
# return Response(ret.data) # 返回查到的数据列表
ret = BuidlingListSerialiser(page_list, many=True)
jsondata = {}
for building in ret.data:
online = 0
offline = 0
open = 0
close = 0
total = 0
power = ActualData.objects.filter(
device__building_id=building['id']).aggregate(
power=Sum('tPower'))
for group in building['group']:
for device in group['device']:
total += 1
if device['status'] == '0':
offline += 1
else:
online += 1
if device['switch'] == '0':
close += 1
else:
open += 1
building['power'] = power
building['online'] = online
building['offline'] = offline
building['open'] = open
building['close'] = close
building['device_total'] = total
jsondata['code'] = 20000
jsondata['total'] = page.page.paginator.count
jsondata['items'] = ret.data
content = user.username + '进行获取楼层列表操作；结果：成功！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response(jsondata)
except:
content = user.username + '进行获取楼层列表操作；结果：失败！'
Logs.objects.create(content=content,
user=user,
addtime=datetime.datetime.now(),
ip=request.META['REMOTE_ADDR'])
return Response({'code': 0, 'msg': '设备列表获取失败'})
def get(self, request, format=None):
usuarios = Users.objects.all()
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(usuarios, request)
serializer = UsersSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_paginated_queryset_response(qs, request, *args, **kwargs):
paginator = PageNumberPagination()
paginator.page_size = TWEETS_ON_SINGLE_PAGE
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = TweetReadSerializer(paginated_qs, many=True)
return paginator.get_paginated_response(serializer.data)
def tests(self, request, **kwargs):
tests = TestCase.objects.filter(suite__job=self.get_object()).order_by("id")
paginator = PageNumberPagination()
page = paginator.paginate_queryset(tests, request)
serializer = TestCaseSerializer(page, many=True, context={"request": request})
return paginator.get_paginated_response(serializer.data)
def suites(self, request, **kwargs):
suites = self.get_object().testsuite_set.all().order_by("id")
paginator = PageNumberPagination()
page = paginator.paginate_queryset(suites, request)
serializer = TestSuiteSerializer(page, many=True, context={"request": request})
return paginator.get_paginated_response(serializer.data)
def element_fancy_search(request, query):
"""
List all ancestors' pk of the first element found.
"""
queryset = TreeNode.objects.only('id')
for param in query.split():
if '!' in param:
p = param.split('!')
if len(p) > 2:
break
queryset = queryset.filter(
dataset__doctype__name=p[0],
dataset__name=p[1]
)
elif '@' in param:
# Search specified element by attribute
p = param.split('@')
if len(p) > 2:
continue
if p[0] and p[1]:
if '=' in p[1]:
a = p[1].split('=')
if len(a) > 2:
continue
if a[0] and a[1]:
# 'e@a=v' Search specified element by attribute name and value
queryset = queryset.filter(
element__type__name=p[0],
element__attributes__type__name=a[0],
element__attributes__value=a[1]
)
elif a[1]:
# 'e@=v' Search specified element by attribute value
queryset = queryset.filter(
element__type__name=p[0],
element__attributes__value=a[1]
)
else:
# 'e@a' Search specified element by attribute name
queryset = queryset.filter(
element__type__name=p[0],
element__attributes__type__name=p[1],
)
elif p[1]:
# Search any element by attribute
if '=' in p[1]:
a = p[1].split('=')
if len(a) > 2:
continue
if a[0] and a[1]:
# '@a=v' Search any element by attribute name and value
queryset = queryset.filter(
element__attributes__type__name=a[0],
element__attributes__value=a[1]
)
elif a[1]:
# '@=v' Search any element by attribute value
queryset = queryset.filter(
element__attributes__value=a[1]
)
else:
# '@a' Search any element by attribute name
queryset = queryset.filter(
element__attributes__type__name=p[1]
)
else:
# '@' Search any element with attribute
queryset = queryset.filter(
element__attributes__isnull=False
)
else:
# if '=' in p[1]:
# 'e=t' Search element by content
# else:
# 'e' Search specified element by name
queryset = queryset.filter(
element__type__name=param
)
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 paginate_orders(request, orders):
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(orders, request)
serializer = OrderSerializer(result_page, 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, context={'request':request})
return paginator.get_paginated_response(serializer.data) #Response(serializer.data, status=200)
def get(self, request, *args, **kwargs):
project_id = request.query_params.get('project', None)
search_param = self.request.query_params.get('q', None)
if project_id:
try:
project_obj = Project.objects.get(id=project_id)
paginator = PageNumberPagination()
paginator.page_size = 200
if is_project_manager_or_team_admin(project_obj, request.user):
if search_param:
data = Site.objects.filter(
Q(name__icontains=search_param)
| Q(identifier__icontains=search_param),
project=project_obj,
is_active=True,
site__isnull=True,
is_survey=False)
else:
data = Site.objects.filter(project=project_obj,
is_active=True,
site__isnull=True,
is_survey=False)
result_page = paginator.paginate_queryset(data, request)
sites = MySiteSerializer(result_page,
many=True,
context={'request': request})
return paginator.get_paginated_response({
'data':
sites.data,
'query':
search_param
})
else:
region_ids = request.roles.filter(group__name__in=["Region Supervisor", "Region Reviewer"],
region__is_active=True, project=project_obj, ended_at=None).\
distinct('region_id').values_list('region_id', flat=True)
reg_sites = []
for reg in region_ids:
region = Region.objects.get(id=reg)
reg_sites.extend(region.get_sites_id())
sites_id = request.roles.select_related('user', 'group', 'site', 'organization',
'staff_project', 'region').filter(
group__name__in=["Site Supervisor", "Reviewer"], ended_at=None, project=project_obj).\
distinct('site_id').values_list('site_id', flat=True)
total_sites = list(chain(reg_sites, sites_id))
if search_param:
data = Site.objects.filter(
Q(name__icontains=search_param)
| Q(identifier__icontains=search_param),
id__in=total_sites)
else:
data = Site.objects.filter(id__in=total_sites)
result_page = paginator.paginate_queryset(data, request)
sites = MySiteSerializer(result_page,
many=True,
context={'request': request})
return paginator.get_paginated_response({
'data':
sites.data,
'query':
search_param
})
except Exception as e:
return Response(data=str(e), status=status.HTTP_204_NO_CONTENT)
else:
return Response(data="Project Id params required.",
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
items = Like.objects.all()
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(items, request)
serializer = LikeSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
paginator = PageNumberPagination()
queryset = CurrencyRepository.getCurrencies()
context = paginator.paginate_queryset(queryset, request)
serializer = CurrencySerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
pagination = PageNumberPagination()
dossies = dossie_service.getAllDossies()
result = pagination.paginate_queryset(dossies, request)
serializer = dossie_serializer.DossieSerializer(result, many=True)
return pagination.get_paginated_response(serializer.data)
def get(self, request):
global role_list, project_list
pro_id = request.query_params.get('id', None)
if pro_id:
resp = dict()
project = Project.objects.get(id=int(pro_id))
if request.auth:
colla_user = ProjectCollaborator.objects.filter(
project=project, user=request.user).count()
else:
colla_user = 0
try:
allow_download = ProjectReport.objects.get(project=project)
except:
allow_download = False
if (project.role == 1) and (
request.user != project.create_user) and (colla_user == 0):
resp['code'] = 2
elif project.role == 2:
user_list = project.role_value
if request.auth:
if (request.user.username not in user_list) and \
(request.user != project.create_user) and \
(colla_user == 0):
resp['code'] = 2
else:
resp['code'] = 2
elif project.role == 3:
if request.user != project.create_user and colla_user == 0:
viewcode = project.role_value
viewcode_name = 'viewcode-{}'.format(project.id)
r_viewcode = request.data.get(viewcode_name, 0)
if viewcode != r_viewcode:
resp['code'] = 3
else:
serializer = ProjectSerializer(project)
resp = {'code': 0, 'data': serializer.data}
return Response(resp)
else:
kw = request.query_params.get('kw', '')
sort = request.query_params.get('sort', 0)
role = request.query_params.get('role', -1)
if sort in ['', 0, '0']:
sort_str = ''
else:
sort_str = '-'
if kw == '':
is_kw = False
else:
is_kw = True
if request.auth:
is_auth = True
else:
is_auth = False
if role in ['', -1, '-1']:
is_role = False
role_list = [0, 3]
else:
is_role = True
if (is_kw is False) and (is_auth) and (is_role is False):
colla_list = [
i.project.id for i in ProjectCollaborator.objects.filter(
user=request.user)
]
project_list = Project.objects.filter(
Q(role__in=role_list) | \
Q(role=2, role_value__contains=str(request.user.username)) | \
Q(create_user=request.user) | \
Q(id__in=colla_list)
).order_by("{}create_time".format(sort_str))
elif (is_kw is False) and (is_auth) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(role=0).order_by(
"{}create_time".format(sort_str))
elif role in ['1', 1]:
project_list = Project.objects.filter(
create_user=request.user,
role=1).order_by("{}create_time".format(sort_str))
elif role in ['2', 2]:
project_list = Project.objects.filter(
role=2,
role_value__contains=str(
request.user.username)).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(role=3).order_by(
"{}create_time".format(sort_str))
elif role in ['99', 99]:
colla_list = [
i.project.id
for i in ProjectCollaborator.objects.filter(
user=request.user)
]
project_list = Project.objects.filter(
id__in=colla_list).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 2, 'data': []})
elif (is_kw is False) and (is_auth is False) and (is_role is
False):
project_list = Project.objects.filter(
role__in=[0, 3]).order_by("{}create_time".format(sort_str))
elif (is_kw is False) and (is_auth is False) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(role=0).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(role=3).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 2, 'data': []})
elif (is_kw) and (is_auth) and (is_role is False):
colla_list = [
i.project.id for i in ProjectCollaborator.objects.filter(
user=request.user)
]
project_list = Project.objects.filter(
Q(role__in=[0, 3]) | \
Q(role=2, role_value__contains=str(request.user.username)) | \
Q(create_user=request.user) | \
Q(id__in=colla_list),
Q(name__icontains=kw) | Q(intro__icontains=kw)
).order_by('{}create_time'.format(sort_str))
elif (is_kw) and (is_auth) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=0).order_by("{}create_time".format(sort_str))
elif role in ['1', 1]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
create_user=request.user).order_by(
"{}create_time".format(sort_str))
elif role in ['2', 2]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=2,
role_value__contains=str(
request.user.username)).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=3).order_by("{}create_time".format(sort_str))
elif role in ['99', 99]:
colla_list = [
i.project.id
for i in ProjectCollaborator.objects.filter(
user=request.user)
]
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
id__in=colla_list).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 1, 'data': []})
elif (is_kw) and (is_auth is False) and (is_role is False):
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role__in=[0, 3]).order_by("{}create_time".format(sort_str))
elif (is_kw) and (is_auth is False) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=0).order_by("{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=3).order_by("{}create_time".format(sort_str))
else:
return Response({'code': 1, 'data': []})
page = PageNumberPagination()
page_projects = page.paginate_queryset(project_list,
request,
view=self)
serializer = ProjectSerializer(page_projects, many=True)
resp = {
'code': 0,
'data': serializer.data,
'count': project_list.count()
}
return Response(resp)
def get(self, request):
pro_id = request.query_params.get('id', None)
if pro_id:
resp = dict()
# 获取文集信息
project = Project.objects.get(id=int(pro_id))
# 获取文集的协作用户信息
# print(request.auth)
# print(request.user)
if request.auth: # 对登陆用户查询其协作文档信息
colla_user = ProjectCollaborator.objects.filter(
project=project, user=request.user).count()
else:
colla_user = 0
# 获取文集前台下载权限
try:
allow_download = ProjectReport.objects.get(project=project)
except:
allow_download = False
# 私密文集并且访问者非创建者非协作者
if (project.role == 1) and (
request.user != project.create_user) and (colla_user == 0):
# return Response({'code': 2, 'data': []})
resp['code'] = 2
# 指定用户可见文集
elif project.role == 2:
user_list = project.role_value
if request.auth: # 认证用户判断是否在许可用户列表中
if (request.user.username not in user_list) and \
(request.user != project.create_user) and \
(colla_user == 0): # 访问者不在指定用户之中
resp['code'] = 2
else: # 游客直接返回404
resp['code'] = 2
# 访问码可见
elif project.role == 3:
# 浏览用户不为创建者、协作者
if request.user != project.create_user and colla_user == 0:
viewcode = project.role_value
viewcode_name = 'viewcode-{}'.format(project.id)
r_viewcode = request.data.get(viewcode_name, 0) # 获取访问码
if viewcode != r_viewcode: # 访问码不等于文集访问码，跳转到访问码认证界面
# return Response({'code': 3})
resp['code'] = 3
else:
serializer = ProjectSerializer(project)
resp = {'code': 0, 'data': serializer.data}
return Response(resp)
else:
kw = request.query_params.get('kw', '') # 搜索词
sort = request.query_params.get('sort',
0) # 排序,0表示按时间升序排序，1表示按时间降序排序，默认为0
role = request.query_params.get('role', -1) # 筛选文集权限，默认为显示所有可显示的文集
# 是否排序
if sort in ['', 0, '0']:
sort_str = ''
else:
sort_str = '-'
# 是否搜索
if kw == '':
is_kw = False
else:
is_kw = True
# 是否认证
if request.auth:
is_auth = True
else:
is_auth = False
# 是否筛选
if role in ['', -1, '-1']:
is_role = False
role_list = [0, 3]
else:
is_role = True
# 没有搜索 and 认证用户 and 没有筛选
if (is_kw is False) and (is_auth) and (is_role is False):
colla_list = [
i.project.id for i in ProjectCollaborator.objects.filter(
user=request.user)
] # 用户的协作文集列表
project_list = Project.objects.filter(
Q(role__in=role_list) | \
Q(role=2, role_value__contains=str(request.user.username)) | \
Q(create_user=request.user) | \
Q(id__in=colla_list)
).order_by("{}create_time".format(sort_str))
# 没有搜索 and 认证用户 and 有筛选
elif (is_kw is False) and (is_auth) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(role=0).order_by(
"{}create_time".format(sort_str))
elif role in ['1', 1]:
project_list = Project.objects.filter(
create_user=request.user,
role=1).order_by("{}create_time".format(sort_str))
elif role in ['2', 2]:
project_list = Project.objects.filter(
role=2,
role_value__contains=str(
request.user.username)).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(role=3).order_by(
"{}create_time".format(sort_str))
elif role in ['99', 99]:
colla_list = [
i.project.id
for i in ProjectCollaborator.objects.filter(
user=request.user)
] # 用户的协作文集列表
project_list = Project.objects.filter(
id__in=colla_list).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 2, 'data': []})
# 没有搜索 and 游客 and 没有筛选
elif (is_kw is False) and (is_auth is False) and (is_role is
False):
project_list = Project.objects.filter(
role__in=[0, 3]).order_by("{}create_time".format(sort_str))
# 没有搜索 and 游客 and 有筛选
elif (is_kw is False) and (is_auth is False) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(role=0).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(role=3).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 2, 'data': []})
# 有搜索 and 认证用户 and 没有筛选
elif (is_kw) and (is_auth) and (is_role is False):
colla_list = [
i.project.id for i in ProjectCollaborator.objects.filter(
user=request.user)
] # 用户的协作文集
# 查询所有可显示的文集
project_list = Project.objects.filter(
Q(role__in=[0, 3]) | \
Q(role=2, role_value__contains=str(request.user.username)) | \
Q(create_user=request.user) | \
Q(id__in=colla_list),
Q(name__icontains=kw) | Q(intro__icontains=kw)
).order_by('{}create_time'.format(sort_str))
# 有搜索 and 认证用户 and 有筛选
elif (is_kw) and (is_auth) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=0).order_by("{}create_time".format(sort_str))
elif role in ['1', 1]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
create_user=request.user).order_by(
"{}create_time".format(sort_str))
elif role in ['2', 2]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=2,
role_value__contains=str(
request.user.username)).order_by(
"{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=3).order_by("{}create_time".format(sort_str))
elif role in ['99', 99]:
colla_list = [
i.project.id
for i in ProjectCollaborator.objects.filter(
user=request.user)
] # 用户的协作文集列表
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
id__in=colla_list).order_by(
"{}create_time".format(sort_str))
else:
return Response({'code': 1, 'data': []})
# 有搜索 and 游客 and 没有筛选
elif (is_kw) and (is_auth is False) and (is_role is False):
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role__in=[0, 3]).order_by("{}create_time".format(sort_str))
# 有搜索 and 游客 and 有筛选
elif (is_kw) and (is_auth is False) and (is_role):
if role in ['0', 0]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=0).order_by("{}create_time".format(sort_str))
elif role in ['3', 3]:
project_list = Project.objects.filter(
Q(name__icontains=kw) | Q(intro__icontains=kw),
role=3).order_by("{}create_time".format(sort_str))
else:
return Response({'code': 1, 'data': []})
page = PageNumberPagination() # 实例化一个分页器
page_projects = page.paginate_queryset(project_list,
request,
view=self) # 进行分页查询
serializer = ProjectSerializer(page_projects,
many=True) # 对分页后的结果进行序列化处理
resp = {
'code': 0,
'data': serializer.data,
'count': project_list.count()
}
return Response(resp)
def post(self, request, **kwargs):
try:
task_id = kwargs['task_id']
comment = ''
file_list = []
dir = os.path.join(settings.MEDIA_ROOT, "comments")
if not os.path.exists(dir):
os.makedirs(dir)
if 'files' in request.data:
files = request.data.getlist('files')
for file in files:
uploaded_file = CommonView.handle_uploaded_file(
request, file)
if uploaded_file != "":
file_list.append(uploaded_file)
if 'text' in request.data:
comment = request.data["text"]
if comment != '' or len(file_list) > 0:
comment_form = {
"text": comment,
"file_type": file_list if (len(file_list) > 0) else None,
"task_id": task_id,
"user": request.user,
"type": "text"
}
new_comment = Comments(**comment_form)
new_comment.save()
task = Tasks.objects.get(id=task_id)
task.save()
if request.user.is_staff:
user_name = request.user.get_full_name()
else:
user_name = request.user.handworker.company_name
if comment != '':
# Send Notification
message = NotificationText.get_task_comment_notification_text(
user_name, task.building_component.component.name)
task_thread = threading.Thread(
target=NotificationsView.create_notfication,
args=(request, 'task_comment', message, task_id,
request.user.id))
task_thread.start()
if len(file_list) > 0:
# Send Notification
message = NotificationText.get_attach_file_notification_text(
user_name, task.building_component.component.name)
task_thread = threading.Thread(
target=NotificationsView.create_notfication,
args=(request, 'attach_file', message, task_id,
request.user.id))
task_thread.start()
paginator = PageNumberPagination()
paginator.page_size = 10
comments = Comments.objects.filter(
task_id=task_id).order_by('-created_at')
result_page = paginator.paginate_queryset(comments, request)
serializer = CommentSerializer(result_page, many=True)
return paginator.get_paginated_response(data=serializer.data)
else:
return Response(
{
'success': False,
'message': "Something went wrong."
},
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
LogHelper.efail(e)
return Response(
{
'success': False,
'message': "Something went wrong."
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def products(request):
# query params
skin_type = request.query_params.get("skin_type")
if skin_type is None:
raise InvalidQueryParam("skin_type should be specified")
elif skin_type not in configs.SKIN_TYPES:
raise InvalidQueryParam("Invalid query param: skin_type")
category = request.query_params.get("category")
page = request.query_params.get("page")
exclude_ingredient = request.query_params.get("exclude_ingredient")
include_ingredient = request.query_params.get("include_ingredient")
# querysets
querysets = Item.objects.all()
if category is not None:
querysets = querysets.filter(category=category)
def preprocessing(param):
param_list = param.split(",")
# remove left/right space, normalize to lower case
return [param.strip().lower() for param in param_list]
if exclude_ingredient is not None:
ingr_list = preprocessing(exclude_ingredient)
for ingr in ingr_list:
querysets = querysets.exclude(ingredients__name=ingr)
if include_ingredient is not None:
ingr_list = preprocessing(include_ingredient)
for ingr in ingr_list:
querysets = querysets.filter(ingredients__name=ingr)
# sum by skin_type and ordering(score desc, price asc)
querysets = querysets.annotate(
score=Sum("ingredients__{}".format(skin_type))).order_by(
"-score", "price")
# paging
if page is not None:
try:
page = int(page)
except:
raise InvalidQueryParam("Invalid query param: page")
paginator = PageNumberPagination()
paginator.page_size = settings.QUERY_PAGE_SIZE
querysets = paginator.paginate_queryset(querysets, request)
# serializing
serializer = ItemSerializer(querysets,
many=True,
fields=[
"id", "imgUrl", "name", "price",
"ingredients", "monthlySales"
],
image_type="thumbnail")
if not len(serializer.data):
raise NotFound
return Response(serializer.data)
def get(self,request):
pro_id = request.query_params.get('pid','') # 文集ID
doc_id = request.query_params.get('did','') # 文档ID
doc_format = request.query_params.get('type','json') # 返回格式
# 存在文集ID和文档ID，进行数据库检索
if pro_id != '' and doc_id != '':
# 获取文集信息
project = Project.objects.get(id=int(pro_id))
# 获取文集的协作用户信息
if request.auth:
colla_user = ProjectCollaborator.objects.filter(project=project, user=request.user)
if colla_user.exists():
colla_user_role = colla_user[0].role
colla_user = colla_user.count()
else:
colla_user = colla_user.count()
else:
colla_user = 0
# 私密文集且访问者非创建者、协作者 - 不能访问
if (project.role == 1) and (request.user != project.create_user) and (colla_user == 0):
return Response({'code':2})
# 指定用户可见文集
elif project.role == 2:
user_list = project.role_value
if request.user.is_authenticated: # 认证用户判断是否在许可用户列表中
if (request.user.username not in user_list) and \
(request.user != project.create_user) and \
(colla_user == 0): # 访问者不在指定用户之中，也不是协作者
return Response({'code': 2})
else: # 游客直接返回404
return Response({'code': 2})
# 访问码可见
elif project.role == 3:
# 浏览用户不为创建者和协作者 - 需要访问码
if (request.user != project.create_user) and (colla_user == 0):
viewcode = project.role_value
viewcode_name = 'viewcode-{}'.format(project.id)
r_viewcode = request.data.get(viewcode_name,0) # 获取访问码
if viewcode != r_viewcode: # cookie中的访问码不等于文集访问码，跳转到访问码认证界面
return Response({'code':3})
# 获取文档内容
try:
doc = Doc.objects.get(id=int(doc_id), status=1)
if doc_format == 'json':
serializer = DocSerializer(doc)
resp = {'code':0,'data':serializer.data}
return Response(resp)
elif doc_format == 'html':
logger.info("返回HTML")
# return Response({'status':'html'})
return render(request,'app_api/single_doc_detail.html',locals())
else:
logger.info(doc_format)
except ObjectDoesNotExist:
return Response({'code':4})
# 不存在文集ID和文档ID，返回用户自己的文档列表
else:
if request.auth:
doc_list = Doc.objects.filter(create_user=request.user,status=1).order_by('-modify_time')
page = PageNumberPagination() # 实例化一个分页器
page_docs = page.paginate_queryset(doc_list, request, view=self) # 进行分页查询
serializer = DocSerializer(page_docs, many=True) # 对分页后的结果进行序列化处理
resp = {
'code': 0,
'data': serializer.data,
'count': doc_list.count()
}
return Response(resp)
else:
return Response({'code':4})
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)
def get_paginated_queryset(request, qs, serializer_obj, page_size=10):
paginator = PageNumberPagination()
paginator.page_size = page_size
page = paginator.paginate_queryset(qs, request)
serializer = serializer_obj(page, many=True, context={'request': request})
return paginator.get_paginated_response(serializer.data)
def paginationapi(request):
paginator = PageNumberPagination()
query_set = details.objects.all()
context = paginator.paginate_queryset(query_set, request)
serializer = detailsSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def parseRequestToFilter(self, request, dbModel, serModel):
if(request.body is not None):
try:
queryset = dbModel.objects.all()
page = PageNumberPagination()
try:
if request.body != '':
req_params = json.loads('%s' % request.body.decode().replace('\n',''))
else:
req_params = None
except Exception as e:
req_params = None
print('step0: %s' % e)
# 分页
try:
self.pageno = int(request.GET.get('page', 1))
if req_params is not None and req_params['pager'] is not None:
# if req_params['pager']['page'] is not None:
# page.page = req_params['pager']['page']
# self.pageno = int(req_params['pager']['page'])
# else:
# page.page = self.pageno
if req_params['pager']['size'] is not None:
page.page_size = req_params['pager']['size']
self.pagesize = int(req_params['pager']['size'])
else:
page.page_size = self.pagesize
except Exception as e:
page.page = self.pageno
page.page_size = self.pagesize
print('step1: %s' %e)
# 字段筛选
try:
if req_params is not None and req_params['filter'] != '':
condtions = self.parseCondtions(req_params['filter'])
queryset = queryset.filter(condtions)
except Exception as e:
print('step2: %s' %e)
# 排序
try:
if req_params is not None and req_params['order'] is not None:
queryset = queryset.order_by(*req_params['order'])
except Exception as e:
print('step3: %s' %e)
pass
# 计算总页数
self.rows = queryset.count()
if self.rows > 0: self.pagetotal = math.ceil(self.rows / self.pagesize)
# 查询
page_roles = page.paginate_queryset(queryset=queryset, request=request, view=self)
ser = serModel(instance=page_roles, many=True)
return self.successful(data=ser.data)
except Exception as e:
print('step4: %s' %e)
return self.unsuccessful(msg= str(e))
else:
return self.unsuccessful()
def get(self, request, format=None):
items = AgencyType.objects.order_by('pk')
paginator = PageNumberPagination()
result_page = paginator.paginate_queryset(items, request)
serializer = AgencyTypeSerializer(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 get(self, request, format=None):
movies = Movie.objects.all()
paginator = PageNumberPagination()
result = paginator.paginate_queryset(movies, request)
serializer = MovieSerializer(result, many=True)
return paginator.get_paginated_response(serializer.data)
def location_search_company(request):
"""
사용자의 위치에 따른 업체 검색 API
---
# 내용
- q = 검색어
- page = 현재 페이지
- page_size = 한번에 뿌려주는 상품 갯수
# Header
- id-member : header에 id_member를 캐치해서 선택된 addr, dis를 활용한다.
* header에 id-member값이 없을경우, 비회원 전체검색 로직
"""
paginator = PageNumberPagination()
paginator.page_size_query_param = "page_size"
Search = request.GET['q']
# 회원 검색
if 'id-member' in request.headers:
try:
member_addr = Memberaddr.objects.filter(
id_member=request.headers['id-member']).get(select='Y')
addr = member_addr.addr
dis = member_addr.distance
except Memberaddr.DoesNotExist:
content = {"message": "설정된 주소가 없습니다. 주소를 설정해 주세요.", "result": {}}
return Response(content, status=status.HTTP_204_NO_CONTENT)
location = [addr] + list(
NearbyLocation.objects.filter(dong=addr).filter(
distance=dis).values_list('nearby_dong', flat=True))
company_list = Company.objects.filter(name__contains=Search).filter(
addr__in=location).order_by('-cdate')
if company_list.count() == 0:
content = {
"message": "검색한 업체가 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
paginated_company_list = paginator.paginate_queryset(
company_list, request)
if paginated_company_list is not None:
serializers = CompanySearchSerializer(paginated_company_list,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializers.data)
serializer = CompanySearchSerializer(company_list,
many=True,
context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
# 비회원
else:
company = Company.objects.filter(
name__contains=Search).order_by('-cdate')
if company.count() == 0:
content = {
"message": "검색한 없체가 없습니다.",
"result": {
"입력한 검색어": Search
}
}
return Response(content, status=status.HTTP_204_NO_CONTENT)
paginated_company = paginator.paginate_queryset(company, request)
if paginated_company is not None:
serializers = CompanySearchSerializer(paginated_company,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializers.data)
serializer = CompanySearchSerializer(company,
many=True,
context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request):
users = User.objects.all()
paginator = PageNumberPagination()
paginated_users = paginator.paginate_queryset(users, request)
serializer = AuthorListSerializer(paginated_users, many=True)
return paginator.get_paginated_response(serializer.data)
def list(self, request):
paginator = PageNumberPagination()
paginator.page_size = helper.settings.PAGE_SIZE
if request.user.is_superuser:
if "search" in request.GET:
if "filter" in request.GET and request.GET['filter'] != '':
if request.GET['filter'] == 'expiring_soon':
agrements = Agreements.objects.filter(
end_date__lte=helper.datetime.now().date() +
helper.timedelta(15),
end_date__gte=helper.datetime.now(),
product__name__icontains=request.GET['search'])
else:
agrements = Agreements.objects.filter(
product__name__icontains=request.GET['search'],
status=request.GET['filter'])
else:
agrements = Agreements.objects.filter(
product__name__icontains=request.GET['search'])
else:
if "filter" in request.GET and request.GET['filter'] != '':
if request.GET['filter'] == 'expiring_soon':
agrements = Agreements.objects.filter(
end_date__lte=helper.datetime.now().date() +
helper.timedelta(15),
end_date__gte=helper.datetime.now())
else:
agrements = Agreements.objects.filter(
status=request.GET['filter'])
else:
agrements = Agreements.objects.all()
else:
if "search" in request.GET:
if "filter" in request.GET and request.GET['filter'] != '':
if request.GET['filter'] == 'expiring_soon':
agrements = Agreements.objects.filter(
vendor=request.user,
end_date__lte=helper.datetime.now().date() +
helper.timedelta(15),
end_date__gte=helper.datetime.now(),
product__name__icontains=request.GET['search'])
else:
agrements = Agreements.objects.filter(
vendor=request.user,
product__name__icontains=request.GET['search'],
status=request.GET['filter'])
else:
agrements = Agreements.objects.filter(
vendor=request.user,
product__name__icontains=request.GET['search'])
else:
if "filter" in request.GET and request.GET['filter'] != '':
if request.GET['filter'] == 'expiring_soon':
agrements = Agreements.objects.filter(
vendor=request.user,
end_date__lte=helper.datetime.now().date() +
helper.timedelta(15),
end_date__gte=helper.datetime.now())
else:
agrements = Agreements.objects.filter(
vendor=request.user, status=request.GET['filter'])
else:
agrements = Agreements.objects.filter(vendor=request.user)
page_context = paginator.paginate_queryset(agrements, request)
return paginator.get_paginated_response(
ReadAgreementSerializer(page_context, many=True).data)
def get(self, request, format=None):
pagination = PageNumberPagination()
clientes = pre_cliente_service.getAllClients()
result = pagination.paginate_queryset(clientes, request)
serializer = pre_cliente_serializer.PreClienteSerializer(result, many=True)
return pagination.get_paginated_response(serializer.data)
