Drupal 8 Module Development

Build modules and themes using the latest version of Drupal 8, 2nd Edition

Daniel Sipos

• Éditeur: Packt Publishing
• Année: 2019
• ISBN:
  9781789807868
• Édition: 2
• Sujet: Computer Science
• Sous-sujet: Content Management Systems

Learn to create and customize impressive Drupal 8 modules to extend your website's functionalities

Key Features

• Explore a plethora of Drupal 8 APIs and get the best out of them using the power of PHP coding
• Learn to implement efficient data management and data security by creating dedicated modules for it.
• Stay up to date with the changes introduced in the new Drupal 8 releases

Book Description

Drupal 8 comes with a release cycle that allows for new functionality to be added at a much faster pace. However, this also means code deprecations and changing architecture that you need to stay on top of. This book updates the first edition and includes the new functionality introduced in versions up to, and including 8.7.

The book will first introduce you to the Drupal 8 architecture and its subsystems before diving into creating your first module with basic functionality. You will work with the Drupal logging and mailing systems, learn how to output data using the theme layer and work with menus and links programmatically. Then, you will learn how to work with different kinds of data storages, create custom entities, field types and leverage the Database API for lower level database queries.

You will further see how to introduce JavaScript into your module, work with the various file systems and ensure the code you write works on multilingual sites. Finally, you will learn how to programmatically work with Views, write automated tests for your functionality and also write secure code in general.

By the end, you will have learned how to develop your own custom module that can provide complex business solutions. And who knows, maybe you'll even contribute it back to the Drupal community.

Foreword by Dries Buytaert, founder of Drupal.

What you will learn

• Develop Drupal 8 modules that do all the things you want
• Master numerous Drupal 8 sub-systems and APIs in the process
• Model, store, manipulate and process data to serve your purposes
• Display data and content in a clean and secure way using the Drupal 8 theme system
• Test your business logic to prevent regressions
• Stay ahead of the curve and write code following the current best practices

Who this book is for

The primary target of this book is Drupal developers who want to learn how to write modules and develop in Drupal 8. It is also intended for Drupal site builders and PHP developers who have basic Object Oriented Programming skills.

A little bit of Symfony experience is helpful but not mandatory.

Your Own Custom Entity and Plugin Types

I am sure that you are looking forward to applying some of the knowledge gained from the previous chapters and doing something practical and fun. As promised, in this chapter, we will do just that. Also, apart from implementing our own entity types, we will cover some new things as well. So, here's the game plan.

The premise is that we want to have products on our site that hold some basic product information, such as an ID, a name, and a product number. However, these products need to somehow get onto our site. One way will be manual entry. Another, more important way will be through an import from multiple external sources (such as a JSON endpoint). Now, things will be kept simple. For all intents and purposes, these products aren't going to do much, so don't expect an e-commerce solution being laid out for you. Instead, we will practice modeling data and functionality in Drupal 8.

First, we will create a simple content entity type to represent our products. In doing so, we will make sure that we can use the UI to create, edit, and delete these products with ease by taking advantage of many Entity API benefits available out of the box.

Second, we will model our importing functionality. One side of the coin will be a simple configuration entity type to represent the configuration needed for our various importers. Again, we will make use of the Entity API for quick scaffolding and entity management. The other side will be a custom plugin type that will actually perform the import based on the configuration found in the entities. As such, these will be linked from the direction of the config entities, which will choose to use one plugin or another.

So these are the highlights. In building all this, we will see much of what is needed to define a content and configuration entity type with fields to hold data and configuration, as well as a plugin type to encapsulate logic. When defining these things, we will take the manual, more tedious, route to make sure that we understand what each component does and we are comfortable with what we are doing. Once you know all that, you'll be able to greatly speed up these processes using the Drupal Console to automatically generate much of the boilerplate code.

The code we write in this chapter will go inside a new module called products. Since we have learned how to create a module from scratch, I will not cover the initial steps needed for getting started with it.

Custom content entity type

As we saw in the previous chapter, when looking at the Node and NodeType entity types, entity type definitions belong inside the Entity folder of our module's namespace. In there, we will create a class called Product, which will have an annotation at the top to tell Drupal this is a content entity type. This is the most important part in defining a new entity type:

namespace Drupal\products\Entity;

use Drupal\Core\Entity\ContentEntityBase;

/**
 * Defines the Product entity.
 *
 * @ContentEntityType(
 * id = "product",
 * label = @Translation("Product"),
 * handlers = {
 * "view_builder" = "Drupal\Core\Entity\EntityViewBuilder",
 * "list_builder" = "Drupal\products\ProductListBuilder",
 *
 * "form" = {
 * "default" = "Drupal\products\Form\ProductForm",
 * "add" = "Drupal\products\Form\ProductForm",
 * "edit" = "Drupal\products\Form\ProductForm",
 * "delete" = "Drupal\Core\Entity\ContentEntityDeleteForm",
 * },
 * "route_provider" = {
 * "html" = "Drupal\Core\Entity\Routing\AdminHtmlRouteProvider"
 * }
 * },
 * base_table = "product",
 * admin_permission = "administer site configuration",
 * entity_keys = {
 * "id" = "id",
 * "label" = "name",
 * "uuid" = "uuid",
 * },
 * links = {
 * "canonical" = "/admin/structure/product/{product}",
 * "add-form" = "/admin/structure/product/add",
 * "edit-form" = "/admin/structure/product/{product}/edit",
 * "delete-form" = "/admin/structure/product/{product}/delete",
 * "collection" = "/admin/structure/product",
 * }
 * )
 */
class Product extends ContentEntityBase implements ProductInterface {}

In the above code block, I omitted the actual contents of the class to first focus on the annotation and some other aspects. We wil...