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 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 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 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='all') |
                                                             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 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 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='all') |
            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 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_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_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 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)