Processamento de eventos AEM usando a ação do Adobe I/O Runtime

Saiba como processar eventos AEM recebidos usando a Ação Adobe I/O Runtime. Este exemplo aprimora o exemplo anterior Ação do Adobe I/O Runtime e Eventos AEM. Verifique se você o concluiu antes de continuar com este.

Neste exemplo, o processamento de eventos armazena os dados originais do evento e o evento recebido como uma mensagem de atividade no armazenamento do Adobe I/O Runtime. No entanto, se o evento for do tipo Fragmento de conteúdo modificado, ele também chamará o serviço de autor do AEM para encontrar os detalhes de modificação. Por fim, exibe os detalhes do evento em um aplicativo de página única (SPA).

Pré-requisitos

Para concluir este tutorial, você precisa:

Ação do processador de eventos AEM

Neste exemplo, a ação do processador de eventos executa as seguintes tarefas:

  • Analisa o evento recebido em uma mensagem de atividade.
  • Se o evento recebido for do tipo Fragmento de Conteúdo Modificado, chame de volta para o serviço de autor do AEM para encontrar os detalhes da modificação.
  • Mantém os dados originais do evento, a mensagem de atividade e os detalhes de modificação (se houver) no armazenamento da Adobe I/O Runtime.

Para executar as tarefas acima, vamos começar adicionando uma ação ao projeto, desenvolver módulos do JavaScript para executar as tarefas acima e, finalmente, atualizar o código de ação para usar os módulos desenvolvidos.

Consulte o arquivo WKND-AEM-Eventing-Runtime-Action.zip anexado para obter o código completo, e a seção abaixo destaca os arquivos principais.

Adicionar ação

  • Para adicionar uma ação, execute o seguinte comando:

    code language-bash
    aio app add action
    
  • Selecione @adobe/generator-add-action-generic como modelo de ação, nomeie a ação como aem-event-processor.

    Adicionar ação

Desenvolver módulos do JavaScript

Para executar as tarefas mencionadas acima, vamos desenvolver os seguintes módulos do JavaScript.

  • O módulo src/dx-excshell-1/actions/aem-event-processor/eventValidator.js determina se o evento recebido é do tipo Fragmento de conteúdo modificado.

    code language-javascript
    async function needsAEMCallback(aemEvent) {
    // create a Logger
    const logger = Core.Logger('eventValidator', {
        level: 'info',
    });
    
    let isValid = false;
    
    // verify the event is a Content Fragment Modified event
    if (
        aemEvent
        && aemEvent.ContentType === 'contentFragment'
        && aemEvent.EventName === 'modified'
    ) {
        logger.info('Processing Content Fragment Modified Event');
        isValid = true;
    }
    
    return isValid;
    }
    
    module.exports = needsAEMCallback;
    
  • O módulo src/dx-excshell-1/actions/aem-event-processor/loadEventDetailsFromAEM.js chama o serviço de autor do AEM para localizar os detalhes da modificação.

    code language-javascript
    ...
    const auth = require('@adobe/jwt-auth');
    ...
    // Get AEM Service Credentials aka Technical Account details.
    // These are passed to the action as params and added in .env file.
    const clientId = params.AEM_SERVICECREDENTIALS_TECHNICALACCOUNT_CLIENTID;
    const technicalAccountId = params.AEM_SERVICECREDENTIALS_ID;
    const orgId = params.AEM_SERVICECREDENTIALS_ORG;
    const clientSecret = params.AEM_SERVICECREDENTIALS_TECHNICALACCOUNT_CLIENTSECRET;
    // Private key is passed as a string with \n and \r characters escaped.
    const privateKey = params.AEM_SERVICECREDENTIALS_PRIVATEKEY.replace(
        /\\n/g,
        '\n',
    ).replace(/\\r/g, '\r');
    const metaScopes = params.AEM_SERVICECREDENTIALS_METASCOPES.split(',');
    const ims = `https://${params.AEM_SERVICECREDENTIALS_IMSENDPOINT}`;
    
    // Get the access token from IMS using Adobe I/O SDK
    const { access_token } = await auth({
        clientId,
        technicalAccountId,
        orgId,
        clientSecret,
        privateKey,
        metaScopes,
        ims,
    });
    ...
    // Call AEM Author service to get the CF details using AEM Assets API
    const res = await fetch(
        `${aemAuthorHost}${cfPath.replace('/content/dam/', '/api/assets/')}.json`,
    {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${access_token}`,
      },
    },
    );
    
    let newValuesOfCFPropertiesAddedOrModified = {};
    // If the response is OK, get the values of the CF properties that were added or modified
    if (res.ok) {
        logger.info('AEM Event Details loaded from AEM Author instance');
        const responseJSON = await res.json();
    
        // Get the values of the CF properties that were added or modified
        if (
        responseJSON
        && responseJSON.properties
        && responseJSON.properties.elements
        ) {
        const allCurrentCFProperties = responseJSON.properties.elements;
    
        newValuesOfCFPropertiesAddedOrModified = cfPropertiesAddedOrModified.map(
            (key) => ({
            key,
            value: allCurrentCFProperties[key],
            }),
        );
        }
    }
    ...
    

    Consulte o tutorial sobre credenciais de serviço do AEM para saber mais. Além disso, os Arquivos de Configuração do App Builder para gerenciar segredos e parâmetros de ação.

  • O módulo src/dx-excshell-1/actions/aem-event-processor/storeEventData.js armazena os dados originais do evento, a mensagem de atividade e os detalhes de modificação (se houver) no armazenamento do Adobe I/O Runtime.

    code language-javascript
    ...
    const filesLib = require('@adobe/aio-lib-files');
    ...
    
    const files = await filesLib.init();
    
    const eventDataAsJSON = JSON.stringify({
        activity: activityMessage,
        aemEvent,
        aemEventDetails,
    });
    
    // store details in a folder named YYYY-MM-DD and a file named <eventID>.json
    const bytesWritten = await files.write(
        `${formattedDate}/${aemEvent.getEventID()}.json`,
        eventDataAsJSON,
    );
    ...
    

Atualizar código de ação

Finalmente, atualize o código de ação em src/dx-excshell-1/actions/aem-event-processor/index.js para usar os módulos desenvolvidos.

...
// handle the challenge probe request, they are sent by I/O to verify the action is valid
if (params.challenge) {
    logger.info('Challenge probe request detected');
    responseMsg = JSON.stringify({ challenge: params.challenge });
} else {
    logger.info('AEM Event request received');

    // create AEM Event object from request parameters
    const aemEvent = new AEMEvent(params);

    // get AEM Event as activity message using the helper method
    const activityMessage = aemEvent.getEventAsActivityMessage();

    // determine if AEM Event requires callback to AEM Author service
    const callbackAEMForEventDetails = await needsAEMCallback(aemEvent);

    let eventDetails = {};
    if (callbackAEMForEventDetails) {
    // call AEM Author service to get specifics about the event
    eventDetails = await loadEventDetailsFromAEMAuthorService(
        aemEvent,
        params,
    );
    }

    // store AEM Event and Event details in the file system
    const storageDetails = await storeEventData(
    activityMessage,
    aemEvent,
    eventDetails || {},
    );
    logger.info(`Storage details: ${JSON.stringify(storageDetails)}`);

    // create response message
    responseMsg = JSON.stringify({
    message: 'AEM Event processed',
    activityMessage,
    });

    // response object
    const response = {
    statusCode: 200,
    body: responseMsg,
    };
    logger.info('Adobe I/O Runtime action response', response);

    // Return the response to the caller
    return response;
}
...

Recursos adicionais

  • A pasta src/dx-excshell-1/actions/model contém arquivos aemEvent.js e errors.js, que são usados pela ação para analisar o evento recebido e manipular erros, respectivamente.
  • A pasta src/dx-excshell-1/actions/load-processed-aem-events contém o código de ação. Essa ação é usada pelo SPA para carregar os Eventos AEM processados do armazenamento Adobe I/O Runtime.
  • A pasta src/dx-excshell-1/web-src contém o código SPA, que exibe os Eventos AEM processados.
  • O arquivo src/dx-excshell-1/ext.config.yaml contém parâmetros e configurações de ação.

Conceito e principais pontos

Os requisitos de processamento de eventos diferem de projeto para projeto. No entanto, os principais argumentos deste exemplo são:

  • O processamento do evento pode ser feito usando a Ação do Adobe I/O Runtime.
  • A Ação em tempo de execução pode se comunicar com sistemas como seus aplicativos internos, soluções de terceiros e soluções de Adobe.
  • A ação de tempo de execução serve como ponto de entrada para um processo de negócios projetado em torno de uma alteração de conteúdo.
recommendation-more-help
4859a77c-7971-4ac9-8f5c-4260823c6f69