sgcOpenAPI in cinque minuti

sgcOpenAPI è un generatore di codice, non un componente della palette. Lo punti a una specifica, scrive una unit Pascal e tu chiami quella unit dal tuo progetto. Questa pagina esegue il generatore una volta e poi effettua una vera chiamata sul client generato.

OpenAPI 3, JSON e YAML
Genera un client Delphi tipizzato o uno stub di server
Solo Delphi, le risposte tipizzate richiedono XE7 e successivi

Non c'è nessun componente da trascinare

È l'unica cosa da capire prima di iniziare. sgcOpenAPI non registra nulla nella palette dell'IDE e non include alcun package di design-time. Il flusso di lavoro è: genera, poi usa.

Lo strumento

sgcOpenAPI.exe, che è sia una procedura guidata grafica sia una riga di comando. Legge una specifica e scrive un file .pas.

Cosa scrive

Una unit contenente una classe client derivata da TsgcOpenAPI_Client, un metodo per operazione, le classi di richiesta e risposta e una funzione GetOpenAPIClient che restituisce un singleton pronto all'uso.

Come lo chiami

Aggiungi la unit generata al tuo progetto, inseriscila nella clausola uses e chiama GetOpenAPIClient.YourOperation(...). Il risultato è un oggetto risposta che liberi quando hai finito.

I package

Sono inclusi cinque package di runtime, che contengono SDK precompilati per AWS, Azure, Google e Microsoft. Servono per essere compilati, non installati, perché non c'è alcuna pagina della palette da aggiungere.

Requisiti ed edizioni

La colonna dell'edizione indica il define che regola il codice, con la riga in cui si trova nel Source/sgcVer.inc del prodotto.

Cosa Valore
IDE Da Delphi 7 a RAD Studio 13 per il codice generato. Gli oggetti di risposta tipizzati richiedono XE7 o successivo e la demo inclusa li protegge con {$IF CompilerVersion >= 28.0}. Prima di quella versione il metodo generato restituisce una semplice stringa.
C++Builder Non supportato per il client generato. SGC_HTTP_OPENAPI, che regola l'intero sgcHTTP_OpenAPI_Client.pas, è definito dentro un {$IFNDEF BCB} alla riga 702 del sgcVer.inc del prodotto, quindi una build C++Builder compila quella unit in nulla.
Edizione Le build di sgcOpenAPI sono fissate ai due livelli più bassi. Le righe da 7 a 10 del suo sgcVer.inc riportano {$IFDEF SGC_OPENAPI} seguito da {$UNDEF SGC_EDT_PRO}, {$UNDEF SGC_EDT_ENT} e {$UNDEF SGC_EDT_ALL}, lasciando definiti Core e Standard. I livelli commerciali si distinguono per numero di postazioni, non per funzionalità.
Generazione del server La stessa build definisce SGC_HTTP_OPENAPI_SERVER alla riga 11, quindi il generatore può produrre sia uno stub di server sia un client. Passa -s sulla riga di comando.
Piattaforme Nessuna guardia per sistema operativo a livello di unit. Le uniche condizioni dentro la unit base del client generato sono il consueto import {$IFDEF MSWINDOWS} e le sostituzioni del tipo dell'id di thread, quindi Windows, macOS, Linux, Android e iOS compilano tutti.
Attivazione della licenza Se la macchina non è stata attivata, passa -user e -password sulla riga di comando, altrimenti l'esecuzione termina con codice 2.

Il generatore accetta JSON e YAML e li legge entrambi in locale. Anche un documento Swagger 2.0 viene convertito in OpenAPI 3 in locale. Il convertitore remoto è facoltativo, tramite -r, e carica la tua specifica su un server di terze parti, quindi resta disattivato a meno che tu non lo chieda.

Installa e genera

Non c'è alcun package di design-time da installare, quindi l'installazione è più breve rispetto agli altri prodotti.

1. Decomprimi

Decomprimi il download in una cartella, chiamata {$DIR} qui sotto. Ottieni Demos\, Bin\ e Source\.

2. Library path

Tools, Options, Library. Aggiungi {$DIR}\Source in modo che le unit generate e la classe base del client vengano risolte. Non c'è nulla da installare nell'IDE.

3. Facoltativo, compila un SDK precompilato

Se vuoi uno degli SDK inclusi, apri il package di runtime corrispondente in {$DIR}\Packages\ e compilalo. Sono package di runtime, quindi compila invece di installare.

4. Genera un client

Esegui Bin\sgcOpenAPI.exe per la procedura guidata, oppure usa la riga di comando. Un input, un output e hai una unit.

5. Aggiungi la unit al tuo progetto

Metti il .pas generato accanto alle tue altre unit, aggiungilo al progetto e inseriscilo nella clausola uses. Questa è l'intera integrazione.

Una specifica in ingresso, un client funzionante in uscita

Una riga di comando genera la unit. Una chiamata la usa. La terza scheda mostra le opzioni da conoscere il primo giorno.

riga di comando
> sgcOpenAPI.exe -i "geolocation.json" -o "geolocation.pas"

File successfully created geolocation.pas

Entrambe le opzioni sono obbligatorie. -i accetta un file locale o un URL e supporta JSON e YAML, mentre -o è la unit Pascal da scrivere. Nello stesso eseguibile c'è una procedura guidata grafica se preferisci cliccare. Aggiungi il .pas generato al tuo progetto ed è pronto all'uso.

fGeolocation.pas
uses
  geolocation;   // the unit you just generated

procedure TfrmGeolocation.btnGeolocationClick(Sender: TObject);
var
  oResponse: TsgcOpenAPI_Retrieve_the_location_of_an_IP_address_Response;
begin
  oResponse := GetOpenAPIClient.Retrieve_the_location_of_an_IP_address(
    txtAPIKey.Text, txtIPAddress.Text);
  try
    if oResponse.IsSuccessful then
      memoResponse.Lines.Text :=
        'country: ' + oResponse.Successful.Country + #13#10 +
        'city: ' + oResponse.Successful.City
    else
      memoResponse.Lines.Text := oResponse.ResponseError;
  finally
    oResponse.Free;
  end;
end;

GetOpenAPIClient viene generata nella unit e non accetta parametri. Un metodo per operazione, con il nome ricavato dall'id dell'operazione. L'oggetto risposta va liberato da te, ed è per questo che la demo usa un try finally. Nelle versioni di Delphi precedenti a XE7 il metodo generato restituisce invece una semplice stringa e la demo inclusa protegge il percorso tipizzato con {$IF CompilerVersion >= 28.0}.

riga di comando
-s              generate a server stub instead of a client
-a 3            add an OAuth2 flow to the generated client
                (0 none, 1 basic, 2 token, 3 oauth2, 4 jwt)
-u <url>        set the base url the generated client uses
-m 1            name methods from summary rather than operationid
                (0 operationid, 1 summary, 2 endpoint)
-x <list|file>  exclude operations, as "VERB endpoint"
-p              generate only the classes the kept operations use
-nc             do not create pascal classes
-l              show progress messages (errors are always shown)
-user -password activate the licence on this machine

Su una specifica di grandi dimensioni, -x e -p insieme fanno la differenza tra una unit che puoi aprire nell'IDE e una che non puoi. Esiste anche -r, ed è volutamente disattivata per impostazione predefinita perché carica l'intera specifica su un convertitore di terze parti.

Il comando di generazione è la riga di utilizzo stampata dalla guida dello strumento stesso. La chiamata è la demo inclusa Demos\20.Client\abstractapi.com\geolocation\fGeolocation.pas, con i controlli del form sostituiti da valori letterali. Quella demo include la specifica e si aspetta che tu generi la unit, ed è per questo che la guida rapida parte dal generatore.

Verifica che il generatore sia riuscito

Due cose da controllare, e una di esse si può automatizzare.

Il messaggio

Lo strumento stampa File successfully created seguito dal percorso di output. Gli errori vanno sempre sullo standard error, quindi un'esecuzione silenziosa che non ha scritto nulla non è davvero muta.

Il codice di uscita

0 successo, 1 errore, 2 licenza non valida, 3 opzione non valida, 4 file di configurazione non valido, 5 file di input non valido, 6 file di output non valido, 7 la specifica non ha potuto essere convertita in un documento OpenAPI 3 valido. Verificalo nel tuo script di build.

La unit compila

Aggiungi il .pas generato al progetto e compila. Dovrebbe compilare con nient'altro che {$DIR}\Source nel library path.

IsSuccessful

A runtime te lo dice l'oggetto risposta. Quando è false, ResponseError contiene il messaggio e ResponseCode lo stato HTTP.

Cosa va storto di solito la prima volta

Sei problemi spiegano quasi ogni prima esecuzione.

Stai cercando un componente nella palette

Non ce n'è nessuno. sgcOpenAPI non registra componenti e non include alcun package di design-time. La unit generata è il punto di integrazione e GetOpenAPIClient è il modo per raggiungere il client.

La unit citata nella demo non esiste

È previsto. Le demo includono la specifica e non la unit generata, quindi esegui prima il generatore. La demo di geolocalizzazione richiede una unit chiamata geolocation, che esce da geolocation.json.

Codice di uscita 2

La licenza non è stata attivata su questa macchina. Passa -user e -password sulla riga di comando.

L'oggetto di risposta tipizzato non compila

Le risposte tipizzate richiedono XE7 o successivo. La demo inclusa le protegge con {$IF CompilerVersion >= 28.0} e ripiega su un metodo che restituisce una semplice stringa sui compilatori più vecchi. Mantieni quella guardia se supporti Delphi 7.

Nulla compila con C++Builder

SGC_HTTP_OPENAPI è definito dentro un {$IFNDEF BCB} alla riga 702 del sgcVer.inc del prodotto, quindi la classe base del client generato non viene compilata affatto per C++Builder.

La specifica non si converte

Il codice di uscita 7 significa che il documento non ha potuto essere trasformato in un documento OpenAPI 3 valido. YAML e Swagger 2.0 sono gestiti in locale; il convertitore remoto dietro -r è la via di fuga e carica l'intero file su un server che eSeGeCe non controlla.

Oltre il primo client

Quattro direzioni, tutte dallo stesso generatore.

Genera un server, non un client

Passa -s e il generatore produce invece uno stub di server. Le demo del server mostrano come le operazioni prodotte vengono smistate e validate rispetto alla specifica.

sgcOpenAPI Server

Usa gli SDK precompilati

Più di mille specifiche sono già generate e incluse, tra cui AWS, Azure, Google e Microsoft. Compila il package che ti serve e salta del tutto il passaggio di generazione.

Le API incluse

Riduci ciò che generi

-x esclude le operazioni per verbo ed endpoint e -p elimina le classi che nessuna operazione rimasta usa. Su una specifica di grandi dimensioni fa la differenza tra una unit che puoi aprire e una che non puoi.

Il parser

Collega l'autenticazione

Il client generato ha una proprietà Authentication e -a sceglie lo schema al momento della generazione: nessuno, basic, token, OAuth2 o JWT.

Funzionalità di sgcOpenAPI

Riferimento, demo e documentazione

I progetti demo sono inclusi nel download, in Demos\: SDK precompilati, un client generato e due esempi di server.

Cosa fa sgcOpenAPI Il parser, il generatore e il componente server in una sola pagina.
Il parser Come una specifica viene letta, validata e trasformata in tipi Pascal.
Il componente server Servire un'API a partire da una specifica invece di consumarne una.
API incluse Gli SDK precompilati che arrivano pronti da compilare.
Scarica la versione di prova Il generatore e i sorgenti, con limite di tempo.
Cos'è OpenAPI Contesto, se il formato di specifica in sé è nuovo per te.

Letture correlate: generare un client Delphi da OpenAPI, raggruppare gli schemi, sgcOpenAPI a confronto con swagger-codegen e il server OpenAPI. Ogni prodotto ha la propria guida rapida, elencata nella pagina per iniziare.

Domande sulla guida rapida di sgcOpenAPI

Nessuno. sgcOpenAPI è un generatore di codice e una libreria di runtime e non registra nulla nella palette dell'IDE. Nel prodotto non c'è alcun package di design-time. Esegui sgcOpenAPI.exe su una specifica, scrive una unit Pascal e tu aggiungi quella unit al tuo progetto. Al suo interno, GetOpenAPIClient restituisce un oggetto client pronto con un metodo per operazione.
Lo strumento la stampa nella propria guida: sgcOpenAPI.exe -i "c:\openapi.json" -o "c:\openapi.pas". Entrambe le opzioni sono obbligatorie. -i accetta un file locale o un URL e sono accettati sia JSON sia YAML. -o è la unit Pascal da scrivere. Un valore può anche essere aggiunto dopo i due punti, come in -i:"c:\openapi.json".
In due modi. Lo strumento stampa File successfully created seguito dal percorso di output e imposta un codice di uscita che puoi verificare in uno script di build. I codici sono 0 successo, 1 errore, 2 licenza non valida, 3 opzione non valida, 4 file di configurazione non valido, 5 file di input non valido, 6 file di output non valido e 7 la specifica non ha potuto essere convertita in un documento OpenAPI 3 valido. Gli errori vanno sempre sullo standard error.
Il metodo generato restituisce un oggetto risposta derivato da TsgcOpenAPIResponse. Leggi prima IsSuccessful. Quando è false, ResponseError contiene il messaggio e ResponseCode lo stato HTTP. Libera l'oggetto risposta quando hai finito, cosa che la demo inclusa fa in un try finally.
Il client generato no. SGC_HTTP_OPENAPI, che racchiude l'intera interfaccia di sgcHTTP_OpenAPI_Client.pas, è definito dentro un {$IFNDEF BCB} alla riga 702 del sgcVer.inc del prodotto, quindi con C++Builder quella unit viene compilata in nulla e il codice generato non ha una classe base. Genera per Delphi.
Il codice generato è destinato a Delphi 7 e successivi. Gli oggetti di risposta tipizzati richiedono XE7 o successivo e la demo inclusa lo rende esplicito con {$IF CompilerVersion >= 28.0}: sopra quella soglia ottieni un oggetto risposta con campi tipizzati, sotto lo stesso metodo restituisce una semplice stringa. Mantieni la guardia se il tuo progetto deve compilare in entrambi i casi.
Sì. Passa -s e il generatore produce uno stub di server con attributi code-first invece di un client. La build distribuita come sgcOpenAPI definisce SGC_HTTP_OPENAPI_SERVER alla riga 11 del suo sgcVer.inc, quindi il lato server è presente in ogni licenza. Due demo di server sono incluse in Demos\30.Server.
Non a meno che tu non lo chieda. YAML viene letto in locale e un documento Swagger 2.0 viene convertito in OpenAPI 3 in locale. L'opzione -r, disattivata per impostazione predefinita, consente di ripiegare sul convertitore pubblico converter.swagger.io e il testo della guida dice chiaramente che questo carica il file completo su un server che eSeGeCe non controlla. Lasciala disattivata per qualsiasi cosa riservata.
La scelta più conveniente: All-AccessTutti i prodotti eSeGeCe, con Supporto Premium incluso, a partire da €1,059/anno.
Vedi i prezzi All-Access

Pronto a smettere di scrivere a mano i client REST?

Scarica la versione di prova e genera un client da una specifica che hai già.