add paagination to invokers page

from flask_jwt_extended import jwt_required, get_jwt_identity

from flask_cors import cross_origin

import requests

from flask import request

GRAFANA_URL = 'http://grafana.mon.svc.cluster.local:3000'

def get_invokers():

    return operations.get_invokers()

# GET /resources/invokers?page=1&page_size=10

@cross_origin()

@backoffice_routes.route("/resources/invokersPages", methods=["GET"])

@jwt_required()

def get_invokers():

    page = request.args.get('page', default=1, type=int)

    page_size = request.args.get('page_size', default=10, type=int)

    return operations.get_invokersPages(page, page_size)

@cross_origin()

@backoffice_routes.route("/resources/numInvokers", methods=["GET"])

@jwt_required()

    def retrieve_invokers(self):

        mycol = self.db.get_col_by_name(self.db.invokers)

        #user_col = self.db.get_col_by_name_register(self.db.user)

        #users = user_col.find({}, {"_id": 0})

        invokers = mycol.find({}, {"_id": 0})

        invokers = mycol.find({}, {"_id": 0, "onboarding_information": 0, "request_test_notification": 0, "supported_features": 0, "websock_notif_config": 0})

        users = self.retrieve_users()

        json_invokers = []

        return json_invokers

    def get_invokersPages(self, page, page_size):

        try:

            # Obtener el total de invocadores

            total_invokers = self.db.get_col_by_name(self.db.invokers).count_documents({})

            # Calcular el índice de inicio y fin para la paginación

            start_index = (page - 1) * page_size

            end_index = start_index + page_size

            # Validar los parámetros

            if page <= 0 or page_size <= 0:

                return jsonify({"error": "Los parámetros 'page' y 'page_size' deben ser valores positivos."}), 400

            # Obtener los invocadores para la página actual

            invokers_cursor = self.db.get_col_by_name(self.db.invokers).find({}, {"_id": 0, "onboarding_information": 0, "request_test_notification": 0, "supported_features": 0, "websock_notif_config": 0}).skip(start_index).limit(page_size)

            invokers = list(invokers_cursor)

            # Procesar los invocadores si es necesario

            users = self.retrieve_users()

            for invoker in invokers:

                invoker_aux = copy.deepcopy(invoker)

                for user in users:

                    if invoker["api_invoker_id"] in user["list_invokers"]:

                        invoker_aux["username"] = user["username"]

            # Calcular el número total de páginas

            total_pages = (total_invokers + page_size - 1) // page_size

            # Construir el objeto de respuesta

            response = {

                "data": invokers,

                "total": total_invokers,

                "totalPages": total_pages

            }

            return jsonify(response), 200

        except Exception as e:

            return "Error when retrieving invoker list: ", e

    def get_invoker_security_context(self, invoker_id):

        security_context_col = self.db.get_col_by_name(

            self.db.security_context)

        security_context_col = self.db.get_col_by_name(self.db.security_context)

        apis_col = self.db.get_col_by_name(self.db.services)

        security_contexts = security_context_col.find({"api_invoker_id": invoker_id}, {"_id": 0, "request_test_notification": 0, "supported_features": 0, "websock_notif_config": 0})

        try:

            security_contexts = security_context_col.find(

               {"api_invoker_id": invoker_id}, {"_id": 0})

        json_security_contexts = []

        for security_context in security_contexts:

            json_security_contexts.append(security_context)

            return jsonify(message="Security context retrieved succesfully",

                           object=json_security_contexts), 200

        # Obtener los datos de APIs

        apis = apis_col.find({}, {"_id": 0})

        # Iterar sobre cada security context

        for sec_context in json_security_contexts:

            # Buscar la API correspondiente en los datos de APIs

            for api in apis:

                if sec_context["security_info"][0]["api_id"] == api["api_id"]:

                    sec_context["security_info"][0]["api_name"] = api["api_name"]

        return json_security_contexts

        except Exception as e:

            return "Error when retreiving invoker list: ", e

    def get_providers(self):

        try:

                    provider_aux["username"] = user["username"]

            json_providers.append(provider_aux)

        json_providers = self.rearrange_api_prov_funcs(json_providers)

        return json_providers

    def retrieve_providers2(self):

        mycol = self.db.get_col_by_name(self.db.providers)

        #user_col = self.db.get_col_by_name_register(self.db.user)

        #users = user_col.find({}, {"_id": 0})

    def rearrange_api_prov_funcs(self, providers):

        for provider in providers:

            # Inicializamos una lista para almacenar los elementos reordenados

            new_api_prov_funcs = [None] * len(provider["api_prov_funcs"])

        users = self.retrieve_users()

        providers = mycol.find({}, {"_id": 0})

            # Iteramos sobre los elementos de api_prov_funcs

            for func in provider["api_prov_funcs"]:

                # Obtenemos el rol de la función

                role = func["api_prov_func_role"]

        json_providers = []

        for provider in providers:

            provider_aux = copy.deepcopy(provider)

            for user in users:

                if provider["api_prov_dom_id"] in user["list_providers"]:

                    provider_aux["username"] = user["username"]

            json_providers.append(provider_aux)

        return json_providers

                # Asignamos el elemento a la posición correspondiente en la nueva lista

                if role == "APF":

                    new_api_prov_funcs[0] = func

                elif role == "AEF":

                    new_api_prov_funcs[1] = func

                elif role == "AMF":

                    new_api_prov_funcs[2] = func

            # Reemplazamos la lista original con la nueva lista reordenada

            provider["api_prov_funcs"] = new_api_prov_funcs

        return providers

    def get_provider_services(self, id):

    def get_apis(self):

        try:   

            mycol = self.db.get_col_by_name(self.db.services)

            apis = mycol.find({}, {"_id": 0})

            apis = mycol.find({}, {"_id": 0, "data_format": 0, "api_supp_feats": 0, "ccf_id": 0, "pub_api_path": 0, "service_api_category": 0, "shareable_info": 0, "supported_features": 0})

            json_apis = []

            for api in apis: