Erstellen Sie Ihre eigenen benutzerdefinierten Einheiten in Drupal - Setup

Schlüsselpunkte

• Entitäten in Drupal sind eine leistungsstarke Möglichkeit, Daten zu organisieren, und können so angepasst werden, dass eine bestimmte Art von Informationen dargestellt wird. Dieses Tutorial zeigt, wie ein benutzerdefiniertes Entitätstyp namens Projekt erstellt wird, das Attribute wie Titel, Beschreibung und Frist enthält.
• Um einen neuen Entitätstyp zu erstellen, muss seine Schema -Definition deklariert werden, die eine Datenbanktabelle mit Entitätsdaten generiert. Dieses Tutorial enthält ein Code -Beispiel zum Erstellen einer "Demo_Projects" -Tabelle mit vier Spalten (ID, Name, Beschreibung und Deadline).
• Entität -API -Modul muss auf Ihrer Website aktiviert und als Abhängigkeit von benutzerdefinierten Modulen festgelegt werden, die viele Funktionen für Entitätsverarbeitungsfunktionen bieten, die Drupal -Kern fehlen. Dies beinhaltet das Erstellen neuer Entitäten, das Speichern in der Datenbank und das Anzeigen.
• In diesem Tutorial wird auch erläutert, wie die Methode "BuildContent () der Standard -Entitätsapicontroller -Klasse überschreibt, um Ihre Entität anzuzeigen, und wie Sie eine Entitätsliste über die Funktion entity_view () Helfer erstellen. Der zweite Teil des Tutorials führt das Erstellen einer Seite vor, um einzelne Projekteinheiten anzuzeigen, sie über die Benutzeroberfläche auf Feldzustände zu bringen und sie den Ansichten für Abfragen und Listenanzeigen auszusetzen.

Drupal -Entitäten sind eine großartige Möglichkeit, Daten zu organisieren. Wenn Sie mit Knoten, Klassifizierungsbegriffen, Kommentaren oder Benutzern vertraut sind, sollten Sie auch wissen, dass diese seit Drupal 7 Entitäten sind. Ein weiterer wichtiger Aspekt an ihnen ist, dass sie über die Feld -API auf dem Feld geraten können. In diesem Tutorial werde ich Ihnen zeigen, wie Sie Ihren eigenen benutzerdefinierten Entitätstyp definieren und damit beginnen. Warum möchte jemand dies tun, anstatt Knoten zu verwenden? Denn während sie großartig sind, können Knoten manchmal übermäßig komplex sein. Möglicherweise benötigen Sie nicht viele Funktionen, wie z. B. Überarbeitungen oder Kommentare.

In diesem Tutorial werden wir unseren eigenen benutzerdefinierten Entitätstyp mit dem Namen "Projekt" definieren, um unsere einfachen Informationen zum Projekt (Titel, Beschreibung und Deadline) darzustellen. Wir werden dann ein wenig über die Verwendung dieser Art von Entität lernen.

Um weiter zu lernen, gehe ich davon aus, dass Sie wissen, wie man ein grundlegendes benutzerdefiniertes Modul schreibt (mein Modul heißt Demo). Hier finden Sie hervorragende Tutorials zu diesem Thema. Schreiben Sie weiterhin die .Info -Datei und erstellen Sie eine leere .module- und .install -Datei. Ich habe auch ein Git -Repository eingerichtet, in dem Sie den gesamten Quellcode für dieses Tutorial erhalten können (ein Zweig für jeden Abschnitt, zwei Abschnitte werden veröffentlicht).

Zusätzlich müssen Sie das Entity -API -Auftragsmodul auf Ihrer Website aktivieren und als Abhängigkeit für das benutzerdefinierte Modul festlegen. Das Entität -API -Modul ist im Umgang mit Entitäten sehr leistungsfähig, da es viele der Funktionen bietet, die dem Drupal -Kern fehlt.

Definieren Sie unseren eigenen Drupal -Entitätstyp

Erstellen eines neuen Entitätstyps zuerst erfordert die Definition der Schema -Definition. Das heißt, schreiben Sie Code, mit dem die Entitätsdatenbanktabelle generiert wird. In meiner Demo.install -Datei habe ich den folgenden Code:

/**
 * Implements hook_schema().
 */
function demo_schema() {

  $schema = array();

  $schema['demo_projects'] = array(
    'description' => 'The base table for the Project entity',
    'fields' => array(
      'id' => array(
        'description' => 'Primary key of the Project entity',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'name' => array(
        'description' => 'Project name.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => FALSE,
      ),
      'description' => array(
        'description' => 'Project description.',
        'type' => 'text',
        'size' => 'big',
        'not null' => FALSE,
        'default' => NULL
      ),
      'deadline' => array(
        'description' => 'Project deadline.',
        'type' => 'int',
        'length' => 11,
        'not null' => FALSE,
      ),
    ),
    'primary key' => array('id'),
  );

  return $schema;
}

Dies ist eine einfache Implementierung von Hook_schema (). Es ist keine große Sache.

Als nächstes müssen wir Hook_entity_info () implementieren. Wir können viele Optionen in diesem Haken angeben, aber hier sind die grundlegendsten und erforderlichen Optionen (dies befindet sich in der Demo.Module -Datei):

/**
 * Implements hook_entity_info().
 */
function demo_entity_info() {

  $info = array();

  $info['project'] = array(
    'label' => t('Project'),
    'base table' => 'demo_projects',
    'entity keys' => array(
      'id' => 'id',
      'label' => 'name',
    ),
    'module' => 'demo',
    'entity class' => 'Entity',
    'controller class' => 'ProjectEntityController',
  );

  return $info;
}

Mit diesem Haken geben wir einen neuen Schlüssel im $ Info -Array zurück, der den Namen der Entitätsmaschine darstellt. In diesem Array geben wir Optionen an (wir werden in diesem Tutorial weitere Optionen hinzufügen). Jetzt halten wir uns an die Verwendung von Tags (den lesbaren Namen des Entitätstyps), die Basistabelle, die Entitätsdaten speichert, die Entitätsschlüssel, die als Attribute der Entitätskennung fungieren, und des Moduls, das angibt, welches Modul den Entitätstyp definiert. Der letzte ist nicht obligatorisch, wird aber empfohlen.

Auf diese Weise registrieren wir unseren eigenen grundlegenden Entitätstyp mit Drupal. Aktivieren Sie das Modul zum ersten Mal, um zu testen, ob es funktioniert, und überprüfen Sie, ob die Tabelle in der Datenbank erstellt wurde. Füllen Sie es dann mit ein paar Zeilen, damit etwas zu verwenden ist:

INSERT INTO `demo_projects` (`id`, `name`, `description`, `deadline`)
VALUES
    (1, 'Summer House', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.', 1397501105),
    (2, 'Winter House', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.', 1397501132);

Verwenden Sie schließlich Hook_Menu (), um einen Pfad (für alle Pfade nur zum Testen) mit Drupal zu registrieren und Folgendes in seine Rückruffunktion einzufügen:

$projects = entity_load('project', array(1, 2));
dpm($projects);
return 'Some string';

Erstens verwenden wir die Funktion entity_load (), um Projektentitäten mit den IDs 1 und 2 zu laden, und dann verwenden wir die Devel DPM () -Funktion Bildschirm überlegen. Vergessen Sie nicht, dass die Rückruffunktion der Seite etwas zurückgeben muss, sonst wird sie nicht erstellt.

Wenn Sie nun zu dieser Seite navigieren, werden Daten für 2 Entitäten in der Datenbank in Krumo angezeigt.

Alternativ können Sie die EntityFieldQuery -Klasse verwenden, um neue Entitäten basierend auf einer gewünschten Eigenschaft abzufragen (nicht nur ID). Weitere Informationen darüber, wie dies funktioniert, können Sie sich dieses SitePoint -Tutorial ansehen, mit denen Sie loslegen können.

Entitätsklassen und Controller

Leider bietet der Drupal -Kern nicht zu viele Helferfunktionen, um Entitäten zu verarbeiten (entity_load () ist fast eindeutig). Das Entität -API -Modul füllt diese Lücke jedoch.

Um seine Funktionalität zu verwenden, müssen wir die zuvor deklarierten Entitätsinformationen ändern und die PHP -Klasse angeben, mit der die Entität verarbeitet werden kann. Jetzt werden wir dem Projekt Array, der in der Implementierung von Hook_entity_Info () getippt wurde, zwei weitere Schlüssel hinzufügen:

Der oben erwähnte Code enthält bereits 'entity class' => 'Entity', 'controller class' => 'ProjectEntityController',

EntityAPICONTROLLER -Klasse (befindet sich im Modul entity.controller.inc) bietet einige angemessene Standardwerte für Verarbeitungsentitäten. Es erweitert die Standard -Drupal -Kern -DrupaldeFaultEntityController -Klasse und ist für (unter anderem), die CRUD -Operationen durchführen, verantwortlich.

Beide Klassen können in Ihrem benutzerdefinierten Modul erweitert werden, um die Funktionalität anzupassen (z. B. Abfragen, Laden oder Anzeigen von Entitäten). Wir werden sehen, wie das später geht.

Aber zuerst möchte ich Ihnen zeigen, wie Sie eine neue Entität retten können. Derzeit gibt es 2 Datensätze in meiner Datenbank mit IDS 1 und 2. Ich möchte den Code, den wir in der obigen Testseite geschrieben haben, anpassen, um eine neue Entität mit ID 3 ohne sie zu erstellen. Es könnte so aussehen:

/**
 * Implements hook_schema().
 */
function demo_schema() {

  $schema = array();

  $schema['demo_projects'] = array(
    'description' => 'The base table for the Project entity',
    'fields' => array(
      'id' => array(
        'description' => 'Primary key of the Project entity',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'name' => array(
        'description' => 'Project name.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => FALSE,
      ),
      'description' => array(
        'description' => 'Project description.',
        'type' => 'text',
        'size' => 'big',
        'not null' => FALSE,
        'default' => NULL
      ),
      'deadline' => array(
        'description' => 'Project deadline.',
        'type' => 'int',
        'length' => 11,
        'not null' => FALSE,
      ),
    ),
    'primary key' => array('id'),
  );

  return $schema;
}

Wie Sie sehen, versuchen wir jetzt, 3 Projektentitäten zu laden und zu überprüfen, ob die dritte Entität existiert. Wenn es nicht vorhanden ist, verwenden wir die von der Entity -API bereitgestellte Helferfunktion entity_create (), setzen Sie die Eigenschaft auf einen zufälligen Wert und verwenden Sie dann die SAVE () -Methode auf der Entität, um in der Datenbank zu bestehen. Diese Methode wird von der Entity -Klasse bereitgestellt, und ihre Aufgabe besteht darin, die oben definierte Save () -Methode in der oben definierten Controller -Klasse aufzurufen. Diese Methode führt die Logik aus, die erforderlich ist, um die Entität zu bestehen. Aber all dies geschieht hinter den Kulissen, wir müssen uns keine Sorgen machen.

Wenn Sie die Seite neu laden, sollten Sie nur die 2 Projekteinheiten zurückgeben. Wenn Sie jedoch beim zweiten Mal 3 haben sollten.

decken Sie die Entitätsklasse

ab

Das Letzte, was ich Ihnen in diesem Teil dieses Tutorials zeigen möchte, ist, wie Sie Ihre Entität anzeigen. Dazu bleiben wir an der Seiten -Rückruffunktion, die wir verwendet haben, und machen sie eine echte Liste.

Zunächst müssen wir die Methode "BuildContent () der Standard -Entitätsapicontroller -Klasse überschreiben. Der Grund dafür ist, dass der Controller keine Annahmen über unsere Daten treffen kann. Daher müssen wir einige Informationen darüber angeben, wie sie angezeigt werden. Lassen Sie uns zunächst die Controller -Klasse deklarieren, die die vorherige Klasse erweitert:

/**
 * Implements hook_entity_info().
 */
function demo_entity_info() {

  $info = array();

  $info['project'] = array(
    'label' => t('Project'),
    'base table' => 'demo_projects',
    'entity keys' => array(
      'id' => 'id',
      'label' => 'name',
    ),
    'module' => 'demo',
    'entity class' => 'Entity',
    'controller class' => 'ProjectEntityController',
  );

  return $info;
}

Ich habe den Klassennamen ProjectEntityController ausgewählt. Vergiss nicht.

In dieser Klasse können wir den Methodennamen aus der Originalklasse kopieren und damit zurückgeben, was seine übergeordnete Klasse zurückgibt:

In dieser Klasse können wir den Methodennamen aus der Originalklasse kopieren und damit zurückgeben, was seine übergeordnete Klasse zurückgibt. Wir haben dem Array im Grunde zwei neue Elemente hinzugefügt. Der erste wickelt die Beschreibung mit <div> ein und das zweite gibt das formatierte Datum zwischen Absatzetiketten aus. Dies ist das grundlegende Drupal -Thema. Wenn Sie nicht verstehen, was hier los ist, überprüfen Sie es bitte. Sie werden jedoch den fehlenden Projektnamen bemerken. Drupal rendert es automatisch, da wir es als Tag in der von Hook_entity_info () implementierten Entitätstaste angeben. Der letzte Schritt ist, zu unserer Seiten -Rückruffunktion zu gehen und unsere Entität anzuzeigen. Ein schneller Weg (nur zu Demonstrationszwecken):

INSERT INTO `demo_projects` (`id`, `name`, `description`, `deadline`)
VALUES
    (1, 'Summer House', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.', 1397501105),
    (2, 'Winter House', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.', 1397501132);

Wie zuvor laden wir die Entität zuerst mit der entsprechenden ID. Wir führen sie dann über die Funktion entity_view () Helfer aus, die schließlich die von uns überschriebene BuildContent () -Methode aufruft. Diese Funktion gibt eine Liste der gerenderten Arrays für jede Entität zurück. Wir rendern jeweils und speichern das Ergebnis im $ Output -Array, verkettet es dann und geben es zurück.

Sie können die Seite aktualisieren und sollten eine Liste aller von Ihnen geladenen Entitäten sehen. Stellen Sie sicher, dass der Cache so gelöscht wird, damit die Änderungen sichtbar sind.

Schlussfolgerung

In diesem Tutorial lernen wir über Entitäten in Drupal, indem wir unsere eigenen Entitätstypen im Code definieren. Wir haben gelernt, wie man Schema -Definitionen für die Daten schreibt, die sie repräsentieren, und wie sie sie bei Drupal registrieren können. Anschließend sehen wir die Kraft, das Entität-API-Beitragsmodul zu verwenden, um Entitäten auf objektorientierte Weise zu verarbeiten.

Im zweiten Teil dieses Tutorials werden wir drei Hauptaspekte betrachten. Erstens erstellen wir einige Seiten, um einzelne Projekteinheiten anzuzeigen und die Verwaltungsschnittstelle für die Verwaltung von Projekten zu starten. Zweitens werden wir es über die Benutzeroberfläche auf dem Feld machen. Drittens werden wir es den Ansichten aussetzen, damit wir einige geeignete Abfragen und Listenanzeigen durchführen können. bleiben Sie dran!

FAQs zum Aufbau kundenspezifischer Einheiten in Drupal

Was sind die Voraussetzungen für die Erstellung einer Drupal -benutzerdefinierten Einheit?

Bevor Sie anfangen, Drupal -benutzerdefinierte Entitäten zu erstellen, müssen Sie ein grundlegendes Verständnis der Entität -API von Drupal haben. Sie sollten auch mit den Konzepten von PHP und objektorientierter Programmierung vertraut sein. Darüber hinaus sollten Sie eine Drupal -Entwicklungsumgebung einrichten sollen. Dies beinhaltet die Installation und Konfiguration von Drupal auf einem lokalen Computer oder Server.

Wie erstelle ich eine benutzerdefinierte Inhaltseinheit mit einem Bündel in Drupal?

Erstellen einer benutzerdefinierten Inhaltseinheit mit einem Bundle in Drupal umfasst mehrere Schritte. Zunächst müssen Sie Ihre Entität und seine Eigenschaften in einem benutzerdefinierten Modul definieren. Dann müssen Sie ein Formular erstellen, um Ihre Entität hinzuzufügen und zu bearbeiten. Danach müssen Sie die Route für den Betrieb des Unternehmens definieren. Schließlich müssen Sie einen Ansichtserbauer erstellen, um Ihre Entität anzuzeigen.

Was ist der Unterschied zwischen Content -Entität und Konfigurationsentität in Drupal?

In Drupal sind Content -Entitäten Inhaltsfragmente, die von Benutzern erstellt, bearbeitet und gelöscht werden können. Beispiele sind Knoten, Benutzer und Kommentare. Andererseits ist eine Konfigurationsentität ein Konfigurationsfragment, das in einer Datenbank gespeichert ist und in Code exportiert werden kann. Beispiele sind Ansichten, Bildstile und Benutzerrollen.

Wie erstellt man Contententity -Typ in Drupal 8?

Erstellen eines Inhaltsentitätstyps in Drupal 8 beinhaltet die Definition Ihrer Entität und deren Eigenschaften in einem benutzerdefinierten Modul. Sie müssen außerdem ein Formular erstellen, um Ihre Entität hinzuzufügen und zu bearbeiten, die Route für Entitätsvorgänge zu definieren und einen Ansichtsbauer zu erstellen, um Ihre Entität anzuzeigen.

Kann ich mit dem Entität -API -Modul benutzerdefinierte Entitäten in Drupal erstellen?

Ja, Sie können mithilfe des Entity -API -Moduls benutzerdefinierte Entitäten in Drupal erstellen. Dieses Modul bietet eine einheitliche Möglichkeit, Entitäten und deren Eigenschaften zu bewältigen. Es bietet auch APIs für die Durchführung von Vorgängen bei Unternehmen wie Erstellung, Lesen, Aktualisierung und Löschen.

Was sind die Vorteile der Schaffung von Drupal -Unternehmen?

Erstellen von Drupal -benutzerdefinierten Entitäten können Sie Ihre eigenen Datenstrukturen und Geschäftslogik definieren. Dies kann Ihre Website effizienter und überschaubarer machen. Mit benutzerdefinierten Entitäten können Sie auch die Entitäts -API von Drupal nutzen, die leistungsstarke Werkzeuge für den Umgang mit Einheiten bietet.

Wie füge ich Felder zu benutzerdefinierten Einheiten in Drupal hinzu?

Um benutzerdefinierte Entitäten in Drupal Felder hinzuzufügen, müssen Sie die Feld API verwenden. Dies beinhaltet die Definition Ihrer Felder in der Basisfelddefinitionsmethode des Entität. Sie können das Feld UI auch verwenden, um Entitäten über die Drupal -Verwaltungsschnittstelle Felder hinzuzufügen.

Wie kann man benutzerdefinierte Entitäten in Drupal anzeigen?

Um eine benutzerdefinierte Entität in Drupal anzuzeigen, müssen Sie einen Ansichtsbauer für Ihre Entität erstellen. Dies beinhaltet die Definition einer Klasse, die die EntityViewBuilder -Klasse erweitert und die Ansichtsmethode implementiert. Sie können das View -Modul auch verwenden, um benutzerdefinierte Ansichten von Entitäten zu erstellen.

Wie erstelle ich ein Formular zum Hinzufügen und Bearbeiten von benutzerdefinierten Entitäten in Drupal?

Um ein Formular in Drupal zum Hinzufügen und Bearbeiten benutzerdefinierter Entitäten zu erstellen, müssen Sie eine Formklasse für Ihre Entität definieren. Dies beinhaltet die Erweiterung der Entityform -Klasse und die Implementierung von Formular, validieren und einreichen Methoden.

Wie lösche ich eine benutzerdefinierte Entität in Drupal?

Um eine benutzerdefinierte Entität in Drupal zu löschen, müssen Sie die Löschenmethode der Entität -API verwenden. Dies beinhaltet das Laden Ihrer Entität, das Aufrufen der Löschmethode und das Speichern Ihrer Entität. Sie können auch die Deletemultip -Methode der Entität -API verwenden, um mehrere Entitäten gleichzeitig zu löschen.

Das obige ist der detaillierte Inhalt vonErstellen Sie Ihre eigenen benutzerdefinierten Einheiten in Drupal - Setup. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!