AEM-Tagging-Framework aem-tagging-framework

So taggen Sie Inhalte und nutzen die AEM Tagging-Infrastruktur :

Tags: cq:Tag-Knotentyp tags-cq-tag-node-type

Die Funktion eines Tags wird im Repository in einem Knoten vom Typ cq:Tag. erfasst.

Ein Tag kann ein einfaches Wort sein (z. B. fruit) oder stellen eine hierarchische Taxonomie dar (z. B. fruit/apple, d. h. sowohl Obst im Allgemeinen als auch der spezifischere Apfel).

Tags werden durch eine eindeutige Tag-ID identifiziert.

Ein Tag verfügt über optionale Metainformationen wie einen Titel, lokalisierte Titel und eine Beschreibung. Der Titel sollte, falls vorhanden, auf Benutzeroberflächen anstelle der TagID angezeigt werden.

Das Tagging-Framework bietet außerdem die Möglichkeit, Autoren und Website-Besuchern die Verwendung bestimmter, vordefinierter Tags vorzugeben.

Tag-Eigenschaften tag-characteristics

TagID (Tag-ID) tagid

Eine TagID identifiziert einen Pfad, der einen Tag-Knoten im Repository ergibt.

In der Regel wird die TagID ist eine Kurzform, die mit dem -Namespace beginnt oder absolut beginnend mit der Stammknoten der Taxonomie.

Wenn Inhalt mit Tags versehen ist und noch nicht vorhanden ist, wird die cq:tags -Eigenschaft zum Inhaltsknoten hinzugefügt wird und die TagID wird zum String-Array-Wert der Eigenschaft hinzugefügt.

Die TagID besteht aus einem Namespace gefolgt von der lokalen TagID. Container-Tags weisen untergeordnete Tags auf, die eine hierarchische Reihenfolge in der Taxonomie darstellen. Untergeordnete Tags können dazu verwendet werden, auf Tags genau wie auf eine andere lokale TagID zu verweisen. Beispielsweise ist es erlaubt, Inhalte mit dem Tag fruit zu versehen, auch wenn es sich um ein Container-Tag mit untergeordneten Tags handelt, z. B. fruit/apple oder fruit/banana.

Stammknoten der Taxonomie taxonomy-root-node

Der Stammknoten der Taxonomie ist der Basispfad für alle Tags im Repository. Der Stammknoten der Taxonomie darf kein Knoten vom Typ cq:Tag sein.

In AEM ist der Basispfad /content/cq:tags und der Stammknoten ist vom Typ cq:Folder.

Tag-Namespace tag-namespace

Namespaces erlauben Gruppeneinträge. Der häufigste Anwendungsfall besteht darin, einen Namespace pro Site (z. B. öffentlich, intern und portal) oder pro größerer Anwendung (z. B. Sites, Assets, Forms) zu verwenden. Namespaces können jedoch für verschiedene andere Anforderungen verwendet werden. Namespaces werden in der Benutzeroberfläche verwendet, um nur die Untergruppe von Tags (d. h. die Tags eines bestimmten Namespace) anzuzeigen, die auf den aktuellen Inhalt anwendbar sind.

Der Namespace des Tags ist die erste Ebene im Teilbaum der Taxonomie, der den Knoten direkt unterhalb des Stammknotens der Taxonomie darstellt. Ein Namespace ist ein Knoten vom Typ cq:Tag, dessen übergeordnetes Element nicht vom Knotentyp cq:Tag ist.

Alle Tags haben einen Namespace. Wenn kein Namespace angegeben ist, wird das Tag dem Standard-Namespace zugewiesen, der TagID default (Titel ist Standard Tags), das /content/cq:tags/default.

Container-Tags container-tags

Container-Tags sind Knoten vom Typ cq:Tag, die eine beliebige Anzahl untergeordneter Knoten von beliebigen Typen enthalten. Das ermöglicht die Erweiterung des Tag-Modells mit benutzerdefinierten Metadaten.

Darüber hinaus dienen Container-Tags (oder Super-Tags) in einer Taxonomie als Unter-Zusammenfassung aller Unter-Tags. Beispielsweise Inhalte, die mit fruit/apple wird als mit fruit sowie Das bedeutet, dass die Suche nach Inhalten nur mit fruit auch den Inhalt finden, mit dem fruit/apple.

Auflösen von Tag-IDs resolving-tagids

Wenn die Tag-ID einen Doppelpunkt enthält :, trennt der Doppelpunkt den Namespace vom Tag oder der Unter-Taxonomie, die dann durch normale Schrägstriche getrennt werden. /. Wenn in der Tag-ID kein Doppelpunkt vorkommt, ist der Standard-Namespace impliziert.

Der standardmäßige und einzige Speicherort von Tags befindet sich unter /content/cq:tags.

Verweisen auf nicht vorhandene Pfade oder Pfade, die nicht auf eine cq:Tag -Knoten werden als ungültig betrachtet und ignoriert.

Die folgende Tabelle zeigt einige Beispiele TagIDs, ihre Elemente und wie die TagID wird in einen absoluten Pfad im Repository aufgelöst.

Lokalisierung des Tag-Titels localization-of-tag-title

Wenn das Tag den optionalen Titelstring enthält (jcr:title) ist es möglich, den Titel zur Anzeige zu lokalisieren, indem die Eigenschaft jcr:title.<locale> > hinzugefügt wird.

Weitere Informationen finden Sie unter:

Zugriffssteuerung access-control

Tags bestehen als Knoten im Repository unter dem Stammknoten der Taxonomie. Sie können Autoren und Site-Besuchern die Möglichkeit geben, Tags in einem bestimmten Namespace zu erstellen oder zu verweigern, indem Sie entsprechende ACLs im Repository festlegen.

Außerdem wird durch das Verweigern von Leseberechtigungen für bestimmte Tags oder Namespaces die Fähigkeit gesteuert, Tags auf bestimmte Inhalte anzuwenden.

Eine typische Konfiguration umfasst:

Tag-barer Inhalt: cq:Taggable-Mixin taggable-content-cq-taggable-mixin

Damit Anwendungsentwickler einen Inhaltstyp mit Tags versehen können, muss die Registrierung eines Knotens (CND) das Mixin cq:Taggable oder das Mixin cq:OwnerTaggable umfassen.

Das Mixin cq:OwnerTaggable, das von cq:Taggable übernimmt, soll anzeigen, dass der Inhalt vom Besitzer/Autor klassifiziert werden kann. In AEM handelt es sich hierbei nur um ein Attribut des Knotens cq:PageContent. Das Mixin cq:OwnerTaggable wird vom Tagging-Framework nicht benötigt.

Knotentypnotation (CND) node-type-notation-cnd

Knotentypdefinitionen sind im Repository als CND-Dateien vorhanden. Die CND-Notation wird als Teil der JCR-Dokumentation hier definiert.

Die wichtigsten Definitionen für die Knotentypen in AEM sind wie folgt:

[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

Inhalt mit Tags: cq:tags-Eigenschaft tagged-content-cq-tags-property

Die cq:tags -Eigenschaft ist ein Zeichenfolgen-Array, mit dem eine oder mehrere TagIDist, wenn sie von Autoren oder Site-Besuchern auf Inhalte angewendet werden. Die Eigenschaft hat nur dann eine Bedeutung, wenn sie einem Knoten hinzugefügt wird, der mit dem Mixin cq:Taggable definiert wird.

Verschieben und Zusammenführen von Tags moving-and-merging-tags

Im Folgenden finden Sie eine Beschreibung der Auswirkungen, die im Repository auftreten, wenn Sie Tags mit der Tagging-Konsole verschieben oder zusammenführen:

Migration von Tags tags-migration

Ab Adobe Experience Manager 6.4 werden Tags unter /content/cq:tags. In Fällen, in denen Adobe Experience Manager ein Upgrade von der vorherigen Version erhielt, sind die Tags jedoch immer noch unter dem alten Speicherort /etc/tags vorhanden. In aktualisierten Systemen müssen Tags in /content/cq:tags.

Wenn die aktualisierte AEM-Instanz die TagManager-API unterstützt**

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

Das Skript ruft alle Tags ab, die /etc/tags im Wert der cq:movedTo/cq:backLinks-Eigenschaft haben. Anschließend wird der abgerufene Ergebnissatz schrittweise durchlaufen und die Eigenschaftswerte cq:movedTo und cq:backlinks werden in /content/cq:tags Pfade aufgelöst (in dem Fall, dass /etc/tags im Wert erkannt wird).

Wenn die aktualisierte AEM auf der klassischen Benutzeroberfläche ausgeführt wird**

Falls die aktualisierten AEM-Instanzen von der TagManager-API unterstützt werden und in der klassischen Benutzeroberfläche ausgeführt werden: