Classes

GridFieldDropdownFilter provides a dropdown that can be used to filter a GridField arbitrarily

Facilitates adding arbitrary HTML to grid fields

A button that contains a link to an URL.

Adds a "Refresh" button to the bottom or top of a GridField.

Refresh report job. Runs as a queued job.

Describes an installed composer package version.

A report listing all installed modules used in this site (from a cache).

Parses a composer lock file in order to cache information about the installation.

Handles fetching supported addon details from addons.silverstripe.org

The composer loader class is responsible for dealing directly with composer.json and composer.lock files, in terms of loading and parsing their contents.

Handles fetching module health information from addons.silverstripe.org

Handles fetching supported addon details from addons.silverstripe.org

Composer security checker job. Runs the task which does the check as a queuedjob.

Describes a known security issue of an installed Composer package

Checks if there are any insecure dependencies.

Task which does the actual checking of updates

Describes any available updates to an installed Composer package

The update checker class is provided a Link object representing a package and uses the Composer API to determine the next available updates for the package.

Class CWPPageExtension

Class CWPCleanupSiteConfigExtension

Used to configure proxy settings for bringyourownideas/silverstripe-maintenance and its related modules

Adds new global settings.

Customises the comment form to conform to government usability standards

Extends the site summary report to list the appropriate versions in the report header

Ensures that the default template is created

BaseHomePage is the basic home page.

BasePage is a foundation page class which can be used for constructing your own page types. By default it is hidden from the CMS - we rely on developers creating their own Page class in mysite/code which will extend from BasePage.

The parameters apply in the following preference order:

• Highest priority: Tag & date (or date range)
• Month (and Year)
• Pagination

The parameters apply in the following preference order:

• Highest priority: Tag & date (or date range)
• Month (and Year)
• Pagination

FooterHolder is intended as an invisible container for footer links and pages.

Summary report on the page and file counts managed by this CMS.

Used to populate sample data when installing the starter or Wātea theme

Initialises CWP-specific configuration settings, to avoid _config.php.

TODO: describe.

Adds capability to augment links with extra attributes and meta information.

Provides Password-Based Key Derivation Function hashing for passwords, using the provided algorithm (default is SHA512), which is NZISM compliant under version 3.2 section 17.2.

If the silverstripe/crontask module is installed, this will enable the PDF cleanup task to be run on a schedule

Provides interface for generating search results for a SolrIndex

Abstract wrapper for all cwp-core features

Dummy page to assist with display of search results

Description of SearchPageController

Container for a set of search results

Adds field boosting capabilities to fulltext search for pages

Adds a search form and handling method to a Controller instance, using the configured CWP search engine

Allows siteconfig to configure synonyms for fulltext search Requires silverstripe/fulltextsearch 1.1.1 or above

CwpSolr configures Solr in a CWP-compatible manner.

Default search index

Bulk action handler for recursive archiving records.

Bulk action handler for deleting records.

Bulk action handler for editing records.

Base class to extend for all custom bulk action handlers Gives access to the GridField, Component and Controller and implements useful functions like getRecordIDList()} and {@link getRecords().

Bulk action handler for recursive publishing records.

Bulk action handler for recursive unpublishing records.

Bulk action handler for unlinking records.

GridField component for editing attached models in bulk.

Custom HTTPResponse for all bulk tools to use for a unified response format and facilitate forn-end handling

Custom UploadField used to override Link() and redirect UploadField action properly through the GridField.

Handles request from the GridFieldBulkUpload component.

GridField component for uploading images in bulk.

Make elements compatible with subsites Apply this extension to BaseElement

Optional controller for every element which has its own logic, e.g. in forms.

Controller for "ElementalArea" - handles loading and saving of in-line edit forms in an elemental area in admin

This extension handles most of the relationships between pages and element area, it doesn't add an ElementArea to the page however. Because of this, developers can add multiple ElementArea areas to to a page.

Class GridFieldAddNewMultiClassHandlerExtension

Given a source block ID and the ID of the block to reorder the source block after, update all affected sort orders for the block and its siblings. Only the source block will have a new version written, all siblings will be updated underneath the ORM to avoid this.

Creates a "scalar" type that is a single dimension object - represented as an associative array on the PHP side.

Class BaseElement

Class ElementalArea

Provides ability to index Elemental content for a page, so it can be returned in the context of the page that the elements belong to

Class DataExtension

Class FluentExtension

Class SiteTreeExtension

Collects data about the config usage during a SilverStripe request

Collects data about SQL statements executed through the proxied behaviour

Collects data about the partial cache hits and misses during a SilverStripe request

Extends the default PhpInfoCollector to trim long PHP version numbers

A simple helper

A open handler controller for DebugBar

A controller extension to log times and render the Debug Bar

Formats incoming log messages for display in the debug bar

The template parser proxy will monitor the templates that are used during a page request. Since the use of the template parser is behind cache checks, this will only execute during a cache flush.

A class representing back actions.

Special request handler for admin/batchaction

An extension that automatically generates a CMS edit link for DataObjects even if they are canonically edited in some nested GridField.

The object manages the main CMS menu. See LeftAndMain::init() for example usage.

A simple CMS menu item.

Abstract form builder for insert link form

Provides a table which displays the provided record's owners

Shim to make readOne work like GraphQL 4

Imports Group records by CSV upload, as defined in GroupCsvBulkLoader.

LeftAndMain is the parent class of all the two-pane views in the CMS.

Plug-ins for additional functionality in your LeftAndMain classes.

Allows CMS forms to be decorated with additional context arguments.

Allow overriding finished state for faux redirects.

Abstract interface for a class which may be used to filter the results displayed in a nested tree

Imports Member records by CSV upload, as defined in MemberCsvBulkLoader.

Parent controller for all CMS-global modals

Generates a three-pane UI for editing model classes, tabular results and edit forms.

Security section of the CMS

Form field to handle akismet error display and handling

Spam protector for Akismet

Extends {SiteConfig} to allow akismet key to be set via the CMS

Allows akismet to be configured via siteconfig instead of hard-coded configuration

Describes TijsVerkoyen\Akismet\Akismet

Applies AkismetService to TijsVerkoyen\Akismet\Akismet

Delete multiple Folder records (and the associated filesystem nodes).

AssetAdmin is the 'file store' section of the CMS.

Update File dataobjects to be editable in this asset admin

This exception is thrown by RemoteFileFormFactory when failing to fetch an embeddable remote resource because it's either an invalid URL or because the resource is invalid

Extension that updates the Popover menu of FileFormFactory.

Decorates ModalController with an insert-oembed modal

Hides several types of DataObjects on the "Used On" tab when viewing files

Scaffolds a form for searching files

Empty form factory, because the defaults from AssetFormFactory was enough

History view for file editor form

For providing schema data to the client side to build a preview field with upload replacement feature

Represents a file upload field with ReactJS based frontend.

API available but currently not used, as create folder uses FormBuilder

Handles create and update

Define the return type for ReadDescendantFileCountsQueryCreator Return as an array of object with an 'id' property and 'count' property.

Define the return type for ReadFileUsageQueryCreator. File usage is return as an array of object with an 'id' property and 'inUseCount' property.

Represents a notice related to a graphql Action. This could be a failure, warning, or recoverable query (e.g. "are you sure you want to publish this item?")

GraphQL Query to retrieve the file count within a folder

Connection that sorts by folders first

GraphQL Query to retrieve usage count for files and folders on GraphQL request.

Handles create and update

Generate thumbnails and thumbnail links

This class provides the necessary business logic to ensure that any assets attached to a record are safely deleted, published, or protected during certain operations.

Provides a mechanism for determining the effective visibility of a set of assets (identified by filename and hash), given their membership to objects of varying visibility.

Service to help migrate File dataobjects to the new APL.

Service to help migrate Folder dataobjects to the new database format.

A task to manually flush InterventionBackend cache

Service to migrate legacy format thumbnails, to avoid regenerating them on demand.

Service to help identify and migrate Files that have been saved to the wrong asset store and restore them to the appropriate physical location.

Removes stray .htaccess files created through the silverstripe/secureassets module on a 3.x-based site. The 4.x protections work differently: One central assets/.htaccess file routes non-existent paths through SilverStripe, which can choose to return a file from assets/.protected.

SS4 and its File Migration Task changes the way in which files are stored in the assets folder, with files placed in subfolders named with partial hashmap values of the file version. This helper class goes through the HTML content fields looking for instances of image links, and corrects the link path to what it should be, with an image shortcode.

SS4 and its File Migration Task changes the way in which files are stored in the assets folder, with files placed in subfolders named with partial hashmap values of the file version. This build task goes through the HTML content fields looking for instances of image links, and corrects the link path to what it should be, with an image shortcode.

Allows you to mock a backend store in a custom directory beneath assets.

This class handles the representation of a file on the filesystem within the framework.

Permissions for root files with Can*Type = Inherit

A utility class that finds any files matching a set of rules that are present within a directory tree.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

Helps build and parse Filename Identifiers (ake: FileIDs) according to a predefined format.

File resolution strategy that relies on a list of FileIDHelpers to find files.

Represents a strategy for resolving files on a Flysystem Adapter.

Parsed Hash path URLs. Hash paths group a file and its variant under a directory based on a hash generated from the content of the original file.

Parsed SS3 style legacy asset URLs. e.g.: Uploads/_resampled/ResizedImageWzYwLDgwXQ/sam.jpg

Parsed Natural path URLs. Natural path is the same hashless path that appears in the CMS.

Immutable representation of a parsed fileID broken down into its sub-components.

A collection of static methods for manipulating the filesystem.

Adapter for local filesystem based on assets directory

Asset store based on flysystem Filesystem as a backend

Simple Flysystem implementation of GeneratedAssetHandler for storing generated content

An adapter which does not publicly expose protected files

Represents an AbstractAdapter which exposes its assets via public urls

Represents a logical folder, which may be used to organise assets stored in the configured backend.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

Represents an Image

Creates backends for images as necessary, avoiding redundant asset writes and loads

Provides image manipulation functionality.

Represents a link between a dataobject parent and a file shortcode in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Provides shortcodes for File dataobject

Class ImageShortcodeProvider

Represents a container for a specific asset.

Provides a mechanism for suggesting filename alterations to a file

Represents an abstract asset persistence layer. Acts as a backend to files.

Represents a store usable with ProtectedFileController to serve up non-direct file requests

Represents a file reference stored in a database

Basic filename renamer

Utility for computing and comparing unique file hash. All $fs parameters can either be:

• an AssetStore constant VISIBILITY constant or
• an actual Filesystem object.

Interface to define a handler for persistent generated files

Provides routing for session-whitelisted protected files

Utility for computing and comparing unique file hash. All $fs parameters can either be:

• an AssetStore constant VISIBILITY constant or
• an actual Filesystem object.

An object which may have a thumbnail url

Manages uploads via HTML forms processed by PHP, uploads to Silverstripe's default upload directory, and either creates a new or uses an existing File-object for syncing with the database.

Logs are written using a side-channel, because audit trail should not be mixed up with regular PHP errors.

Provides logging hooks that are inserted into Framework objects.

Provides logging actions on extension hooks from certain silverstripe/mfa actions.

Provides logging actions on extension hooks from certain silverstripe/session-manager actions.

Loads SilverStripe core. Required to initialize autoloading.

Behat\SilverStripe container compilation pass.

Context used to define steps related to email sending.

Context used to create fixtures in the SilverStripe ORM.

SilverStripe aware contexts initializer.

Represents a behat context which is aware of a main {SilverStripeContext} context.

SilverStripe aware interface for contexts.

Initialises module test environment.

Locates test suite configuration based on module name.

SilverStripe extension for Behat class.

Subclass the main extension in order to get a say in the config compilation.

Step tools to help debug failing steps

Copy paste of Behat\Testwork\Tester\Runtime\RuntimeSuiteTester which is a final class

Copy paste of Behat\Behat\Output\Statistics\TotalStatistics which is a final class

Replaces RuntimeCallHandler with a retry feature All scenarios or features OPT-IN to retry behaviour with the @retry tag.

Helpers for working with steps

Same principle as core TestMailer class, but saves emails in TestSessionEnvironment to share the state between PHP calls (CLI vs. browser).

Provides a component to the GridField which tells the user whether or not a blog post has been published and when.

GridField config necessary for managing a SiteTree object.

Blog Holder

A blog category for generalising blog posts.

Adds Blog specific behaviour to Comment.

This class is responsible for filtering the SiteTree when necessary and also overlaps into filtering only published posts.

Enables children of non-editable pages to be edited.

This class is responsible for add Blog specific behaviour to Members.

An object shared by BlogTag and BlogCategory.

An individual blog post.

Adds a checkbox field for featured blog posts widget.

This is responsible for filtering only published posts to users who do not have permission to view non-published posts.

Customise blog post to support comment notifications.

A blog tag for keyword descriptions of a blog post.

Presents a title for the Resource data set and selected resource, as well as a toggle to hide or show the resource locator field in the CMS.

A PresentedOptionsField renders either a list of options that can be chosen for a DropdownFilter, or a text area allowing free text entry per line.

A ResultConditionsField renders a list of "must have" and "must not have" text conditions which are then used to determine whether a column is displayed to frontend users.

A CKAN Resource that belongs to a DataSet/Package, as to be accessed via the CKAN API.

Represents a generic field on a CKAN Resource, e.g. a column in a spreadsheet.

Represents a filter for a data resource, which accepts user inputted data and generates a query string (?key=value) to use in a request against a CKAN API for that particular resource in order to filter the results shown in a representation of that data.

Provides a single select option for CKAN resources to be filtered by

A CKANRegistryPage will render a chosen CKAN data set on the frontend, provide the user with configurable filters and display a set of CMS configured columns.

A service responsible for communicating with a CKAN API endpoint

This service will take a CKAN Resource and populate its Fields has_many relationship and other data from the CKAN API

Delete items batch action.

Publish items batch action.

Batch restore of pages

Unpublish items batch action.

The main "content" area of the CMS.

Legacy CMS History controller. This functionality has been moved to the silverstripe/versioned-admin module and this class will be removed completly in SilverStripe 5.0.0.

Base class for filtering the subtree for certain node statuses.

Gets all pages which have changed on stage.

Works a bit different than the other filters: Shows all pages including those deleted from stage and live.

This filter will display the SiteTree as a site visitor might see the site, i.e only the pages that is currently published.

Filters pages which have a status "Deleted".

Filters pages which have a status "Draft".

Filters pages which have a status "Removed from Draft".

The most common kind of controller; effectively a controller linked to a DataObject.

Extension to include custom page icons

ModelAsController deals with mapping the initial request to the first SiteTree}/{@link ContentController pair, which are then used to handle the request.

Utility class representing links to different views of a record for CMS authors, usually for SiteTree objects with "stage" and "live" links.

Navigator items are links that appear in the $SilverStripeNavigator bar.

Class will be moved from silverstripe/cms to silverstripe/admin

Class will be moved from silverstripe/cms to silverstripe/admin.

Class will be moved from silverstripe/cms to silverstripe/admin.

Class will be moved from silverstripe/cms to silverstripe/admin.

Assists with selecting anchors on a given page

Provides a form factory for inserting internal page links in a HTML editor

Decorates ModalController with insert internal link

Used to edit the SiteTree->URLSegment property, and suggest input based on the serverside rules defined through SiteTree->generateURLSegment()} and {@link URLSegmentFilter.

Readonly version of a site tree URL segment field

This interface lets us set up objects that will tell us what the current page is.

A redirector page redirects when the page is visited.

Controller for the RedirectorPage.

Basic data-object representing all pages within the site tree. All page types that live within the hierarchy should inherit from this. In addition, it contains a number of static methods for querying the site tree and working with draft and published states.

Plug-ins for additional functionality in your SiteTree classes.

Represents a link between a dataobject parent and a page in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Virtual Page creates an instance of a page, with the same fields that the original page had, but readonly.

Content side-report listing pages with broken links

Extension to provide a search interface when applied to ContentController

Standard basic search form which conducts a fulltext search on all SiteTree objects.

Updates legacy SiteTree link tracking into new polymorphic many_many relation.

Identify "orphaned" pages which point to a parent that no longer exists in a specific stage.

Class AddToCampaignHandler - handle the AddToCampaign action.

A form action to return from geCMSActions or otherwise include in a CMS Edit Form that has the right action name and CSS classes to trigger the AddToCampaignHandler.

Campaign section of the CMS

Warning: Volatile API as placeholder for standard "GridField"

Handles adding the "Add to Campaign" button to a page's secondary actions menu

Extension applied to CommentingController to invoke notifications

Comment administration system within the CMS

A Handler for bulk approving comments

A GridFieldBulkActionHandler for bulk marking comments as spam

A Handler for bulk marking comments as spam

Extension to DataObject to enable tracking comments.

Represents a single comment object.

Provides the ability to generate cryptographically secure tokens for comment moderation

Migrates all 3.x comment's BaseClass fields to the new ParentClass fields

This represents a collection of config keys and values.

Applies config modifications as a set of deltas on top of the middleware, instead of as modifications to the underlying list.

Basic mutable config collection stored in memory

Applies a set of user-customised modifications to config

Abstract flag-aware middleware

This is a helper class which lets us do things with content review data without subsites messing our SQL queries up.

CMSPageEditController extension to receive the additional action button from SiteTreeContentReview::updateCMSActions()

This extensions add a default schema for new pages and pages without a content review setting.

Set dates at which content needs to be reviewed and provide a report and emails to alert to content needing review.

Allows the content review module to use the optional queued jobs module to automatically process content review emails. If the module isn't installed, nothing is done - SilverStripe will never include this class declaration.

Show all pages that need to be reviewed.

Show all pages that need to be reviewed.

Daily task to send emails to the owners of content items when the review date rolls around.

Task which migrates the ContentReview Module's SiteTree->OwnerID column to a new column name.

Content Widget

CLI specific request building logic

Base class invoked from CLI rather than the webserver (Cron jobs, handling email bounces).

The content negotiator performs "text/html" or "application/xhtml+xml" switching. It does this through the public static function ContentNegotiator::process(). By default, ContentNegotiator will comply to the Accept headers the clients sends along with the HTTP request, which is most likely "application/xhtml+xml" (see "Order of selection" below).

Controllers are the cornerstone of all site functionality in SilverStripe. The Director selects a controller to pass control to, and then calls handleRequest(). This method will execute the appropriate action - either by calling the action method, or displaying the action's template.

A set of static methods for manipulating cookies.

A default backend for the setting and getting of cookies

The Cookie_Backend interface for use with Cookie::$inst.

Director is responsible for processing URLs, and providing environment information.

Class to support sending emails.

A class with HTTP-related helpers. Like Debug, this is more a bundle of methods than a class.

Invokes the HTTP application within an ErrorControlChain

Represents a HTTP-request, including a URL that is tokenised for parsing, and a request method (GET/POST/PUT/DELETE). This is used by RequestHandler objects to decide what to do.

Represents a response returned by a controller.

A HTTPResponse encapsulated in an exception, which can interrupt the processing flow and be caught by the RequestHandler and returned to the user.

A response which contains a streamable data source.

Indicator for a class which cannot handle requests directly, but is able to generate a delegate for those requests.

Secures requests by only allowing a whitelist of Host values

Implements the following URL normalisation rules

• redirect basic auth requests to HTTPS
• force WWW, redirect to the subdomain "www."
• force SSL, redirect to https

Handles internal change detection via etag / ifmodifiedsince headers, conditionally sending a 304 not modified if possible.

Checks whether user manual confirmation is required for HTTPRequest depending on the rules given.

Bypass for AJAX requests

A bypass for manual confirmation by user (depending on some runtime conditions)

Allows a bypass when the request has been run in CLI mode

Allows a bypass for a list of environment types (e.g. DEV, TEST, LIVE)

A rule to match a GET parameter within HTTPRequest

Allows to bypass requests of a particular HTTP method

Path aware trait for rules and bypasses

A rule for checking whether we need to protect a Request

A rule to match a particular URL

A rule to match beginning of URL

A case insensitive rule to match beginning of URL

Display execution metrics for the current request if in dev mode and execmetric is provided as a request variable.

Triggers a call to flush() on all implementors of Flushable.

HTTP Request middleware Based on https://github.com/php-fig/fig-standards/blob/master/proposed/http-middleware/middleware.md#21-psrhttpservermiddlewaremiddlewareinterface

Adds middleware support to an object.

Extends the ConfirmationMiddleware with checks for user permissions

Decorates a request handler with the HTTP Middleware pattern

This middleware will rewrite headers that provide IP and host details from an upstream proxy.

Check the request for the URL special variables.

Schedule flush operation for a following request

Implements switching user session into Test and Dev environment types

Interface that is implemented by controllers that are designed to hand control over to another controller.

Implements the "Null Object" pattern for a missing http request.

Handle the X-Pjax header that AJAX responses may provide, returning the fragment, or, in the case of non-AJAX form submissions, redirecting back to the submitter.

RSSFeed class

RSSFeed_Entry class

A request filter is an object that's executed before and after a request occurs. By returning 'false' from the preRequest method, request execution will be stopped from continuing

This class is the base class of any SilverStripe object that can be used to handle HTTP requests.

Middleware that provides back-support for the deprecated RequestFilter API.

Handles all manipulation of the session.

Generate URLs assuming that BASE_PATH is also the webroot Standard SilverStripe 3 operation

Http utility functions.

Identifies a class as a root silverstripe application

Simple Kernel container

Returns the most performant combination of caches available on the system:

• PhpFilesCache (PHP 7 with opcache enabled)
• ApcuCache (requires APC) with a FilesystemCache fallback (for larger cache volumes)
• FilesystemCache if none of the above is available

Assists with building of manifest cache prior to config being available

Defines a service that can flush its cache for a list of members

Provides introspection information about the class tree.

Registers config sources via ConfigCollectionInterface

Provides extensions to this object to integrate it with standard config API methods.

Factory for silverstripe configs

Library of conversion functions, implemented as static methods.

Simple Kernel container

Allows an object to declare a set of custom methods

Consolidates access and modification of PHP global variables and settings.

Loads environment variables from .env files Loosely based on https://github.com/vlucas/phpdotenv/blob/master/src/Loader.php

Allows an object to have extensions applied to it.

Add extension that can be added to an object with Object::add_extension().

Provides an interface for classes to implement their own flushing functionality whenever flush=1 is requested.

An AfterCallAspect is run after a method is executed

A class that proxies another, allowing various functionality to be injected.

A BeforeCallAspect is run before a method is executed.

A factory which is used for creating service instances.

A class that can be instantiated or replaced via DI

A class for creating new objects by the injector.

A simple injection manager that manages creating objects and injecting dependencies between them. It borrows quite a lot from ideas taken from Spring's configuration, but is adapted to the stateless PHP way of doing things.

Registers chained injectors

Used to locate configuration for a particular named service.

Use the SilverStripe configuration system to lookup config for a particular service.

Represents the core state of a SilverStripe application Based loosely on symfony/http-kernel's KernelInterface component

Class ClassContentRemover

A class that handles loading classes and interfaces from a class manifest instance.

A utility class which builds a manifest of all classes, interfaces and caches it.

Error handler which throws, but retains the original path context.

An extension to the default file finder with some extra filters to facilitate autoload and template manifest generation:

• Only modules with _config.php files are scanned.

Abstraction of a PHP Package. Can be used to retrieve information about Silverstripe CMS modules, and other packages managed via composer, by reading their composer.json file.

Module manifest holder

A utility class which builds a manifest of configuration items

This object represents a single resource file attached to a module, and can be used as a reference to this to be later turned into either a URL or file path.

Helper for mapping module resources to paths / urls

Sorts an associative array of items given a list of priorities, where priorities are the keys of the items in the order they are desired.

Generate URLs for client-side assets and perform any preparation of those assets needed.

The version provider will look up configured modules and examine the composer.lock file to find the current version installed for each. This is used for the logo title in the CMS via LeftAndMain::CMSVersion()

Path manipulation helpers

Represents a class with a local cache which normally invalidates itself between requests.

Handle a callable object as a discoverer

Implements the composite over flush discoverers

Checks whether a filesystem resource has been changed since the manifest generation

Public interface for startup flush discoverers

The default flush discovery implementation

Checks the manifest cache for flush being scheduled in a previous request

Guesses location for temp folder

This is the controller that finds, checks and process all crontasks

Record status of each cron task execution

By implementing this interface a /dev/cron will be able to start in on the expression that you return frmo getSchedule();

Backtrace helper

Interface for a generic build task. Does not support dependencies. This will simply run a chunk of code when called.

A base for bulk loaders of content into the SilverStripe database.

Encapsulates the result of a BulkLoader import (usually through the BulkLoader->processAll() method).

Class to facilitate command-line output.

CSSContentParser enables parsing & assertion running of HTML content via CSS selectors.

Class to handle parsing of CSV files, where the column headers are in the first row.

A basic HTML wrapper for stylish rendering of a development info view.

Constraint for checking if a SS_List contains items matching the given key-value pairs.

Constraint for checking if a SS_List contains only items matching the given key-value pairs. Each match must correspond to 1 distinct record.

Constraint for checking if every item in a SS_List matches a given match, e.g. every Member has isActive set to true

Constraint for checking if a ViewableData (e.g. ArrayData or any DataObject) contains fields matching the given key-value pairs.

Utility class to facilitate complex CSV-imports by defining column-mappings and custom converters.

Supports debugging and core error handling.

A basic HTML wrapper for stylish rendering of a development info view.

Handles raising an notice when accessing a deprecated method, class, configuration, or behaviour.

Outputs the full configuration.

A simple controller using DebugView to wrap up the confirmation form with a template similar to other DevelopmentAdmin endpoints and UIs

Base class for development tools.

A blueprint on how to create instances of a certain DataObject subclass.

Manages a set of database fixtures for DataObject records as well as raw database table rows.

SilverStripe-specific testing object designed to support functional testing of your web app. It simulates get/post requests, form submission, and can validate resulting HTML, looking up content by CSS selector.

This class keeps track of the available database adapters and provides a meaning of registering community built adapters in to the installer process.

Interface for database helper classes.

This is a helper class for the SS installer.

Simple controller that the installer uses to test that URL rewriting is working.

A migration task is a build task that is reversible.

A custom exporter for prettier formatting of SilverStripe specific Objects in PHPUnit's failing test messages.

Returns information about the current site instance.

Test case class for the Sapphire framework.

Manages illegal and required extensions for sapphiretest

Clears flushable / resettable objects

Cleans up and reset global env vars between tests

Handles nesting of kernel before / after tests

Disables any user configured loggers by pushing a NullHandler during PHPUnit tests.

Helper for resetting, booting, or cleaning up test state.

Cleans up leftover databases from aborted test executions (starting with ss_tmpdb) Task is restricted to users with administrator rights or running through CLI.

Files imported from SS3 might end up with broken permissions if there is a case conflict.

Migrates all 3.x file dataobjects to use the new DBFile field.

Collects i18n strings

Kernel for running unit tests

Classes that implement TestOnly are only to be used during testing

Represents a test usage session of a web-app It will maintain session-state from request to request

Wrapper around HTTPResponse to make it look like a SimpleHTTPResposne

Hook up static validation to the deb/build process

Basic validation of relationship setup, this tool makes sure your relationships are set up correctly in both directions The validation is configurable and inspection can be narrowed down by namespace, class and relation name

Uses Symfony's YAML component to parse a YAML document (see http://yaml.org).

DocumentImporterField is built on top of UploadField to access a document conversion capabilities. The original field is stripped down to allow only uploads from the user's computer, and triggers the conversion when the upload is completed.

Utility class hiding the specifics of the document conversion process.

Provides a document import capability through the use of an external service.

Readonly version of a BlockLinkField field, which displays the data fields as readonly text inputs and a checkbox for "target blank".

A DBLink field will be stored as serialised JSON, and contain link information presented via a "insert link" modal popup, similar to those used in TinyMCE.

Check cache headers for any response, can specify directives that must be included and also must be excluded from Cache-Control headers in response. Also checks for existence of ETag.

Check that the connection to the database is working, by ensuring that the table exists and that the table contains some records.

Check whether the environment setting is safe. Useful for live sites where a non "Live" setting might disclose sensitive information.

Checks that one or more URLs are reachable via HTTP.

Checks for the accessibility and file type validation of one or more files or folders.

Checks for the maximum age of one or more files or folders.

Check that the given file is writable.

Check that the given class exists.

Check that the given function exists.

Checks if the SMTP connection configured through PHP.ini works as expected.

Check that a given URL does not generate a session.

Check the availability of all Solr indexes

Check that a given URL is functioning, by default, the homepage.

Class DevCheckController

Class DevHealthController

Interface for environment checks

Represents a suite of environment checks.

A single set of results from running an EnvironmentCheckSuite

Provides an interface for checking the given EnvironmentCheckSuite.

Factory class for creating HTTP client which are injected into some env check classes. Inject via YAML, arguments for Guzzle client can be supplied using "constructor" property or set as default_config.

Simple helper for env checks which require HTTP clients.

ErrorPage holds the content for the page of an error response.

Controller for ErrorPages.

Enhances error handling for a controller with ErrorPage generated output

Provides {ErrorPage}-gnostic error handling

Decorates {File} with ErrorPage support

A Job for running a external link check for published pages

Represents a single link checked for a single run that is broken

Represents a track for a single page

Represents the status of a track run

Content side-report listing pages with external broken links

Check links using curl

Provides an interface for checking that a link is valid

Single checkbox field.

Readonly version of a checkbox field - "Yes" or "No".

Displays a set of checkboxes as a logical group.

Base class for all fields that contain other fields.

CompositeValidator can contain between 0 and many different types of Validators. Each Validator is itself still responsible for Validating its form and generating its ValidationResult.

Two masked input fields, checks for matching passwords.

Renders a text field, validating its input as a currency.

Readonly version of a CurrencyField.

Readonly version of a CurrencyField.

Abstract class for all fields without data.

Form used for editing a date string

Disabled version of DateField.

Form field used for editing date time strings.

Transformation that disables all the fields on the form.

Dropdown field, created from a select tag.

Text input field with validation for correct email format according to RFC 2822.

Lets you include a nested group of fields inside a template.

A list designed to hold form field instances.

Validates the internal state of all fields in the form.

Represents a file type which can be added to a form.

Provides operations for reading and writing uploaded files to/from {File} dataobject instances.

Base class for all forms.

The action buttons are <input type="submit"> as well as tags.

A service which can generate a form

Represents a field in a form.

Form component which contains a castable message

Will convert a SilverStripe message type into a Bootstrap alert type

A helper class for managing Form} and {@link FormField HTML template output.

This class represents "transformations" of a form - such as making it printable or making it readonly.

Stores GridField action state on an attribute on the action and then analyses request parameters to load it back

Stores GridField action state in the session in exactly the same way it has in the past

Displays a SS_List in a grid format.

This class is is responsible for adding objects to another object's has_many and many_many relation, as defined by the RelationList passed to the GridField constructor.

This component provides a button for opening the add new form provided by GridFieldDetailForm.

Adding this class to a GridFieldConfig} of a {@link GridField adds a button row to that field.

Base interface for all components that can be added to GridField.

Encapsulates a collection of components following the GridFieldComponent} interface. While the {@link GridField itself has some configuration in the form of setters, most of the details are dealt with through components.

A simple readonly, paginated view of records, with sortable and searchable headers.

Allows editing of records contained within the GridField, instead of only allowing the ability to view records in the GridField.

Allows viewing readonly details of individual records.

Similar to GridFieldConfig_RecordEditor, but adds features to work on has-many or many-many relationships.

This class is a GridField component that adds a delete action for objects.

Provides view and edit forms at GridField-specific URLs.

Provides the entry point to editing a single record presented by the GridField.

Adds an "Export list" button to the bottom of a GridField.

GridFieldFilterHeader alters the GridField with some filtering fields in the header of each column.

Adding this class to a GridFieldConfig} of a {@link GridField adds a footer bar to that field.

Adds a delete action for the gridfield to remove a relationship from group.

GridFieldLazyLoader alters the GridField behavior to delay rendering of rows until the tab containing the GridField is selected by the user.

Adds a "level up" link to a GridField table, which is useful when viewing hierarchical data. Requires the managed record to have a "getParent()" method or has_one relationship called "Parent".

GridFieldPage displays a simple current page count summary.

GridFieldPaginator paginates the GridField list and adds controls to the bottom of the GridField.

Adds an "Print" button to the bottom or top of a GridField.

GridFieldSortableHeader adds column headers to a GridField that can also sort the columns.

A trait that makes a class able to consume and use a GridFieldStateManagerInterface implementation

Creates a unique key for the gridfield, and uses that to write to and retrieve its state from the request

Defines a class that can create a key for a gridfield and apply its state to a request, and consume state from the request

Adding this class to a GridFieldConfig} of a {@link GridField adds a header title to that field.

A button that allows a user to view readonly details of a record. This is disabled by default and intended for use in readonly GridField instances.

Groups exiting actions in the Actions column in to a menu

GridField action menu item interface, this provides data so the action will be included if there is a {GridField_ActionMenu}

Allows GridField_ActionMenuItem to act as a link

An action is defined by two things: an action name, and zero or more named arguments.

Add a new column to the table display body, or modify existing columns.

Can modify the data list.

This class is the base class when you want to have an action that alters the state of the GridField, rendered as a button element.

A GridField manipulator that provides HTML for the header/footer rows, or f or before/after the template.

A component which is used to handle when a GridField is saved into a record.

A GridField component that provides state, notably default state.

Sometimes an action isn't enough: you need to provide additional support URLs for the GridField.

This class is a snapshot of the current status of a GridField.

Simple set of data, similar to stdClass, but without the notice-level errors.

Grouped dropdown, using optgroup tags.

A PHP version of TinyMCE's configuration, to allow various parameters to be configured on a site or section basis

A TinyMCE-powered WYSIWYG HTML editor field with image and link insertion and tracking capabilities. Editor fields are created from <textarea> tags, which are then converted with JavaScript.

Readonly version of an HTMLEditorField.

Sanitises an HTMLValue so it's contents are the elements and attributes that are whitelisted using the same configuration as TinyMCE

Generates tinymce config using a combined file generated via a standard SilverStripe GeneratedAssetHandler

Default configuration for HtmlEditor specific to tinymce

Uses the default tiny_mc_gzip.php handler

Declares a service which can generate a script URL for a given HTMLEditor config

Readonly field equivalent for literal HTML

Field that generates a heading tag.

Hidden field.

Simple label, to add extra text in your forms.

Multi-line listbox field, created from a select tag.

This field lets you put an arbitrary piece of HTML into your forms.

Read-only complement of MultiSelectField.

A form field that can save into a Money database field.

Represents a SelectField that may potentially have multiple selections, and may have a ManyManyList as a data source.

NullableField is a field that wraps other fields when you want to allow the user to specify whether the value of the field is null or not.

Text input field with validation for numeric values. Supports validating the numeric value as to the i18n::get_locale() value, or an overridden locale specific to this field.

Set of radio buttons designed to emulate a dropdown.

Password input field.

Popup form action menu for "more options"

Transformation that will make a form printable.

Class representing printable tabsets

Read-only field to display a non-editable value with a label.

Transformation that will turn a form into a readonly version of itself

Required Fields allows you to set which fields need to be present before submitting the form. Submit an array of arguments or each field as a separate argument.

Represents a Form as structured data which allows a frontend library to render it.

Represents a field that allows users to select one or more items from a list

Represents a number of fields which are selectable by a radio button that appears at the beginning of each item. Using CSS, you can configure the field to only display its contents if the corresponding radio button is selected. Each item is defined through SelectionGroup_Item.

Read-only complement of DropdownField.

Represents the base class for a single-select field

Implements a single tab in a TabSet.

Defines a set of tabs in a form.

Text input field.

TextareaField creates a multi-line text field, allowing more data to be entered than a standard text field. It creates the <textarea> tag in the form HTML.

Form field to display editable time values in an field.

The readonly class for our TimeField.

Represents a Tip which can be rendered alongside a form field in the front-end.

Declares that a form field has the ability to accept and render Tips.

Allows visibility of a group of fields to be toggled.

Dropdown-like field that allows you to select an item from a hierarchical AJAX-expandable tree.

This formfield represents many-many joins using a tree selector shown in a dropdown styled element which can be added to any form usually in the CMS.

Represents a form field which has an Upload() instance and can upload to a folder

This validation class handles all form and custom form validation through the use of Required fields. It relies on javascript for client-side validation, and marking fields after server-side validation. It acts as a visitor to individual form fields.

Interface SearchAdapterInterface

Class SolrSearchAdapter

Class SearchCriteria

Interface SearchCriteriaInterface

Class SearchCriterion

This extension can be applied to SilverStripe\Dev\Tasks\MigrateFileTask to avoid constantly re-indexing files while the file migration is running.

This database connector proxy will allow SearchUpdater::handle_manipulation to monitor database schema changes that may need to be propagated through to search indexes.

Delete operations do not use database manipulations.

Base class to manage active search indexes.

SearchIndex is the base index class. Each connector will provide a subclass of this that provides search engine specific behavior.

A search index that does nothing. Useful for testing

A search index that just records actions. Useful for testing

Provides batching of search updates

Class AbstractSearchQueryWriter

Represents a search query

Create one of these and pass as one of the values in filter or exclude to filter or exclude by a (possibly open ended) range

Some additional introspection tools that are used often by the fulltext search code

Checks if a DataObject is publicly viewable, thus able to be added to or retrieved from a publicly searchable index.

This class is responsible for capturing changes to DataObjects and triggering index updates of the resulting dirty index items.

A Search Variant handles decorators and other situations where the items to reindex or search through are modified from the default state - for instance, dealing with Versioned or Subsite

Internal utility class used to hold the state of the SearchVariant::with call

Base class for re-indexing of solr content

Provides interface for queueing a solr reindex

Invokes an immediate reindex

Represents a queued task to start the reindex job

Queuedjob to re-index a small group within an index.

Represents a queuedjob which invokes a reindex

Base class for jobs which perform re-index

The API for accessing the primary Solr installation, which includes both SolrService_Core, plus extra methods for interrogating, creating, reloading and getting SolrService_Core instances for Solr cores.

The API for accessing a specific core of a Solr server. Exactly the same as Apache_Solr_Service for now.

Class SolrConfigStore

Class SolrConfigStore_File

Class SolrConfigStore_WebDAV

Abstract class for build tasks

Task used for both initiating a new reindex, as well as for processing incremental batches within a reindex.

Class SolrSearchQueryWriter_Basic

Class SolrSearchQueryWriter_In

Class SolrSearchQueryWriter_Range

Provides logging based on monolog

Handler for logging events into QueuedJob message data

A task that initialises a GraphQL 4+ schema with boilerplate config and files.

An AuthenticatorInterface is responsible for authenticating against a SilverStripe CMS Member from the given request data.

An authenticator using SilverStripe's BasicAuth

The authentication Handler is responsible for handling authentication requirements and providing a Member to the Manager if required, so it can be used in request contexts.

Top level controller for handling graphql requests.

Attaches itself to {DataQuery} and records any classes that are queried within a closure context.

Adds functionality that checks a request for a token before allowing a mutation to happen. Protects against CSRF attacks

Ensures mutations use POST requests

Represents middleware for evaluating a graphql query

Allows any class to hold Member state

Class FileProvider

Class HTTPProvider

Class ConfigStringProvider

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Throws everything, including notices, so the JSON response doesn't get corruped by E_NOTICE, E_WARN outputs.

An exception that was thrown during execution of a query

This class is responsible for taking query information from a controller, processing it through middlewares, extracting the results from the GraphQL schema, and formatting it into a suitable JSON response.

Query handlers are responsible for applying a query as a string to a Schema object and returning a result.

Provides an arbitrary state container that can be passed through the resolver chain. It is empty by default and derives no state from the actual schema

Provides base functionality to all bulk loaders. Should override the collect() method with computations that parse the include/exclude directives and return a collection of classes.

Composed with a list of bulk loaders to be executed in serial and return the aggregate result of all their collect() calls

Defines a collection of class names paired with file paths

Loads classes that have a given extension assigned to them.

Loads classes by fuzzy match (glob), relative to the root e.g. src/*.model.php

Loads classes that are in a given inheritance tree, e.g. MyApp\Models\Page

Loads classes based on fuzzy match of FQCN, e.g. App\Models*

Frontend for creating a cached registry instance based on all the qualifying subclasses.

The instance of the registry, as composed by the Registry frontend

Used for unions and interfaces to map a class instance to a type

Creates a "create" mutation for a DataObject

Defines the model that generates types, queries, and mutations based on DataObjects

Creates a delete operation for a DataObject

A utility class that handles an assortment of issues related to field access on DataObjects, particularly with case insensitivity.

A schema-aware service for DataObject model types that builds out their inheritance chain in an ORM-like way, applying inherited fields and implicitly exposing ancestral types, etc.

Utility class that abstracts away class ancestry computations and creates an inheritance "type" for a DataObject

A schema-aware services for DataObject model types that creates union types for all the members of an inheritance chain. Can also apply these unions to queries to enforce unions when return types have descendants.

A schema-aware service for DataObject model types that emulates class inheritance by capturing groups of common fields into interfaces and applying one or many interfaces to concrete model types. Also creates a "base" interface for fields common to all DataObjects (i.e. "extends DataObject" pattern)

Creates a model for a DataObject

Defines a permission checking plugin for queries. Subclasses just need to provide a resolver function

A permission checking plugin for DataLists

Defines a set of arguments that applies to a field that maps to a DBField.

Adds inheritance fields to a DataObject type, and exposes its ancestry

Ensures DataObject models merge their plugins with ancestors

Adds pagination to a DataList query

Defines the interface used by all read filters for operations

Filters for queries are registered as services and retrieved by identifiers.

A filter that selects records that partially match a keyword

A query filter that filters records by the end of a field's contents

A query filter that filters records by exact match of a keyword

A query filter that filters records by greater than comparison

A query filter that filters records by greater than or equal comparison

A query filter that filters records by the presence of a value in an array

A query filter that filters records by a less than comparison

A query filter that filters records by a less than or equal comparison

A query filter that filters records by negating an exact match

A query filter that filters records by the start of a field's content

A special type of filter that accepts list values

Adds a filter parameter to a DataObject query

Adds a sort parameter to a DataObject query

Ensures any field that ends up as ViewableData, e.g. DBField, invokes forTemplate() after resolving.

Creates a read operation for a DataObject

Creates a readOne query for a DataObject

Generic resolver for DataObjects

Creates an update operation for a DataObject

Thrown when a mutation operation fails

Thrown when an operation encounters a permissions problem, e.g. lack of read/write permissions

Captures a failure that happened within a resolver. Designed to add context to the failure, as a chain of closures in a nested query can be very hard to debug.

The primary exception thrown by the Schema and its components. Used whenever the schema is put into a state where it cannot build a valid schema.

An abstraction of a field argument

An abstraction of a field that appears on a Type abstraction

Used for a variety of classes that rely on SchemaModelInterface

A field that appears on model type

Defines a mutation created by a model

Defines a query generated by a model

Defines a generic mutation

Defines a generic query

Defines a model that provides required fields for all the types it creates

Applies an array of config to a class

A class that can store a generic array of context

For models that can provide a default set of fields

A class that is capable of expressing itself in generated code

For models that provide extra types to the schema

A plugin that applies to a Field abstraction

Used by any class that declares an identifier

Implementors of this interface provide input types back to the schema

Implementors of this interface can prevent a given set of fields from being added

A plugin that applies only to mutations created by models

Applies to an operation that was crated by a model

A plugin that applies only to queries generated by models

A plugin that only applies to types generated by models

A plugin that applies to a generic mutation

Implementors of this interface can create queries and mutations dynamically

Implementors of this interface provide a lookup for operations by identifiers

Base plugin interface. There is a lot of "duck programming" happening in this API that will go away once we have better type variance in PHP 7.4: https://wiki.php.net/rfc/covariant-returns-and-contravariant-parameters

Validates that a given plugin is acceptable for the implementing class

A plugin that is used for a generic query

Implementors of this class can create a model for a given classname, e.g. Blog -> DataObjectModel

Implementors of this interface can be models that generate types and operations

Given a name, create a SchemaStorageInterface implementation

Persists a graphql-php Schema object, and retrieves it

Implementors of this interface can make a one-time, context-free update to the schema, e.g. adding a shared Enum type

Implementors of this class that can validate that they are ready to be encoded into the schema

Any class that can represent its state as a string. Kind of like serialize, but doesn't need to support unserialization

A plugin that applies to a generic Type

Generic plugin that can be used for filter inputs

Generic plugin that can be used to add sort paramaters to a query

Generic pagination functionality for a query that can be customised in subclasses

Allows adding, loading, and sorting of plugins

A central place for all the plugins to be registered and accessed by ID

Given a stack of resolver middleware and afterware, compress it into one composed function, passing along the return value.

Default field resolver for any type

A good starting point for a resolver discovery implementation.

A resolver function that can be expressed in generated PHP code

A uniform way of referring to a resolver callable. Normalises the string/array variants

The main Schema definition. A docking station for all type, model and interface abstractions.

Encapsulates configuration required for a Schema object.

An agnostic service that builds an input type based on a given field, with nesting.

Persists a graphql schema to a json document consumable by Apollo

A readonly value object that represents a schema in its final consumable state. It knows nothing about models or operations, plugins, or all the abstractions surrounding how the schema gets defined

For the most obscure approach, hash the file names so they're highly undiscoverable in IDE search

Hashed for less discoverability, but still readable if you focus on it

Naive implementation for debugging. Allow the class file name to be the same as the class

Defines a service that can obfuscate classnames to make their files less discoverable in IDE Search

A type that can be expressed as generated PHP code

Abstraction for enum types

Abstraction that can express input types as code

Defines a GraphQL interface. It may seem counter-intuitive that an abstraction would inherit from the concretion, but since these are just value objects that end up getting rendered as code, an unconventional architecture is probably okay. The irrelevant fields just just ignored in rendering.

Defines an interface that is backed by a model

A type that is generated by a model

Defines a union that is backed by a model definition

Abstraction for a generic type

Uniform way of referring to a type as a string. Accepts default value syntax

Abstraction of a union type

Adjusts UserDefinedForm to use GridFieldQueuedExportButton instead of GridFieldExportButton (the default)

A button you can add to a GridField to export that GridField as a CSV. Should work with any sized GridField, as the export is done using a queuedjob in the background.

A special type of SS_HTTPResponse that GridFieldQueuedExportButton returns in response to the "findgridfield" action, which includes a reference to the gridfield

Iteratively exports GridField data to a CSV file on disk, in order to support large exports.

Some cryptography used for Session cookie encryption. Requires the mcrypt extension.

Some cryptography used for Session cookie encryption.

A session store which stores the session data in an encrypted & signed cookie.

Iframe page type embeds an iframe of URL of choice into the page.

Class LDAPAuthenticator

Class LDAPDebugController

Class LDAPGroupExtension

Class LDAPMemberExtension.

Class LDAPLoginForm

Class LDAPIterator

Class LDAPAllSyncJob

Class LDAPMemberSyncJob

Class LDAPGateway

Class LDAPGroupMapping

Class LDAPUtil

Class LDAPService

Class LDAPGroupSyncTask

Class LDAPMemberSyncOneTask

Class LDAPMemberSyncTask

Class LDAPMigrateExistingMembersTask

Produce a friendly error message

Monolog-compatible error handler that will output a detailed error message to the screen.

Core error handler for a SilverStripe application

Output the error to the browser, with the given HTTP status code.

Applies to the {Security} controller in order to detect requests for actions related to the log in process or other such credential management (such as the forgot password flow).

GridField config necessary for managing a SiteTree object.

This component creates a dropdown of possible page types and a button to create a new page.

Swaps the GridField Link out for the SiteTree edit link using SiteTree::CMSEditLink().

Provides a component to the GridField which shows the publish status of a page.

Class Lumberjack

Extends the "MemberAuthenticator version of the ChangePasswordHandler in order to allow MFA to be inserted into the flow when an AutoLoginHash is being used - that is when the user has clicked a reset password link in an email after using the "forgot password" functionality.

This controller handles actions that a user may perform on MFA methods registered on their own account while logged in. This includes deleting methods, registering new methods and replacing (re-registering) existing methods.

Clears any user defined loggers during unit test execution

Representing a failure during encryption or decryption with an EncryptionAdapterInterface

A member was not found when one was expected to exist

Handles removing a member's registered MFA methods during Account Reset. Also resets the 'MFA Skipped' flag on the member so that they are prompted to set up MFA again when they next log in.

Provides DB columns / methods for account resets on Members

This extension is applied to SecurityAdmin to provide an additional endpoint for sending account reset requests.

Extends the Security controller to support Account Resets. This extension can itself be extended to add procedures to the reset action (such as removing additional authentication factors, sending alerts, etc.)

Extend Member to add relationship to registered methods and track some specific preferences

Adds multi-factor authentication related settings to the SiteConfig "Access" tab

Provides a simplified method for creating JSON-based HTTPResponses.

Represents the base requirements for implementing an MFA Method's RegisterHandler, which has the responsibility of initiating and managing registration of the MFA Method in question against the current Member.

Define how MFA Methods will initiate and check verification attempts.

Defines an Authentication Method, which serves as an additional factor for authentication beyond the standard username / password method.

This trait encapsulates logic that can be added to a RequestHandler to work with registering MFA authenticators using the MFA front-end app. It provides two main methods; createStartRegistrationResponse - creates a response that can be easily consumed by the MFA app to start the registration process for a method, and

This trait encapsulates logic that can be added to a RequestHandler to work with logging in using MFA front-end app. It provides two main methods; createStartVerificationResponse - a response that can be easily consumed by the MFA app to prompt a login, and completeVerificationRequest - used to verify a request sent by the MFA app containing the login attempt.

A service class implementation for generating and hashing backup codes.

An encryption adapter for defuse/php-encryption, enabled by default.

A generic encryption service implementation, responsible for encrypting and decrypting strings.

The EnforcementManager class is responsible for making decisions regarding multi-factor authentication app flow, e.g. "should we redirect to the MFA section", "can the user skip MFA registration" etc.

A service class that holds the configuration for enabled MFA methods and facilitates providing these methods

Encapsulates setting up an Email in order to allow for dependency injection and to avoid introducing a hard coupling to the SilverStripe core Email class in code that consumes this class.

The RegisteredMethodManager service class facilitates the communication of Members and RegisteredMethod instances in a reusable singleton.

Generates a multi-factor authentication frontend app schema from the given request

Used to provide details about an available \SilverStripe\MFA\Method\MethodInterface instance, for example when being used in the multi-factor application schema.

A container for a backup code and its hash, normally used during backup code generation

Used to provide details about a registered \SilverStripe\MFA\Method\MethodInterface instance, for example when being used in the multi-factor application schema.

An immutable result object often detailing the result of a registration or validation completed by the respective handlers

This class provides an interface to store data in session during an MFA process. This is implemented as a measure to prevent bleeding state between individual MFA auth types

Represents a place for temporarily storing state related to a login or registration attempt.

Adds an additional validation rule to Upload_Validator that attempts to detect the file extension of an uploaded file matches it's contents, which is done by detecting the MIME type and doing a fuzzy match.

Library of static methods for manipulating arrays.

A list object that wraps around an array of objects or arrays.

Interface to provide enough information about a record to make it previewable through the CMS. It uses the record database ID, its "frontend" and "backend" links to link up the edit form with its preview.

Represents an object responsible for wrapping DB connector api

Builds a SQL query string from a SQLExpression object

Represents and handles all schema management for a database

Abstract database connectivity class.

Error class for database exceptions

MySQL connector class.

A result-set from a MySQL database (using MySQLiConnector) Note that this class is only used for the results of non-prepared statements

Builds a SQL query string from a SQLExpression object

Represents schema management object for MySQL

Provides a record-view for mysqli prepared statements

TransactionManager that executes MySQL-compatible transaction control queries

Connector for MySQL using the MySQLi method

TransactionManager decorator that adds virtual nesting support.

PDO driver database connector

A result-set from a PDO database.

A handle to a PDOStatement, with cached column metadata, and type conversion

Abstract query-result class. A query result provides an iterator that returns a map for each record of a query result.

Represents an object that is capable of controlling transactions.

Global database interface, complete with static methods.

An extension that adds additional functionality to a DataObject.

Implements a "lazy loading" DataObjectSet.

A single database record & abstract class for the data-access-model.

DataObjectInterface is an interface that other data systems in your application can implement in order to behave in a manner similar to DataObject.

Provides dataobject and database schema mapping functionality

An object representing a query of data from the DataObject's supporting database.

Allows middleware to modily finalised dataquery on a per-instance basis

Represents a subgroup inside a WHERE clause in a DataQuery

DatabaseAdmin class

Represents a signed 8 byte integer field. Do note PHP running as 32-bit might not work with Bigint properly, as it would convert the value to a float when queried from the database since the value is a 64-bit one.

Represents a boolean field.

Represents a classname selector, which respects obsolete clasess.

Extend this class when designing a DBField that doesn't have a 1-1 mapping with a database field.

Represents a decimal field containing a currency amount.

Represents a date field.

Represents a date-time field.

Represents a Decimal field.

Supports double precision DB types

Class Enum represents an enumeration of a set of strings.

Single field in the database.

Represents a floating point field.

A special type Int field used for foreign keys in has_one relationships.

Represents a large text field that contains HTML content.

Represents a short text field that is intended to contain HTML content.

Classes that implement the DBIndexable interface will provide options to set various index types and index contents, which will be processed by \SilverStripe\ORM\DataObjectSchema

Represents a signed 32 bit integer field.

Locale database field, mainly used in Translatable extension.

Provides storage of a localised money object in currency and amount components.

Represents an multi-select enumeration field.

Represents a decimal field from 0-1 containing a percentage value.

A special ForeignKey class that handles relations with arbitrary class types

A special type Int field used for primary keys.

An abstract base class for the string field types (i.e. Varchar and Text)

Represents a variable-length string of up to 16 megabytes, designed to store raw text

Represents a column in the database with the type 'Time'.

Class Varchar represents a variable-length string of up to 255 characters, designed to store raw text

Represents a single year field.

Additional interface for SS_List classes that are filterable.

Base class for creating comparison filters, eg; greater than, less than, greater than or equal, etc

Matches textual content with a substring match on a text fragment leading to the end of the string.

Selects textual content with an exact match between columnname and keyword.

Filters by full-text matching on the given field.

Selects numerical/date content greater than the input

Selects numerical/date content greater than or equal to the input

Selects numerical/date content less than the input

Selects numerical/date content less than or equal to the input

Matches textual content with a LIKE '%keyword%' construct.

Base class for filtering implementations, which work together with SearchContext to create or amend a query for DataObject instances.

Matches textual content with a substring match from the beginning of the string.

A list decorator that allows a list to be grouped into sub-lists by common values of a field.

Subclass of DataList representing a has_many relation.

Anything that implements HiddenClass won't be shown in user-interface elements. For example, DataObjects that implement HiddenClass won't be showing in the "new page" dropdown.

DataObjects that use the Hierarchy extension can be be organised as a hierarchy, with children and parents. The most obvious example of this is SiteTree.

Contains a set of hierarchical objects generated from a marking compilation run.

Additional interface for SS_List classes that are limitable - able to have a subset of the list extracted.

A base class for decorators that wrap around a list to provide additional functionality. It passes through list methods to the underlying list implementation.

Subclass of DataList representing a many_many relation.

ManyManyList backed by a dataobject join table

Injected into DataQuery to augment getFinalisedQuery() with a join table

Creates a map from an SS_List by defining a key column and a value column.

Builds a map iterator around an Iterator. Called by Map

A decorator that wraps around a data list in order to provide pagination.

Represents a has_many list linked against a polymorphic relationship

Represents a list of updates / inserts made to a single row in a table

Represents a where condition that is dynamically generated. Maybe be stored within a list of conditions, altered, and be allowed to affect the result of the parent sql query during future execution.

Represents a SQL query for an expression which interacts with existing rows (SELECT / DELETE / UPDATE) with a WHERE clause

Object representing a SQL DELETE query.

Abstract base class for an object representing an SQL query.

Object representing a SQL INSERT query.

Object representing a SQL SELECT query.

Object representing a SQL UPDATE query.

Represents a SQL expression which may have field values assigned (UPDATE/INSERT Expressions)

Abstract representation of a DB relation field, either saved or in memory

A DataList that represents a relation.

An interface that a class can implement to be treated as a list container.

Provides a simple search engine for your site based on the MySQL FULLTEXT index.

Manages searching of properties on one or more DataObject types, based on a given set of input parameters.

Additional interface for SS_List classes that are sortable.

Throw this exception whenever unexpected data is found.

Interface UniqueKeyInterface

Class UniqueKeyService

An ArrayList that represents an unsaved relation.

Exception thrown by DataObject::write if validation fails. By throwing an exception rather than a user error, the exception can be caught in unit tests and as such can be used as a successful test.

A class that combined as a boolean result with an optional list of error messages.

PostgreSQL connector class using the PostgreSQL specific api

PostgreSQL connector class.

This is a helper class for the SS installer.

A result-set from a PostgreSQL database.

PostgreSQL schema manager

Class RealMeAuthenticator

Class MemberExtension

Class RealMeFederatedIdentity

Class RealMeUser

Class RealMeSetupTask