Drupal 8 Module Development

Cover
Title Page
Copyright and Credits
About Packt
Foreword
Contributors
Table of Contents
Preface
Chapter 1: Developing for Drupal 8
	Introducing Drupal (for developers)
	Developing for Drupal 8
	Technologies that drive Drupal
		PHP
		Databases and MySQL
		The web server
			HTML, CSS, and JavaScript
		Drupal architecture
			Drupal core, modules, and themes
			Hooks, plugins, and events
			Services and the dependency injection container
			From request to response
		Drupal's major subsystems
			Routing
			Entities
			Fields
			Menus
			Views
			Forms
			Configuration
			Plugins
			The theme system
			Caching
			Other subsystems
		Tools for developing in Drupal
			Version control
			Composer
			The API site and coding standards
			The developer (Devel) module
			Drush (the Drupal shell)
			Drupal Console
			Developer settings
	Summary
Chapter 2: Creating Your First Module
	Creating a module
		Your first hook implementation
		Route and controller
			The route
				Route variables
			Namespaces
			The Controller
		Services
			What is a service?
			The HelloWorldSalutation service
			Tagged services
	Using services in Drupal 8
		Injecting the service into our Controller
		Invoked Controllers
	The form
		Altering forms
		Custom submit handlers
		Rendering forms
		Service dependencies
	Blocks
		Our first block plugin
		Block configuration
	Working with links
		The URL
		The link
		Which way to link?
	Event Dispatcher and redirects
		Redirecting from a Controller
		Redirecting from a subscriber
		Dispatching events
	Summary
Chapter 3: Logging and Mailing
	Logging
		The Drupal 8 logging theory
		Our own logger channel
		Our own logger
		Logging for Hello World
		Logging summary
	Mail API
		The theory of the Mail API
		Implementing hook_mail()
		Sending emails
		Altering someone else's emails
		Custom mail plugins
			The mail plugin
			Using mail plugins
	Tokens
		The Token API
		Using tokens
		Defining new tokens
		Token summary
	Summary
Chapter 4: Theming
	Business logic versus presentation logic
	Twig
	Theme hooks
	Theme hook suggestions
	Render arrays
		The structure of a render array
			#type
			#theme
			#markup
		The render pipeline
	Assets and libraries
		Libraries
			Attaching libraries
	Common theme hooks
		Lists
		Links
		Tables
	Attributes
	Layouts
		Defining layouts
		Rendering a layout
	Theming our Hello World module
	Summary
Chapter 5: Menus and Menu Links
	The menu system
		Menus
		Menu links
			Multiple types of menu links
				Local tasks
				Local actions
				Contextual links
		MenuLink trees
			Menu link tree manipulators
			Menu active trail
	Rendering menus
	Working with menu links
		Defining menu links
		Working with menu links
	Defining local tasks
	Defining local actions
	Defining contextual links
	Summary
Chapter 6: Data Modeling and Storage
	Different types of data storage
	State API
	TempStore
		Private TempStore
		Shared TempStore
		Tempstore conclusion
	UserData
	Configuration
		Introduction
			What is configuration used for?
			Managing configuration
		Different types of configuration
		Configuration storage
			Schema
			Overrides
				Global overrides
				Module overrides
				Language overrides
				Priority
		Interacting with simple configuration
	Entities
		Content versus configuration entity types
		Entity type plugins
			Identifiers
			Bundles
			Database tables
			Entity keys
			Links
			Entity translation
			Entity revisions
			Configuration export
			Handlers
		Fields
			Configuration entity fields
			Content entity fields
				Base fields
				Configurable fields
				Field storage
		Entity types summary
	TypedData
		Why TypedData?
		What is TypedData?
		The low-level API
			DataType plugins
			Data definitions
		Content entities
		TypedData summary
	Interacting with the Entity API
		Querying entities
			Building queries
		Loading entities
		Reading entities
		Manipulating entities
		Creating entities
		Rendering content entities
		Pseudo-fields
		Entity validation
			Content entities
			Configuration entities
			Validation summary
	Summary
Chapter 7: Your Own Custom Entity and Plugin Types
	Custom content entity type
		Custom plugin type
		Custom configuration entity type
		The Importer plugin
		Content entity bundles
	Drush command
	Summary
Chapter 8: The Database API
	The Schema API
	Running queries
		Select queries
			Handling the result
			More complex select queries
			Range queries
		Pagers
		Insert queries
		Update queries
		Delete queries
		Transactions
		Query alters
		Update hooks
	Summary
Chapter 9: Custom Fields
	A recap of Field type plugins
	Field type
	Field widget
	Field formatter
	Field settings
	Using our custom field type as a base field
	Summary
Chapter 10: Access Control
	Introduction to the Drupal access system
		Roles and permissions under the hood
	Defining permissions
	Checking the user credentials
	Route access
		Custom route access
			Static approach
			Service approach
		Programmatically checking access on routes
		Bonus—dynamic route options for access control
		CSRF protection on routes
		Altering routes
	Entity access
		Injecting services into Entity handlers
		Entity access hooks
		Field access
		Entity access in routes
		Node access grants
	Block access
	Summary
Chapter 11: Caching
	Introduction to Caching
	Cacheability metadata
		Cache tags
		Cache contexts
		Max-age
		Using the cache metadata
			Caching in block plugins
			Caching access results
	Placeholders and lazy building
		Lazy builders
	Using the Cache API
		Creating our own cache bin
	Summary
Chapter 12: JavaScript and the Ajax API
	JavaScript in Drupal
		Drupal behaviors
			Our library
			The JavaScript
		Drupal settings
	The Ajax API
		Ajax links
		Ajax in forms
		States (Form) system
	Summary
Chapter 13: Internationalization and Languages
	Introduction to the multilingual ecosystem
		Language
		Content translation
		Configuration translation
		Interface translation
	Internationalization
	Content entities and the Translation API
	Summary
Chapter 14: Batches, Queues, and Cron
	Batch-powered update hooks
	Batch operations
		Creating the batch
		Batch operations
	Cron
	Queues
		Introduction to the Queue API
		Cron-based queues
		Processing a queue programmatically
	The Lock API
	Summary
Chapter 15: Views
	Entities in Views
	Exposing custom data to Views
		Views data
			Views fields
			Views relationships
			Views sorts and filters
			Views arguments
			Altering Views data
	Custom Views field
		Field configuration
	Custom Views filter
	Custom Views argument
	Views theming
	Views hooks
	Summary
Chapter 16: Working with Files and Images
	The filesystem
	Stream wrappers
	Managed versus unmanaged files
	Using the File and Image fields
	Working with managed files
		Attaching managed files to entities
		Helpful functions for dealing with managed files
		Managed file uploads
			Managed file form element
			Entity CRUD hooks
			Managed file usage service
			Processing the CSV file
	Our own stream wrapper
	Working with unmanaged files
	Private filesystem
	Images
		Image toolkits
		Image styles
		Rendering images
	Summary
Chapter 17: Automated Testing
	Testing methodologies in Drupal 8
	PHPUnit
	Registering tests
	Unit tests
		Mocked dependencies
	Kernel tests
		TeamCleaner test
		CsvImporter test
	Functional tests
		Configuration for functional tests
		Hello World page test
		Hello World form test
	Functional JavaScript tests
		Time test
		CsvImporter test
	Summary
Chapter 18: Drupal 8 Security
	Cross-Site Scripting (XSS)
		Sanitization methods in Drupal 8
		Double escaping
	SQL Injection
	Cross-Site Request Forgery (CSRF)
	Summary
Other Books You May Enjoy
Index