Contents¶

Preface

• CakePHP at a Glance
  • Conventions Over Configuration
  • The Model Layer
  • The View Layer
  • The Controller Layer
  • CakePHP Request Cycle
  • Just the Start
  • Additional Reading
    • Where to Get Help
      • The Official CakePHP website
      • The Cookbook
      • The Bakery
      • The API
      • The Test Cases
      • The IRC Channel
      • Official CakePHP Forum
      • Stackoverflow
      • Where to get Help in your Language
        • Danish
        • French
        • German
        • Iranian
        • Dutch
        • Japanese
        • Portuguese
        • Spanish
    • CakePHP Conventions
      • Controller Conventions
        • URL Considerations for Controller Names
      • File and Class Name Conventions
      • Database Conventions
      • Model Conventions
      • View Conventions
      • Plugins Conventions
      • Summarized
      • Database Convention Summary
    • CakePHP Folder Structure
      • The src Folder
• Quick Start Guide
  • Content Management Tutorial
    • Getting CakePHP
    • Checking our Installation
  • CMS Tutorial - Creating the Database
    • Database Configuration
    • Creating our First Model
  • CMS Tutorial - Creating the Articles Controller
    • Create the Article List Template
    • Create the View Action
    • Create the View Template
    • Adding Articles
    • Create Add Template
    • Adding Simple Slug Generation
    • Add Edit Action
    • Create Edit Template
    • Update Validation Rules for Articles
    • Add Delete Action
• Migration Guides
  • 5.0 Upgrade Guide
    • Fix Deprecation Warnings
    • Upgrade to PHP 8.1
    • Use the Upgrade Tool
    • Update CakePHP Dependency
  • 5.0 Migration Guide
    • Deprecated Features Removed
    • Breaking Changes
      • Global
      • Cache
      • Auth
      • Console
      • Controller
      • Core
      • Database
      • Datasource
      • Event
      • Error
      • Filesystem
      • Http
      • I18n
      • Log
      • Mailer
      • ORM
      • Routing
      • TestSuite
      • Validation
      • View
    • Deprecations
      • Database
    • New Features
      • Improved type checking
      • Core
      • Database
      • Http
      • TestSuite
• Tutorials & Examples
  • Content Management Tutorial
    • Getting CakePHP
    • Checking our Installation
  • CMS Tutorial - Creating the Database
    • Database Configuration
    • Creating our First Model
  • CMS Tutorial - Creating the Articles Controller
    • Create the Article List Template
    • Create the View Action
    • Create the View Template
    • Adding Articles
    • Create Add Template
    • Adding Simple Slug Generation
    • Add Edit Action
    • Create Edit Template
    • Update Validation Rules for Articles
    • Add Delete Action
  • CMS Tutorial - Tags and Users
    • Adding Tagging to Articles
    • Updating Articles to Enable Tagging
    • Finding Articles By Tags
      • Creating the Finder Method
      • Creating the View
    • Improving the Tagging Experience
      • Adding a Computed Field
      • Updating the Views
      • Persisting the Tag String
    • Auto-populating the Tag String
  • CMS Tutorial - Authentication
    • Installing Authentication Plugin
      • Adding Password Hashing
    • Adding Login
    • Logout
    • Enabling Registrations
  • CMS Tutorial - Authorization
    • Installing Authorization Plugin
    • Enabling the Authorization Plugin
    • Creating our First Policy
    • Checking Authorization in the ArticlesController
    • Fixing the Add & Edit Actions
    • Wrapping Up
• Contributing
  • Documentation
    • Translations
      • New Translation Language
      • Reminder for Docs Administrators
      • Translator tips
    • Documentation Formatting Guide
      • Line Length
      • Headings and Sections
      • Paragraphs
      • Inline Markup
      • Lists
      • Links
        • External Links
        • Links to Other Pages
        • Cross Referencing Links
        • Prevent Sphinx to Output Warnings
      • Describing Classes and their Contents
      • Describing Classes and Constructs
        • Prevent Sphinx to Output Warnings
        • Cross Referencing
      • Source Code
      • Notes and Warnings
        • Samples
  • Tickets
    • Reporting Bugs
    • Reporting Security Issues
  • Code
    • Initial Setup
    • Working on a Patch
    • Submitting a Pull Request
      • Choosing Where Your Changes will be Merged Into
  • Coding Standards
    • Adding New Features
    • IDE Setup
    • Indentation
    • Line Length
    • Control Structures
      • Ternary Operator
      • Template Files
    • Comparison
    • Function Calls
    • Method Definition
    • Bail Early
      • Typehinting
      • Anonymous Functions (Closures)
    • Method Chaining
    • Commenting Code
      • Variable Types
    • Including Files
    • PHP Tags
      • Short Echo
    • Naming Convention
      • Functions
      • Classes
      • Variables
      • Member Visibility
      • Example Addresses
      • Files
      • Casting
      • Constants
    • Careful when using empty()/isset()
  • Backwards Compatibility Guide
    • Migration Guides
    • Using CakePHP
      • Interfaces
      • Classes
    • Working on CakePHP
    • Deprecations
    • Experimental Features
• Release Policy
  • Major Releases
  • Minor Releases
  • Patch Releases
  • Experimental Features

Getting Started

• Installation
  • Installing CakePHP
    • Installing Composer
    • Create a CakePHP Project
    • Keeping Up To Date with the Latest CakePHP Changes
    • Installation using Oven
  • Permissions
  • Development Server
  • Production
  • Fire It Up
  • URL Rewriting
    • Apache
    • nginx
    • NGINX Unit
    • IIS7 (Windows hosts)
    • Lighttpd
    • I Can’t Use URL Rewriting
• Configuration
  • Configuring your Application
    • Loading Additional Configuration Files
  • Environment Variables
    • General Configuration
    • Using a CDN
    • Database Configuration
    • Caching Configuration
    • Error and Exception Handling Configuration
    • Logging Configuration
    • Email Configuration
    • Session Configuration
    • Routing configuration
  • Additional Class Paths
    • Plugin, View Template and Locale Paths
  • Inflection Configuration
  • Configure Class
    • Writing Configuration data
    • Reading Configuration Data
    • Checking to see if Configuration Data is Defined
    • Deleting Configuration Data
    • Reading & Deleting Configuration Data
  • Reading and writing configuration files
    • Loading Configuration Files
    • Creating or Modifying Configuration Files
    • Storing Runtime Configuration
    • Restoring Runtime Configuration
    • Configuration Engines
  • Disabling Generic Tables
• Application
  • Bootstrapping your Application
    • Application::bootstrap()
• Dependency Injection
  • Adding Services
    • Adding Shared Services
    • Extending Definitions
    • Tagging Services
    • Using Configuration Data
  • Service Providers
    • Creating Service Providers
    • Using Service Providers
    • Bootable ServiceProviders
  • Mocking Services in Tests
  • Auto Wiring
• Routing
  • Quick Tour
  • Connecting Routes
    • Route Elements
    • Reserved Route Elements
    • Configuring Route Options
    • Passing Parameters to Action
    • Using Path Routing
    • Using Named Routes
    • Prefix Routing
    • Creating Links to Prefix Routes
    • Plugin Routing
    • Creating Links to Plugin Routes
    • SEO-Friendly Routing
    • Matching Specific HTTP Methods
    • Matching Specific Hostnames
    • Routing File Extensions
  • Route Scoped Middleware
    • Grouping Middleware
  • RESTful Routing
    • Creating Nested Resource Routes
    • Limiting the Routes Created
    • Changing the Controller Actions Used
    • Mapping Additional Resource Routes
    • Prefixed Resource Routing
    • Custom Route Classes for Resource Routes
    • URL Inflection for Resource Routes
    • Changing the Path Element
  • Passed Arguments
  • Generating URLs
    • Using Router::url()
    • Using Router::reverse()
    • Routing Arrays vs Request Parameters
  • Generating Asset URLs
  • Redirect Routing
  • Entity Routing
  • Custom Route Classes
    • Default Route Class
    • Fallbacks Method
  • Creating Persistent URL Parameters
• Request & Response Objects
  • Request
    • Request Parameters
    • Query String Parameters
    • Request Body Data
    • File Uploads
    • PUT, PATCH or DELETE Data
    • Environment Variables (from $_SERVER and $_ENV)
    • XML or JSON Data
    • Path Information
    • Checking Request Conditions
    • Session Data
    • Host and Domain Name
    • Reading the HTTP Method
    • Restricting Which HTTP method an Action Accepts
    • Reading HTTP Headers
    • Trusting Proxy Headers
    • Checking Accept Headers
    • Reading Cookies
    • Uploaded Files
    • Manipulating URIs
  • Response
    • Dealing with Content Types
    • Sending Files
    • Sending a String as File
    • Setting Headers
    • Setting the Body
    • Setting the Character Set
    • Interacting with Browser Caching
    • Fine Tuning HTTP Cache
      • The Cache Control Header
      • The Expiration Header
      • The Etag Header
      • The Last Modified Header
      • The Vary Header
      • Sending Not-Modified Responses
    • Setting Cookies
  • Setting Cross Origin Request Headers (CORS)
  • Common Mistakes with Immutable Responses
  • Cookie Collections
    • Creating Cookies
    • Reading Cookies
• Middleware
  • Middleware in CakePHP
  • Using Middleware
    • Adding Middleware from Plugins
  • Creating Middleware
  • Routing Middleware
  • Encrypted Cookie Middleware
  • Body Parser Middleware
• Controllers
  • The App Controller
  • Request Flow
  • Controller Actions
  • Interacting with Views
    • Setting View Variables
    • Setting View Options
    • Rendering a View
      • Rendering a Specific Template
  • Content Type Negotiation
  • Content Type Negotiation Fallbacks
  • Redirecting to Other Pages
    • Forwarding to an Action on the Same Controller
  • Loading Additional Models
  • Paginating a Model
  • Configuring Components to Load
  • Request Life-cycle Callbacks
    • Event List
    • Controller Callback Methods
  • Controller Middleware
  • More on Controllers
    • The Pages Controller
    • Components
      • AuthComponent
        • Suggested Reading Before Continuing
        • Authentication
          • Choosing an Authentication Type
          • Configuring Authentication Handlers
          • Customizing Find Query
          • Identifying Users and Logging Them In
          • Redirecting Users After Login
          • Creating Stateless Authentication Systems
          • Using Basic Authentication
            • Creating API Keys for Basic Authentication
          • Using Digest Authentication
            • Hashing Passwords For Digest Authentication
          • Creating Custom Authentication Objects
          • Using Custom Authentication Objects
          • Handling Unauthenticated Requests
          • Displaying Auth Related Flash Messages
          • Hashing Passwords
          • Creating Custom Password Hasher Classes
          • Changing Hashing Algorithms
          • Manually Logging Users In
          • Accessing the Logged In User
          • Logging Users Out
          • Deciding When to run Authentication
        • Authorization
          • Configuring Authorization Handlers
          • Creating Custom Authorize Objects
            • Using Custom Authorize Objects
          • Using No Authorization
          • Making Actions Public
          • Making Actions Require Authorization
          • Using ControllerAuthorize
        • Configuration options
        • Testing Actions Protected By AuthComponent
      • Flash
        • Setting Flash Messages
        • HTML in Flash Messages
      • Security
        • Handling Blackhole Callbacks
        • Restrict Actions to SSL
        • Form Tampering Prevention
        • Usage
        • CSRF Protection
        • Disabling Form Tampering for Specific Actions
      • FormProtection
        • Form tampering prevention
        • Usage
        • Disabling form tampering checks
        • Disabling form tampering for specific actions
        • Handling validation failure through callbacks
      • Checking HTTP Cache
      • Configuring Components
        • Aliasing Components
        • Loading Components on the Fly
      • Using Components
      • Creating a Component
        • Including your Component in your Controllers
        • Using Other Components in your Component
        • Accessing a Component’s Controller
      • Component Callbacks
      • Using Redirects in Component Events
• Views
  • The App View
  • View Templates
    • Alternative Echos
    • Alternative Control Structures
    • View Variables
    • Setting View Variables
    • Extending Views
  • Using View Blocks
    • Displaying Blocks
    • Using Blocks for Script and CSS Files
  • Layouts
    • Using Layouts from Plugins
  • Elements
    • Passing Variables into an Element
    • Caching Elements
    • Requesting Elements from a Plugin
    • Routing prefix and Elements
    • Caching Sections of Your View
  • View Events
    • Event List
  • Creating Your Own View Classes
  • More About Views
    • View Cells
      • When to use Cells
      • Creating a Cell
      • Implementing the Cell
      • Loading Cells
      • Passing Arguments to a Cell
      • Rendering a Cell
        • Rendering Alternate Templates
        • Caching Cell Output
      • Paginating Data inside a Cell
      • Cell Options
      • Using Helpers inside a Cell
    • Themes
      • Theme Assets
    • JSON and XML views
      • Defining View Classes to Negotiate With
      • Using Data Views with the Serialize Key
      • Using a Data View with Template Files
      • Creating XML Views
      • Creating JSON Views
        • JSONP Responses
      • Choosing a View Class
    • Helpers
      • Breadcrumbs
        • Creating a Breadcrumbs Trail
        • Rendering the Breadcrumbs Trail
          • Customizing the Output
          • Defining Attributes for the Item
        • Clearing the Breadcrumbs
      • Flash
        • Rendering Flash Messages
        • Routing Prefix and Flash Messages
        • Flash Messages and Themes
      • Form
        • Starting a Form
          • Options for Form Creation
          • Getting form values from other values sources
          • Changing the HTTP Method for a Form
          • Setting a URL for the Form
          • Using Custom Validators
          • Creating context classes
        • Creating Form Controls
          • Field Naming Conventions
          • Options for Control
        • Generating Specific Types of Controls
          • Common Options For Specific Controls
        • Creating Input Elements
          • Creating Text Inputs
          • Creating Password Inputs
          • Creating Hidden Inputs
          • Creating Textareas
          • Creating Select, Checkbox and Radio Controls
            • Options for Select, Checkbox and Radio Controls
            • Using Collections to build options
            • Creating Checkboxes
            • Creating Radio Buttons
            • Creating Select Pickers
          • Creating File Inputs
          • Creating Date & Time Related Controls
            • Creating Date Controls
            • Creating Time Controls
            • Creating Month Controls
            • Creating Year Controls
        • Creating Labels
        • Displaying and Checking Errors
          • Displaying Errors
          • Checking for Errors
          • Displaying validation messages in HTML5 validity messages
        • Creating Buttons and Submit Elements
          • Creating Submit Elements
          • Creating Button Elements
        • Closing the Form
        • Creating Standalone Buttons and POST Links
          • Creating POST Buttons
          • Creating POST Links
        • Customizing the Templates FormHelper Uses
          • List of Templates
            • Using Distinct Custom Control Containers
            • Using Distinct Custom Form Groups
          • Adding Additional Template Variables to Templates
          • Moving Checkboxes & Radios Outside of a Label
        • Generating Entire Forms
          • Creating Multiple Controls
          • Creating Controls for a Whole Entity
        • Creating Inputs for Associated Data
        • Adding Custom Widgets
          • Building a Widget Class
          • Using Widgets
        • Working with SecurityComponent
      • Html
        • Inserting Well-Formatted Elements
          • Creating Charset Tags
          • Linking to CSS Files
          • Creating CSS Programatically
          • Creating meta Tags
          • Linking to Images
          • Creating Links
          • Linking to Videos and Audio Files
          • Linking to Javascript Files
          • Creating Inline Javascript Blocks
          • Creating Nested Lists
          • Creating Table Headings
          • Creating Table Cells
        • Changing the Tags Output by HtmlHelper
      • Number
        • Formatting Currency Values
        • Setting the Default Currency
        • Getting the Default Currency
        • Formatting Floating Point Numbers
        • Formatting Percentages
        • Interacting with Human Readable Values
        • Formatting Numbers
        • Format Differences
      • Paginator
        • Setting the paginated resultset
          • PaginatorHelper Templates
        • Loading Templates from a File
        • Changing Templates at Run-time
        • Template Names
          • Creating Sort Links
          • Creating Page Number Links
          • Creating Jump Links
          • Creating Header Link Tags
          • Checking the Pagination State
          • Creating a Page Counter
          • Generating Pagination URLs
          • Creating a Limit Selectbox Control
          • Configuring Pagination Options
          • Example Usage
          • Paginating Multiple Results
      • Text
        • Linking Email addresses
        • Linking URLs
        • Linking Both URLs and Email Addresses
        • Converting Text into Paragraphs
        • Highlighting Substrings
        • Removing Links
        • Truncating Text
        • Truncating the Tail of a String
        • Extracting an Excerpt
        • Converting an Array to Sentence Form
      • Time
        • Using the Helper
      • Url
        • Generating URLs
        • Customizing Asset URL generation
      • Configuring Helpers
        • Conditionally Loading Helpers
        • Configuration options
        • Aliasing Helpers
      • Using Helpers
        • Loading Helpers On The Fly
      • Callback Methods
      • Creating Helpers
        • Including Other Helpers
        • Using Your Helper
        • Accessing View Variables Inside Your Helper
        • Rendering A View Element Inside Your Helper
      • Helper Class
        • Callbacks
• Database Access & ORM
  • Quick Example
  • More Information
    • Database Basics
      • Quick Tour
        • Running Select Statements
        • Running Insert Statements
        • Running Update Statements
        • Running Delete Statements
      • Configuration
      • Read and Write Connections
      • Managing Connections
        • Accessing Connections
        • Creating Connections at Runtime
      • Data Types
        • DateTime Type
        • Enum Type
        • Adding Custom Types
        • Connecting Custom Datatypes to Schema Reflection and Generation
        • Mapping Custom Datatypes to SQL Expressions
        • Enabling Immutable DateTime Objects
      • Connection Classes
        • Executing Queries
        • Using Transactions
      • Interacting with Statements
        • Executing & Fetching Rows
        • Getting affected Row Counts
        • Checking Error Codes
      • Query Logging
      • Identifier Quoting
      • Metadata Caching
      • Creating Databases
    • Query Builder
      • The SelectQuery Object
        • Selecting Rows From A Table
        • Selecting A Single Row From A Table
        • Getting A List Of Values From A Column
        • Resultset Are Collection Objects
        • Queries Are Lazily Evaluated
      • Selecting Data
        • Selecting Specific Fields
        • Using SQL Functions
          • Window-Only Functions
          • Custom Functions
        • Ordering Results
        • Limiting Results
        • Aggregates - Group and Having
        • Case Statements
        • Fetching Arrays Instead of Entities
        • Adding Calculated Fields
      • Advanced Conditions
        • Using Identifiers in Expressions
        • Automatically Creating IN Clauses
        • Automatic IS NULL Creation
        • Automatic IS NOT NULL Creation
        • Raw Expressions
        • Using Connection Roles
      • Getting Results
        • Returning the Total Count of Records
        • Caching Loaded Results
      • Loading Associations
        • Passing Conditions to Contain
        • Sorting Contained Associations
        • Filtering by Associated Data
        • Using innerJoinWith
        • Using notMatching
        • Using leftJoinWith
        • Adding Joins
      • Inserting Data
      • Updating Data
      • Deleting Data
      • SQL Injection Prevention
        • Binding values
      • More Complex Queries
        • Unions
        • Subqueries
        • Adding Locking Statements
        • Window Functions
        • Common Table Expressions
        • Executing Complex Queries
    • Table Objects
      • Basic Usage
        • Customizing the Entity Class a Table Uses
        • Getting Instances of a Table Class
      • Lifecycle Callbacks
        • Event List
        • initialize
        • beforeMarshal
        • afterMarshal
        • beforeFind
        • buildValidator
        • buildRules
        • beforeRules
        • afterRules
        • beforeSave
        • afterSave
        • afterSaveCommit
        • beforeDelete
        • afterDelete
        • afterDeleteCommit
        • Stopping Table Events
        • Callback priorities
      • Behaviors
      • Configuring Connections
      • Using the TableLocator
        • Configuring Table Objects
        • Flushing the Registry
        • Configuring the Namespace to Locate ORM classes
    • Entities
      • Creating Entity Classes
      • Creating Entities
      • Accessing Entity Data
      • Accessors & Mutators
        • Accessors
        • Mutators
        • Creating Virtual Fields
      • Checking if an Entity Has Been Modified
      • Validation Errors
      • Mass Assignment
        • Avoiding Mass Assignment Protection
        • Modifying the Guarded Fields at Runtime
        • Bypassing Field Guarding
        • Checking if an Entity was Persisted
      • Lazy Loading Associations
      • Creating Re-usable Code with Traits
      • Converting to Arrays/JSON
        • Exposing Virtual Fields
        • Hiding Fields
      • Storing Complex Types
    • Retrieving Data & Results Sets
      • Debugging Queries and ResultSets
      • Getting a Single Entity by Primary Key
      • Using Finders to Load Data
      • Getting the First Result
      • Getting a Count of Results
      • Finding Key/Value Pairs
        • Customize Key-Value Output
      • Finding Threaded Data
      • Custom Finder Methods
      • Dynamic Finders
      • Retrieving Associated Data
      • Eager Loading Associations Via Contain
        • Passing Conditions to Contain
        • Sorting Contained Associations
      • Filtering by Associated Data Via Matching And Joins
        • Using innerJoinWith
        • Using notMatching
        • Using leftJoinWith
      • Changing Fetching Strategies
        • Fetching With The Subquery Strategy
      • Lazy Loading Associations
      • Working with Result Sets
        • Getting the First & Last Record From a ResultSet
        • Getting an Arbitrary Index From a ResultSet
        • Checking if a ResultSet is Empty
        • Loading Additional Associations
      • Modifying Results with Map/Reduce
        • Stacking Multiple Operations
        • Removing All Stacked Map-reduce Operations
    • Validating Data
      • Validating Data Before Building Entities
      • Creating A Default Validation Set
      • Using A Different Validation Set
        • Using A Different Validation Set For Associations
      • Combining Validators
      • Validation Providers
      • Getting Validators From Tables
      • Default Validator Class
      • Applying Application Rules
        • Creating a Rules Checker
        • Creating Unique Field Rules
        • Foreign Key Rules
        • Association Count Rules
        • Association Link Constraint Rule
        • Using Entity Methods as Rules
        • Using Conditional Rules
        • Conditional/Dynamic Error Messages
        • Creating Custom re-usable Rules
        • Creating Custom Rule Objects
        • Disabling Rules
      • Validation vs. Application Rules
        • Using Validation as Application Rules
    • Saving Data
      • A Glance Over Saving Data
        • Inserting Data
        • Updating Data
        • Saving With Associations
        • Associate Many To Many Records
        • Unlink Many To Many Records
      • Converting Request Data into Entities
        • Converting BelongsToMany Data
        • Converting HasMany Data
        • Converting Multiple Records
        • Changing Accessible Fields
        • Merging Request Data Into Entities
          • Validation and patchEntity
          • Patching HasMany and BelongsToMany
        • Modifying Request Data Before Building Entities
        • Modifying Entities After Updating From Request Data
        • Validating Data Before Building Entities
        • Avoiding Property Mass Assignment Attacks
      • Saving Entities
        • Saving Associations
        • Saving BelongsTo Associations
        • Saving HasOne Associations
        • Saving HasMany Associations
        • Saving BelongsToMany Associations
        • Saving Additional Data to the Join Table
        • Saving Complex Types
      • Strict Saving
      • Find or Create an Entity
      • Creating with an existing primary key
      • Saving Multiple Entities
      • Bulk Updates
    • Deleting Data
      • Cascading Deletes
      • Bulk Deletes
      • Strict Deletes
    • Associations - Linking Tables Together
      • HasOne Associations
      • BelongsTo Associations
      • HasMany Associations
      • BelongsToMany Associations
        • Using the ‘through’ Option
        • Using Association Finders
      • Association Conventions
      • Loading Associations
    • Behaviors
      • Using Behaviors
      • Core Behaviors
        • CounterCache
          • Basic Usage
          • Advanced Usage
          • Belongs to many Usage
        • Timestamp
          • Basic Usage
          • Using and Configuring the Behavior
          • Updating Timestamps on Entities
          • Saving Updates Without Modifying Timestamps
        • Translate
          • Translation Strategies
          • Shadow Table Strategy
          • Eav Strategy
          • Attaching the Translate Behavior to Your Tables
          • Quick tour
            • Using a Separate Translations Table for Eav strategy
          • Reading Translated Content
            • Retrieve All Translations For An Entity
            • Limiting the Translations to be Retrieved
            • Preventing Retrieval of Empty Translations
            • Retrieving All Translations For Associations
            • Retrieving one language without using I18n::setLocale
            • Querying Translated Fields
          • Saving in Another Language
          • Saving Multiple Translations
            • Validating Translated Entities
        • Tree
          • Requirements
          • A Quick Tour
            • Getting direct descendents
            • Getting formatted tree lists
            • Finding a path or branch in the tree
          • Configuration
            • Node Level (Depth)
            • Scoping and Multi Trees
            • Deletion Behavior
          • Recovering with custom sort field
          • Saving Hierarchical Data
          • Deleting Nodes
      • Creating a Behavior
        • Defining Mixin Methods
          • Limiting or Renaming Exposed Mixin Methods
        • Defining Event Listeners
        • Defining Finders
          • Limiting or Renaming Exposed Finder Methods
      • Transforming Request Data into Entity Properties
      • Removing Loaded Behaviors
      • Accessing Loaded Behaviors
        • Re-configuring Loaded Behaviors
    • Schema System
      • Schema\TableSchema Objects
        • Accessing Column Data
        • Indexes and Constraints
        • Reading Indexes and Constraints
        • Adding Table Options
        • Converting Tables into SQL
      • Schema Collections
    • Schema Cache Tool

Using CakePHP

• Caching
  • Configuring Cache Engines
    • Engine Options
    • FileEngine Options
    • RedisEngine Options
    • MemcacheEngine Options
    • Configuring Cache Fallbacks
    • Removing Configured Cache Engines
  • Writing to a Cache
    • Writing Multiple Keys at Once
    • Atomic writes
    • Read Through Caching
  • Reading From a Cache
    • Reading Multiple Keys at Once
  • Deleting From a Cache
    • Deleting Multiple Keys at Once
  • Clearing Cached Data
  • Using Cache to Store Counters
  • Using Cache to Store Common Query Results
  • Using Groups
  • Globally Enable or Disable Cache
  • Creating a Cache Engine
• Console Commands
  • The CakePHP Console
  • Console Applications
  • Renaming Commands
  • Commands
    • Command Objects
      • Creating a Command
      • Changing the Default Command Name
      • Defining Arguments and Options
      • Creating Output
      • Using Models in Commands
      • Exit Codes and Stopping Execution
      • Calling other Commands
      • Setting Command Description
      • Testing Commands
        • Testing Interactive Shells
        • Testing the CommandRunner
        • Assertion methods
    • Command Input/Output
      • Command Helpers
      • Creating Helpers
      • Built-In Helpers
        • Table Helper
        • Progress Helper
      • Getting User Input
      • Creating Files
      • Creating Output
      • Output Levels
      • Styling Output
      • Turning Off Colouring
    • Option Parsers
      • Defining an OptionParser
      • Using Arguments
        • Adding Multiple Arguments
        • Validating Arguments
      • Using Options
        • Adding Multiple Options
        • Validating Options
        • Using Boolean Options
        • Building a ConsoleOptionParser from an Array
        • Merging Option Parsers
      • Getting Help from Shells
        • Getting Help as XML
      • Customizing Help Output
        • Set the Description
        • Set the Epilog
    • Running Shells as Cron Jobs
      • Cron Jobs on Shared Hosting
  • CakePHP Provided Commands
    • Cache Tool
    • Completion Tool
      • Sub Commands
        • Commands
        • subCommands
        • options
      • How to enable Bash autocompletion for the CakePHP Console
        • Bash Completion file content
      • Using autocompletion
        • Commands
        • Subcommands
        • Options
    • I18N Tool
      • Generating POT Files
        • Generating POT Files for Plugins
        • Extracting from multiple folders at once
        • Excluding Folders
        • Skipping Overwrite Warnings for Existing POT Files
        • Extracting Messages from the CakePHP Core Libraries
    • Plugin Tool
      • Loading Plugins
      • Unloading Plugins
      • Plugin Assets
    • Schema Cache Tool
    • Routes Tool
      • Getting a List of all Routes
      • Testing URL parsing
      • Testing URL Generation
    • Server Tool
      • Changing the Port and Document Root
    • Interactive Console (REPL)
  • Routing in the Console Environment
• Debugging
  • Basic Debugging
  • Using the Debugger Class
  • Outputting Values
    • Masking Data
  • Logging With Stack Traces
  • Generating Stack Traces
  • Getting an Excerpt From a File
  • Editor Integration
  • Using Logging to Debug
  • Debug Kit
• Deployment
  • Moving files
  • Adjusting Configuration
  • Check Your Security
  • Set Document Root
  • Improve Your Application’s Performance
  • Deploying an update
• Mailer
  • Basic Usage
    • Choosing the Sender
  • Configuration
    • Configuration Profiles
  • Setting Headers
  • Sending Templated Emails
  • Sending Attachments
    • Relaxing Address Validation Rules
  • Sending Emails from CLI
  • Creating Reusable Emails
  • Configuring Transports
    • Creating Custom Transports
  • Sending emails without using Mailer
  • Testing Mailers
    • Assertion methods
• Error & Exception Handling
  • Error & Exception Configuration
    • Deprecation Warnings
  • Changing Exception Handling
  • Listen to Events
  • Custom Error Templates
    • Custom Error Page Layout
  • Custom ErrorController
  • Custom ExceptionRenderer
    • Changing the ErrorController Class
  • Custom Error Logging
  • Custom Error Rendering
  • Creating your own Application Exceptions
    • Logging Exceptions
  • Built in Exceptions for CakePHP
    • HTTP Exceptions
    • Using HTTP Exceptions in your Controllers
    • Other Built In Exceptions
  • Creating your Own Error Handler
    • Changing Fatal Error Behavior
• Events System
  • Example Event Usage
  • Accessing Event Managers
    • Global Event Manager
    • Tracking Events
  • Core Events
  • Registering Listeners
    • Registering Anonymous Listeners
    • Interacting with Existing Listeners
    • Establishing Priorities
    • Getting Event Data as Function Parameters
  • Dispatching Events
    • Stopping Events
    • Getting Event Results
    • Removing Callbacks and Listeners
  • Additional Reading
• Internationalization & Localization
  • Setting Up Translations
    • Language Files
    • Extract Pot Files with I18n Shell
    • Setting the Default Locale
    • Changing the Locale at Runtime
  • Using Translation Functions
    • Using Variables in Translation Messages
    • Plurals
      • Using ICU Plural Selection
      • Using Gettext Plural Selection
  • Creating Your Own Translators
    • Creating Message Parsers
    • Creating Generic Translators
    • Plurals and Context in Custom Translators
    • Using Different Formatters
  • Localizing Dates and Numbers
    • Parsing Localized Datetime Data
    • Converting Request Data from the User’s Timezone
  • Automatically Choosing the Locale Based on Request Data
  • Translate Content/Entities
• Logging
  • Logging Configuration
  • Error and Exception Logging
  • Writing to Logs
    • Using Placeholders in Messages
    • Using Levels
    • Logging Scopes
  • Logging to Files
  • Logging to Syslog
  • Creating Log Engines
    • Logging Formatters
  • Log API
    • Convenience Methods
  • Logging Trait
  • Using Monolog
• Modelless Forms
  • Creating a Form
  • Processing Request Data
  • Setting Form Values
  • Getting Form Errors
  • Invalidating Individual Form Fields from Controller
  • Creating HTML with FormHelper
• Pagination
  • Basic Usage
  • Advanced Usage
  • Simple Pagination
  • Paginating Multiple Queries
    • Paginating the Same Model multiple Times
  • Control which Fields Used for Ordering
  • Limit the Maximum Number of Rows per Page
  • Joining Additional Associations
  • Out of Range Page Requests
  • Using a paginator class directly
  • Pagination in the View
• Plugins
  • Installing a Plugin With Composer
  • Manually Installing a Plugin
    • Manually Autoloading Plugin Classes
  • Loading a Plugin
  • Plugin Hook Configuration
  • Using Plugin Classes
  • Creating Your Own Plugins
    • Creating a Plugin Using Bake
  • Plugin Objects
  • Plugin Routes
  • Plugin Controllers
  • Plugin Models
  • Plugin Templates
    • Overriding Plugin Templates from Inside Your Application
  • Plugin Assets
    • Linking to Assets in Plugins
  • Components, Helpers and Behaviors
  • Commands
  • Testing your Plugin
  • Publishing your Plugin
  • Plugin Map File
  • Manage Your Plugins using Mixer
• REST
  • The Simple Setup
  • Accepting Input in Other Formats
  • RESTful Routing
• Security
  • Security Utility
    • Encrypting and Decrypting Data
    • Hashing Data
    • Getting Secure Random Data
  • Form Protection Middleware
    • Form tampering prevention
    • Usage
    • Disabling form tampering checks
    • Disabling form tampering for specific actions
    • Handling validation failure through callbacks
  • CSRF Protection
    • Cross Site Request Forgery (CSRF) Middleware
      • Cookie based CSRF middleware options
      • Session based CSRF middleware options
      • Skipping CSRF checks for specific actions
      • Integration with FormHelper
      • CSRF Protection and AJAX Requests
  • Content Security Policy
  • Security Headers
  • HTTPS Enforcer
    • Adding Strict-Transport-Security
• Sessions
  • Session Configuration
  • Built-in Session Handlers & Configuration
    • Session Handlers
    • Database Sessions
    • Cache Sessions
  • Setting ini directives
  • Creating a Custom Session Handler
  • Accessing the Session Object
  • Reading & Writing Session Data
  • Destroying the Session
  • Rotating Session Identifiers
  • Flash Messages
• Testing
  • Installing PHPUnit
    • Install PHPUnit with Composer
    • Using the PHAR File
  • Test Database Setup
  • Checking the Test Setup
  • Test Case Conventions
  • Creating Your First Test Case
  • Running Tests
    • Filtering Test Cases
    • Generating Code Coverage
    • Combining Test Suites for Plugins
  • Test Case Lifecycle Callbacks
  • Fixtures
    • Test Connections
    • PHPUnit Configuration
    • Creating Schema in Tests
    • Creating Schema with Migrations
    • Creating Schema with Abstract Schema
    • Creating Schema with SQL Dump Files
    • Fixture State Managers
    • Creating Fixtures
    • Dynamic Data
    • Loading Fixtures in your Test Cases
    • Fixture Factories
  • Loading Routes in Tests
    • Creating Routes in Tests
    • Loading Plugins in Tests
  • Testing Table Classes
    • Creating a Test Method
    • Mocking Model Methods
  • Controller Integration Testing
    • Setting up the Request
    • Testing Actions That Require Authentication
    • Testing Stateless Authentication and APIs
    • Testing Actions Protected by CsrfComponent or SecurityComponent
    • Integration Testing PSR-7 Middleware
    • Testing with Encrypted Cookies
    • Testing Flash Messages
    • Testing a JSON Responding Controller
    • Testing with file uploads
    • Disabling Error Handling Middleware in Tests
    • Assertion methods
    • Comparing test results to a file
  • Console Integration Testing
  • Mocking Injected Dependencies
  • Mocking HTTP Client Responses
  • Testing Views
  • Testing Components
  • Testing Helpers
  • Testing Events
  • Testing Email
  • Creating Test Suites
  • Creating Tests for Plugins
  • Generating Tests with Bake
• Validation
  • Creating Validators
    • Requiring Field Presence
    • Allowing Empty Fields
    • Adding Validation Rules
    • Using Custom Validation Rules
    • Conditional/Dynamic Error Messages
    • Conditional Validation
    • Marking Rules as the Last to Run
  • Make Rules ‘last’ by default
    • Adding Validation Providers
    • Nesting Validators
    • Creating Reusable Validators
  • Validating Data
  • Validating Entity Data
  • Core Validation Rules

Utility Classes

• App Class
  • Finding Classes
  • Finding Paths to Resources
  • Finding Paths to Namespaces
  • Locating Themes
  • Loading Vendor Files
• Collections
  • Quick Example
  • List of Methods
  • Iterating
  • Filtering
  • Aggregation
    • Grouping and Counting
  • Sorting
  • Working with Tree Data
  • Other Methods
    • Withdrawing Elements
    • Expanding Collections
    • Modifiying Elements
    • Making Collection Methods Reusable
    • Optimizing Collections
    • Making Collections Rewindable
    • Cloning Collections
• Folder & File
  • Basic Usage
  • Folder API
  • File API
• Hash
  • Hash Path Syntax
    • Expression Types
    • Attribute Matching Types
• Http Client
  • Doing Requests
  • Creating Multipart Requests with Files
    • Building Multipart Request Bodies
  • Sending Request Bodies
  • Request Method Options
  • Authentication
    • Using Basic Authentication
    • Using Digest Authentication
    • OAuth 1 Authentication
    • OAuth 2 Authentication
    • Proxy Authentication
  • Creating Scoped Clients
  • Setting and Managing Cookies
  • Response Objects
    • Reading Response Bodies
    • Reading JSON and XML Response Bodies
    • Accessing Response Headers
    • Accessing Cookie Data
    • Checking the Status Code
  • Changing Transport Adapters
  • Testing
• Inflector
  • Summary of Inflector Methods and Their Output
  • Creating Plural & Singular Forms
  • Creating CamelCase and under_scored Forms
  • Creating Human Readable Forms
  • Creating Table and Class Name Forms
  • Creating Variable Names
  • Inflection Configuration
    • Loading Custom Inflections
• Number
  • Formatting Currency Values
  • Setting the Default Currency
  • Getting the Default Currency
  • Formatting Floating Point Numbers
  • Formatting Percentages
  • Interacting with Human Readable Values
  • Formatting Numbers
  • Format Differences
  • Configure formatters
• Plugin Class
  • Locating Plugins
  • Check if a Plugin is Loaded
  • Finding Paths to Namespaces
  • Finding Paths to Resources
• Registry Objects
  • Loading Objects
  • Triggering Callbacks
  • Disabling Callbacks
• Text
  • Convert Strings into ASCII
  • Creating URL Safe Strings
  • Generating UUIDs
  • Simple String Parsing
  • Formatting Strings
  • Wrapping Text
  • Highlighting Substrings
  • Removing Links
  • Truncating Text
  • Truncating the Tail of a String
  • Extracting an Excerpt
  • Converting an Array to Sentence Form
• Date & Time
  • Creating DateTime Instances
  • Manipulation
  • Formatting
    • Setting the Default Locale and Format String
    • Formatting Relative Times
  • Conversion
  • Comparing With the Present
  • Comparing With Intervals
  • Date
  • Mutable Dates and Times
  • Accepting Localized Request Data
  • Supported Timezones
• Xml
  • Loading XML documents
  • Loading HTML documents
  • Transforming a XML String in Array
  • Transforming an Array into a String of XML
    • Using Namespaces
    • Creating a Child

Plugins & Packages

• Standalone Packages
  • ORM
  • Database
  • Datasource
  • HTTP
  • Console
  • Collection
  • I18n
  • Cache
  • Log
  • Event
  • Utility
  • Validation
  • Form
• Authentication
• Authorization
• Bake
• Debug Kit
• Migrations
• Elasticsearch
• Phinx
• Chronos
• Queue

Other

• Constants & Functions
  • Global Functions
  • Core Definition Constants
  • Timing Definition Constants
• Appendices
  • 4.x Migration Guide
    • 5.0 Upgrade Guide
      • Fix Deprecation Warnings
      • Upgrade to PHP 8.1
      • Use the Upgrade Tool
      • Update CakePHP Dependency
    • 5.0 Migration Guide
      • Deprecated Features Removed
      • Breaking Changes
        • Global
        • Cache
        • Auth
        • Console
        • Controller
        • Core
        • Database
        • Datasource
        • Event
        • Error
        • Filesystem
        • Http
        • I18n
        • Log
        • Mailer
        • ORM
        • Routing
        • TestSuite
        • Validation
        • View
      • Deprecations
        • Database
      • New Features
        • Improved type checking
        • Core
        • Database
        • Http
        • TestSuite
  • Backwards Compatibility Shimming
  • Forwards Compatibility Shimming
  • General Information
    • CakePHP Development Process
      • Major Releases
      • Feature Releases
      • Patch Releases
      • Release Cadence
      • Deprecation Policy
    • Glossary