Estrutura de marcação do AEM aem-tagging-framework

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

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, fruit) ou representar uma taxonomia hierárquica (por exemplo, fruit/apple, ou seja, frutos em geral e 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 nas interfaces do usuário em vez de 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 tag-characteristics

TagID tagid

A TagID identifica um caminho que resolve um nó de tag no repositório.

Normalmente, a variável TagID é um encurtamento que começa com o namespace ou pode ser absoluto a partir do nó raiz da taxonomia.

Quando o conteúdo é marcado, se ainda não existir, a variável cq:tags é adicionada ao nó de conteúdo e a variável TagID é adicionado ao valor da matriz da string da propriedade.

O TagID consiste em um namespace seguido pelo TagID. Tags do contêiner têm subtags que representam uma ordem hierárquica na taxonomia. As subtags podem ser usadas para referenciar tags da mesma forma que qualquer TagID. Por exemplo, marcar conteúdo com fruit é permitido, mesmo que seja uma tag container com subtags , como fruit/apple e fruit/banana.

Nó raiz da taxonomia taxonomy-root-node

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

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

Namespace de tag tag-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, Sites, Assets, Forms), 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 da taxonomia, que é o nó imediatamente abaixo do nó raiz da taxonomia. Um namespace é um nó do tipo cq:Tag cujo pai não é um cq:Tag tipo de nó.

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 container-tags

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

Além disso, tags de contêiner (ou supertags) em uma taxonomia servem como subsoma de todas as subtags. Por exemplo, conteúdo marcado com fruit/apple é considerado como marcado com fruit também. Isso significa que a pesquisa de conteúdo foi apenas marcada com fruit também encontraria o conteúdo marcado com fruit/apple.

Resolvendo TagIDs resolving-tagids

Se a ID da tag contiver dois pontos :, o sinal de dois pontos separa o namespace da tag ou da subtaxonomia, que são entã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 /content/cq:tags.

Tag que faz referência a caminhos ou caminhos não existentes que não apontam para um cq:Tag são considerados inválidos e são ignorados.

A tabela a seguir mostra algumas amostras TagIDs, seus elementos e como a função TagID resolve para um caminho absoluto no repositório.

Localização do título da tag localization-of-tag-title

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 access-control

As tags existem como nós no repositório no nó raiz da taxonomia. Permitir ou negar aos autores e visitantes do site a capacidade de criar 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 configuração típica inclui:

Conteúdo marcável : cq:Taggable Mixin taggable-content-cq-taggable-mixin

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

O cq:OwnerTaggable mixin, 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 cq:PageContent nó . O cq:OwnerTaggable a mixin não é exigida pela estrutura de marcação.

Notação de tipo de nó (CND) node-type-notation-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. here.

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 tagged-content-cq-tags-property

O cq:tags é uma matriz de string usada para armazenar um ou mais TagIDs quando forem aplicadas ao conteúdo por autores ou visitantes do site. A propriedade só tem significado quando adicionada a um nó que é definido com a variável cq:Taggable mistura.

Mover e mesclar tags moving-and-merging-tags

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

Migração de tags tags-migration

No Adobe Experience Manager 6.4 em diante, as tags são armazenadas em /content/cq: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 para /content/cq:tags.

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

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 de cq:movedTo/cq:backLinks propriedade. Em seguida, ele repete por meio do conjunto de resultados buscados e resolve a variável cq:movedTo e cq:backlinks valores de propriedade para /content/cq:tags caminhos (no caso em que /etc/tags é detectado no valor).

Se a atualização da instância AEM for executada na interface clássica**

Caso as instâncias de AEM atualizadas sejam compatíveis com a API do TagManager e sejam executadas na interface clássica: