Viktigt

Översättning är en gemenskapsinsats du kan gå med i. Den här sidan är för närvarande översatt till 100.00%.

20. QGIS Server och Python

20.1. Introduktion

Om du vill veta mer om QGIS Server kan du läsa QGIS Server Guide/Manual.

QGIS Server är tre olika saker:

1. QGIS Server-bibliotek: ett bibliotek som tillhandahåller ett API för att skapa OGC-webbtjänster

2. QGIS Server FCGI: en binär FCGI-applikation qgis_mapserv.fcgi som tillsammans med en webbserver implementerar en uppsättning OGC-tjänster (WMS, WFS, WCS etc.) och OGC API:er (WFS3/OAPIF)

3. QGIS Development Server: en binär applikation för utvecklingsserver qgis_mapserver som implementerar en uppsättning OGC-tjänster (WMS, WFS, WCS etc.) och OGC API:er (WFS3/OAPIF)

Detta kapitel i kokboken fokuserar på det första ämnet och genom att förklara användningen av QGIS Server API visar det hur det är möjligt att använda Python för att utöka, förbättra eller anpassa serverns beteende eller hur man använder QGIS Server API för att bädda in QGIS Server i ett annat program.

Det finns några olika sätt att ändra QGIS Servers beteende eller utöka dess kapacitet för att erbjuda nya anpassade tjänster eller API:er, det här är de viktigaste scenarierna du kan ställas inför:

• EMBEDDING → Använd QGIS Server API från ett annat Python-program

• STANDALONE → Kör QGIS Server som en fristående WSGI/HTTP-tjänst

• FILTERS → Förbättra/anpassa QGIS Server med filtertillägg

• SERVICES → Lägg till en ny SERVICE

• OGC APIs → Lägg till ett nytt OGC API

Inbäddning och fristående applikationer kräver att du använder QGIS Server Python API direkt från ett annat Python-skript eller en annan applikation. De återstående alternativen är bättre lämpade för när du vill lägga till anpassade funktioner i en binär standardapplikation för QGIS Server (FCGI eller utvecklingsserver): i det här fallet måste du skriva ett Python-tillägg för serverapplikationen och registrera dina anpassade filter, tjänster eller API:er.

20.2. Grunderna i server-API:et

De grundläggande klasser som ingår i en typisk QGIS Server-applikation är:

• QgsServer serverinstansen (vanligtvis en enda instans under hela programmets livslängd)

• QgsServerRequest objektet för begäran (återskapas vanligtvis vid varje begäran)

• QgsServer.handleRequest(request, response) behandlar begäran och fyller i svaret

Arbetsflödet för QGIS Server FCGI eller utvecklingsserver kan sammanfattas enligt följande:

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

Inuti metoden QgsServer.handleRequest(request, response) anropas filtertilläggets callbacks och QgsServerRequest och QgsServerResponse görs tillgängliga för tilläggen genom klassen QgsServerInterface.

Varning

QGIS-serverklasser är inte trådsäkra, du bör alltid använda en multiprocessmodell eller containrar när du bygger skalbara applikationer baserade på QGIS Server API.

20.3. Fristående eller inbäddad

För fristående serverapplikationer eller inbäddning måste du använda de ovan nämnda serverklasserna direkt och förpacka dem i en webbserverimplementation som hanterar alla HTTP-protokollinteraktioner med klienten.

Här följer ett minimalt exempel på användning av QGIS Server API (utan HTTP-delen):

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()

Här är ett komplett fristående applikationsexempel som utvecklats för kontinuerlig integrationstestning på QGIS källkodsarkiv, det visar en bred uppsättning olika tilläggsfilter och autentiseringsscheman (inte avsedda för produktion eftersom de endast utvecklades för teständamål men ändå intressanta för inlärning): qgis_wrapped_server.py

20.4. Tillägg för server

Python-tillägg för server laddas en gång när QGIS Server-programmet startar och kan användas för att registrera filter, tjänster eller API:er.

Strukturen för ett servertillägg är mycket lik dess motsvarighet på skrivbordet, ett QgsServerInterface-objekt görs tillgängligt för tilläggen och tillägget kan registrera ett eller flera anpassade filter, tjänster eller API:er till motsvarande register genom att använda en av de metoder som exponeras av servergränssnittet.

20.4.1. Tillägg för serverfilter

Filter finns i tre olika varianter och de kan instansieras genom att underklassa en av klasserna nedan och anropa motsvarande metod i QgsServerInterface:

Filtertyp	Basklass	Registrering av QgsServerInterface
I/O	QgsServerFilter	registerFilter()
Åtkomstkontroll	QgsAccessControlFilter	registerAccessControl()
Cache	QgsServerCacheFilter	registerServerCache()

20.4.1.1. I/O-filter

I/O-filter kan modifiera serverns in- och utdata (begäran och svar) för kärntjänsterna (WMS, WFS etc.), vilket gör det möjligt att manipulera tjänsternas arbetsflöde på alla sätt. Det är t.ex. möjligt att begränsa åtkomsten till utvalda lager, att injicera en XSL-stilmall i XML-svaret, att lägga till en vattenstämpel i en genererad WMS-bild och så vidare.

Från den här punkten kan det vara bra att snabbt titta på server tillägg API docs.

Varje filter ska implementera minst en av tre callbacks:

• onRequestReady()

• onResponseComplete()

• onSendResponse()

Alla filter har tillgång till request/response-objektet (QgsRequestHandler) och kan manipulera alla dess egenskaper (input/output) och skapa undantag (men på ett ganska speciellt sätt som vi ska se nedan).

Alla dessa metoder returnerar ett booleanskt värde som anger om anropet ska spridas till efterföljande filter. Om någon av dessa metoder returnerar False så stoppas kedjan, annars kommer anropet att spridas till nästa filter.

Här följer en pseudokod som visar hur servern hanterar en typisk förfrågan och när filtrets callbacks anropas:

for each incoming request:
    create GET/POST request handler
    pass request to an instance of QgsServerInterface
    call onRequestReady filters

    if there is not a response:
        if SERVICE is WMS/WFS/WCS:
            create WMS/WFS/WCS service
            call service’s executeRequest
                possibly call onSendResponse for each chunk of bytes
                sent to the client by a streaming services (WFS)
        call onResponseComplete
    request handler sends the response to the client

I följande stycken beskrivs de tillgängliga callbacks i detalj.

20.4.1.1.1. onRequestReady

Detta kallas när begäran är klar: inkommande URL och data har analyserats och innan de går in i kärntjänsterna (WMS, WFS etc.) växlar, detta är den punkt där du kan manipulera inmatningen och utföra åtgärder som:

• autentisering/auktorisering

• omdirigeringar

• lägga till/ta bort vissa parametrar (t.ex. typnamn)

• göra undantag

Du kan till och med ersätta en kärntjänst helt och hållet genom att ändra parametern SERVICE och därmed kringgå kärntjänsten helt och hållet (vilket dock inte är särskilt meningsfullt).

20.4.1.1.2. onSendResponse

Detta anropas närhelst någon del av utdata spolas från svarsbufferten (dvs. till FCGI stdout om fcgi-servern används) och därifrån till klienten. Detta inträffar när stort innehåll strömmas (som WFS GetFeature). I detta fall kan onSendResponse() anropas flera gånger.

Observera att om svaret inte är streamat, kommer onSendResponse() inte att anropas alls.

I samtliga fall kommer den sista (eller unika) delen att skickas till klienten efter ett anrop till onResponseComplete().

Att returnera False kommer att förhindra att data skickas till klienten. Detta är önskvärt när ett tillägg vill samla in alla delar från ett svar och undersöka eller ändra svaret i onResponseComplete().

20.4.1.1.3. onResponseComplete

Detta anropas en gång när kärntjänsterna (om de har träffats) har avslutat sin process och begäran är klar att skickas till klienten. Som diskuterats ovan kommer den här metoden att anropas innan den sista (eller unika) delen av data skickas till klienten. För strömningstjänster kan flera anrop till onSendResponse() ha anropats.

onResponseComplete() är den perfekta platsen för att implementera nya tjänster (WPS eller anpassade tjänster) och för att utföra direkt manipulation av utdata som kommer från kärntjänster (till exempel för att lägga till en vattenstämpel på en WMS-bild).

Observera att om du returnerar False förhindras nästa tillägg att utföra onResponseComplete(), men i vilket fall som helst förhindras att svaret skickas till klienten.

20.4.1.1.4. Utlösa undantag från ett tillägg

Det återstår fortfarande en del arbete med detta ämne: den nuvarande implementeringen kan skilja mellan hanterade och ohanterade undantag genom att ställa in en QgsRequestHandler-egenskap till en instans av QgsMapServiceException, på så sätt kan den huvudsakliga C++-koden fånga hanterade pythonundantag och ignorera ohanterade undantag (eller bättre: logga dem).

Detta tillvägagångssätt fungerar i princip men det är inte särskilt ”pythoniskt”: ett bättre tillvägagångssätt skulle vara att skapa undantag från pythonkod och se dem bubbla upp till C++-loopen för att hanteras där.

20.4.1.1.5. Skriva ett servertillägg

Ett servertillägg är ett standard QGIS Python-tillägg enligt beskrivningen i Utveckla Python-tillägg, som bara tillhandahåller ett ytterligare (eller alternativt) gränssnitt: ett typiskt QGIS-skrivbordsplugin har tillgång till QGIS-applikationen via QgisInterface, medan ett servertillägg endast har tillgång till QgsServerInterface när det körs i QGIS Server-applikationskontext.

För att göra QGIS Server medveten om att ett tillägg har ett servergränssnitt behövs en speciell metadatapost (i metadata.txt):

server=True

Viktigt

Endast tillägg som har metadatauppsättningen server=True kommer att laddas och köras av QGIS Server.

Exempeltillägget qgis3-server-vagrant som diskuteras här (med många fler) finns tillgängligt på github, några servertillägg publiceras också i det officiella QGIS tillägg repository.

20.4.1.1.5.1. Tilläggsfiler

Här är katalogstrukturen för vårt exempel på servertillägg.

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

20.4.1.1.5.1.1. __init__.py

Denna fil krävs av Pythons importsystem. QGIS Server kräver också att denna fil innehåller en serverClassFactory()-funktion, som anropas när tillägget laddas in i QGIS Server när servern startar. Den tar emot en referens till en instans av QgsServerInterface och måste returnera en instans av plugin-programmets klass. Så här ser exempelpluginet __init__.py ut:

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

20.4.1.1.5.1.2. HelloServer.py

Det är här det magiska händer och det är så här det magiska ser ut: (t.ex. HelloServer.py)

Ett servertillägg består vanligtvis av en eller flera callbacks som packas in i instanser av en QgsServerFilter.

Varje QgsServerFilter implementerar en eller flera av följande callbacks:

• onRequestReady()

• onResponseComplete()

• onSendResponse()

I följande exempel implementeras ett minimalt filter som skriver ut HelloServer! om parametern SERVICE är lika med ”HELLO”:

class HelloFilter(QgsServerFilter):

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

    def onRequestReady(self) -> bool:
        QgsMessageLog.logMessage("HelloFilter.onRequestReady")
        return True

    def onSendResponse(self) -> bool:
        QgsMessageLog.logMessage("HelloFilter.onSendResponse")
        return True

    def onResponseComplete(self) -> bool:
        QgsMessageLog.logMessage("HelloFilter.onResponseComplete")
        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!')
        return True

Filtren måste registreras i serverIface som i följande exempel:

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

Den andra parametern i registerFilter() anger en prioritet som definierar ordningen för callbacks med samma namn (den med lägre prioritet anropas först).

Genom att använda de tre callbacks kan tillägg manipulera ingången och/eller utgången från servern på många olika sätt. I varje ögonblick har plugin-instansen tillgång till QgsRequestHandler genom QgsServerInterface. Klassen QgsRequestHandler har många metoder som kan användas för att ändra ingångsparametrarna innan de går in i serverns kärnbearbetning (genom att använda requestReady()) eller efter att begäran har bearbetats av kärntjänsterna (genom att använda sendResponse()).

Följande exempel täcker några vanliga användningsfall:

20.4.1.1.5.2. Modifiera inmatningen

Exempeltillägget innehåller ett testexempel som ändrar inmatningsparametrar som kommer från frågesträngen, i det här exemplet injiceras en ny parameter i (redan analyserad) parameterMap, den här parametern är sedan synlig av kärntjänster (WMS etc.), i slutet av kärntjänstbearbetningen kontrollerar vi att parametern fortfarande finns kvar:

class ParamsFilter(QgsServerFilter):

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

    def onRequestReady(self) -> bool:
        request = self.serverInterface().requestHandler()
        params = request.parameterMap( )
        request.setParameter('TEST_NEW_PARAM', 'ParamsFilter')
        return True

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

Detta är ett utdrag av vad du ser i loggfilen:

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: (onRequestReady) [0ms] QgsServerFilter plugin default onRequestReady called
src/core/qgsmessagelog.cpp: 45: (logMessage) [0ms] 2014-12-12T12:39:29 plugin[0] SUCCESS - ParamsFilter.onResponseComplete

På den markerade raden anger strängen ”SUCCESS” att tillägget klarade testet.

Samma teknik kan utnyttjas för att använda en anpassad tjänst i stället för en kärntjänst: du kan t.ex. hoppa över en WFS SERVICE-begäran eller någon annan kärntjänstbegäran bara genom att ändra SERVICE-parametern till något annat och kärntjänsten kommer att hoppas över. Sedan kan du injicera dina anpassade resultat i utdata och skicka dem till klienten (detta förklaras nedan).

Tips

Om du verkligen vill implementera en anpassad tjänst rekommenderas att du underklassar QgsService och registrerar din tjänst på registerFilter() genom att anropa dess registerService(service)

20.4.1.1.5.3. Modifiera eller byta ut utmatningen

Exemplet med vattenstämpelfiltret visar hur man ersätter WMS-utdata med en ny bild som erhålls genom att lägga till en vattenstämpelbild ovanpå den WMS-bild som genereras av WMS-kärntjänsten:

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 onResponseComplete(self) -> bool:
        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.onResponseComplete: 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)
        return True

I det här exemplet kontrolleras parametervärdet SERVICE och om den inkommande begäran är en WMS GETMAP och inga undantag har ställts in av ett tidigare exekverat plugin eller av kärntjänsten (WMS i det här fallet), hämtas den WMS-genererade bilden från utmatningsbufferten och vattenstämpelbilden läggs till. Det sista steget är att rensa utmatningsbufferten och ersätta den med den nyligen genererade bilden. Observera att i en verklig situation bör vi också kontrollera den begärda bildtypen i stället för att bara stödja PNG eller JPG.

20.4.1.2. Filter för åtkomstkontroll

Filter för åtkomstkontroll ger utvecklaren en finkornig kontroll över vilka lager, funktioner och attribut som kan nås, följande callbacks kan implementeras i ett filter för åtkomstkontroll:

• layerFilterExpression(layer)

• layerFilterSubsetString(layer)

• layerPermissions(layer)

• authorizedLayerAttributes(layer, attributes)

• allowToEdit(layer, feature)

• cacheKey()

20.4.1.2.1. Tilläggsfiler

Här är katalogstrukturen för vårt exempel på tillägg:

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

20.4.1.2.1.1. __init__.py

Den här filen krävs av Pythons importsystem. Som för alla QGIS-servertillägg innehåller denna fil en serverClassFactory()-funktion, som anropas när tillägget laddas in i QGIS Server vid uppstart. Den tar emot en referens till en instans av QgsServerInterface och måste returnera en instans av ditt tilläggs klass. Så här ser exempelpluginet __init__.py ut:

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

20.4.1.2.1.2. 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)

Detta exempel ger full åtkomst för alla.

Det är tilläggets uppgift att veta vem som är inloggad.

För alla dessa metoder har vi argumentet lager på lager för att kunna anpassa begränsningen per lager.

20.4.1.2.2. layerFilterExpression

Används för att lägga till ett uttryck för att begränsa resultaten.

Till exempel för att begränsa till funktioner där attributet role är lika med user.

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

20.4.1.2.3. layerFilterSubsetString

Samma som föregående men använd SubsetString (exekveras i databasen)

Till exempel för att begränsa till funktioner där attributet role är lika med user.

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

20.4.1.2.4. layerPermissions

Begränsa åtkomsten till lagret.

Returnera ett objekt av typen LayerPermissions(), som har egenskaperna:

• canRead för att se den i GetCapabilities och ha läsbehörighet.

• canInsert för att kunna infoga en ny funktion.

• canUpdate för att kunna uppdatera en funktion.

• canDelete för att kunna ta bort en funktion.

Till exempel för att begränsa allt till endast läsrättigheter:

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

20.4.1.2.5. authorizedLayerAttributes

Används för att begränsa synligheten för en specifik delmängd av attributet.

Argumentet attribute returnerar den aktuella uppsättningen synliga attribut.

Till exempel för att dölja attributet role:

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

20.4.1.2.6. allowToEdit

Detta används för att begränsa redigeringen till en delmängd av funktionerna.

Det används i protokollet WFS-Transaction.

Till exempel för att bara kunna redigera funktioner som har attributet role med värdet user:

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

20.4.1.2.7. cacheKey

QGIS Server upprätthåller en cache av funktionerna och om du vill ha en cache per roll kan du returnera rollen i den här metoden. Eller returnera None för att helt inaktivera cacheminnet.

20.4.2. Anpassade tjänster

I QGIS Server implementeras kärntjänster som WMS, WFS och WCS som underklasser till QgsService.

Om du vill implementera en ny tjänst som körs när frågesträngparametern SERVICE matchar tjänstens namn kan du implementera din egen QgsService och registrera tjänsten på serviceRegistry() genom att anropa dess registerService(service).

Här är ett exempel på en anpassad tjänst med namnet 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. Anpassade API:er

I QGIS Server implementeras centrala OGC API:er som OAPIF (även känt som WFS3) som samlingar av QgsServerOgcApiHandler subklasser som är registrerade till en instans av QgsServerOgcApi (eller dess överordnade klass QgsServerApi).

För att implementera ett nytt API som kommer att köras när webbadressens sökväg matchar en viss URL kan du implementera dina egna QgsServerOgcApiHandler-instanser, lägga till dem i en QgsServerOgcApi och registrera API:et på serviceRegistry() genom att anropa dess registerApi(api).

Här är ett exempel på ett anpassat API som kommer att köras när URL:en innehåller /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)