AEM Taggningsramverk aem-tagging-framework

Så här taggar du innehåll och använder den AEM taggningsinfrastrukturen:

Taggar: cq:Tag Node Type tags-cq-tag-node-type

Deklarationen för en tagg hämtas i databasen i en nod av typen cq:Tag.

En tagg kan vara ett enkelt ord (t.ex. fruit) eller representerar en hierarkisk taxonomi (t.ex. fruit/apple, vilket innebär både frukt i allmänhet och mer specifikt äpple).

Taggar identifieras av ett unikt TagID.

En tagg har valfri metainformation, t.ex. en titel, lokaliserade titlar och en beskrivning. Titeln ska visas i användargränssnitt i stället för i TagID, om det finns.

Med taggningsramverket kan du även begränsa möjligheten för författare och besökare att endast använda specifika, fördefinierade taggar.

Märkordsegenskaper tag-characteristics

TaggID tagid

A TagID identifierar en sökväg som löses till en taggnod i databasen.

Vanligtvis är TagID är en kortskrift som börjar med namnutrymmet eller så kan det vara absolut från taxonomirotnod.

Om innehållet är taggat och inte finns än, cq:tags -egenskapen läggs till i innehållsnoden och TagID läggs till i egenskapens strängmatrisvärde.

The TagID består av en namespace följt av TagID. Behållartaggar har undertaggar som representerar en hierarkisk ordning i taxonomin. Undertaggar kan användas för att referera till taggar som är samma som alla lokala TagID. Exempel: tagga innehåll med fruit tillåts, även om det är en behållartagg med undertaggar, som fruit/apple och fruit/banana.

Taxonomirotnod taxonomy-root-node

Taxonomirotnoden är grundsökvägen för alla taggar i databasen. Taxonomirotnoden får inte vara en nod av typen cq:Tag.

I AEM är bassökvägen /content/cq:tags och rotnoden är av typen cq:Folder.

Namnutrymme för tagg tag-namespace

Namnutrymmen tillåter gruppobjekt. Det vanligaste användningsområdet är att ha ett namnutrymme per webbplats (t.ex. public, internal och portal) eller per större program (t.ex. Sites, Assets, Forms), men namnutrymmen kan användas för olika andra behov. Namnutrymmen används i användargränssnittet för att endast visa deluppsättningen taggar (d.v.s. taggar för ett visst namnutrymme) som är tillämpliga för det aktuella innehållet.

Taggens namnutrymme är den första nivån i taxonomiunderträdet, som är noden direkt under taxonomirotnod. Ett namnutrymme är en nod av typen cq:Tag vars överordnade inte är en cq:Tag nodtyp.

Alla taggar har ett namnutrymme. Om inget namnutrymme anges tilldelas taggen standardnamnutrymmet, som är TagID default (title is Standard Tags) som /content/cq:tags/default.

Behållartaggar container-tags

En behållartagg är en nod av typen cq:Tag som innehåller valfritt antal och valfri typ av underordnade noder, vilket gör det möjligt att förbättra taggmodellen med anpassade metadata.

Dessutom fungerar behållartaggar (eller supertaggar) i en taxonomi som delsummering av alla undertaggar. Innehåll som du t.ex. taggat med fruit/apple anses vara taggad med fruit också. Det innebär att sökning efter innehåll som är taggat med fruit söker även efter innehåll som taggats med fruit/apple.

Lösa tagg-ID:n resolving-tagids

Om tagg-ID:t innehåller ett kolon :avgränsar kolonet namnutrymmet från taggen eller undertaxonomin, som sedan avgränsas med normala snedstreck /. Om tagg-ID:t inte har ett kolon används standardnamnutrymmet.

Standardplatsen och den enda platsen för taggar är under /content/cq:tags.

Tagg som refererar till icke-befintliga banor eller banor som inte pekar på en cq:Tag noden betraktas som ogiltig och ignoreras.

I följande tabell visas några exempel TagIDs, deras element och hur TagID tolkas till en absolut sökväg i databasen.

Lokalisering av taggtitel localization-of-tag-title

När -taggen innehåller den valfria titelsträngen (jcr:title) går det att lokalisera titeln för visning genom att lägga till egenskapen jcr:title.<locale>.

Mer information finns i:

Åtkomstkontroll access-control

Taggar finns som noder i databasen under taxonomirotnod. Du kan göra det möjligt för skribenter och besökare att skapa taggar i ett givet namnutrymme genom att ange lämpliga åtkomstkontrollistor i databasen.

Om du dessutom nekar läsbehörighet för vissa taggar eller namnutrymmen kan du styra möjligheten att använda taggar för visst innehåll.

En typisk konfiguration innefattar:

Taggbart innehåll: cq:Taggable Mixin taggable-content-cq-taggable-mixin

För att programutvecklare ska kunna bifoga taggning till en innehållstyp, nodens registrering (CND) måste innehålla cq:Taggable blanda eller cq:OwnerTaggable blanda.

The cq:OwnerTaggable mixin, som ärver från cq:Taggable, är avsedd att indikera att innehållet kan klassificeras av ägaren/författaren. I AEM är det bara ett attribut för cq:PageContent nod. The cq:OwnerTaggable mixin krävs inte av taggningsramverket.

Nodtypsnotation (CND) node-type-notation-cnd

Det finns nodtypsdefinitioner i databasen som CND-filer. CND-notation definieras som en del av JCR-dokumentationen här.

De viktigaste definitionerna för de nodtyper som ingår i AEM är följande:

[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

Taggat innehåll: cq:tagg, egenskap tagged-content-cq-tags-property

The cq:tags egenskapen är en strängmatris som används för att lagra en eller flera TagIDnär de tillämpas på innehåll av författare eller webbplatsbesökare. Egenskapen har bara betydelse när den läggs till i en nod som definieras med cq:Taggable blanda.

Flytta och sammanfoga taggar moving-and-merging-tags

Nedan följer en beskrivning av effekterna i databasen när du flyttar eller sammanfogar taggar med Taggningskonsol:

Migrering av taggar tags-migration

I Adobe Experience Manager 6.4 och senare lagras taggar under /content/cq:tags. Om Adobe Experience Manager har uppgraderats från en tidigare version finns dock taggarna kvar på den gamla platsen /etc/tags. I uppgraderade system måste taggar migreras till /content/cq:tags.

Om uppgraderad AEM instans stöder TagManager API**

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-------------------------------------"

Skriptet hämtar alla taggar som har /etc/tags i värdet av cq:movedTo/cq:backLinks -egenskap. Sedan itereras den genom den hämtade resultatuppsättningen och löser problemet cq:movedTo och cq:backlinks egenskapsvärden till /content/cq:tags banor (i det fall där /etc/tags identifieras i värdet).

Om den uppgraderade AEM instansen körs i det klassiska användargränssnittet**

Om de uppgraderade AEM-instanserna stöds av TagManager API och körs i Classic UI: