Estrutura de marcação AEM

Para marcar o conteúdo e aproveitar a infraestrutura de marcação de AEM :

  • A tag deve existir como um nó do tipo [cq:Tag](#tags-cq-tag-node-type) no nó raiz da taxonomia

  • O NodeType do nó de conteúdo marcado deve incluir a mistura cq:Taggable

  • O TagID é adicionado à propriedade cq:tags do nó de conteúdo e resolve um nó do tipo [cq:Tag](#tags-cq-tag-node-type)

Tags : cq:Tag Node Type

A declaração de uma tag é capturada no repositório em um nó do tipo cq:Tag.

Uma tag pode ser uma palavra simples (por exemplo, céu) ou representar uma taxonomia hierárquica (por exemplo, frutas/maçã, ou seja, tanto o fruto genérico como a maçã mais específica).

As tags são identificadas por uma TagID exclusiva.

Uma tag tem meta informações opcionais, como um título, títulos localizados e uma descrição. O título deve ser exibido em interfaces do usuário, em vez da TagID, quando presente.

A estrutura de marcação também fornece a capacidade de restringir autores e visitantes do site a usar somente tags específicas e predefinidas.

Características da tag

  • o tipo de nó é cq:Tag

  • o nome do nó é um componente do [TagID](#tagid)

  • o [TagID](#tagid) sempre inclui um namespace

  • propriedade opcional jcr:title (o Título a ser exibido na interface do usuário)

  • propriedade opcional jcr:description

  • quando contém nós filho, é referido como uma tag container

  • é armazenado no repositório abaixo de um caminho base chamado nó raiz de taxonomia

TagID

Uma TagID identifica um caminho que é resolvido para um nó de tag no repositório.

Normalmente, a TagID é uma TagID abreviada que começa com o namespace ou pode ser uma TagID absoluta que começa no nó raiz da taxonomia.

Quando o conteúdo é marcado, se ainda não existir, a propriedade [cq:tags](#tagged-content-cq-tags-property) é adicionada ao nó de conteúdo e a TagID é adicionada ao valor da matriz String da propriedade.

A TagID consiste em um namespace seguido pela TagID local. Os marcadores do contêiner têm subtags que representam uma ordem hierárquica na taxonomia. As subtags podem ser usadas para referenciar tags da mesma maneira que qualquer TagID local. Por exemplo, é permitido marcar o conteúdo com "fruta", mesmo que seja uma tag container com subtags, como "fruta/maçã" e "frutas/banana".

Nó raiz da taxonomia

O nó raiz da taxonomia é o caminho base para todas as tags no repositório. O nó raiz da taxonomia deve e não ser um nó do tipo cq :Tag.

No AEM, o caminho base é /content/ cq :tags e o nó raiz é do tipo cq :Folder.

Marcar namespace

Os namespaces permitem agrupar itens. O caso de uso mais comum é ter um namespace por site (por exemplo, público, interno e portal) ou por aplicativo maior (por exemplo, WCM, Ativos, Comunidades), mas os namespaces podem ser usados para várias outras necessidades. Os namespaces são usados na interface do usuário para mostrar apenas o subconjunto de tags (ou seja, tags de um determinado namespace) que é aplicável ao conteúdo atual.

O namespace da tag é o primeiro nível na subárvore de taxonomia, que é o nó imediatamente abaixo do nó raiz de taxonomia. Um namespace é um nó do tipo cq:Tag cujo pai não é um tipo de nó cq:Tag.

Todas as tags têm um namespace. Se nenhum namespace for especificado, a tag será atribuída ao namespace padrão, que é TagID default (o Título é Standard Tags),que é /content/cq:tags/default.

Tags do contêiner

Uma tag container é um nó do tipo cq:Tag que contém qualquer número e tipo de nós filho, o que possibilita aprimorar o modelo de tag com metadados personalizados.

Além disso, tags de contêiner (ou supertags) em uma taxonomia servem como subsoma de todas as subtags: por exemplo, o conteúdo marcado com frutos/maçã também é considerado marcado com frutos, ou seja, a pesquisa de conteúdo marcado apenas com frutos também encontraria o conteúdo marcado com frutas/maçã.

Resolvendo TagIDs

Se a ID da tag contiver dois pontos ":", o dois pontos separará o namespace da tag ou da subtaxonomia, que são separadas por barras normais "/". Se a ID da tag não tiver dois pontos, o namespace padrão será implícito.

O local padrão e único das tags está abaixo de /content/cq:tags.

A tag que faz referência a caminhos ou caminhos não existentes que não apontam para um nó cq:Tag é considerada inválida e é ignorada.

A tabela a seguir mostra algumas TagIDs de exemplo, seus elementos e como a TagID é resolvida para um caminho absoluto no repositório:

A tabela a seguir mostra algumas TagIDs de exemplo, seus elementos e como a TagID é resolvida para um caminho absoluto no repositório :
A tabela a seguir mostra algumas TagIDs de exemplo, seus elementos e como a TagID é resolvida para um caminho absoluto no repositório :

TagID
Namespace ID local Tags do contêiner Tag Folha Repositório
Caminho absoluto da tag
dam:frut/apple/braeburn barragem fruta/maçã/queimadura fruta, maçã queimadura /content/cq:tags/dam/setor de frutas/apple/braeburn
cor/vermelho default cor/vermelho cor vermelho /content/cq:tags/default/color/red
céu default céu (nenhum) céu /content/cq:tags/default/sky
dam: barragem (nenhum) (nenhum) (nenhum, o namespace) /content/cq:tags/dam
/content/cq:tags/category/car categoria carro carro carro /content/cq:tags/category/car

Localização do título da tag

Quando a tag inclui a string de título opcional ( jcr:title), é possível localizar o título para exibição ao adicionar a propriedade jcr:title.<locale>.

Para obter mais detalhes, consulte

Controle de acesso

As tags existem como nós no repositório no nó raiz da taxonomia. Permitir ou negar que autores e visitantes do site criem tags em um determinado namespace pode ser obtido definindo ACLs apropriadas no repositório.

Além disso, negar permissões de leitura para determinadas tags ou namespaces controlará a capacidade de aplicar tags a conteúdo específico.

Uma prática típica inclui:

  • Permitir o acesso de gravação de tag-administrators grupo/função a todos os namespaces (adicionar/modificar em /content/cq:tags). Este grupo vem com AEM pronto para uso.

  • Permitir que usuários/autores leiam o acesso a todos os namespaces que devem ser legíveis a eles (em sua maioria, todos).

  • Permitir que usuários/autores gravem acesso aos namespaces, onde as tags devem ser definidas livremente por usuários/autores (add_node em /content/cq:tags/some_namespace)

Conteúdo marcável : cq:Taggable Mixin

Para que os desenvolvedores de aplicativos anexem marcação a um tipo de conteúdo, o registro do nó (CND) deve incluir a mistura cq:Taggable ou a mistura cq:OwnerTaggable.

A mistura cq:OwnerTaggable, que herda de cq:Taggable, destina-se a indicar que o conteúdo pode ser classificado pelo proprietário/autor. No AEM, é apenas um atributo do nó cq:PageContent. A combinação cq:OwnerTaggable não é exigida pela estrutura de marcação.

OBSERVAÇÃO

É recomendável ativar tags somente no nó de nível superior de um item de conteúdo agregado (ou em seu nó jcr:content). Os exemplos incluem:

  • páginas ( cq:Page) onde o nó jcr:contenté do tipo cq:PageContent que inclui a mistura cq:Taggable.

  • ativos ( cq:Asset) em que o nó jcr:content/metadata sempre tem a combinação cq:Taggable.

Notação de tipo de nó (CND)

As definições de Tipo de nó existem no repositório como arquivos CND. A notação CND é definida como parte da documentação JCR aqui.

As definições essenciais para os Tipos de nó incluídos no AEM são as seguintes:

[cq:Tag] > mix:title, nt:base
    orderable
    - * (undefined) multiple
    - * (undefined)
    + * (nt:base) = cq:Tag version

[cq:Taggable]
    mixin
    - cq:tags (string) multiple

[cq:OwnerTaggable] > cq:Taggable
    mixin

Conteúdo marcado: cq:tags Propriedade

A propriedade cq:tags é uma matriz de string usada para armazenar uma ou mais TagIDs quando elas são aplicadas ao conteúdo por autores ou visitantes do site. A propriedade só tem significado quando adicionada a um nó que é definido com a combinação [cq:Taggable](#taggable-content-cq-taggable-mixin).

OBSERVAÇÃO

Para aproveitar AEM funcionalidade de marcação, os aplicativos desenvolvidos e personalizados não devem definir propriedades de tag diferentes de cq:tags.

Mover e mesclar tags

Veja a seguir uma descrição dos efeitos no repositório ao mover ou mesclar tags usando o Tagging console:

  • Quando uma tag A é movida ou mesclada na tag B em /content/cq:tags:

    • a tag A não é excluída e obtém uma propriedade cq:movedTo .
    • A tag B é criada (no caso de um movimento) e obtém uma propriedade cq:backlinks .
  • cq:movedTo aponta para a tag B. Essa propriedade significa que a tag A foi movida ou mesclada na tag B. Mover a tag B atualizará essa propriedade de acordo. A tag A fica oculta e é mantida somente no repositório para resolver IDs de tag em nós de conteúdo que apontam para a tag A. O coletor de lixo de tag remove tags como a tag A, uma vez que mais nós de conteúdo apontam para elas.
    Um valor especial para a propriedade cq:movedTo é nirvana: ela é aplicada quando a tag é excluída, mas não pode ser removida do repositório porque há subtags com um cq:movedTo que devem ser mantidas.

    OBSERVAÇÃO

    A propriedade cq:movedTo só será adicionada à tag movida ou mesclada se uma dessas condições for atendida:

    1. A tag é usada no conteúdo (o que significa que tem uma referência) OU
    2. A tag tem filhos que já foram movidos.
  • cq:backlinks mantém as referências na outra direção, ou seja, mantém uma lista de todas as tags que foram movidas para ou mescladas com a tag B. Isso é necessário principalmente para manter cq:movedToas propriedades atualizadas quando a tag B é movida/mesclada/excluída, ou quando a tag B é ativada, nesse caso, todas as tags de backlinks também devem ser ativadas.

    OBSERVAÇÃO

    A propriedade cq:backlinks só será adicionada à tag movida ou mesclada se uma dessas condições for atendida:

    1. A tag é usada no conteúdo (o que significa que tem uma referência) OU >
    2. A tag tem filhos que já foram movidos.
  • A leitura de uma propriedade cq:tags de um nó de conteúdo envolve a seguinte resolução:

    1. Se não houver correspondência em /content/cq:tags, nenhuma tag será retornada.

    2. Se a tag tiver uma propriedade cq:movedTo definida, a ID da tag referenciada será seguida.
      Essa etapa é repetida, desde que a tag seguida tenha uma propriedade cq:movedTo .

    3. Se a tag seguida não tiver uma propriedade cq:movedTo , a tag será lida.

  • Para publicar a alteração quando uma tag tiver sido movida ou mesclada, o nó cq:Tag e todos os seus backlinks devem ser replicados: isso é feito automaticamente quando a tag é ativada no console de administração de tags.

  • Posteriormente, as atualizações na propriedade cq:tags da página limpam automaticamente as referências "antigas". Isso é acionado porque a resolução de uma tag movida pela API retorna a tag de destino, fornecendo a ID da tag de destino.

OBSERVAÇÃO

O movimento das tags é diferente da migração das tags.

Migração de tags

As tags do Experience Manager 6.4 em diante são armazenadas em /content/cq:tags, que foram armazenadas anteriormente em /etc/tags. No entanto, em cenários em que o Adobe Experience Manager foi atualizado da versão anterior, as tags ainda estão presentes no local antigo /etc/tags. Em sistemas atualizados, as tags precisam ser migradas em /content/cq:tags.

OBSERVAÇÃO

Na página Propriedades da página de tags, é recomendável usar a ID da tag (geometrixx-outdoors:activity/biking) em vez de codificar o caminho da base da tag (por exemplo, /etc/tags/geometrixx-outdoors/activity/biking).

Para listar tags, com.day.cq.tagging.servlets.TagListServlet pode ser usado.

OBSERVAÇÃO

É recomendável usar a API do gerenciador de tags como recurso.

Se a instância de AEM atualizada suportar a API do TagManager

  1. No início do componente, a API do TagManager detecta se é uma instância de AEM atualizada. No sistema atualizado, as tags são armazenadas em /etc/tags.

  2. A API do TagManager é executada no modo de compatibilidade retroativa, o que significa que a API usa /etc/tags como o caminho base. Caso contrário, ele usará uma nova localização /content/cq:tags.

  3. Atualize o local das tags.

  4. Depois de migrar as tags para o novo local, execute o seguinte script:

import org.apache.sling.api.resource.*
import javax.jcr.*

ResourceResolverFactory resourceResolverFactory = osgi.getService(ResourceResolverFactory.class);
ResourceResolver resolver = resourceResolverFactory.getAdministrativeResourceResolver(null);
Session session = resolver.adaptTo(Session.class);

def queryManager = session.workspace.queryManager;
def statement = "/jcr:root/content/cq:tags//element(*, cq:Tag)[jcr:contains(@cq:movedTo,\'/etc/tags\') or jcr:contains(@cq:backlinks,\'/etc/tags\')]";
def query = queryManager.createQuery(statement, "xpath");

println "query = ${query.statement}\n";

def tags = query.execute().getNodes();


tags.each { node ->
  def tagPath = node.path;
  println "tag = ${tagPath}";

  if(node.hasProperty("cq:movedTo") && node.getProperty("cq:movedTo").getValue().toString().startsWith("/etc/tags"))
    {
     def movedTo = node.getProperty("cq:movedTo").getValue().toString();

     println "cq:movedTo = ${movedTo} \n";

     movedTo = movedTo.replace("/etc/tags","/content/cq:tags");
     node.setProperty("cq:movedTo",movedTo);
     } else if(node.hasProperty("cq:backlinks")){

     String[] backLinks = node.getProperty("cq:backlinks").getValues();
     int count = 0;

     backLinks.each { value ->
             if(value.startsWith("/etc/tags")){
                     println "cq:backlinks = ${value}\n";
                     backLinks[count] = value.replace("/etc/tags","/content/cq:tags");
    }
             count++;
     }

    node.setProperty("cq:backlinks",backLinks);
  }
}
session.save();

println "---------------------------------Success-------------------------------------"

O script busca todas as tags que têm /etc/tags no valor da propriedade cq:movedTo/cq:backLinks. Em seguida, ela repete o conjunto de resultados buscados e resolve os valores das propriedades cq:movedTo e cq:backlinks para os caminhos /content/cq:tags (no caso em que /etc/tags é detectado no valor ).

Se a instância de AEM atualizada for executada na interface de usuário clássica

OBSERVAÇÃO

A interface clássica não é compatível com tempo de inatividade zero e não é compatível com o novo caminho de base de tags. Se você quiser usar a interface do usuário clássica, /etc/tags precisa ser criada, em seguida, por cq-tagging reinicialização do componente.

No caso de instâncias de AEM atualizadas compatíveis com a API do TagManager e em execução na interface clássica:

  1. Depois que as referências ao caminho base da tag antiga /etc/tags forem substituídas usando tagId ou novo local da tag /content/cq:tags, você poderá migrar as tags para o novo local /content/cq:tags no CRX seguido de reinicialização do componente.

  2. Depois de migrar as tags para o novo local, execute o script acima mencionado.

Nesta página