Archiv der Kategorie: Taxonomien

Es geht auch ohne Views: Anzahl Rezepte zu einer Kategorie ausgeben

Ich hab ja redlich versucht, mehr über die Parameterübergabe an Views herauszufinden, aber ganz ehrlich: das war mir alles zu esoterisch, und viel zu kompliziert – man muss ja nicht unbedingt mit Kanonen auf Spatzen schiessen. Ich möchte nach wie vor eine Ausgabe so in der Art:

316 Rezepte insgesamt

111 davon Vegetarisch

Jetzt hab ich einfach die Anforderung ein bisschen geändert: ich lasse den Benutzer auswählen, zu welcher Kategorie er die Anzahl der Rezepte ausgegeben haben möchte. Also dann, auf gehts!

Wie man Drupal eigenen PHP-Code unterschiebt

.. hab ich in diesem Artikel beschrieben. Dafür erstellt man sich ein einfaches Modul, in dem man seine eigenen Funktionen unterbringt. Dann kan man sich zum Beispiel auch einen eigenen Block definieren, in dem man schlicht und ergreifend eine eigene PHP-Funktion aufruft, und den kann man dann positionieren wo man ihn gern haben möchte.

Die Gesamtzahl der Rezepte

Das ist easy, wir selektieren alle Rezepte mit Status1 = veröffentlicht und holen uns die Anzahl mit rowCount:

//Datenbankabfrage für die Gesamtzahl der Rezepte
    $query = db_query("SELECT * FROM node WHERE type like 'rezept' AND status = 1");
    $anzahl = $query->rowCount();
    echo "<h2>".$anzahl." Rezepte insgesamt </h2><br>";

Auswahl der Kategorien über Dropdown-Feld

Dafür basteln wir uns ein Formular mit einer Options-Liste und füttern diese mit einer Datenbankabfrage.

//Datenbankabfrage für das Optionsfeld
    $query = db_query("SELECT * FROM taxonomy_term_data WHERE vid = 2");
    $records = $query->fetchAll();

Ich habe hier die Kategorie Rezepte mit der vid = 2 fest verdrahtet. Das Abfrageergebnis schieben wir so in das Formular rein:

//Beginn Formular    
        echo "<h3>Kategorie auswählen</h3>";

        echo "<form action='#' method='post'>";

        //Beginn des Dropdownmenü
        echo '<select name="Name">';
        
        //hier kommen nun die Werte für die Options rein
        foreach ($records as $record){
               echo '<option>'.$record->name.'</option>';
        }
        echo "</select>";

        echo "<input type='submit' name='absenden' value='Anzahl ausgeben'>";
        echo "</form>";
//End Formular

Am Ende kommt noch ein Submit-Button, und das war, wir haben jetzt unsere Dropdown-Liste mit den Kategorienamen gefüllt.

dropdown_kategorien
dropdown_kategorien

Wenn jetzt der Anwender eine Kategorie ausgewählt hat, muss er noch auf den Button „Anzahl ausgeben“ klicken, dann legen wir los.

auswahl
auswahl

Mit einem if(isset)… fragen wir ab, ob der Submit-Button gedrückt wurde. Dann holen wir uns den Wert aus dem Dropdown-Feld mit $_POST[‚Name‘] und machen zwei kleine Datenbankabfragen. In der ersten holen wir uns die tid zum ausgewählten Kategorienamen, in der zweiten zählen wir, wie oft diese tid mit einem Rezept verknüpft wurde:

if (isset($_POST['absenden'])){
// tid zum Namen der Kategorie holen
    $query = db_query("Select tid from taxonomy_term_data where name like '".$_POST['Name']."'");
    $akt_katid = $query->fetchField();
    
    //Zählen, wieviele Rezepte zur tid vorhanden sind
    $query = db_query("SELECT * FROM taxonomy_index where tid = ".$akt_katid."");
    $anzahl = $query->rowCount();
    
    echo $anzahl." Rezepte zur Kategorie ".$_POST['Name']."<br>";
} //End if isset absenden

Und am Ende geben wir unsere Ergebnisse noch aus.

Wenn man es ganz genau machen wollte, müsste man in die Abfrage für die Anzahl noch einen Join über die nid (Node ID) der Rezepte auf die Tabelle nodes machen und nur alle selektieren, die den Status 1=veröffentlicht haben, aber ich lass es mal so stehen. Meine Ausgabe sieht dann so aus:

111vegetarisch
111vegetarisch

Damit das ganze ein bisschen mehr Nährwert kriegt, legen wir auf den Namen der Kategorie jetzt noch einen Link, der uns dann die Seite der gewählten Kategorie aufruft. Die URL unserer Seite holen wir mit global $base_url; daraus bauen wir dann den Link:

global $base_url;
        
$html_string = '<a href=' . $base_url . '/taxonomy/term/'.$akt_katid.'>'.$_POST['Name'].'</a>';
    echo $html_string;

Das wars jetzt aber, das lass ich so stehen. Ich finde es für einen Block sogar recht gut, weil es nicht so viel Platz wegnimmt wie die View mit allen Kategorien untereinander, das Dropdown-Feld ist da deutlich kompakter.

mit_link_zur_kategorie
mit_link_zur_kategorie

 

Drupal nach WordPress: Beiträge mit Kategorien erzeugen

Kurze Wiederholung: unsere Import-Tabelle sieht folgendermassen aus:

ersterwert_letzterwert
ersterwert_letzterwert

Dabei sind die Ersterwert/Letzterwert Felder die term_ids aus WordPress. Ich vegebe mal noch hübschere Feldnamen und hole zum Testen nur eine Handvoll Datensätze:

neue_feldnamen
neue_feldnamen

 

Wir bauen jetzt unser Import-Plugin entsprechend um. Der Select bleibt gleich, der Tabellenname liegt auf der Variablen $akt_import:

global $wpdb;
    $allezeilen = $wpdb->get_results( "SELECT * from ".$akt_import."");

Innerhalb der Foreach-Schleife konstruieren wir uns jetzt unsere neuen Beiträge:

foreach ($allezeilen as $zeile){
        
        $akt_titel = $zeile->title;
        $akt_body_value = $zeile->body_value;
        $akt_term_id1 = $zeile->term_id1;
        $akt_term_id2 = $zeile->term_id2;

        // Beitragsobjekt anlegen
        $my_post = array();
        $my_post['post_title']    = $akt_titel;
        $my_post['post_content']  = $akt_body_value;
        $my_post['post_status']   = 'publish';
        $my_post['post_author']   = 1;
        $my_post['post_category'] = array( $akt_term_id1,$akt_term_id2 );

        // Beitrag in Datenbank einfügen
        $neue_id = wp_insert_post( $my_post );
        echo "Beitrag mit neuer ID: ".$neue_id." angelegt <br><br>";
        
    } //end foreach

Erst wird das Array für das neue Beitragsobjekt mit den Datenfeldern aus der aktuellen Zeile gefüllt, und dann mit wp_insert_post der neue Beitrag angelegt. Das wars schon! Alle Rezepte mitsamt Kategorien werden erzeugt.

import_komplett
import_komplett

Natürlich muss man an der Logik noch ein bisschen rumschrauben, wenn man mehr als zwei Kategorien pro Rezept importieren will, aber prinzipiell funktioniert die Sache so, das geht eigentlich ganz unkompliziert, wenn man die Export-Tabelle einmal konstruiert hat.

Meine Export-Datei, und wie man die Nodes jetzt tatsächlich anlegt

Ich hab mir die Tabelle taxonomy_term_data aus Drupal ins Access überspielt und mit meinen WordPress-Tabellen verknüpft, so komme ich an die tag-IDs. Das läuft genau wie bei der Erzeugung der Export-Datei in Joomla, nachzulesen hier in meinem Artikel über das Tag-Mapping. Das vorläufige Endergebnis habe ich mal auf 24 Rezepte beschränkt, aussehen tut es so:

24_rezepte
24_rezepte

ID, post_content, post_name und titel kommen aus WordPress, die tags 1..3 sind die gemappten tag-IDs aus Drupal. Den post_content hab ich schon bereinigt, da sind schon alle Links draussen und alle Caption-Shortcodes entfernt, wie das geht habe ich in diesem Artikel beschrieben.

Ich habs mal auf maximal drei Tags beschränkt, das reicht zum Vorführen. Diese Tabelle kommt jetzt in die Drupal-Database mit rein, und dann wollen wir mal.

Vorbereitungen

Voraussetzung für den Import ist, dass das Modul „Blogs“ aktiviert und ein Menüpunkt für die Blogseite erstellt ist, wie das geht hab ich in diesem Artikel beschrieben. Dann ändern wir in unserem Source den node type auf blog:

$node->type = 'blog';

Der Import mit db_query

Die Import-Tabelle lesen wir wie gehabt mit einem db_query ein, ich hab hier mal für den ersten Test noch eine where-Klausel mit drin, um die Sache erstmal auf einen Datensatz zu beschränken:

//***exporttabelle einlesen
        $query = db_query("SELECT * FROM 24_export where id = 205");
        $records = $query->fetchAll();

Mit einem Foreach() holen wir uns die einzelnen Zeilen der Query und legen uns die Inhalte auf Variable:

foreach ($records as $record) {
                
                $akt_titel = $record->titel;
                $akt_content = $record->post_content;
                $akt_alias = $record->post_name;
                $akt_tag1 = $record->tag1;

            // hier kommt die Action hin

}

Query-Ergebnisse in Variable einlesen

Diese Variablen passen wir dann in die Kreation des Nodes ein.

$body_text = $akt_content;

                $node = new stdClass();
                $node->type = 'blog';
                node_object_prepare($node);

                $node->title    = $akt_titel;
                $node->language = LANGUAGE_NONE;

                $node->body[$node->language][0]['value']   = $body_text;
                //$node->body[$node->language][0]['summary'] = text_summary($body_text);
                $node->body[$node->language][0]['format']  = 'full_html';
                $node->promote = 0; //nicht auf der Starseite
                
                // Alias erzeugen, post_name aus WP übernehmen
                $path = $akt_alias;
                $node->path = array('alias' => $path);
                
                /**Taxonomy Term zuordnen*/
                //id of your taxonomy term
                $tid = $akt_tag1;

                //add term to a node field
                //field_yourfield_name - machine name of your term reference field

                $node->field_tags[$node->language][0]['tid'] = $tid;
                /** end taxonomy term zuordnen */
                
                node_save($node);

Tags mitnehmen

Ich hab erstmal nur einen tag mitgenommen, aber das lässt sich leicht ausbauen. Sicherheitshalber frag ich auch noch ab, ob das tag-Feld nicht leer ist:

/**Taxonomy Terms zuordnen*/
                //id of your taxonomy term
                
                if ($akt_tag1 != ""){
                $tid1 = $akt_tag1;
                $node->field_tags[$node->language][0]['tid'] = $tid1;
                }
                
                if ($akt_tag2 !=""){
                $tid2 = $akt_tag2;
                $node->field_tags[$node->language][]['tid'] = $tid2;
                }
                
                if ($akt_tag3 !=""){
                $tid3 = $akt_tag3;
                $node->field_tags[$node->language][]['tid'] = $tid3;
                }
                
                //**end taxonomy terms zuordnen

Achtung: man muss in den Zeilen:

$node->field_tags[$node->language][]['tid'] = $tid3;

… den Parameter hinter $node->language leer lassen [], sonst werden die folgenden Tags nicht hinzugefügt, sondern überschrieben, so dass dann nur der letzte Tag zugeordnet ist.

Import komplett

Das wars jetzt aber – meine 24 Rezepte hat Drupal klaglos in den Blog importiert, die erscheinen auch brav im Block „Neueste Blogeinträge“:

neueste_blogbeiträge
neueste_blogbeiträge

Auch die Kategorien und die URL-aliase sind korrekt zugeordnet. Das nenn ich Spaß auf der Datenbank! 🙂

Jetzt lassen wir uns doch gleich mal das Inhaltsverzeichnis ausgeben:

ivz_24
ivz_24

Da hätte ich noch eine kleine Korrektur der Source für das Inhaltsverzeichnis nachzuliefern, das Array mit den Buchstaben braucht noch Anführungsstricherl, das sollte so aussehen, sonst wirft es PHP-Warnings:

$alfa = array('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z');

Aber jetzt lass’mas gut sein, und nehmen eine Kaffeepause.

Drupal-Nodes programmatisch erzeugen

Node erstellen: ganz basic

Da ich ja nach wie vor auf über 300 Rezepten sitze, die ich nicht per Copy&Paste nach Drupal bringen will, hab ich mal nach Importmöglichkeiten gegooglet, und bin hier bei Group 42 fündig geworden. Der folgende Code erstellt einen Node vom Typ article, das funktioniert schon mal ganz gut. Was nicht so schön ist, ist dass die Sprache auf LANGUAGE_NONE gestellt wird, aber genau genommen stört das auch nicht weiter. Mal sehen, wie weit wir damit kommen. Hier der leicht modifizierte Code von Group 42:

/* Basic Node Creation Example for Drupal 7
        *
        * This example:
        * - Assumes a standard Drupal 7 installation
        * - Does not verify that the field values are correct
        */
        $body_text = '<h1>Text des neuen Nodes.</h1>';

        $node = new stdClass();
        $node->type = 'article';
        node_object_prepare($node);

        $node->title    = 'Node mit NID Evi full html';
        $node->language = LANGUAGE_NONE;

        $node->body[$node->language][0]['value']   = $body_text;
        //$node->body[$node->language][0]['summary'] = text_summary($body_text);
        $node->body[$node->language][0]['format']  = 'full_html';
        $node->promote = 0; //nicht auf der Starseite
        
        // Alias erzeugen, evtl. aus WP übernehmen
        //$path = 'content/programmatically_created_node_' . date('YmdHis');
        //$node->path = array('alias' => $path);

        node_save($node);

        echo "Node erzeugt, ID= ".$node->nid;

Besonders nützlich macht sich hier das:

node_object_prepare()

das nimmt einem schon einen Haufen Arbeit ab, indem es den neuen Node mit etlichen validen Werten vorbelegt, wer will kann das in der Drupal 7 API genauer nachlesen.

Eigentlich muss man jetzt nur noch den body text und den title mit eigenen Inhalten füttern, das könnte klappen. Das Format habe ich auf full_html gestellt, weil ich ja meine Überschriften-Headings aus WordPress übernehmen möchte.

Schön wärs natürlich, wenn man den alias auch gleich vernünftig anlegt, dafür könnte der post_name aus WordPress herhalten, aber das sehen wir dann schon noch, ob das was wird.

Kriegen wir die Kategorien als Tags hier auch mit rein?

Ja, kriegen wir! Und zwar mit folgender Ergänzung:

//id of your taxonomy term
        $tid = 8;

        //add term to a node field
        //field_yourfield_name - machine name of your term reference field

        $node->field_tags[$node->language][0]['tid'] = $tid;

Das macht man für mehrere Tags im Zweifelsfall einfach n mal. Damit sind wir bestens ausgerüstet und machen mal einen kurzen Break, weil ich erst in Access das Mapping von den WordPress-Kategorien auf die Drupal-Terms erstellen und mir eine vernünftige Export-Datei basteln muss.

WordPress-Kategorien als Drupal-Tags importieren

Bevor ich jetzt anfange, noch mehr Rezepte und Kategorien per Hand einzuhacken, schauen wir mal gleich, wie weit wir damit kommen diese aus WordPress zu importieren. Das wird eine ganz ähnliche Mechanik wie in Joomla werden, soviel kann ich jetzt schon absehen. Aber jetzt erstmal Schritt für Schritt. Und eine Warnung vorneweg: sowas macht man als Initial Load auf einer jungfräulichen Drupal-Instanz, wenn schon per Hand Kategorien als Tags angelegt wurden, hat man leicht doppelte Einträge und muss das dann erstmal bereinigen. Übrigens: kommen sie nicht auf die Idee, bereits vorhandene Tags einfach mit dem phpmyadmin aus der Datenbank zu löschen, das führt ganz schnell zu Inkonsistenzen!

Voraussetzungen

Wir ignorieren mal die Möglichkeit der geschachtelten Tags, die brauche ich nicht wirklich, eine Ebene reicht. Ich benutze auch das bereits vorhandene Vokabular Tags, das hat bei mir die vid=1. Die vorhandenen Taxonomien und vids sind  nachzuschauen in der Tabelle taxonomy_vocabulary, die zugehörigen Vocabulary-Einträge stecken in der taxonomy_term_data.

Ich brauche meine Kategorien zum Import in einer kleinen Tabelle, die hole ich mir aus Access und schubse sie als CSV nach MySQL rein.

Eine sehr praktische Funktion zum Import

Für den tatsächlichen Import benutze ich dann die Drupal-Funktion taxonomy_term_save($term). Die nimmt als Minimum-Parameter den Namen des Tags und die vid der Taxonomie, das sieht im ersten Testfall so aus:

    $name = 'Testwort2';
    $vid =1;
    $term = new stdClass();
    $term->name = $name;
    $term->vid = $vid;
    taxonomy_term_save($term);
    echo "Neuer Term erzeugt, ID = ".$term->tid;

Wichtig zu wissen: die Funktion erzeugt  immer einen neuen Eintrag in der taxonomy_term_data mit einer neuen tid, auch wenn der Name des Tags schon mal drinsteht. Ich gehe hier aber mal von einem Initial Load aus bzw. lösche vor dem Import die bereits vorhandenen Terms, die ich zum Testen manuell reingehackt habe, einfach raus.

Jetzt kommt unsere Import-Tabelle 00_kat_import ins Spiel, an der ist nicht viel dran, nur id und name, und die kennen wir auch schon:

kat_import_tabelle
kat_import_tabelle

Die lesen wir uns jetzt mit einem  db_query ein und speichern unsere neuen Terms in der Foreach-Schleife:

$query = db_query("SELECT name FROM 00_kat_import");
    $records = $query->fetchAll();
    
foreach ($records as $record) {
  
    // echo $record->name."<br>";
    $name = $record->name;
    $vid =1;
    $term = new stdClass();
    $term->name = $name;
    $term->vid = $vid;
    taxonomy_term_save($term);

  
} //end foreach

Und das war auch schon der ganze Zauber! Da sind die neuen Tags:

import_tags
import_tags

Diese Aktion macht man wie gesagt genau einmal als Initial Load. Wenn die Kategorien erstmal auf die Tags abgebildet sind, werden sie in Drupal weitergepflegt, sonst gibts allzuleicht Inkonsistenzen auf der Datenbank.

So, die Kategorien hätten wir schon mal. Jetzt bräuchten wir noch ein paar Rezepte…

Nachtrag: Kategorienliste mit Anzahl der Rezepte, und das IVZ V.0

Der Weg zur Kategorienliste mit der Anzahl der Rezepte war noch unvollständig. Das machen wir auch mit Views, ich schau mal dass ich es nachvollziehbar aufschreibe:

Struktur->Views->Add new->Namen vergeben, Anzeigen Taxonomie Begriffe of type Tags

Create a Block, Items per Page nehm ich mal 30 (brauch ich später noch), Continue & Edit.

Block Details->Advanced->Relationships->Taxonomie-Begriff Content with term, Use Aggregation

Fields->Inhalt (Titel)->Aggregation Type Count Distinct, im nächsten Fenster das Feld Bezeichnung leer machen.

Speichern. Block auf gewünschte Position setzen.

anzahl_kategorien
anzahl_kategorien

Wichtige Ergänzung: leere Kategorien ausblenden

Damit man Kategorien, die noch keinem Inhalt zugeordnet sind, nicht mit einem Kategoriename 0 angezeigt bekommt, kann man noch einen zweiten Eintrag unter Relationships hinzufügen, und zwar:

(Beitrag) Inhalt: Taxonomy terms on node

Dann muss man noch in Configure Relationship die Option

 

anhaken, und das wars.

Noch etwas Kosmetik

Es wäre jetzt natürlich schöner, wenn die Zahlen hinter dem Kategorienamen stehen würden statt in der nächsten Zeile darunter. Dazu in der View unter Format Anzeigen Fields Einstellungen bei den beiden Inline Fields Häkchen setzen:

inline_fields
inline_fields

So, das wars jetzt aber. Mein Block mit den Rezept-Kategorien sieht jetzt so aus:

distinct_rezeptkategorien
distinct_rezeptkategorien

Das kann so bleiben!

Als nächstes kommt das Inhaltsverzeichnis dran:

Alle Rezepte A-Z

Wir setzen auch da mal mit Views an.

Neue View hinzufügen, Name z.B. IVZ, Anzeigen Inhalt of Type Blogeintrag, Create a page, Seitentitel z.B. Rezepte A-Z, Pfad rezepte-a-z. Items to Display 300 (brauchen wir später noch). Create a Menu Link, Continue&Edit.

Anzeigen->Inhalt->Fields -> Apply, Inline Fields Inhalt:Titel anhaken.

Sort Criteria Post Date entfernen, Sort Criteria hinzufügen Inhalt:Titel,  (asc) ist default, kann man lassen. Apply. Speichern.

Das sollte einen neuen Menüeintrag erzeugen, in dem alle Rezepte alfabetisch aufgelistet werden:

ivz
ivz

Das ist zwar mal ein Anfang, aber so richtig schön ist es noch nicht. Es wäre viel hübscher, wenn die Anfangsbuchstaben und die Anzahl der Rezepte pro Buchstaben in der Liste auftauchen würden, aber das, so fürchte ich, wird nicht so einfach, jedenfalls nicht ohne ein bisschen Programmierung. Da wollen wir Drupal mal auf den Zahn fühlen, wie sowas gehen könnte – in einem neuen Beitrag.

Ohne Views geht anscheinend gar nichts

Ich bin bei meinen Recherchen jetzt schon das x-te Mal darüger gestolpert, dass bestimmte Funktionalitäten in Drupal offenbar nur über das Modul Views zu realisieren sind. Hab ich ja prinzipiell erstmal nix dagegen, aber mir scheint doch dass hier mit Kanonen auf Spatzen geschossen wird. Um Views zu installieren, muss man erstmal die CTools Chaos Tool Suite herunterladen installieren und aktivieren, darauf kann man dann Views für Drupal 7 aufsetzen. Ich habe auf die Schnelle keine einfache Installationsanleitung gefunden, das ging jetzt ziemlich mit Trial and Error. Hat man beide Module installiert, gibt es unter Struktur einen oder mehrere neue Einträge, für den Anfang ist mal nur Views interessant.

Wir basteln mal einen ersten View

Wir probierens mal mit „Add new View“ und sehen, wie weit wir kommen. Ich möchte jetzt gerne eine Liste meiner Kategorien sehen.  Dafür wähle ich im Feld Anzeigen „Taxonomiebegriffe“ und by of Type „Tags“.

Ich möchte einen Block erstellen, deswegen kommt das Häkchen bei Create Page raus und bei Create Block rein, die Anzahl der Items to Display stelle ich auf 10. Nach Save&Exit siollte unter Struktur->Blöcke unser neuer Block namens Kategorien auftauchen, den positioniere ich mal in die zweite Sidebar. Das sieht dann so aus:

katliste_sidebar
katliste_sidebar

Schon mal kein schlechter Anfang! Klick auf eine Kategorie öffnet eine Liste der zugehörigen Rezepte, das ist ja eigentlich schon mal ganz gut. Ich hätte jetzt aber gerne noch die Anzahl der zugeordneten Rezept bei jeder Kategorie stehen, und dafür muss ich mal ein bisschen abtauchen.

Erst die gute Nachricht?

Ich habs hingekriegt, das sieht jetzt so aus:

kategorien_anzahl
kategorien_anzahl

Die schlechte Nachricht: ich kanns noch nicht wirklich nachvollziehbar darstellen, das war jetzt Stochern im Views-Nebel mit einer sehr langen Stange. Wer sich selber dran versuchen möchte, dem kann ich diese beiden Artikel empfehelen:

http://www.espend.de/projekte/artikel/drupal-tags-taxonomie-terms-als-liste-mit-anzahl-nodes-ueber-views-ausgeben.html

https://www.drupal.org/node/603868#comment-4421144

Ich lass es hier mal für heute gut sein, das Views-Konzept ist zu komplex, um es so mal auf die Schnelle darzustellen. Man kann sicher irre viel damit machen, aber genauso irre ist die Vielzahl an Optionen und Konfigurationsmöglichkeiten, da brauchts eine längere Lernkurve dafür. Aufgehoben ist aber nicht aufgeschoben, ich schau mir das Ganze später nochmal an, und dann gibts eine Schritt-für-Schritt Anleitung… hoffe ich zumindest 😉

Blog für Rezepte, Kategorien als Tags

Ich habe mich dafür entschieden, meine Rezepte als User Blog darzustellen. Dafür muss man zunächst unter Module das Modul Blog aktivieren.

blog_aktivieren
blog_aktivieren

Dann findet sich unter Inhalte hinzufügen der neue Inhaltstyp Blog-Eintrag. Wir verfassen mal kurz ein paar Rezepte vom Typ Blog-Eintrag,  dabei nur bei den Veröffentlichungseinstellungen das Häkchen bei Auf der Startseite anzeigen herausnehmen, alle anderen Optionen können bleiben wie sie sind.

Eigenen Menüpunkt für den Blog anlegen

Unter Struktur->Menüs->Hauptmenü->Link hinzufügen, Namen vergeben z.B. Alle Rezepte, bei Pfad blog eintragen. Das erzeugt einen neuen Karteireiter, unter dem die Blogeinträge chronologisch angezeigt werden.

weblog
weblog

Hier sieht man gleich, dass man die Option mit der Zusammenfassung nutzen sollte, weil Drupal sonst den Teaser-Text auf eine bestimmte Anzahl Zeichen beschneidet, und das ist nicht immer schön. Alternativ kann man auch im Sourcecode des Beitrags den sogenannten Teaser-Break einfügen <!– break –> und damit steuern, wo der Beitrag geteilt wird.

Für meine Zwecke ist keine dieser Lösungen ideal, weil ich als Teaser-Text zwar die Einleitung verwenden könnte (jedes meiner Rezepte hat einen Einleitungstext), aber diese wird dann in der Gesamtansicht des Rezeptes nicht mehr mit angezeigt. Das heißt, eigentlich müsste ich einen extra-Zusammenfassungstext verfassen und die Einleitung im Body lassen, aber das ist mir echt zu viel Aufwand. Ich lass es mal so wie es ist, und kümmere mich mal um die:

Kategorien?

Drupal bringt eine eigene, recht ausgefeilte Logik für Tags und dergleichen mit, zu finden unter Struktur->Taxonomien. Hier ist eine Taxonomie für Tags vordefiniert, man könnte aber auch eigene Taxonomien mit Vokabular hinzufügen anlegen. Das ist fein, weil man für jeden Inhaltstyp eine eigene Taxonomie anlegen könnte, zum Beispiel auch für die Kochbücher z.B. eine Schlagwortliste.

Ich bleibe aber mal bei den vordefinierten Tags, die tun es nämlich für meine Zwecke. Ich werde wieder meine einstufige flache Hierarchie von WordPress-Kategorien auf die Tags abbilden. Verschachtelungen sind zwar möglich, ich brauche sie aber nicht.

Sie können gleich unter Struktur->Taxonomie->Begriffe hinzufügen ein paar Kategorien anlegen, das ist aber auch „on the fly“ im Beitragseditor möglich. Zuvor muss man allerdings den Inhaltstyp Blogeintrag erweitern, das geht unter Struktur->Inhaltstypen-Blogeintrag->Felder verwalten, hier kann man unter Vorhandenes Feld hinzufügen Referenz auf Taxonomie-Begriffe auswählen, ich benenne es mal mit Kategorien.

taxonomie_kategorien
taxonomie_kategorien

Wenn man auf Speichern klickt, landet man in den Einstellungen für das eben hinzugefügte Feld. Hier alles lassen wie es ist, nur sollte man darauf achten dass unten bei Anzahl von Werten „unbegrenzt“ aktiviert ist, wir wollen ja beliebig viele Kategorien zu einem Rezept hinzufügen können.

Wenn man jetzt einen neuen Blogeintrag hinzufügt (oder einen bestehenden editiert) findet sich das Auswahlfeld für die Kategorien unterhalb des Body-Feldes. Es arbeitet mit Auto-Vervollständigen nach den ersten drei Zeichen, man kann hier aber auch gleich eine neue Kategorie eingeben, oder mehrere Kategorien durch Komma getrennt.

kategorie_mittelmeerkueche
kategorie_mittelmeerkueche

Wo sieht man jetzt aber unsere neu erstellten Kategorien? Zunächst nur in der vollen Beitragsansicht, im Blog werden sie so ohne weiteres nicht angezeigt. Ich hätte aber doch gerne einen Block mit den vegebenen Kategorien wie in WordPress, wenns geht mit der Anzahl der zugeordneten Rezepte, und da mach ich mich jetzt mal auf die Suche.