A class representing back actions.
Special request handler for admin/batchaction
The object manages the main CMS menu. See {@link 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
Imports {@link Group} records by CSV upload, as defined in {@link 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 {@link Member} records by CSV upload, as defined in {@link 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
Delete multiple {@link 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
Extension that updates the Popover menu of FileFormFactory.
Decorates ModalController with an insert-oembed modal
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
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?")
Handles create and update
EmbedResource deprecated
Embeddable deprecated
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.
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.
Service to help migrate File dataobjects to the new APL.
Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility. Can be used for files and folders.
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.
Represents an Image
Creates backends for images as necessary, avoiding redundant asset writes and loads
Provides image manipulation functionality.
Image_Backend
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
Interface to define a handler for persistent generated files
Provides routing for session-whitelisted protected files
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.
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 {@link DataObject}.
Extension to include custom page icons
ModelAsController deals with mapping the initial request to the first {@link 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 {@link SiteTree} objects with "stage" and "live" links.
Navigator items are links that appear in the $SilverStripeNavigator bar.
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 {@link 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 {@link 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 {@link 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"
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
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 {@link Director} selects a controller to pass control to, and then calls {@link 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.
Mailer objects are responsible for actually 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 {@link RequestHandler} objects to decide what to do.
Represents a response returned by a controller.
A {@link HTTPResponse} encapsulated in an exception, which can interrupt the processing flow and be caught by the {@link 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
Allows events to be registered and passed through middleware.
Handles internal change detection via etag / ifmodifiedsince headers, conditonally sending a 304 not modified if possible.
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.
Decorates a request handler with the HTTP Middleware pattern
This middleware will rewrite headers that provide IP and host details from an upstream proxy.
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
RequestFilter deprecated
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.
RequestProcessor deprecated
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
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 {@link 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 faciliate autoload and template manifest generation: - Only modules with _config.php files are scanned.
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 {@link LeftAndMain::CMSVersion()}
Path manipulation helpers
Represents a class with a local cache which normally invalidates itself between requests.
Guesses location for temp folder
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 {@link BulkLoader} import (usually through the {@link BulkLoader->processAll()} method).
CLI
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 developement 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 developement info view.
Handles raising an notice when accessing a deprecated method
Base class for development tools.
A blueprint on how to create instances of a certain {@link DataObject} subclass.
Manages a set of database fixtures for {@link 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.
Provides environment settings from the current request + environment
For classes which are aware of install, project, and environment state.
This class checks requirements Each of the requireXXX functions takes an argument which gives a user description of the test.
This installer doesn't use any of the fancy SilverStripe stuff in case it's unsupported.
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
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.
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
Provides upgrade interface for bootstrapping.
Uses Symfony's YAML component to parse a YAML document (see http://yaml.org).
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 {see ErrorPage}-gnostic error handling
Decorates {see File} with ErrorPage support
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.
Two masked input fields, checks for matching passwords.
Renders a text field, validating its input as a currency.
Readonly version of a {@link CurrencyField}.
Readonly version of a {@link CurrencyField}.
Abstract class for all fields without data.
Form used for editing a date string
Disabled version of {@link 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.
Represents a file type which can be added to a form.
Provides operations for reading and writing uploaded files to/from {see File} dataobject instances.
Base class for all forms.
The action buttons are <input type="submit"> as well as
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 {@link Form} and {@link FormField} HTML template output.
This class represents "transformations" of a form - such as making it printable or making it readonly.
Displays a {@link 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 {@link RelationList} passed to the {@link GridField} constructor.
This component provides a button for opening the add new form provided by {@link GridFieldDetailForm}.
Adding this class to a {@link 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 {@link 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 {@link GridFieldConfig_RecordEditor}, but adds features to work on has-many or many-many relationships.
This class is a {@link 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 {@link GridField}.
Adds an "Export list" button to the bottom of a {@link GridField}.
GridFieldFilterHeader alters the {@link GridField} with some filtering fields in the header of each column.
Adding this class to a {@link 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 {@link 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 {@link GridField} list and adds controls to the bottom of the {@link GridField}.
Adds an "Print" button to the bottom or top of a GridField.
GridFieldSortableHeader adds column headers to a {@link GridField} that can also sort the columns.
Adding this class to a {@link 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 {@link 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 {see 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 {@link 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 {@link GridField} is saved into a record.
Sometimes an action isn't enough: you need to provide additional support URLs for the {@link GridField}.
This class is a snapshot of the current status of a {@link 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 {@link 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 {@link 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 {@link MultiSelectField}.
A form field that can save into a {@link Money} database field.
Represents a SelectField that may potentially have multiple selections, and may have a {@link 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 {@link 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 {@link 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 {@link SelectionGroup_Item}.
Read-only complement of {@link DropdownField}.
Represents the base class for a single-select field
Tab
Implements a single tab in a {@link 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 {@link TimeField}.
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.
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.
Base interface for any {@link DataObject} passed back as a node.
Base type for query types within graphql. I.e. mutations or queries
Base type creator for interface type generation.
Manager is the master container for a graphql endpoint, and contains all queries, mutations, and types.
Represents middleware for evaluating a graphql query
Represents a writable entrypoint field in the top level graphql 'mutation' schema
Standard resolve callback for Mutations or Queries
A connection to a list of items on a object type. Collections are paginated and return a list of edges.
Supports offset based pagination within GraphQL.
A helper class for making a paginated query. A paginated query uses the {@link Connection} object type to encapsulate the edges, nodes and page information.
Type for specifying the sort direction for a specific field.
Type creator for an enum value for a list of possible sortable fields
Represents a queryable entrypoint field in the top level graphql 'query' schema
Adds functionality to associate an object with a given GraphQL type, either internal (e.g. String) or complex (e.g. object)
Defines the methods required for a class to accept a configuration as an array
Defines a class that updates the Manager
Applied to classes that resolve queries or mutations
Defines a class that transforms into a type or field creator
Use on classes that update the GraphQL scaffolder
Defines the interface used for services that create GraphQL types based on simple input, e.g. a formatted string or array
A generic "create" operation for a DataObject.
A generic delete operation.
Scaffolds a generic read operation for DataObjects.
Scaffolds a generic read operation for DataObjects.
Scaffolds a generic update operation for DataObjects.
Scaffolds a DataObjectTypeCreator.
Scaffolds a GraphQL query field.
Scaffolds a GraphQL query field.
Scaffolds a GraphQL mutation field.
Provides functionality common to both operation scaffolders. Cannot be a subclass due to their distinct inheritance chains.
Scaffolds a GraphQL query field.
The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions, and their nested Mutation/Query definitions.
Offers a few helper methods for classes that are DataObject subclass bound.
Parses a map of type, e.g. Int!(20) into an array defining the arg type
An array list designed to work with OperationScaffolders
Parses a type, e.g. Int!(20) into an array defining the arg type
Represents a GraphQL type in a way that allows customization through SilverStripe's {@link DataExtension} system.
Infer original field name casing from case insensitive field comparison.
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.
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)
Builds a SQL query string from a SQLExpression object
Represents schema management object for MySQL
Provides a record-view for mysqli 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.
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.
DB
Global database interface, complete with static methods.
An extension that adds additional functionality to a {@link 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 {@link 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.
Apply this interface to any {@link 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 {@link \SilverStripe\ORM\DataObjectSchema}
Represents a signed 32 bit integer field.
Locale database field, mainly used in {@link 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 {@link 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 {@link SearchContext} to create or amend a query for {@link DataObject} instances.
Matches textual content with a substring match from the beginning of the string.
Incomplete.
A list decorator that allows a list to be grouped into sub-lists by common values of a field.
Subclass of {@link 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 {@link 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 {@link DataList} representing a many_many relation.
ManyManyList backed by a dataobject join table
Injected into DataQuery to augment getFinalisedQuery() with a join table
Map
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 {@link DataObject} types, based on a given set of input parameters.
Additional interface for {@link SS_List} classes that are sortable.
Throw this exception whenever unexpected data is found.
An {@link ArrayList} that represents an unsaved relation.
Exception thrown by {@link 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.
Base "abstract" class creating reports on your data.
Reports section of the CMS.
SS_ReportWrapper is a base class for creating report wappers.
Renderer for showing SideReports in CMSMain
A report wrapper that makes it easier to define slightly different behaviour for side-reports.
An AuthenticationHandler is responsible for providing an identity (in the form of a Member object) for a given HTTPRequest.
Abstract base class for an authentication method
Provides an interface to HTTP basic authentication.
Provides a security interface functionality within the cms
Provides access to the default admin
Allows objects to enforce permissions for the "root" level, where permissions can not be tied to a particular database record.
A security group.
Represents an authentication handler that can have identities logged into & out of it.
Calculates batch permissions for nested objects for: - canView: Supports 'Anyone' type - canEdit - canDelete: Includes special logic for ensuring parent objects can only be deleted if their children can be deleted also.
Provides standard permission fields for inheritable permissions
Record all login attempts through the {@link LoginForm} object.
Abstract base class for a login form
Log out form to display to users who arrive at 'Security/logout' without a CSRF token. It's preferable to link to {@link Security::logout_url()} directly - we only use a form so that we can preserve the "BackURL" if set
The member class which represents the users of the system
Provides authentication for the user within the CMS
Provides the in-cms session re-authentication form for the "member" authenticator
Standard Change Password Form
Authenticate a member pased on a session cookie
Handle login requests from MemberLoginForm
Class LogoutHandler handles logging out Members from their session and/or cookie.
Class LostPasswordForm handles the requests for lost password form generation
Handle login requests from MemberLoginForm
Authenticator for the default "member" method
Log-in form for the "member" authentication method.
Authenticate a member pased on a session cookie
Imports member records, and checks/updates duplicates based on their 'Email' property.
Keep track of users' previous passwords, so that we can check that new passwords aren't changed back to old ones.
Represents a set of Groups attached to a member.
Member Validator
Specialized subclass for disabled security tokens - always returns TRUE for token checks. Use through {@link SecurityToken::disable()}.
Allows pluggable password encryption.
Blowfish encryption - this is the default from SilverStripe 3.
Legacy implementation for SilverStripe 2.1 - 2.3, which had a design flaw in password hashing that caused the hashes to differ between architectures due to floating point precision problems in base_convert().
Uses MySQL's OLD_PASSWORD encyrption. Requires an active DB connection.
Uses MySQL's PASSWORD encryption. Requires an active DB connection.
Cleartext passwords (used in SilverStripe 2.1).
Encryption using built-in hash types in PHP.
This class represents a validator for member passwords.
Represents a permission assigned to a group.
Shows a categorized list of available permissions (through {@link Permission::get_codes()}).
Readonly version of a {@link PermissionCheckboxSetField} - uses the same structure, but has all checkboxes disabled.
Calculates edit / view / delete permissions for one or more objects
Throw this exception to register that a user doesn't have permission to do the given action and potentially redirect them to the log-in page. The exception message may be presented to the user, so it shouldn't be in nerd-speak.
Used to let classes provide new permission codes.
A PermissionRole represents a collection of permission codes that can be applied to groups.
A PermissionRoleCode represents a single permission code assigned to a {@link PermissionRole}.
Permission_Group class
Convenience class for generating cryptographically secure pseudo-random strings/tokens
Persists a token associated with a device for users who opted for the "Remember Me" feature when logging in.
Core authentication handler / store
Implements a basic security model
Cross Site Request Forgery (CSRF) protection for the {@link Form} class and other GET links.
SiteConfig
Root permission provider for pages in the SiteTree root
psr-6 cache proxy for an internal cache, which provides segmentation of cache keys based on current versioned mode. This ensures that cross-stage content cannot cross-pollenate each other.
Allows injection of a psr-6 proxy over an inner cache backend.
The ChangeSet model tracks several VersionedAndStaged objects for later publication as a single atomic action
A single line in a changeset
Utility class to render views of the differences between two data objects (or two versions of the same data object).
Decorates TestSession object to update get / post requests with versioned querystring arguments.
Decorate sapphire test with versioning
Decorator for either a Read or ReadOne query scaffolder
A generic "create" operation for a DataObject.
Scaffolds a generic update operation for DataObjects.
Scaffolds a generic update operation for DataObjects.
Scaffolds a generic read operation for DataObjects.
Scaffolds a generic update operation for DataObjects.
This class is a {@link GridField} component that replaces the delete action and adds an archive action for objects.
This class is a {@link GridField} component that adds a restore action for versioned objects.
Converter helpers for versioned args
Provides owns / owned_by and recursive publishing API for all objects.
Provides recursive publishable behaviour for LeftAndMain and GridFieldDetailForm_ItemRequest
Generic restore action to restore an archived item to draft
Minimum level extra fields required by extensions that are versonable
The Versioned extension allows your DataObjects to have several versions, allowing you to rollback changes and view history. An example of this is the pages used in the CMS.
Decorates a GridFieldConfig with a archive action
Extends {see GridFieldDetailForm}
Provides versioned dataobject support to {see GridFieldDetailForm_ItemRequest}
Decorates a GridFieldConfig with gridfield publishing state
Initialises the versioned stage when a request is made.
Persists versioned state between requests via querystring arguments
Represents a single version of a record.
Lets you wrap a bunch of array data, or object members, into a {@link ViewableData} object.
Resets requirements for test state
Encapsulation of an embed tag, linking to an external media source.
Abstract interface for an embeddable resource
HTML Helper class
Class representing a 'diff' between two sequences of strings.
Base class for HTML cleaning implementations.
This class handles the converting of HTML fragments between a string and a DOMDocument based representation.
Cleans HTML using the HTMLPurifier package http://htmlpurifier.org/
Format a SQL Query for better readable output in HTML or Plaintext.
Abstract interface for a class which handles shortcodes
A simple parser that allows you to map BBCode-like "shortcodes" to an arbitrary callback.
Cleans HTML using the Tidy package http://php.net/manual/en/book.tidy.php
Support class for converting unicode strings into a suitable 7-bit ASCII equivalent.
Filter certain characters from "URL segments" (also called "slugs"), for nicer (more SEO-friendly) URLs.
Requirements tracker for JavaScript and CSS.
Provides an abstract interface for minifying content
This is the exception raised when failing to parse a template. Note that we don't currently do any static analysis, so we can't know if the template will run, just if it's malformed. It also won't catch mistakes that still look valid.
This is the parser for the SilverStripe template language. It gets called on a string and uses a php-peg parser to match that string against the language structure, building up the PHP code to execute that structure as it parses
Parses a template file with an *.ss file extension.
Defines an extra set of basic methods that can be used in templates that are not defined on sub-classes of {@link ViewableData}.
This extends SSViewer_Scope to mix in data on top of what the item provides. This can be "global" data that is scope-independant (like BaseURL), or type-specific data that is layered on top cross-cut like (like $FirstLast etc).
Special SSViewer that will process a template passed as a string, rather than a filename.
This tracks the current scope for an SSViewer instance. It has three goals: - Handle entering & leaving sub-scopes in loops and withs - Track Up and Top - (As a side effect) Inject data that needs to be available globally (used to live in ViewableData)
Provider for the [embed] shortcode tag used by the embedding service in the HTML Editor field.
Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template.
Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template that returns values dependant on the state of the iterator of the current scope.
This interface needs to be implemented by any template parser that is used in SSViewer
Contains references to any number of themes or theme directories
A class which builds a manifest of all themes (which is really just a directory called "templates")
Handles finding templates from a stack of template manifest objects.
A ViewableData object is any object that can be rendered into a template/view.
Allows you to render debug information about a {@link ViewableData} object into a template.
Locale metadata
Locales data source
Data sources for localisation strings. I.e. yml files stored within the /lang folder in any installed module.
Provides localisation of messages
Message reader. Inverse of Writer
Some arbitrary resource which expires when flush is invoked.
Loads yaml localisations across all modules simultaneously.
Implement message localisation using a symfony/translate backend
Allows serialization of entity definitions collected through {@link i18nTextCollector} into a persistent format, usually on the filesystem.
Write yml files compatible with ModuleYamlLoader
Parser that scans through a template and extracts the parameters to the _t and <%t calls
SilverStripe-variant of the "gettext" tool: Parses the string content of all PHP-files and SilverStripe templates for ocurrences of the _t() translation method. Also uses the {@link i18nEntityProvider} interface to get dynamically defined entities by executing the {@link provideI18nEntities()} method on all implementors of this interface.
Base-class for storage and retrieval of translated entities.
Dynamically provide translatable entites for the {@link i18n} logic.