20. Servidor QGIS y Python

Introducción
Conceptos básicos de la API del servidor
Independiente o incrustado
Complementos del servidor

20.1. Introducción 

Para aprender mas sobre QGIS Server, lee Guía/Manual de Servidor QGIS.

QGIS Server es tres cosas diferentes:

Biblioteca de QGIS Server: una biblioteca que proporciona una API para crear servicios web OGC
QGIS Server FCGI: una aplicación binaria FCGI qgis_maserv.fcgi que junto con el servidor web implementa un conjunto de servicios OGC (WMS, WFS, WCS etc.) y OGC APIs (WFS3/OAPIF)
QGIS Development Server: una aplicación binaria de servidor de desarrollo qgis_mapserver que implementa un conjunto de servicios OGC (WMS, WFS, WCS, etc.) y API de OGC (WFS3 / OAPIF)

Este capítulo del libro de cocina se centra en el primer tema y, al explicar el uso de la API de QGIS Server, muestra cómo es posible utilizar Python para ampliar, mejorar o personalizar el comportamiento del servidor o cómo utilizar la API de QGIS Server para incrustar el servidor QGIS en otra aplicación.

Hay algunas formas diferentes en las que puede alterar el comportamiento de QGIS Server o ampliar sus capacidades para ofrecer nuevos servicios personalizados o API, estos son los principales escenarios a los que puede enfrentarse:

EMBEDDING → Utilice la API de QGIS Server desde otra aplicación de Python
STANDALONE → Ejecutar QGIS Server como servicio autónomo WSGI/HTTP
FILTERS → Mejorar/personalizar QGIS Server con complementos de filtro
SERVICES → Añadir un nuevo SERVICE
OGC APIs → Añadir una nueva OGC API

Las aplicaciones integradas e independientes requieren el uso de la API de Python de QGIS Server directamente desde otro script o aplicación de Python. Las opciones restantes son más adecuadas para cuando desee agregar funciones personalizadas a una aplicación binaria estándar de QGIS Server (FCGI o servidor de desarrollo): en este caso, deberá escribir un complemento de Python para la aplicación del servidor y registrar sus filtros personalizados, servicios o API.

20.2. Conceptos básicos de la API del servidor 

Las clases fundamentales involucradas en una aplicación típica de QGIS Server son:

QgsServer la instancia del servidor (normalmente una sola instancia durante toda la vida de la aplicación)
QgsServerRequest el objeto de la solicitud (normalmente recreado en cada solicitud)
QgsServer.handleRequest(request, response) procesa la solicitud y completa la respuesta

El flujo de trabajo del servidor de desarrollo o FCGI de QGIS Server se puede resumir de la siguiente manera:

initialize the QgsApplication
create the QgsServer
the main server loop waits forever for client requests:
    for each incoming request:
        create a QgsServerRequest request
        create a QgsServerResponse response
        call QgsServer.handleRequest(request, response)
            filter plugins may be executed
        send the output to the client

Dentro del métodod QgsServer.handleRequest(request, response) las devoluciones de llamada de los complementos de filtro se llaman y QgsServerRequest y QgsServerResponse están disponibles para los complementos a través de la clase QgsServerInterface

Advertencia

Las clases de servidor de QGIS no son seguras para subprocesos, siempre debe usar un modelo o contenedores de multiprocesamiento cuando cree aplicaciones escalables basadas en la API de QGIS Server.

20.3. Independiente o incrustado 

Para aplicaciones de servidor independientes o incrustaciones, deberá usar las clases de servidor mencionadas anteriormente directamente, envolviéndolas en una implementación de servidor web que gestiona todas las interacciones del protocolo HTTP con el cliente.

A continuación, se muestra un ejemplo mínimo del uso de la API de QGIS Server (sin la parte HTTP):

from qgis.core import QgsApplication
from qgis.server import *
app = QgsApplication([], False)

# Create the server instance, it may be a single one that
# is reused on multiple requests
server = QgsServer()

# Create the request by specifying the full URL and an optional body
# (for example for POST requests)
request = QgsBufferServerRequest(
    'http://localhost:8081/?MAP=/qgis-server/projects/helloworld.qgs' +
    '&SERVICE=WMS&REQUEST=GetCapabilities')

# Create a response objects
response = QgsBufferServerResponse()

# Handle the request
server.handleRequest(request, response)

print(response.headers())
print(response.body().data().decode('utf8'))

app.exitQgis()

Aquí hay un ejemplo completo de aplicación independiente desarrollado para las pruebas de integraciones continuas en el repositorio de código fuente de QGIS, muestra un amplio conjunto de diferentes filtros de complementos y esquemas de autenticación (no es para producción porque se desarrollaron solo con fines de prueba, pero sigue siendo interesante para el aprendizaje): https://github.com/qgis/QGIS/blob/release-3_22/tests/src/python/qgis_wrapped_server.py

20.4. Complementos del servidor 

Los complementos de Python del servidor se cargan una vez cuando se inicia la aplicación QGIS Server y se pueden usar para registrar filtros, servicios o API.

La estructura de un complemento de servidor es muy similar a su contraparte de escritorio, un objeto QgsServerInterface está disponible para los complementos y los complementos pueden registrar uno o más filtros personalizados, servicios o API en el registro correspondiente mediante uno de los métodos expuestos por la interfaz del servidor.

20.4.1. Complementos de filtro de servidor 

Los filtros vienen en tres sabores diferentes y se pueden instanciar subclasificando una de las clases a continuación y llamando al método correspondiente de QgsServerInterface:

Tipo de filtro	Clase Base	Registro de QgsServerInterface
E/S	`QgsServerFilter`	`registerFilter()`
Control de acceso	`QgsAccessControlFilter`	`registerAccessControl()`
Cache	`QgsServerCacheFilter`	`registerServerCache()`

20.4.1.1. Filtros de E/S 

Los filtros de E/S pueden modificar la entrada y salida del servidor (la solicitud y la respuesta) de los servicios centrales (WMS, WFS, etc.) permitiendo realizar cualquier tipo de manipulación del flujo de trabajo de los servicios. Es posible, por ejemplo, restringir el acceso a las capas seleccionadas, inyectar una hoja de estilo XSL a la respuesta XML, agregar una marca de agua a una imagen WMS generada, etc.

A partir de este punto, encontrará útil un vistazo rápido a server plugins API docs.

Cada filtro debe implementar al menos una de las tres devoluciones de llamada:

Todos los filtros tienen acceso al objeto de solicitud/respuesta (QgsRequestHandler) y puede manipular todas sus propiedades (entrada/salida) y generar excepciones (aunque de una manera bastante particular como veremos a continuación).

Aquí está el pseudocódigo que muestra cómo el servidor maneja una solicitud típica y cuándo se llaman las devoluciones de llamada del filtro:

for each incoming request:
    create GET/POST request handler
    pass request to an instance of QgsServerInterface
    call requestReady filters
    if there is not a response:
        if SERVICE is WMS/WFS/WCS:
            create WMS/WFS/WCS service
            call service’s executeRequest
                possibly call sendResponse for each chunk of bytes
                sent to the client by a streaming services (WFS)
        call responseComplete
        call sendResponse
    request handler sends the response to the client

Los siguientes párrafos describen las devoluciones de llamada disponibles en detalle.

20.4.1.1.1. requestReady

Esto se llama cuando la solicitud está lista: la URL entrante y los datos se han analizado y antes de ingresar al conmutador de servicios centrales (WMS, WFS, etc.), este es el punto donde puede manipular la entrada y realizar acciones como:

autenticación/autorización
redirije
añadir/borrar ciertos parámetros (nombres de tipos, por ejemplo)
plantear excepciones

Incluso podría sustituir un servicio central por completo cambiando el parámetro SERVICE y, por lo tanto, omitiendo el servicio central por completo (aunque esto no tiene mucho sentido).

20.4.1.1.2. sendResponse

Esto se llama cada vez que se envía cualquier salida a FCGI stdout (y desde allí, al cliente). Esto normalmente se hace después de que los servicios centrales hayan terminado su proceso y después de que se haya llamado al enlace responseComplete, pero en algunos casos XML puede volverse tan grande que se necesita una implementación de XML de transmisión (WFS GetFeature es uno de ellos). En ese caso, en lugar de una sola llamada a sendResponse(), el método se puede llamar excepcionalmente varias veces antes de que la respuesta esté completa, y en ese caso (y solo en ese caso) también se llama antes responseComplete().

sendResponse() es el mejor lugar para la manipulación directa de la salida del servicio principal y mientras responseComplete() normalmente también es una opción, sendResponse() es la única opción viable en el caso de los servicios de transmisión.

20.4.1.1.3. responseComplete

Esto se llama una vez cuando los servicios centrales (si se activan) terminan su proceso y la solicitud está lista para enviarse al cliente. Como se discutió anteriormente, esto normalmente llama antes a sendResponse() excepto para servicios streaming (u otro filtro de complemento) que podría haber llamado antes a sendResponse().

responseComplete() es el lugar ideal para proporcionar la implementación de nuevos servicios (WPS o servicios personalizados) y para realizar la manipulación directa de la salida proveniente de los servicios centrales (por ejemplo, para agregar una marca de agua en una imagen WMS).

20.4.1.2. Generación de excepciones de un complemento 

Aún queda trabajo por hacer en este tema: la implementación actual puede distinguir entre excepciones manejadas y no manejadas estableciendo una propiedad QgsRequestHandler a una instancia de QgsMapServiceException, de esta manera el código principal de C ++ puede detectar excepciones de Python controladas e ignorar las excepciones no controladas (o mejor: registrarlas).

Este enfoque básicamente funciona, pero no es muy «pitónico»: un mejor enfoque sería generar excepciones del código de Python y verlas burbujear en el bucle C ++ para que se manejen allí.

20.4.1.3. Escribiendo un complemento del servidor 

Un complemento de servidor es un complemento estándar de QGIS Python como se describe en Desarrollando Plugins Python, que solo proporciona una interfaz adicional (o alternativa): un complemento de escritorio QGIS típico tiene acceso a la aplicación QGIS a través de: class:` QgisInterface <qgis. gui.QgisInterface> , un complemento de servidor solo tiene acceso a :class:`QgsServerInterface <qgis.server.QgsServerInterface> cuando se ejecuta dentro del contexto de la aplicación QGIS Server.

Para que QGIS Server sepa que un complemento tiene una interfaz de servidor, se necesita una entrada de metadatos especial (en metadata.txt):

server=True

Importante

QGIS Server solo cargará y ejecutará los complementos que tengan el conjunto de metadatos server=True.

El complemento de ejemplo discutido aquí (con muchos más) está disponible en github en https://github.com/elpaso/qgis3-server-vagrant/tree/master/resources/web/plugins, algunos complementos de servidor también se publican en el repositorio oficial de complementos de QGIS <https://plugins.qgis.org/plugins/server>`_.

20.4.1.4. Archivos de complementos 

Aquí está la estructura de directorios de nuestro complemento de servidor de ejemplo.

PYTHON_PLUGINS_PATH/
  HelloServer/
    __init__.py    --> *required*
    HelloServer.py  --> *required*
    metadata.txt   --> *required*

20.4.1.4.1. init.py

Este archivo es requerido por el sistema de importación de Python. Además, QGIS Server requiere que este archivo contenga una función serverClassFactory(), que se llama cuando el complemento se carga en QGIS Server cuando se inicia el servidor. Recibe una referencia a la instancia de QgsServerInterface y debe devolver la instancia de la clase de su complemento. Así es como se ve el complemento de ejemplo __init __. Py:

def serverClassFactory(serverIface):
    from .HelloServer import HelloServerServer
    return HelloServerServer(serverIface)

20.4.1.4.2. HelloServer.py

Aquí es donde ocurre la magia y así es como se ve la magia: (por ejemplo HelloServer.py)

Un complemento de servidor generalmente consiste en una o más devoluciones de llamada empaquetadas en instancias de QgsServerFilter.

Cada QgsServerFilter implementa una o más de las siguientes devoluciones de llamada:

El siguiente ejemplo implementa un filtro mínimo que imprime HelloServer! En caso de que el parámetro SERVICE sea igual a «HELLO»:

class HelloFilter(QgsServerFilter):

    def __init__(self, serverIface):
        super().__init__(serverIface)

    def requestReady(self):
        QgsMessageLog.logMessage("HelloFilter.requestReady")

    def sendResponse(self):
        QgsMessageLog.logMessage("HelloFilter.sendResponse")

    def responseComplete(self):
        QgsMessageLog.logMessage("HelloFilter.responseComplete")
        request = self.serverInterface().requestHandler()
        params = request.parameterMap()
        if params.get('SERVICE', '').upper() == 'HELLO':
            request.clear()
            request.setResponseHeader('Content-type', 'text/plain')
            # Note that the content is of type "bytes"
            request.appendBody(b'HelloServer!')

Los filtros deben registrarse en serverIface como en el siguiente ejemplo:

class HelloServerServer:
    def __init__(self, serverIface):
        serverIface.registerFilter(HelloFilter(serverIface), 100)

El segundo parámetro del método registerFilter() establece una prioridad que define el orden de las devoluciones de llamada con el mismo nombre (la prioridad más baja se invoca primero).

Al utilizar las tres devoluciones de llamada, los complementos pueden manipular la entrada y / o la salida del servidor de muchas formas diferentes. En todo momento, la instancia del complemento tiene acceso a QgsRequestHandler a través de QgsServerInterface. La clase QgsRequestHandler tiene muchos métodos que se pueden usar para modificar los parámetros de entrada antes de ingresar al procesamiento central del servidor (usando requestReady()) o después de la solicitud ha sido procesado por los servicios centrales (usando sendResponse()).

Los siguientes ejemplos cubren algunos casos comunes de uso:

20.4.1.4.3. Modificando la entrada

El complemento de ejemplo contiene un ejemplo de prueba que cambia los parámetros de entrada provenientes de la cadena de consulta, en este ejemplo se inyecta un nuevo parámetro en el (ya analizado) parameterMap, este parámetro es visible luego por los servicios centrales (WMS, etc.) , al final del procesamiento de los servicios centrales, verificamos que el parámetro todavía esté allí:

class ParamsFilter(QgsServerFilter):

    def __init__(self, serverIface):
        super(ParamsFilter, self).__init__(serverIface)

    def requestReady(self):
        request = self.serverInterface().requestHandler()
        params = request.parameterMap( )
        request.setParameter('TEST_NEW_PARAM', 'ParamsFilter')

    def responseComplete(self):
        request = self.serverInterface().requestHandler()
        params = request.parameterMap( )
        if params.get('TEST_NEW_PARAM') == 'ParamsFilter':
            QgsMessageLog.logMessage("SUCCESS - ParamsFilter.responseComplete")
        else:
            QgsMessageLog.logMessage("FAIL    - ParamsFilter.responseComplete")

Esto es un extracto de lo que puede ver en el archivo de log:

 src/core/qgsmessagelog.cpp: 45: (logMessage) [0ms] 2014-12-12T12:39:29 plugin[0] HelloServerServer - loading filter ParamsFilter
 src/core/qgsmessagelog.cpp: 45: (logMessage) [1ms] 2014-12-12T12:39:29 Server[0] Server plugin HelloServer loaded!
 src/core/qgsmessagelog.cpp: 45: (logMessage) [0ms] 2014-12-12T12:39:29 Server[0] Server python plugins loaded
 src/mapserver/qgshttprequesthandler.cpp: 547: (requestStringToParameterMap) [1ms] inserting pair SERVICE // HELLO into the parameter map
 src/mapserver/qgsserverfilter.cpp: 42: (requestReady) [0ms] QgsServerFilter plugin default requestReady called
 src/core/qgsmessagelog.cpp: 45: (logMessage) [0ms] 2014-12-12T12:39:29 plugin[0] SUCCESS - ParamsFilter.responseComplete

En la línea resaltada, la cadena «SUCCESS» indica que el complemento pasó la prueba.

La misma técnica se puede aprovechar para usar un servicio personalizado en lugar de uno central: por ejemplo, podría omitir una solicitud SERVICE WFS o cualquier otra solicitud principal simplemente cambiando el parámetro SERVICE a algo diferente y se omitirá el servicio principal. Luego, puede inyectar sus resultados personalizados en la salida y enviarlos al cliente (esto se explica a continuación).

Truco

Si realmente desea implementar un servicio personalizado, se recomienda crear una subclase QgsService y registre su servicio en registerFilter() llamando a su método registerService(service)

20.4.1.4.4. Modificar o reemplazar la salida

El ejemplo del filtro de marca de agua muestra cómo reemplazar la salida de WMS con una nueva imagen obtenida agregando una imagen de marca de agua en la parte superior de la imagen de WMS generada por el servicio principal de WMS:

from qgis.server import *
from qgis.PyQt.QtCore import *
from qgis.PyQt.QtGui import *

class WatermarkFilter(QgsServerFilter):

    def __init__(self, serverIface):
        super().__init__(serverIface)

    def responseComplete(self):
        request = self.serverInterface().requestHandler()
        params = request.parameterMap( )
        # Do some checks
        if (params.get('SERVICE').upper() == 'WMS' \
                and params.get('REQUEST').upper() == 'GETMAP' \
                and not request.exceptionRaised() ):
            QgsMessageLog.logMessage("WatermarkFilter.responseComplete: image ready %s" % request.parameter("FORMAT"))
            # Get the image
            img = QImage()
            img.loadFromData(request.body())
            # Adds the watermark
            watermark = QImage(os.path.join(os.path.dirname(__file__), 'media/watermark.png'))
            p = QPainter(img)
            p.drawImage(QRect( 20, 20, 40, 40), watermark)
            p.end()
            ba = QByteArray()
            buffer = QBuffer(ba)
            buffer.open(QIODevice.WriteOnly)
            img.save(buffer, "PNG" if "png" in request.parameter("FORMAT") else "JPG")
            # Set the body
            request.clearBody()
            request.appendBody(ba)

En este ejemplo, el valor del parámetro SERVICE se verifica y si la solicitud entrante es un WMS GETMAP y no se han establecido excepciones por un complemento ejecutado previamente o por el servicio central (WMS en este caso), la imagen generada por WMS se recupera del búfer de salida y se agrega la imagen de marca de agua. El último paso es borrar el búfer de salida y reemplazarlo con la imagen recién generada. Tenga en cuenta que, en una situación del mundo real, también deberíamos comprobar el tipo de imagen solicitada en lugar de admitir solo PNG o JPG.

20.4.1.5. Filtros de control de acceso 

Los filtros de control de acceso brindan al desarrollador un control detallado sobre las capas, características y atributos a los que se puede acceder; las siguientes devoluciones de llamada se pueden implementar en un filtro de control de acceso:

20.4.1.5.1. Archivos de complementos

Aquí está la estructura de directorios de nuestro complemento de ejemplo:

PYTHON_PLUGINS_PATH/
  MyAccessControl/
    __init__.py    --> *required*
    AccessControl.py  --> *required*
    metadata.txt   --> *required*

20.4.1.5.2. init.py

Este archivo es requerido por el sistema de importación de Python. Como para todos los complementos del servidor QGIS, este archivo contiene una función serverClassFactory (), que se llama cuando el complemento se carga en el servidor QGIS al inicio. Recibe una referencia a una instancia de QgsServerInterface y debe devolver una instancia de la clase de su complemento. Así es como el complemento de ejemplo __init__.py aparece:

def serverClassFactory(serverIface):
    from MyAccessControl.AccessControl import AccessControlServer
    return AccessControlServer(serverIface)

20.4.1.5.3. AccessControl.py

class AccessControlFilter(QgsAccessControlFilter):

    def __init__(self, server_iface):
        super().__init__(server_iface)

    def layerFilterExpression(self, layer):
        """ Return an additional expression filter """
        return super().layerFilterExpression(layer)

    def layerFilterSubsetString(self, layer):
        """ Return an additional subset string (typically SQL) filter """
        return super().layerFilterSubsetString(layer)

    def layerPermissions(self, layer):
        """ Return the layer rights """
        return super().layerPermissions(layer)

    def authorizedLayerAttributes(self, layer, attributes):
        """ Return the authorised layer attributes """
        return super().authorizedLayerAttributes(layer, attributes)

    def allowToEdit(self, layer, feature):
        """ Are we authorised to modify the following geometry """
        return super().allowToEdit(layer, feature)

    def cacheKey(self):
        return super().cacheKey()

class AccessControlServer:

   def __init__(self, serverIface):
      """ Register AccessControlFilter """
      serverIface.registerAccessControl(AccessControlFilter(serverIface), 100)

Este ejemplo otorga acceso total para todos.

Es rol del complemento saber quién ha ingresado.

En todos esos métodos tenemos el argumento layer on para poder personalizar la restricción por capa.

20.4.1.5.4. layerFilterExpression

Usado para agregar una Expresión para limitar los resultados, ej.:

def layerFilterExpression(self, layer):
    return "$role = 'user'"

Para limitar la función donde el rol de atributo es igual a «usuario».

20.4.1.5.5. layerFilterSubsetString

Igual que el anterior pero usa el SubsetString (ejecutado en la base de datos)

def layerFilterSubsetString(self, layer):
    return "role = 'user'"

Para limitar la función donde el rol de atributo es igual a «usuario».

20.4.1.5.6. layerPermissions

Limitar el acceso a la capa.

Devuelve un objeto de tipo LayerPermissions(), el cuál tiene las propiedades:

canRead para verlo en GetCapabilities y tiene acceso de lectura.
canInsert para poder insertar una nueva característica.
canUpdate para ser capaz de actualizar una característica.
canDelete para ser capaz de borrar una característica.

Ejemplo:

def layerPermissions(self, layer):
    rights = QgsAccessControlFilter.LayerPermissions()
    rights.canRead = True
    rights.canInsert = rights.canUpdate = rights.canDelete = False
    return rights

Para limitar todo en acceso de solo lectura.

20.4.1.5.7. authorizedLayerAttributes

Usado para limitar la visibilidad de un subconjunto específico de atributo.

El atributo del argumento devuelve el conjunto actual de atributos visibles.

Ejemplo:

def authorizedLayerAttributes(self, layer, attributes):
    return [a for a in attributes if a != "role"]

Para ocultar el atributo “rol”.

20.4.1.5.8. allowToEdit

Esto es usado para limitar la edición de un subconjunto de objetos espaciales.

Se utiliza en el protocolo WFS-Transaction.

Ejemplo:

def allowToEdit(self, layer, feature):
    return feature.attribute('role') == 'user'

Para poder editar solo la característica que tiene el rol de atributo con el valor del usuario.

20.4.1.5.9. cacheKey

El servidor QGIS mantiene un caché de las capacidades y luego, para tener un caché por rol, puede devolver el rol en este método. O devuelva Ninguno para deshabilitar completamente la caché.

20.4.2. Servicios personalizados 

En QGIS Server, los servicios centrales como WMS, WFS y WCS se implementan como subclases de QgsService.

Para implementar un nuevo servicio que se ejecutará cuando el parámetro de la cadena de consulta SERVICE coincida con el nombre del servicio, puede implementar su propio QgsService y registre sus servicio en el serviceRegistry() llamando a su registerService(service).

A continuación, se muestra un ejemplo de un servicio personalizado denominado CUSTOM:

from qgis.server import QgsService
from qgis.core import QgsMessageLog

class CustomServiceService(QgsService):

    def __init__(self):
        QgsService.__init__(self)

    def name(self):
        return "CUSTOM"

    def version(self):
        return "1.0.0"

    def executeRequest(self, request, response, project):
        response.setStatusCode(200)
        QgsMessageLog.logMessage('Custom service executeRequest')
        response.write("Custom service executeRequest")


class CustomService():

    def __init__(self, serverIface):
        serverIface.serviceRegistry().registerService(CustomServiceService())

20.4.3. APIs personalizadas 

En QGIS Server, las API principales de OGC como OAPIF (también conocido como WFS3) se implementan como colecciones de QgsServerOgcApiHandler subclases que están registradas en una instancia de QgsServerOgcApi).

Para implementar una nueva API que se ejecutará cuando la ruta de la URL coincida con una URL determinada, puede implementar sus propias instancias QgsServerOgcApiHandler, agréguelas a una QgsServerOgcApi y registre la API en el serviceRegistry() llamando a su registerApi(api).

A continuación, se muestra un ejemplo de una API personalizada que se ejecutará cuando la URL contenga /customapi:

import json
import os

from qgis.PyQt.QtCore import QBuffer, QIODevice, QTextStream, QRegularExpression
from qgis.server import (
    QgsServiceRegistry,
    QgsService,
    QgsServerFilter,
    QgsServerOgcApi,
    QgsServerQueryStringParameter,
    QgsServerOgcApiHandler,
)

from qgis.core import (
    QgsMessageLog,
    QgsJsonExporter,
    QgsCircle,
    QgsFeature,
    QgsPoint,
    QgsGeometry,
)


class CustomApiHandler(QgsServerOgcApiHandler):

    def __init__(self):
        super(CustomApiHandler, self).__init__()
        self.setContentTypes([QgsServerOgcApi.HTML, QgsServerOgcApi.JSON])

    def path(self):
        return QRegularExpression("/customapi")

    def operationId(self):
        return "CustomApiXYCircle"

    def summary(self):
        return "Creates a circle around a point"

    def description(self):
        return "Creates a circle around a point"

    def linkTitle(self):
        return "Custom Api XY Circle"

    def linkType(self):
        return QgsServerOgcApi.data

    def handleRequest(self, context):
        """Simple Circle"""

        values = self.values(context)
        x = values['x']
        y = values['y']
        r = values['r']
        f = QgsFeature()
        f.setAttributes([x, y, r])
        f.setGeometry(QgsCircle(QgsPoint(x, y), r).toCircularString())
        exporter = QgsJsonExporter()
        self.write(json.loads(exporter.exportFeature(f)), context)

    def templatePath(self, context):
        # The template path is used to serve HTML content
        return os.path.join(os.path.dirname(__file__), 'circle.html')

    def parameters(self, context):
        return [QgsServerQueryStringParameter('x', True, QgsServerQueryStringParameter.Type.Double, 'X coordinate'),
                QgsServerQueryStringParameter(
                    'y', True, QgsServerQueryStringParameter.Type.Double, 'Y coordinate'),
                QgsServerQueryStringParameter('r', True, QgsServerQueryStringParameter.Type.Double, 'radius')]


class CustomApi():

    def __init__(self, serverIface):
        api = QgsServerOgcApi(serverIface, '/customapi',
                            'custom api', 'a custom api', '1.1')
        handler = CustomApiHandler()
        api.registerHandler(handler)
        serverIface.serviceRegistry().registerApi(api)

20. Servidor QGIS y Python

20.4.1.1.1. requestReady

20.4.1.1.2. sendResponse

20.4.1.1.3. responseComplete

20.4.1.4.1. __init__.py

20.4.1.4.2. HelloServer.py

20.4.1.4.3. Modificando la entrada

20.4.1.4.4. Modificar o reemplazar la salida

20.4.1.5.1. Archivos de complementos

20.4.1.5.2. __init__.py

20.4.1.5.3. AccessControl.py

20.4.1.5.4. layerFilterExpression

20.4.1.5.5. layerFilterSubsetString

20.4.1.5.6. layerPermissions

20.4.1.5.7. authorizedLayerAttributes

20.4.1.5.8. allowToEdit

20.4.1.5.9. cacheKey

20.4.1.4.1. init.py

20.4.1.5.2. init.py