Personalização e extensão de fragmentos de conteúdo

Um fragmento de conteúdo estende um ativo padrão; consulte:

Arquitetura

As partes constituintes básicas de um fragmento de conteúdo são:

  • Um Fragmento de conteúdo,
  • consistindo em um ou mais Elemento de conteúdo s,
  • e que pode ter uma ou mais Variação de conteúdo s.

Dependendo do tipo de fragmento, modelos ou modelos também são usados:

ATENÇÃO

Os modelos de fragmento de conteúdo agora são recomendados para criar todos os seus fragmentos.

Os modelos de fragmento de conteúdo são usados para todos os exemplos no We.Retail.

OBSERVAÇÃO

Antes do AEM 6.3, os Fragmentos de conteúdo eram criados com o uso de modelos em vez de modelos. Os modelos não estão mais disponíveis para criar novos fragmentos, mas os fragmentos criados com esse modelo ainda são compatíveis.

  • Modelos de fragmentos do conteúdo:

    • Usado para definir fragmentos de conteúdo que possuem conteúdo estruturado.
    • Os modelos de fragmento de conteúdo definem a estrutura de um fragmento de conteúdo quando ele é criado.
    • Um fragmento faz referência ao modelo; portanto, as alterações no modelo podem/afetarão qualquer fragmento dependente.
    • Os modelos são incorporados aos tipos de dados.
    • As funções para adicionar novas variações, etc., precisam atualizar o fragmento adequadamente.
    ATENÇÃO

    Quaisquer alterações em um modelo de fragmento de conteúdo existente podem afetar fragmentos dependentes; isso pode levar a propriedades órfãs nesses fragmentos.

  • Modelos de fragmentos de conteúdo:

    • Usado para definir fragmentos de conteúdo simples.
    • Os modelos definem a estrutura (básica, somente texto) de um fragmento de conteúdo quando ele é criado.
    • O modelo é copiado para o fragmento ao ser criado; assim, novas alterações no modelo não serão refletidas nos fragmentos existentes.
    • As funções para adicionar novas variações, etc., precisam atualizar o fragmento adequadamente.
    • Os modelos de fragmento de conteúdo operam de maneira diferente da de outros mecanismos de modelagem no ecossistema de AEM (por exemplo, modelos de página etc.). Por conseguinte, devem ser consideradas separadamente.
    • Quando baseado em um modelo, o tipo MIME do conteúdo é gerenciado no conteúdo real; isso significa que cada elemento e variação podem ter um tipo MIME diferente.

Integração com ativos

O Gerenciamento de fragmentos de conteúdo (CFM) faz parte do AEM Assets como:

  • Fragmentos de conteúdo são ativos.
  • Eles usam a funcionalidade Ativos existente.
  • Eles são totalmente integrados aos Ativos (consoles de administrador etc.).

Mapeamento de fragmentos de conteúdo estruturados para ativos

fragmento para ativos estruturados

Fragmentos de conteúdo com conteúdo estruturado (ou seja, com base em um modelo de fragmento de conteúdo) são mapeados para um único ativo:

  • Todo o conteúdo é armazenado no nó jcr:content/data do ativo:

    • Os dados do elemento são armazenados no subnó principal :

      jcr:content/data/master

    • As variações são armazenadas em um subnó que leva o nome da variação:
      por exemplo jcr:content/data/myvariation

    • Os dados de cada elemento são armazenados no respectivo subnó como uma propriedade com o nome do elemento:
      Por exemplo, o conteúdo do elemento text é armazenado como propriedade text em jcr:content/data/master

  • Os metadados e o conteúdo associado são armazenados abaixo de jcr:content/metadata
    Exceto o título e a descrição, que não são considerados metadados tradicionais e armazenados em
    jcr:content

Mapeamento de fragmentos de conteúdo simples para ativos

chlimage_1-90

Fragmentos de conteúdo simples (com base em um modelo) são mapeados para um composto que consiste em um ativo principal e subativos (opcional):

  • Todas as informações não relacionadas ao conteúdo de um fragmento (como título, descrição, metadados, estrutura) são gerenciadas exclusivamente no ativo principal.

  • O conteúdo do primeiro elemento de um fragmento é mapeado para a representação original do ativo principal.

    • As variações (se houver) do primeiro elemento são mapeadas para outras representações do ativo principal.
  • Elementos adicionais (se existirem) são mapeados para subativos do ativo principal.

    • O conteúdo principal desses elementos adicionais mapeia para a representação original do respectivo subativo.
    • Outras variações (se aplicável) de quaisquer elementos adicionais são mapeadas para outras representações do respectivo subativo.

Localização do ativo

Como ocorre com os ativos padrão, um fragmento de conteúdo é mantido em:

/content/dam

Permissões de ativos

Para obter mais detalhes, consulte Fragmento de conteúdo - Excluir considerações.

Integração de recursos

  • O recurso de Gerenciamento de fragmento de conteúdo (CFM) baseia-se no núcleo de Ativos, mas deve ser o mais independente possível.
  • O CFM fornece suas próprias implementações para itens nas visualizações de cartão/coluna/lista; essas são as implementações de renderização de conteúdo do Assets existentes.
  • Vários componentes de Ativos foram estendidos para atender a fragmentos de conteúdo.

Uso de fragmentos de conteúdo em páginas

ATENÇÃO

O Componente principal do fragmento de conteúdo agora é recomendado. Consulte Desenvolvimento de componentes principais para obter mais detalhes.

Os fragmentos de conteúdo podem ser referenciados AEM páginas, como qualquer outro tipo de ativo. AEM fornece o Fragmento de conteúdo componente principal - um componente que permite incluir fragmentos de conteúdo em suas páginas. Você também pode estender, esse componente principal Fragmento de conteúdo.

  • O componente usa a propriedade fragmentPath para fazer referência ao fragmento de conteúdo real. A propriedade fragmentPath é tratada da mesma maneira que as propriedades semelhantes de outros tipos de ativos; por exemplo, quando o fragmento de conteúdo é movido para outro local.

  • O componente permite selecionar a variação a ser exibida.

  • Além disso, um intervalo de parágrafos pode ser selecionado para restringir a saída; por exemplo, isso pode ser usado para saída de várias colunas.

  • O componente permite conteúdo intermediário:

    • Aqui, o componente permite colocar outros ativos (imagens, etc.) entre os parágrafos do fragmento referenciado.

    • Para conteúdo intermediário, é necessário:

      • Estar ciente da possibilidade de referências instáveis; o conteúdo intermediário (adicionado ao criar uma página) não tem relacionamento fixo com o parágrafo ao lado do qual está posicionado, inserindo um novo parágrafo (no editor de fragmentos de conteúdo) antes que a posição do conteúdo intermediário possa perder a posição relativa
      • considere os parâmetros adicionais (como variação e filtros de parágrafo) para evitar falsos positivos nos resultados da pesquisa
OBSERVAÇÃO

Modelo de fragmentos de conteúdo:

Ao usar um fragmento de conteúdo que foi baseado em um modelo de fragmento de conteúdo em uma página, o modelo é referenciado. Isso significa que, se o modelo não tiver sido publicado no momento em que você publicar a página, ela será sinalizada e o modelo será adicionado aos recursos a serem publicados com a página.

Modelo do fragmento de conteúdo:

Ao usar um fragmento de conteúdo que foi baseado em um modelo de fragmento de conteúdo em uma página, não há referência como o modelo foi copiado ao criar o fragmento.

Configuração usando o console OSGi

A implementação de backend de fragmentos de conteúdo é, por exemplo, responsável por tornar as instâncias de um fragmento usadas em uma página pesquisáveis ou por gerenciar conteúdo de mídia mista. Essa implementação precisa saber quais componentes são usados para renderizar fragmentos e como a renderização é parametrizada.

Os parâmetros para isso podem ser configurados no Console da Web, para o pacote OSGi Configuração do componente do fragmento de conteúdo.

  • Tipos de recursos
    Uma lista de
    sling:resourceTypes pode ser fornecido para definir componentes que são usados para renderizar fragmentos de conteúdo e onde o processamento em segundo plano deve ser aplicado.


  • Propriedades de referênciaUma lista de propriedades pode ser configurada para especificar onde a referência ao fragmento é armazenada para o respectivo componente.

OBSERVAÇÃO

Não há mapeamento direto entre a propriedade e o tipo de componente.

AEM simplesmente obtém a primeira propriedade que pode ser encontrada em um parágrafo. Portanto, você deve escolher as propriedades com cuidado.

captura de tela_2019-03-18at100941

Ainda há algumas diretrizes que você deve seguir para garantir que seu componente seja compatível com o processamento em segundo plano do fragmento de conteúdo:

  • O nome da propriedade em que os elementos a serem renderizados são definidos deve ser element ou elementNames.

  • O nome da propriedade em que a variação a ser renderizada é definida deve ser variation ou variationName.

  • Se a saída de vários elementos for suportada (usando elementNames para especificar vários elementos), o modo de exibição real é definido pela propriedade displayMode:

    • Se o valor for singleText (e houver apenas um elemento configurado), o elemento será renderizado como um texto com conteúdo intermediário, suporte para layout etc. Esse é o padrão para fragmentos, onde apenas um único elemento é renderizado.
    • Caso contrário, uma abordagem muito mais simples será usada (poderia ser chamada de "exibição de formulário"), onde nenhum conteúdo intermediário será suportado e o conteúdo do fragmento será renderizado "como está".
  • Se o fragmento for renderizado para displayMode == singleText (implicitamente ou explicitamente), as seguintes propriedades adicionais serão reproduzidas:

    • paragraphScope define se todos os parágrafos, ou apenas um intervalo de parágrafos, devem ser renderizados (valores: all vs. range)

    • se paragraphScope == range então a propriedade paragraphRange define o intervalo de parágrafos a serem renderizados

Integração com outros quadros

Os fragmentos de conteúdo podem ser integrados com:

  • Traduções

    Os Fragmentos de conteúdo são totalmente integrados ao AEM fluxo de trabalho de tradução. A nível arquitetônico, isso significa:

    • As traduções individuais de um fragmento de conteúdo são, na verdade, fragmentos separados; por exemplo:

      • Estão localizadas sob raízes linguísticas diferentes:

        /content/dam/<path>/en/<to>/<fragment>

        vs.

        /content/dam/<path>/de/<to>/<fragment>

      • mas compartilham exatamente o mesmo caminho relativo abaixo da raiz de idioma:

        /content/dam/<path>/en/<to>/<fragment>

        vs.

        /content/dam/<path>/de/<to>/<fragment>

    • Além dos caminhos baseados em regras, não há mais conexão entre as diferentes versões linguísticas de um fragmento de conteúdo; eles são tratados como dois fragmentos separados, embora a interface do usuário forneça os meios de navegar entre as variantes de idioma.

    OBSERVAÇÃO

    O fluxo de trabalho de tradução AEM funciona com /content:

  • Esquemas de metadados

    • Fragmentos de conteúdo (re)use os esquemas de metadados, que podem ser definidos com ativos padrão.

    • O CFM fornece seu próprio schema específico:

      /libs/dam/content/schemaeditors/forms/contentfragment

      isso pode ser estendido se necessário.

    • O respectivo formulário de esquema é integrado ao editor de fragmentos.

A API de gerenciamento de fragmentos de conteúdo - do lado do servidor

Você pode usar a API do lado do servidor para acessar os fragmentos de conteúdo; consulte:

com.adobe.cq.dam.cfm

ATENÇÃO

É altamente recomendável usar a API do lado do servidor em vez de acessar diretamente a estrutura de conteúdo.

Principais interfaces

As três interfaces a seguir podem servir como pontos de entrada:

  • Modelo de fragmento (FragmentTemplate)

    Use FragmentTemplate.createFragment() para criar um novo fragmento.

    Resource templateOrModelRsc = resourceResolver.getResource("...");
    FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
    ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");
    

    Essa interface representa:

    • um modelo de fragmento de conteúdo ou de fragmento de conteúdo do qual criar um fragmento de conteúdo,
    • e (após a criação) a informação estrutural desse fragmento

    Essas informações podem incluir:

    • Acessar dados básicos (título, descrição)

    • Acesse modelos/modelos para os elementos do fragmento:

      • Listar modelos de elemento
      • Obter informações estruturais para um determinado elemento
      • Acesse o modelo de elemento (consulte ElementTemplate)
    • Acessar modelos para as variações do fragmento:

      • Listar modelos de variação
      • Obter informações estruturais para uma determinada variação
      • Acesse o modelo de variação (consulte VariationTemplate)
    • Obter conteúdo associado inicial

    Interfaces que representam informações importantes:

    • ElementTemplate

      • Obter dados básicos (nome, título)
      • Obter conteúdo do elemento inicial
    • VariationTemplate

      • Obter dados básicos (nome, título, descrição)
  • Fragmento de conteúdo (ContentFragment)

    Essa interface permite que você trabalhe com um fragmento de conteúdo de forma abstrata.

    ATENÇÃO

    É altamente recomendável acessar um fragmento por meio dessa interface. A alteração direta da estrutura de conteúdo deve ser evitada.

    A interface fornece os meios para:

    • Gerenciar dados básicos (por exemplo, obter nome; get/set title/description)

    • Acessar metadados

    • Elementos de acesso:

      • Elementos de lista

      • Obter elementos por nome

      • Criar novos elementos (consulte Avisos)

      • Acessar dados do elemento (consulte ContentElement)

    • Listar variações definidas para o fragmento

    • Criar novas variações globalmente

    • Gerenciar conteúdo associado:

      • Listar coleções
      • Adicionar coleções
      • Remover coleções
    • Acessar o modelo ou o modelo do fragmento

    As interfaces que representam os elementos principais de um fragmento são:

    • Elemento de conteúdo (ContentElement)

      • Obter dados básicos (nome, título, descrição)

      • Obter/definir conteúdo

      • Variações de acesso de um elemento:

        • Listar variações
        • Obter variações por nome
        • Criar novas variações (consulte Avisos)
        • Remover variações (consulte Avisos)
        • Acesse os dados de variação (consulte ContentVariation)
      • Atalho para resolver variações (aplicando alguma lógica de fallback adicional específica da implementação se a variação especificada não estiver disponível para um elemento)

    • Variação de conteúdo (ContentVariation)

      • Obter dados básicos (nome, título, descrição)
      • Obter/definir conteúdo
      • Sincronização simples, com base nas informações da última modificação

    Todas as três interfaces ( ContentFragment, ContentElement, ContentVariation) estendem a interface Versionable, que adiciona recursos de controle de versão, necessários para fragmentos de conteúdo:

    • Criar nova versão do elemento
    • Versões de lista do elemento
    • Obter o conteúdo de uma versão específica do elemento com versão

Adaptação - Uso de adaptTo()

Podem ser adaptadas as seguintes condições:

  • ContentFragment pode ser adaptado para:

    • Resource - o recurso Sling subjacente; observe que atualizar o subjacente Resource diretamente requer a reconstrução do ContentFragment objeto.

    • Asset - a Asset abstração do DAM que representa o fragmento de conteúdo; observe que atualizar o Asset diretamente requer a reconstrução do ContentFragment objeto.

  • ContentElement pode ser adaptado para:

    • ElementTemplate - para aceder às informações estruturais do elemento.
  • FragmentTemplate pode ser adaptado para:

    • Resource - a Resource determinação do modelo referenciado ou do modelo original que foi copiado;

      • as alterações feitas por meio de Resource não são refletidas automaticamente no FragmentTemplate.
  • Resource pode ser adaptado para:

    • ContentFragment
    • FragmentTemplate

Avisos

Note-se que:

  • A API é implementada para fornecer funcionalidade compatível com a interface do usuário do .

  • A API inteira foi projetada para not persistir alterações automaticamente (a menos que observado de outra forma no JavaDoc da API). Portanto, sempre será necessário confirmar o resolvedor de recursos da respectiva solicitação (ou o resolvedor que você está realmente usando).

  • Tarefas que podem exigir esforço adicional:

    • Criar/remover novos elementos não atualizará a estrutura de dados de fragmentos simples (com base em um modelo de fragmento).

    • A criação de novas variações a partir de ContentElement não atualizará a estrutura de dados (mas a criação delas globalmente a partir de ContentFragment irá).

    • Remover variações existentes não atualizará a estrutura de dados.

A API de gerenciamento de fragmento de conteúdo - Lado do cliente

ATENÇÃO

Para AEM 6.5, a API do lado do cliente é interna.

Informações adicionais

Consulte o link a seguir:

  • filter.xml

    O filter.xml para gerenciamento de fragmentos de conteúdo é configurado de forma que não se sobreponha ao pacote de conteúdo principal do Assets.

Editar sessões

Uma sessão de edição é iniciada quando o usuário abre um fragmento de conteúdo em uma das páginas do editor. A sessão de edição é concluída quando o usuário deixa o editor selecionando Salvar ou Cancelar.

Requisitos

Os requisitos para controlar uma sessão de edição são:

  • A edição de um fragmento de conteúdo, que pode abranger várias exibições (= páginas HTML), deve ser atômica.
  • A edição também deve ser transacional; no final da sessão de edição, as alterações devem ser confirmadas (salvas) ou revertidas (canceladas).
  • Os casos de borda devem ser manipulados adequadamente; incluem situações como quando o usuário sai da página inserindo um URL manualmente ou usando navegação global.
  • Um salvamento automático periódico (a cada x minutos) deve estar disponível para evitar perda de dados.
  • Se um fragmento de conteúdo for editado simultaneamente por dois usuários, eles não devem substituir as alterações uns dos outros.

Processos

Os processos envolvidos são:

  • Iniciar uma sessão

    • Uma nova versão do fragmento de conteúdo é criada.
    • O salvamento automático é iniciado.
    • Os cookies estão definidos; eles definem o fragmento editado no momento e que há uma sessão de edição aberta.
  • Conclusão de uma sessão

    • O salvamento automático é interrompido.

    • Após confirmação:

      • As últimas informações modificadas são atualizadas.
      • Os cookies são removidos.
    • Após a reversão:

      • A versão do fragmento de conteúdo criada quando a sessão de edição foi iniciada é restaurada.
      • Os cookies são removidos.
  • Edição

    • Todas as alterações (salvamento automático incluído) são feitas no fragmento de conteúdo ativo, não em uma área separada e protegida.
    • Portanto, essas alterações são refletidas imediatamente em AEM páginas que fazem referência ao respectivo fragmento de conteúdo

Ações

As ações possíveis são:

  • Inserir uma página

    • Verifique se uma sessão de edição já está presente; verificando o respectivo cookie.

      • Se existir, verifique se a sessão de edição foi iniciada para o fragmento de conteúdo que está sendo editado no momento

        • Se o fragmento atual, restaure a sessão.
        • Caso contrário, tente cancelar a edição do fragmento de conteúdo editado anteriormente e remover os cookies (nenhuma sessão de edição presente posteriormente).
      • Se não houver uma sessão de edição, aguarde a primeira alteração feita pelo usuário (veja abaixo).

    • Verifique se o fragmento de conteúdo já está referenciado em uma página e, nesse caso, exiba as informações apropriadas.

  • Alteração de conteúdo

    • Sempre que o usuário altera o conteúdo e não há uma sessão de edição presente, uma nova sessão de edição é criada (consulte Iniciar uma sessão).
  • Sair de uma página

    • Se uma sessão de edição estiver presente e as alterações não forem persistentes, uma caixa de diálogo de confirmação modal será exibida para notificar o usuário de conteúdo potencialmente perdido e permitir que ele permaneça na página.

Exemplos

Exemplo: Acesso a um fragmento de conteúdo existente

Para isso, é possível adaptar o recurso que representa a API a:

com.adobe.cq.dam.cfm.ContentFragment

Por exemplo:

// first, get the resource
Resource fragmentResource = resourceResolver.getResource("/content/dam/fragments/my-fragment");
// then adapt it
if (fragmentResource != null) {
    ContentFragment fragment = fragmentResource.adaptTo(ContentFragment.class);
    // the resource is now accessible through the API
}

Exemplo: Criação de um novo fragmento de conteúdo

Para criar um novo fragmento de conteúdo programaticamente, você precisa usar:

com.adobe.cq.dam.cfm.ContentFragmentManager#create

Por exemplo:

Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");

Exemplo: Especificação do intervalo de salvamento automático

O intervalo de salvamento automático (medido em segundos) pode ser definido usando o gerenciador de configuração (ConfMgr):

  • Nó: <*conf-root*>/settings/dam/cfm/jcr:content

  • Nome da Propriedade: autoSaveInterval

  • Tipo: Long

  • Padrão: 600 (10 minutos); isso é definido em /libs/settings/dam/cfm/jcr:content

Para definir um intervalo de salvamento automático de 5 minutos, é necessário definir a propriedade no nó ; por exemplo:

  • Nó: /conf/global/settings/dam/cfm/jcr:content

  • Nome da Propriedade: autoSaveInterval

  • Tipo: Long

  • Valor: 300 (5 minutos equivale a 300 segundos)

Modelos de fragmentos do conteúdo

Consulte Modelos de fragmento de conteúdo para obter informações completas.

Componentes da autoria de página

Para obter mais informações, consulte

Nesta página