Taxonomien

Taxonomien sind Klassifikationssysteme zur Organisation von Inhalten. EmDash bietet integrierte Kategorien und Schlagwörter und unterstützt benutzerdefinierte Taxonomien für spezielle Klassifizierungsanforderungen.

Integrierte Taxonomien

EmDash bietet zwei Standardtaxonomien:

Taxonomie	Typ	Beschreibung
Kategorien	Hierarchisch	Verschachtelte Klassifizierung mit Eltern-Kind-Beziehungen
Schlagwörter	Flach	Einfache Labels ohne Hierarchie

Beide sind standardmäßig für die Posts-Sammlung verfügbar.

Begriffe verwalten

Einen Begriff erstellen

Admin-Dashboard

1. Gehe zur Taxonomie-Seite (z.B. /_emdash/admin/taxonomies/category)

2. Gib den Begriffnamen im Formular Neu hinzufügen ein

3. Optional festlegen:

   • Slug - URL-Identifikator (automatisch aus Name generiert)
   • Eltern - Für hierarchische Taxonomien
   • Beschreibung - Begriffsbeschreibung

4. Klicke auf Hinzufügen

Content-Editor

5. Öffne einen Inhaltseintrag im Editor

6. Finde das Taxonomie-Panel in der Seitenleiste

7. Für Kategorien: Aktiviere die Kontrollkästchen für zutreffende Begriffe oder klicke auf + Neu hinzufügen

8. Für Schlagwörter: Gib Schlagwörter durch Kommas getrennt ein

9. Speichere den Inhalt

API

POST /_emdash/api/taxonomies/category/terms
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "slug": "tutorials",
  "label": "Tutorials",
  "parentId": "term_abc",
  "description": "Anleitungen und Tutorials"
}

Einen Begriff bearbeiten

1. Gehe zur Taxonomie-Begriffe-Seite

2. Klicke neben dem Begriff auf Bearbeiten

3. Aktualisiere Name, Slug, Eltern oder Beschreibung

4. Klicke auf Speichern

Einen Begriff löschen

1. Gehe zur Taxonomie-Begriffe-Seite

2. Klicke neben dem Begriff auf Löschen

3. Bestätige die Löschung

Achtung

Das Löschen eines Begriffs entfernt ihn von allen zugehörigen Inhalten. Die Inhalte werden nicht gelöscht, nur die Begriffs- zuordnung.

Taxonomien abfragen

EmDash bietet Funktionen, um Taxonomiebegriffe abzurufen und Inhalte nach Begriff zu filtern.

Alle Begriffe abrufen

Alle Begriffe einer Taxonomie abrufen:

import { getTaxonomyTerms } from "emdash";

// Alle Kategorien abrufen (liefert eine Baumstruktur)
const categories = await getTaxonomyTerms("category");

// Alle Schlagwörter abrufen (liefert eine flache Liste)
const tags = await getTaxonomyTerms("tag");

Für hierarchische Taxonomien enthalten Begriffe ein children-Array:

interface TaxonomyTerm {
  id: string;
  name: string; // Name der Taxonomie ("category")
  slug: string; // Slug des Begriffs ("news")
  label: string; // Sichtbares Label ("News")
  parentId?: string;
  description?: string;
  children: TaxonomyTerm[];
  count?: number; // Anzahl der Einträge mit diesem Begriff
}

Einen einzelnen Begriff abrufen

import { getTerm } from "emdash";

const category = await getTerm("category", "news");
// Gibt TaxonomyTerm oder null zurück

Begriffe für einen Eintrag abrufen

import { getEntryTerms } from "emdash";

// Alle Kategorien für einen Beitrag abrufen
const categories = await getEntryTerms("posts", "post-123", "category");

// Alle Schlagwörter für einen Beitrag abrufen
const tags = await getEntryTerms("posts", "post-123", "tag");

Inhalte nach Begriff filtern

Verwende getEmDashCollection mit dem where-Filter:

import { getEmDashCollection } from "emdash";

// Beiträge in der Kategorie "news"
const { entries: newsPosts } = await getEmDashCollection("posts", {
  status: "published",
  where: { category: "news" },
});

// Beiträge mit dem Schlagwort "javascript"
const { entries: jsPosts } = await getEmDashCollection("posts", {
  status: "published",
  where: { tag: "javascript" },
});

Oder verwende die Hilfsfunktion:

import { getEntriesByTerm } from "emdash";

const newsPosts = await getEntriesByTerm("posts", "category", "news");

Taxonomie-Seiten erstellen

Kategorie-Archiv

Erstelle eine Seite, die Posts in einer Kategorie auflistet:

src/pages/category/[slug].astro

---
import { getTaxonomyTerms, getTerm, getEmDashCollection } from "emdash";
import Base from "../../../layouts/Base.astro";

export async function getStaticPaths() {
  const categories = await getTaxonomyTerms("category");

  // Hierarchischen Baum für das Routing abflachen
  function flatten(terms) {
    return terms.flatMap((term) => [term, ...flatten(term.children)]);
  }

  return flatten(categories).map((cat) => ({
    params: { slug: cat.slug },
    props: { category: cat },
  }));
}

const { category } = Astro.props;

const { entries: posts } = await getEmDashCollection("posts", {
  status: "published",
  where: { category: category.slug },
});
---

<Base title={category.label}>
  <h1>{category.label}</h1>
  {category.description && <p>{category.description}</p>}
  <p>{category.count} Beiträge</p>

  <ul>
    {posts.map((post) => (
      <li>
        <a href={`/blog/${post.data.slug}`}>{post.data.title}</a>
      </li>
    ))}
  </ul>
</Base>

Schlagwort-Archiv

Erstelle eine Seite, die Posts mit einem Schlagwort auflistet:

src/pages/tag/[slug].astro

---
import { getTaxonomyTerms, getEmDashCollection } from "emdash";
import Base from "../../../layouts/Base.astro";

export async function getStaticPaths() {
  const tags = await getTaxonomyTerms("tag");

  return tags.map((tag) => ({
    params: { slug: tag.slug },
    props: { tag },
  }));
}

const { tag } = Astro.props;

const { entries: posts } = await getEmDashCollection("posts", {
  status: "published",
  where: { tag: tag.slug },
});
---

<Base title={`Beiträge mit dem Schlagwort "${tag.label}"`}>
  <h1>#{tag.label}</h1>

  <ul>
    {posts.map((post) => (
      <li>
        <a href={`/blog/${post.data.slug}`}>{post.data.title}</a>
      </li>
    ))}
  </ul>
</Base>

Kategorielisten-Widget

Zeige eine Liste von Kategorien mit Post-Anzahl an:

src/components/CategoryList.astro

---
import { getTaxonomyTerms } from "emdash";

const categories = await getTaxonomyTerms("category");
---

<nav class="category-list">
  <h3>Kategorien</h3>
  <ul>
    {categories.map((cat) => (
      <li>
        <a href={`/category/${cat.slug}`}>
          {cat.label} ({cat.count})
        </a>
        {cat.children.length > 0 && (
          <ul>
            {cat.children.map((child) => (
              <li>
                <a href={`/category/${child.slug}`}>
                  {child.label} ({child.count})
                </a>
              </li>
            ))}
          </ul>
        )}
      </li>
    ))}
  </ul>
</nav>

Schlagwort-Wolke

Zeige Schlagwörter mit größenbasierter Darstellung an:

src/components/TagCloud.astro

---
import { getTaxonomyTerms } from "emdash";

const tags = await getTaxonomyTerms("tag");

// Schriftgrößen anhand der Häufigkeit berechnen
const counts = tags.map((t) => t.count ?? 0);
const maxCount = Math.max(...counts, 1);
const minSize = 0.8;
const maxSize = 2;

function getSize(count: number) {
  const ratio = count / maxCount;
  return minSize + ratio * (maxSize - minSize);
}
---

<div class="tag-cloud">
  {tags.map((tag) => (
    <a
      href={`/tag/${tag.slug}`}
      style={`font-size: ${getSize(tag.count ?? 0)}rem`}
    >
      {tag.label}
    </a>
  ))}
</div>

Begriffe in Inhalten anzeigen

Zeige Kategorien und Schlagwörter auf einem Post an:

src/components/PostTerms.astro

---
import { getEntryTerms } from "emdash";

interface Props {
  collection: string;
  entryId: string;
}

const { collection, entryId } = Astro.props;

const categories = await getEntryTerms(collection, entryId, "category");
const tags = await getEntryTerms(collection, entryId, "tag");
---

<div class="post-terms">
  {categories.length > 0 && (
    <div class="categories">
      <span>Veröffentlicht in:</span>
      {categories.map((cat, i) => (
        <>
          {i > 0 && ", "}
          <a href={`/category/${cat.slug}`}>{cat.label}</a>
        </>
      ))}
    </div>
  )}

  {tags.length > 0 && (
    <div class="tags">
      {tags.map((tag) => (
        <a href={`/tag/${tag.slug}`} class="tag">
          #{tag.label}
        </a>
      ))}
    </div>
  )}
</div>

Benutzerdefinierte Taxonomien

Erstellen Sie Taxonomien über Kategorien und Tags hinaus für spezielle Anforderungen.

Eine benutzerdefinierte Taxonomie erstellen

Verwenden Sie die Admin-API, um eine Taxonomie zu erstellen:

POST /_emdash/api/taxonomies
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "name": "genre",
  "label": "Genres",
  "labelSingular": "Genre",
  "hierarchical": true,
  "collections": ["books", "movies"]
}

Benutzerdefinierte Taxonomien verwenden

Abfragen und Anzeigen benutzerdefinierter Taxonomien erfolgt auf die gleiche Weise wie bei integrierten:

import { getTaxonomyTerms, getEmDashCollection } from "emdash";

// Alle Genres abrufen
const genres = await getTaxonomyTerms("genre");

// Bücher in einem Genre abrufen
const { entries: sciFiBooks } = await getEmDashCollection("books", {
  where: { genre: "science-fiction" },
});

Sammlungen zuweisen

Taxonomien legen fest, für welche Sammlungen sie gelten:

{
  "name": "difficulty",
  "label": "Schwierigkeitsstufen",
  "hierarchical": false,
  "collections": ["recipes", "tutorials"]
}

Taxonomie-API-Referenz

REST-Endpunkte

Endpunkt	Methode	Beschreibung
/_emdash/api/taxonomies	GET	Taxonomiedefinitionen auflisten
/_emdash/api/taxonomies	POST	Taxonomie erstellen
/_emdash/api/taxonomies/:name/terms	GET	Begriffe auflisten
/_emdash/api/taxonomies/:name/terms	POST	Begriff erstellen
/_emdash/api/taxonomies/:name/terms/:slug	GET	Begriff abrufen
/_emdash/api/taxonomies/:name/terms/:slug	PUT	Begriff aktualisieren
/_emdash/api/taxonomies/:name/terms/:slug	DELETE	Begriff löschen

Begriffe Inhalten zuweisen

POST /_emdash/api/content/posts/post-123/terms/category
Content-Type: application/json
Authorization: Bearer YOUR_API_TOKEN

{
  "termIds": ["term_news", "term_featured"]
}

Nächste Schritte

• Einen Blog erstellen - Verwenden Sie Kategorien und Tags in einem Blog
• Inhalte abfragen - Nach Taxonomiebegriffen filtern
• Mit Inhalten arbeiten - Begriffe im Editor zuweisen