Integrera API i regelredigeraren

Integrering av API i regelredigeraren sker under Tidigt Adobe-program. Du kan skriva till aem-forms-ea@adobe.com från ditt officiella e-post-id för att gå med i det tidiga adopterprogrammet och begära åtkomst till funktionen.

Visual Rule Editor i Adaptive Forms stöder direkt API-integrering utan att skapa en formulärdatamodell. Du kan ansluta till en API-slutpunkt genom att antingen ange API-URL:en (i JSON-format) eller importera konfigurationen med ett cURL-kommando. När åtgärden Anropa tjänst har integrerats kan den användas för att anropa API:t.

Formulärfält kan mappas direkt till de indataparametrar som definieras i API-konfigurationen. På samma sätt kan utdataparametrar mappas till formulärfält med alternativet händelsenyttolast för motsvarande API-svar.

Med Visual Rule Editor kan du dessutom definiera success - och error-hanterare när du anropar en tjänst. Hanterare för lyckade åtgärder anger vilka åtgärder som ska utföras efter ett lyckat API-anrop, medan felhanterare definierar hur formuläret ska svara när ett fel inträffar.

Jämförelse: API-integreringsmetoder

Konfiguration av API-integrering

Skärmbilden nedan visar konfigurationsfönstret för API-integrering:

Alternativ för nyckelkonfiguration

API-integreringskonfiguration

Autentiseringstyp

Indataparametrar

Utdataparametrar

Användningsfall: Fylla i fält för land i en ansökningsblankett för visum

Scenario: En myndighet tillhandahåller ett onlineansökningsformulär för Visa med följande fält:

Istället för att underhålla en statisk lista över länder hämtar formuläret dynamiskt landsinformation (kontinent, huvudstad, ISO Alpha-koder osv.) med getCountryName API:

https://secure.geonames.org/countryInfoJSON?username=aemforms

Detta gör att de sökande alltid ser en uppdaterad och korrekt lista över länder samtidigt som de fyller i formuläret.

Implementering med API-integrering i regelredigeraren

Du kan integrera ett API utan att skapa en formulärdatamodell genom att klicka på knappen Skapa API-integrering i regelredigeraren.

En API-tjänst med namnet getCountryName har konfigurerats under API-integreringskonfiguration i regelredigeraren:

I formuläret för viseringsansökan är de tre listrutefälten, Land för medborgarskap, Land för Passport-utfärdande och Destinationsland, bundna till åtgärden Anropa tjänst .

När formuläret läses in hämtar Invoke Service listan över länder från API:t. Svaret mappas sedan för att automatiskt fylla i alternativen i listrutan.

När användaren till exempel öppnar Land där han/hon är medborgare visas listan över länder dynamiskt från API-svaret.

På samma sätt använder Land för Passport-utfärdande och destinationsland samma API-anrop för att säkerställa konsekventa och aktuella data i alla tre fälten.

Du kan hämta egenskapsvärden från en JSON-array genom att anropa ett API och använda en anpassad funktion ​. På så sätt kan du extrahera värden och binda dem direkt till formulärfält.

Implementera återförsöksmekanism för API-fel

När en API-begäran misslyckas är det ofta användbart att försöka utföra begäran igen innan ett fel rapporteras till användaren. Du kan implementera en avsöknings- och återförsöksmekanism genom att skriva egen kod i filen function.js .

I följande exempel visas hur du hanterar API-fel med upp till två återförsök och exponentiell säkerhetskopiering mellan återförsök:

/**
 * Handles request retries with up to 2 retry attempts
 * @param {function} requestFn - The request function to execute
 * @return {Promise} A promise that resolves with the response or rejects after all retries
 */
function retryHandler(requestFn) {
    const MAX_RETRIES = 2;

    /**
     * Attempts the request with retry metadata
     * @param {number} retryCount - Current retry attempt count
     * @return {Promise} The request promise
     */
    function attemptRequest(retryCount = 0) {
        // Include retry metadata if this is a retry
        const requestOptions = retryCount > 0 ? {
            headers: {
                'X-Retry': 'true',
                'X-Retry-Count': retryCount.toString(),
                'X-Retry-Time': new Date().toISOString()
            },
            body: {
                retry: true,
                retryCount: retryCount,
                timestamp: Date.now()
            }
        } : undefined;

        return requestFn(requestOptions)
            .then(function(response) {
                if (response && response.status >= 400) {
                    console.warn('Request failed with status ' + response.status);
                    throw new Error('Request failed with status ' + response.status);
                }
                return response;
            })
            .catch(function(error) {
                console.warn('Request attempt ' + (retryCount + 1) + ' failed:', error.message);

                // Retry if max attempts not reached
                if (retryCount < MAX_RETRIES) {
                    console.log('Retrying request, attempt ' + (retryCount + 2) + ' of ' + (MAX_RETRIES + 1));

                    // Exponential backoff delay: 1s, 2s, 4s...
                    const delay = Math.pow(2, retryCount) * 1000;

                    return new Promise(function(resolve) {
                        setTimeout(resolve, delay);
                    }).then(function() {
                        return attemptRequest(retryCount + 1);
                    });
                } else {
                    // All retries exhausted
                    console.error('All retry attempts failed. Final error:', error.message);
                    throw new Error('Request failed after ' + (MAX_RETRIES + 1) + ' attempts: ' + error.message);
                }
            });
    }

    // Start the first attempt
    return attemptRequest(0);
}

I ovanstående kod hanterar funktionen retryHandler API-begäranden med automatiska försök om fel uppstår. Den tar en begärandefunktion (requestFn) och försöker utföra begäran upp till två gånger, och lägger till metadata för varje nytt försök.

Vanliga frågor