Verarbeiten von Assets mithilfe von Medien-Handlern und Workflows processing-assets-using-media-handlers-and-workflows

Adobe Experience Manager Assets enthält einen Satz von standardmäßigen Workflows und Medien-Handlern zur Bearbeitung von Assets. Der Workflow definiert die Aufgaben, die an Assets durchgeführt werden, und delegiert dann spezielle Aufgaben an die Medien-Handler, z. B. Erstellung von Miniaturbildern oder Extraktion von Metadaten.

Ein Workflow kann so konfiguriert werden, dass er automatisch ausgeführt wird, wenn ein Asset eines bestimmten MIME-Typs hochgeladen wird. Die Prozessschritte sind in Form einer Reihe von Assets-Medien-Handlern definiert. Experience Manager bietet verschiedene integrierte Handler. Zusätzliche Handler können entweder speziell entwickelt oder definiert werden, indem der Prozess an ein Befehlszeilen-Tool delegiert wird.

Medien-Handler sind Dienste innerhalb von Assets, die spezielle Aktionen an Assets durchführen. Wenn beispielsweise eine MP3-Audiodatei in Experience Manager hochgeladen wird, löst ein Workflow einen MP3-Handler aus, der die Metadaten extrahiert und ein Miniaturbild erstellt. Medien-Handler werden mit Workflows verwendet. Die meisten gängigen MIME-Typen werden in Experience Manager unterstützt. Spezielle Aufgaben können an Assets durchgeführt werden, indem Workflows erweitert bzw. erstellt, Medien-Handler erweitert bzw. erstellt oder Medien-Handler deaktiviert bzw. aktiviert werden.

NOTE
Unter Von Assets unterstützte Formate finden Sie eine Beschreibung aller Formate, die von Assets unterstützt werden, sowie Funktionen, die für jedes Format unterstützt werden.

Standard-Medien-Handler default-media-handlers

Die folgenden Medien-Handler sind in Assets verfügbar und verarbeiten die gängigsten MIME-Typen:

Handler-Name
Dienstname (in der Systemkonsole)
Unterstützte MIME-Typen
TextHandler
com.day.cq.dam.core.impl.handler.TextHandler
text/plain
PdfHandler
com.day.cq.dam.handler.standard.pdf.PdfHandler
  • application/pdf
  • application/illustrator
JpegHandler
com.day.cq.dam.core.impl.handler.JpegHandler
image/jpeg
Mp3Handler
com.day.cq.dam.handler.standard.mp3.Mp3Handler
audio/mpeg
Wichtig: Eine hochgeladene MP3-Datei wird mit einer Drittanbieterbibliothek verarbeitet. Die Bibliothek berechnet grob eine ungefähre Länge, wenn die MP3-Datei eine variable Bitrate (VBR) aufweist verfügt.
ZipHandler
com.day.cq.dam.handler.standard.zip.ZipHandler
  • application/java-archive
  • application/zip
PictHandler
com.day.cq.dam.handler.standard.pict.PictHandler
image/pict
StandardImageHandler
com.day.cq.dam.core.impl.handler.StandardImageHandler
  • image/gif
  • image/png
  • application/photoshop
  • image/jpeg
  • image/tiff
  • image/x-ms-bmp
  • image/bmp
MSOfficeHandler
com.day.cq.dam.handler.standard.msoffice.MSOfficeHandler
application/msword
MSPowerPointHandler
com.day.cq.dam.handler.standard.msoffice.MSPowerPointHandler
application/vnd.ms-powerpoint
OpenOfficeHandler
com.day.cq.dam.handler.standard.ooxml.OpenOfficeHandler
  • application/vnd.openxmlformats-officedocument.wordprocessingml.document
  • application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
  • application/vnd.openxmlformats-officedocument.presentationml.presentation
EPubHandler
com.day.cq.dam.handler.standard.epub.EPubHandler
application/epub+zip
GenericAssetHandler
com.day.cq.dam.core.impl.handler.GenericAssetHandler
Ausweichmöglichkeit, falls kein anderer Handler gefunden wurde, der Daten aus einem Asset extrahiert

Alle Handler führen folgende Aufgaben aus:

  • Extraktion aller verfügbaren Metadaten aus dem Asset.
  • Erstellung eines Miniaturbilds aus einem Asset.

So zeigen Sie die aktiven Medien-Handler an:

  1. Navigieren Sie im Browser zu https://localhost:4502/system/console/components.
  2. Klicken Sie auf com.day.cq.dam.core.impl.store.AssetStoreImpl.
  3. Eine Liste mit allen aktiven Medien-Handlern wird angezeigt. Beispiel:

chlimage_1-437

Verwenden von Medien-Handler in Workflows, um Aufgaben zur Bearbeitung von Assets durchzuführen using-media-handlers-in-workflows-to-perform-tasks-on-assets

Medien-Handler sind Dienste, die mit Workflows verwendet werden.

Experience Manager bietet verschiedene Standard-Workflows zur Verarbeitung von Assets. Um sie anzuzeigen, öffnen Sie die Workflow-Konsole und klicken Sie auf die Registerkarte Modelle: Die Workflow-Titel, die mit Assets beginnen, sind Asset-spezifische Workflows.

Bereits bestehende Workflows können erweitert und neue Workflows können erstellt werden, um Assets nach spezifischen Anforderungen zu bearbeiten.

Das folgende Beispiel zeigt, wie der AEM Assets-Synchronisierungs-Workflow erweitert werden kann, damit Teil-Assets für alle Assets außer PDF-Dokumente erstellt werden.

Deaktivieren oder Aktivieren von Medien-Handlern disabling-enabling-a-media-handler

Die Medien-Handler können über die Apache Felix Web Management-Konsole deaktiviert bzw. aktiviert werden. Wenn der Medien-Handler deaktiviert ist, werden seine Aufgaben nicht für die Assets ausgeführt.

So aktivieren/deaktivieren Sie einen Medien-Handler:

  1. Navigieren Sie im Browser zu https://<host>:<port>/system/console/components.
  2. Klicken Sie neben dem Namen des Medien-Handlers auf Deaktivieren. Beispiel: com.day.cq.dam.handler.standard.mp3.Mp3Handler.
  3. Aktualisieren Sie die Seite: Neben dem Medien-Handler wird ein Symbol angezeigt, das angibt, dass er deaktiviert ist.
  4. Um den Medien-Handler zu aktivieren, klicken Sie neben dem Namen des Medien-Handlers auf Aktivieren.

Erstellen eines Medien-Handlers creating-a-new-media-handler

Um einen neuen Medientyp zu unterstützen oder eine bestimmte Aufgabe an einem Asset durchzuführen, muss ein Medien-Handler erstellt werden. In diesem Abschnitt wird beschrieben, wie Sie dazu vorgehen.

Wichtige Klassen und Schnittstellen important-classes-and-interfaces

Am besten ist es, zu Beginn einer Implementierung den Inhalt einer bereitgestellten abstrakten Implementierung zu übernehmen, wodurch die meisten Dinge im Voraus erledigt werden und ein angemessenes Standardverhalten erreicht wird: die com.day.cq.dam.core.AbstractAssetHandler-Klasse.

Diese Klasse enthält bereits einen abstrakten Dienst-Deskriptor. Wenn Sie also den Inhalt dieser Klasse übernommen haben und das maven-sling-Plug-in verwenden, müssen Sie das Übernahme-Flag auf true setzen.

Implementieren Sie die folgenden Methoden:

  • extractMetadata(): extrahiert alle verfügbaren Metadaten.
  • getThumbnailImage(): erstellt ein Miniaturbild aus einem Asset.
  • getMimeTypes(): gibt die Asset-MIME-Typen zurück.

Hier eine Beispielvorlage:

package my.own.stuff; /** * @scr.component inherit="true" * @scr.service */ public class MyMediaHandler extends com.day.cq.dam.core.AbstractAssetHandler { // implement the relevant parts }

Schnittstelle und Klassen:

  • com.day.cq.dam.api.handler.AssetHandler-Schnittstelle: Diese Schnittstelle beschreibt den Dienst, der Unterstützung für bestimmte MIME-Typen hinzufügt. Wenn ein MIME-Typ hinzugefügt werden soll, muss diese Schnittstelle implementiert werden. Die Schnittstelle enthält Methoden zum Importieren und Exportieren der jeweiligen Dokumente, zum Erstellen von Miniaturbildern und zum Extrahieren von Metadaten.

  • com.day.cq.dam.core.AbstractAssetHandler-Klasse: Diese Klasse dient als Grundlage für alle anderen Asset-Handler-Implementierungen und bietet häufig verwendete Funktionen.

  • com.day.cq.dam.core.AbstractSubAssetHandler-Klasse:

    • Diese Klasse dient als Grundlage für alle anderen Asset-Handler-Implementierungen und bietet häufig verwendete Funktionen sowie übliche Funktion für die Extraktion von Teil-Assets.
    • Am besten ist es, zu Beginn einer Implementierung den Inhalt einer bereitgestellten abstrakten Implementierung zu übernehmen, wodurch die meisten Dinge im Voraus erledigt werden und ein angemessenes Standardverhalten erreicht wird: die com.day.cq.dam.core.AbstractAssetHandler-Klasse.
    • Diese Klasse enthält bereits einen abstrakten Dienst-Deskriptor. Wenn Sie also den Inhalt dieser Klasse übernommen haben und das maven-sling-Plug-in verwenden, müssen Sie das Übernahme-Flag auf „true“ setzen.

Die folgenden Methoden müssen implementiert werden:

  • extractMetadata(): Diese Methode extrahiert alle verfügbaren Metadaten.
  • getThumbnailImage(): Diese Methode erstellt ein Miniaturbild aus dem übergebenen Asset.
  • getMimeTypes(): Diese Methode gibt die Asset-MIME-Typen zurück.

Hier eine Beispielvorlage:

package my.own.stuff; /&ast;&ast; &ast; @scr.component inherit="true" &ast; @scr.service &ast;/ public class MyMediaHandler extends com.day.cq.dam.core.AbstractAssetHandler

Schnittstelle und Klassen:

  • com.day.cq.dam.api.handler.AssetHandler-Schnittstelle: Diese Schnittstelle beschreibt den Dienst, der Unterstützung für bestimmte MIME-Typen hinzufügt. Wenn ein MIME-Typ hinzugefügt werden soll, muss diese Schnittstelle implementiert werden. Die Schnittstelle enthält Methoden zum Importieren und Exportieren der jeweiligen Dokumente, zum Erstellen von Miniaturbildern und zum Extrahieren von Metadaten.
  • com.day.cq.dam.core.AbstractAssetHandler-Klasse: Diese Klasse dient als Grundlage für alle anderen Asset-Handler-Implementierungen und bietet häufig verwendete Funktionen.
  • com.day.cq.dam.core.AbstractSubAssetHandler-Klasse: Diese Klasse dient als Grundlage für alle anderen Asset-Handler-Implementierungen und bietet häufig verwendete Funktionen sowie übliche Funktionen für die Extrahierung von Teil-Assets.

Beispiel: Erstellung eines spezifischen Text-Handlers example-create-a-specific-text-handler

In diesem Abschnitt erstellen Sie einen spezifischen Text-Handler, der Miniaturbilder mit einem Wasserzeichen erstellt.

Gehen Sie wie folgt vor:

Unter Entwicklungs-Tools finden Sie Informationen zur Installation und Einrichtung von Eclipse mit einem Maven-Plug-in und zum Einrichten der Abhängigkeiten, die für das Maven-Projekt erforderlich sind.

Wenn Sie nach der Durchführung des folgenden Verfahrens eine Textdatei in Experience Manager hochladen, werden die Metadaten der Datei extrahiert und zwei Miniaturbilder mit einem Wasserzeichen erstellt.

  1. Erstellen Sie in Eclipse das Maven-Projekt myBundle:

    1. Klicken Sie in der Menüleiste auf Datei > Neu > Andere.

    2. Erweitern Sie im Dialogfeld den Maven-Ordner, wählen Sie das Maven-Projekt aus und klicken Sie auf Weiter.

    3. Aktivieren Sie das Kontrollkästchen „Einfaches Projekt erstellen“ sowie das Kontrollkästchen „Standard-Workspace-Speicherort verwenden“ und klicken Sie dann auf Weiter.

    4. Definieren Sie eine Maven-Projekt:

      • Gruppen-ID: com.day.cq5.myhandler.
      • Artefakt-ID: myBundle.
      • Name: Mein Experience Manager-Bundle.
      • Beschreibung: Das ist mein Experience Manager-Bundle.
    5. Klicken Sie auf Beenden.

  2. Setzen Sie den Java™-Compiler auf Version 1.5:

    1. Klicken Sie mit der rechten Maustaste auf das myBundle-Projekt und wählen Sie Eigenschaften aus.

    2. Wählen Sie Java™ Compiler aus und setzen Sie folgende Eigenschaften auf 1.5:

      • Compiler-Kompatibilitätsstufe
      • Kompatibilität von generierten .class-Dateien
      • Quellkompatibilität
    3. Klicken Sie auf OK. Klicken Sie im Dialogfenster auf Ja.

  3. Ersetzen Sie den Code in der pom.xml-Datei durch folgenden Code:

    code language-xml
    <project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <!-- ====================================================================== -->
     <!-- P A R E N T P R O J E C T D E S C R I P T I O N -->
     <!-- ====================================================================== -->
     <parent>
      <groupId>com.day.cq.dam</groupId>
      <artifactId>dam</artifactId>
      <version>5.2.14</version>
      <relativePath>../parent</relativePath>
     </parent>
     <!-- ====================================================================== -->
     <!-- P R O J E C T D E S C R I P T I O N -->
     <!-- ====================================================================== -->
     <groupId>com.day.cq5.myhandler</groupId>
     <artifactId>myBundle</artifactId>
     <name>My CQ5 bundle</name>
     <version>0.0.1-SNAPSHOT</version>
     <description>This is my CQ5 bundle</description>
     <packaging>bundle</packaging>
     <!-- ====================================================================== -->
     <!-- B U I L D D E F I N I T I O N -->
     <!-- ====================================================================== -->
     <build>
      <plugins>
       <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-scr-plugin</artifactId>
       </plugin>
       <plugin>
        <groupId>org.apache.sling</groupId>
        <artifactId>maven-sling-plugin</artifactId>
        <configuration>
         <slingUrlSuffix>/libs/dam/install/</slingUrlSuffix>
        </configuration>
       </plugin>
       <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
         <instructions>
          <Bundle-Category>cq5</Bundle-Category>
          <Export-Package> com.day.cq5.myhandler </Export-Package>
         </instructions>
        </configuration>
       </plugin>
      </plugins>
     </build>
     <!-- ====================================================================== -->
     <!-- D E P E N D E N C I E S -->
     <!-- ====================================================================== -->
     <dependencies>
      <dependency>
       <groupId>com.day.cq.dam</groupId>
       <artifactId>cq-dam-api</artifactId>
       <version>5.2.10</version>
       <scope>provided</scope>
      </dependency>
      <dependency>
       <groupId>com.day.cq.dam</groupId>
       <artifactId>cq-dam-core</artifactId>
       <version>5.2.10</version>
       <scope>provided</scope>
      </dependency>
      <dependency>
       <groupId>com.day.cq</groupId>
       <artifactId>cq-commons</artifactId>
      </dependency>
      <dependency>
       <groupId>javax.jcr</groupId>
       <artifactId>jcr</artifactId>
      </dependency>
      <dependency>
       <groupId>org.apache.felix</groupId>
       <artifactId>org.osgi.compendium</artifactId>
      </dependency>
      <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
      </dependency>
      <dependency>
       <groupId>commons-lang</groupId>
       <artifactId>commons-lang</artifactId>
      </dependency>
      <dependency>
       <groupId>commons-collections</groupId>
       <artifactId>commons-collections</artifactId>
      </dependency>
      <dependency>
       <groupId>commons-io</groupId>
       <artifactId>commons-io</artifactId>
      </dependency>
      <dependency>
       <groupId>com.day.commons</groupId>
       <artifactId>day-commons-gfx</artifactId>
      </dependency>
      <dependency>
       <groupId>com.day.commons</groupId>
       <artifactId>day-commons-text</artifactId>
      </dependency>
      <dependency>
       <groupId>com.day.cq.workflow</groupId>
       <artifactId>cq-workflow-api</artifactId>
      </dependency>
      <dependency>
       <groupId>com.day.cq.wcm</groupId>
       <artifactId>cq-wcm-foundation</artifactId>
       <version>5.2.22</version>
      </dependency>
     </dependencies>
    
  4. Erstellen Sie das Paket com.day.cq5.myhandler, das die Java™-Klassen unter myBundle/src/main/java enthält:

    1. Klicken Sie unter „myBundle“ mit der rechten Maustaste auf src/main/java, wählen Sie „Neu“ und dann „Paket“ aus.
    2. Benennen Sie es com.day.cq5.myhandler und klicken Sie auf „Fertigstellen“.
  5. Erstellen Sie die Java™-Klasse MyHandler:

    1. Klicken Sie in Eclipse unter myBundle/src/main/java mit der rechten Maustaste auf das Paket com.day.cq5.myhandler. Wählen Sie Neu und dann Klasse aus.
    2. Benennen Sie im Dialogfenster die Java™-Klasse MyHandler und klicken Sie auf Fertigstellen. Eclipse erstellt und öffnet die Datei MyHandler.java.
    3. Ersetzen Sie in MyHandler.java den vorhandenen Code durch Folgendes und speichern Sie dann die Änderungen:
    code language-java
    package com.day.cq5.myhandler;
    import java.awt.Color;
    import java.awt.Rectangle;
    import java.awt.image.BufferedImage;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import javax.jcr.Node;
    import javax.jcr.RepositoryException;
    import javax.jcr.Session;
    import org.apache.commons.io.IOUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import com.day.cq.dam.api.metadata.ExtractedMetadata;
    import com.day.cq.dam.core.AbstractAssetHandler;
    import com.day.image.Font;
    import com.day.image.Layer;
    import com.day.cq.wcm.foundation.ImageHelper;
    
    /**
     * The <code>MyHandler</code> can extract text files
     * @scr.component inherit="true" immediate="true" metatype="false"
     * @scr.service
     *
     **/
    
    public class MyHandler extends AbstractAssetHandler {
     /** * Logger instance for this class. */
     private static final Logger log = LoggerFactory.getLogger(MyHandler.class);
     /** * Music icon margin */
     private static final int MARGIN = 10;
     /** * @see com.day.cq.dam.api.handler.AssetHandler#getMimeTypes() */
     public String[] getMimeTypes() {
      return new String[] {"text/plain"};
     }
    
     public ExtractedMetadata extractMetadata(Node asset) {
      ExtractedMetadata extractedMetadata = new ExtractedMetadata();
      InputStream data = getInputStream(asset);
      try {
       // read text data
       InputStreamReader reader = new InputStreamReader(data);
       char[] buffer = new char[4096];
       String text = "";
       while (reader.read(buffer) != -1) {
        text += new String(buffer);
       }
       reader.close();
       long wordCount = this.wordCount(text);
       extractedMetadata.setProperty("text", text);
       extractedMetadata.setMetaDataProperty("Word Count",wordCount);
       setMimetype(extractedMetadata, asset);
      } catch (Throwable t) {
       log.error("handling error: " + t.toString(), t);
      } finally {
       IOUtils.closeQuietly(data);
      }
      return extractedMetadata; }
     // ----------------------< helpers >----------------------------------------
     protected BufferedImage getThumbnailImage(Node node) {
      ExtractedMetadata metadata = extractMetadata(node);
      final String text = (String) metadata.getProperty("text");
      // create text layer
      final Layer layer = new Layer(500, 600, Color.WHITE);
      layer.setPaint(Color.black);
      Font font = new Font("Arial", 12);
      String displayText = this.getDisplayText(text, 600, 12);
      if(displayText!=null && displayText.length() > 0) {
       // commons-gfx Font class would throw IllegalArgumentException on empty or null text
       layer.drawText(10, 10, 500, 600, displayText, font, Font.ALIGN_LEFT, 0, 0);
      }
      // create watermark and merge with text layer
      Layer watermarkLayer;
      try {
       final Session session = node.getSession();
       watermarkLayer = ImageHelper.createLayer(session, "/content/dam/we-retail/en/products/apparel/gloves/Gloves.jpg");
       watermarkLayer.setX(MARGIN);
       watermarkLayer.setY(MARGIN);
       layer.merge(watermarkLayer);
      } catch (RepositoryException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
      } catch (IOException e) {
       // TODO Auto-generated catch block
       e.printStackTrace(); }
      layer.crop(new Rectangle(510, 600));
      return layer.getImage(); }
     // ---------------< private >-----------------------------------------------
     /**
      * This method cuts lines if the text file is too long..
      * * @param text
      * * text to check
      * * @param height
      * * text box height (px)
      * * @param fontheight
      * * font height (px)
      * * @return the text which will fit into the box
      */
     private String getDisplayText(String text, int height, int fontheight) {
      String trimmedText = text.trim();
      int numOfLines = height / fontheight;
      String lines[] = trimmedText.split("\n");
      if (lines.length <= numOfLines) {
       return trimmedText;
      } else {
       String cuttetText = "";
       for (int i = 0; i < numOfLines; i++) {
        cuttetText += lines[i] + "\n";
       }
       return cuttetText;
      }
     }
     /**
      * * This method counts the number of words in a string
      * * @param text the String whose words would like to be counted
      * * @return the number of words in the string
      * */
     private long wordCount(String text) {
      // We need to keep track of the last character, if we have two whitespaces in a row we do not want to double count.
      // The starting of the document is always a whitespace.
      boolean prevWhiteSpace = true;
      boolean currentWhiteSpace = true;
      char c; long numwords = 0;
      int j = text.length();
      int i = 0;
      while (i < j) {
       c = text.charAt(i++);
       if (c == 0) { break; }
       currentWhiteSpace = Character.isWhitespace(c);
       if (currentWhiteSpace && !prevWhiteSpace) { numwords++; }
       prevWhiteSpace = currentWhiteSpace;
      }
      // If we do not end with a whitespace then we need to add one extra word.
      if (!currentWhiteSpace) { numwords++; }
      return numwords;
     }
    }
    
  6. Kompilieren Sie die Java™-Klasse und erstellen Sie das Bundle:

    1. Klicken Sie mit der rechten Maustaste auf das myBundle-Projekt, wählen Sie Ausführen als und dann Maven Install aus.
    2. Das Bundle myBundle-0.0.1-SNAPSHOT.jar (das die kompilierte Klasse enthält) wird unter myBundle/target erstellt.
  7. Erstellen Sie in CRX Explorer einen neuen Knoten unter /apps/myApp. Name = install, Typ = nt:folder.

  8. Kopieren Sie das Bundle myBundle-0.0.1-SNAPSHOT.jar und speichern Sie es unter /apps/myApp/install (zum Beispiel mit WebDAV). Der neue Text-Handler ist jetzt in Experience Manager aktiv.

  9. Öffnen Sie im Browser die Apache Felix Web Management Console. Wählen Sie die Registerkarte Komponenten aus und deaktivieren Sie den Standard-Text-Handler com.day.cq.dam.core.impl.handler.TextHandler.

Befehlszeilenbasierter Medien-Handler command-line-based-media-handler

Mit Experience Manager können Sie ein beliebiges Befehlszeilen-Tool (z. B. ImageMagick) innerhalb eines Workflows ausführen, um Assets zu konvertieren und dem Asset die neue Ausgabedarstellung hinzuzufügen. Sie müssen lediglich das Befehlszeilen-Tool auf dem Datenträger installieren, der den Experience Manager-Server hostet, dem Workflow einen Prozessschritt hinzufügen und diesen konfigurieren. Der aufgerufene Prozess CommandLineProcess ermöglicht zudem die Filterung nach spezifischen MIME-Typen und die Erstellung mehrerer Miniaturbilder auf Grundlage des neuen Ausgabeformats.

Die folgenden Konvertierungen können automatisch ausgeführt und in Assets gespeichert werden:

  • EPS- und AI-Umwandlung mithilfe von ImageMagick und Ghostscript.
  • FLV-Videotranskodierung mithilfe von FFmpeg.
  • MP3-Kodierung mithilfe von LAME.
  • Verarbeitung von Audiodaten mithilfe von SOX.
NOTE
Auf Nicht-Windows-Systemen gibt das FFMpeg-Tool einen Fehler aus, wenn Ausgabedarstellungen für ein Video-Asset erstellt werden, dessen Dateiname ein einfaches Anführungszeichen (') enthält. Wenn der Name Ihrer Videodatei ein einfaches Anführungszeichen enthält, entfernen Sie es, bevor Sie das Asset auf Experience Manager hochladen.

Der Prozess CommandLineProcess führt folgende Vorgänge in der angegebenen Reihenfolge aus:

  • Filtert die Datei nach bestimmten MIME-Typen, falls angegeben.
  • Erstellt ein temporäres Verzeichnis auf dem Datenträger, der den Experience Manager-Server hostet.
  • Streamt die Originaldatei in das temporäre Verzeichnis.
  • Führt den Befehl aus, der über die Argumente des Schritts definiert ist. Der Befehl wird innerhalb des temporären Verzeichnisses ausgeführt, nachdem die Genehmigung der Benutzerinnen oder Benutzer eingeholt wurde, die Experience Manager ausführen.
  • Streamt das Ergebnis zurück in den Ausgabeordner des Experience Manager-Servers.
  • Löscht das temporäre Verzeichnis.
  • Erstellt Miniaturansichten auf der Grundlage dieser Ausgabeformate, falls angegeben. Die Anzahl und die Abmessungen der Miniaturansichten werden durch die Argumente des Schritts definiert.

Ein Beispiel mit ImageMagick an-example-using-imagemagick

Das folgende Beispiel zeigt, wie Sie den Befehlszeilen-Prozessschritt so einrichten, dass jedes Mal, wenn ein Asset mit dem MIME-Typ GIF oder TIFF zu /content/dam auf dem Experience Manager-Server hinzugefügt wird, ein gespiegeltes Bild des Originals erstellt wird. Außerdem werden drei weitere Miniaturbilder mit einer Größe von 140 x 100, 48 x 48 und 10 x 250 erstellt.

Verwenden Sie dafür ImageMagick. ImageMagick ist eine kostenlose Befehlszeilen-Software zum Erstellen, Bearbeiten und Zusammensetzen von Bitmap-Bildern.

Installieren Sie ImageMagick auf der Festplatte, auf der der Experience Manager-Server gehostet wird:

  1. Installieren Sie ImageMagick: Siehe ImageMagick-Dokumentation.

  2. Richten Sie das Tool so ein, dass Sie in der Befehlszeile convert ausführen können.

  3. Um festzustellen, ob das Tool ordnungsgemäß installiert wurde, führen Sie den Befehl convert -h über die Befehlszeile aus.

    Es wird ein Hilfebildschirm mit allen möglichen Optionen des Konvertierungs-Tools angezeigt.

    note note
    NOTE
    In manchen Versionen von Windows kann der Konvertierungsbefehl eventuell nicht ausgeführt werden, da er in Konflikt mit dem nativen Konvertierungsdienstprogramm steht, das Teil der Windows-Installation ist. In diesem Fall verwenden Sie den vollständigen Pfad für die ImageMagick-Software, die verwendet wird, um Bilddateien in Miniaturbilder zu konvertieren. Beispiel: "C:\Program Files\ImageMagick-6.8.9-Q16\convert.exe" -define jpeg:size=319x319 ${filename} -thumbnail 319x319 cq5dam.thumbnail.319.319.png.
  4. Um zu überprüfen, ob das Tool ordnungsgemäß ausgeführt wird, fügen Sie ein JPG-Bild in das Arbeitsverzeichnis ein und führen Sie dann den Befehl „convert <image-name>.jpg -flip <image-name>-flipped.jpg“ von der Befehlszeile aus. Ein gespiegeltes Bild wird dem Verzeichnis hinzugefügt. Fügen Sie dann den Befehlszeilen-Prozessschritt dem Workflow DAM-Update-Asset hinzu.

  5. Rufen Sie die Konsole Workflow auf.

  6. Bearbeiten Sie auf der Registerkarte Modelle das Modell DAM-Update-Asset.

  7. Ändern Sie die Argumente des Schritts Web-fähige Ausgabe in: mime:image/gif,mime:image/tiff,tn:140:100,tn:48:48,tn:10:250,cmd:convert ${directory}/${filename} -flip ${directory}/${basename}.flipped.jpg.

  8. Speichern Sie den Workflow.

Fügen Sie zum Testen des geänderten Workflows ein Asset zu /content/dam hinzu.

  1. Rufen Sie im Dateisystem ein TIFF-Bild Ihrer Wahl ab. Benennen Sie es in myImage.tiff um und kopieren Sie es in /content/dam, z. B. mithilfe von WebDAV.
  2. Rufen Sie die Konsole CQ5 DAM auf, z. B. https://localhost:4502/libs/wcm/core/content/damadmin.html.
  3. Öffnen Sie das Asset myImage.tiff und prüfen Sie, ob das gespiegelte Bild und die drei Miniaturbilder erstellt wurden.

Konfiguration des Prozessschritts CommandLineProcess configuring-the-commandlineprocess-process-step

In diesem Abschnitt wird beschrieben, wie die Prozess-Argumente des CommandLineProcess festgelegt werden.

Trennen Sie die Werte der Prozessargumente mithilfe von Kommas und beginnen Sie sie nicht mit einem Leerzeichen.

Argument-Format
Beschreibung
mime:<MIME-Typ>
Optionales Argument. Der Prozess wird angewendet, wenn das Asset den gleichen MIME-Typ wie das Argument hat.
Es können mehrere MIME-Typen definiert werden.
tn:<Breite>:<Höhe>
Optionales Argument. Der Prozess erstellt ein Miniaturbild mit den Abmessungen, die im Argument definiert sind.
Es können mehrere Miniaturbilder definiert werden.
cmd: <Befehl>
Definiert den ausgeführten Befehl. Die Syntax hängt vom Befehlszeilen-Tool ab. Nur ein Befehl kann definiert werden.
Die folgenden Variablen können zum Erstellen des Befehls verwendet werden:
${filename}: Name der Eingabedatei, z. B. original.jpg
${file}: vollständiger Pfadname der Eingabedatei, z. B. /tmp/cqdam0816.tmp/original.jpg
${directory}: Verzeichnis der Eingabedatei, z. B. /tmp/cqdam0816.tmp
${basename}: Name der Eingabedatei ohne Erweiterung, z. B. original
${extension}: Erweiterung der Eingabedatei, z. B. JPG.

Wenn beispielsweise ImageMagick auf dem Datenträger installiert ist, der den Experience Manager-Server hostet, und Sie einen Prozessschritt mithilfe von CommandLineProcess als Implementierung erstellen und die folgenden Werte als Prozessargumente verwenden:

mime:image/gif,mime:image/tiff,tn:140:100,tn:48:48,tn:10:250,cmd:convert ${directory}/${filename} -flip ${directory}/${basename}.flipped.jpg

Wenn der Workflow dann ausgeführt wird, gilt der Schritt nur für Assets mit image/gif oder mime:image/tiff als mime-types. Es wird ein gespiegeltes Bild des Originals erstellt und in JPG konvertiert und es werden drei Miniaturbilder mit einer Größe von 140 x 100, 48 x 48 und 10 x 250 generiert.

Verwenden Sie die folgenden Prozessargumente, um die drei Standard-Miniaturbilder mithilfe von ImageMagick zu erstellen:

mime:image/tiff,mime:image/png,mime:image/bmp,mime:image/gif,mime:image/jpeg,cmd:convert ${filename} -define jpeg:size=319x319 -thumbnail "319x319>" -background transparent -gravity center -extent 319x319 -write png:cq5dam.thumbnail.319.319.png -thumbnail "140x100>" -background transparent -gravity center -extent 140x100 -write cq5dam.thumbnail.140.100.png -thumbnail "48x48>" -background transparent -gravity center -extent 48x48 cq5dam.thumbnail.48.48.png

Verwenden Sie die folgenden Prozessargumente, um die Web-fähige Ausgabe mithilfe von ImageMagick zu erstellen:

mime:image/tiff,mime:image/png,mime:image/bmp,mime:image/gif,mime:image/jpeg,cmd:convert ${filename} -define jpeg:size=1280x1280 -thumbnail "1280x1280>" cq5dam.web.1280.1280.jpeg

NOTE
Der Schritt CommandLineProcess gilt nur für Assets (Knoten des Typs dam:Asset) oder untergeordnete Elemente eines Assets.
recommendation-more-help
19ffd973-7af2-44d0-84b5-d547b0dffee2