Classes
The controller for the Auto-Nav block.
An object used by the Autonav Block to display navigation items in a tree.
The controller for the content block.
The controller for the conversation block. This block is used to display conversations in a page.
The controller for the core scrapbook display block. This block is automatically used when a block is copied into a page from a clipboard. It is a proxy block.
The controller for the stack display block. This is an internal proxy block that is inserted when a stack's contents are displayed in a page.
The controller for the block that displays featured add-ons in the dashboard news overlay.
The controller for the block that displays featured themes in the dashboard news overlay.
An object that represents an option in a survey.
Class Block is a backend controller for ajax requests
Note – this came from a half-completed pull request, and no routes actually reference this controller anymore.
Used to join a command to a set of attributes and their associated proposed attribute values entities.
Used to join a command to a set of associations and their proposed entries.
Class BlockTransformer. Used when requested blocks directly via the /blocks API endpoint. This transformer makes an include of "pages" available to show you what pages blocks are on. When blocks are requested through other means, like the pages endpoints, they use the base block transformer because we don't want a recursive situation
OAuth Client Credentials A value object for communicating plain text keys and secrets
Interface ApplicationAwareInterface This interface declares awareness of the concrete5 application.
Trait ApplicationAwareTrait A trait used with ApplicationAwareInterface
The result of an edit operation.
\@package Helpers
Useful functions for generating elements on the Concrete interface.
Interface that all the sitemap providers must implement.
Interface that all the sitemap tree collections (eg multilingual sections) must implement.
Class ApiArea. Wrapper object for working with areas without all the cruft of the legacy area class, and an easier way to set the page object, etc... Used in the REST API.
Interface that all the assets must implement.
Interface that any attribute key must implement.
Interface that category objects (for instance, Express entities) must implement.
Abstract class to be used by attribute category classes.
The interface that any attribute category must implement.
Interface that all the classes that handle the search index of attribute categories must implement.
Class to be implemented by attribute categories to define the attribute indexing table.
Clears a group of attribute keys against an object.
Saves a group of attribute keys against an object.
Attribute controllers should implement this interface to customize the display value when there's no current value.
Handles adding and removing keys from attribute sets.
Formerly the only way to specify an icon – lets attributes provide one as icon.png in their folder.
Attribute controllers should implement this interface if they want to make it possible to filter a result list by the exact value of an attribute. This enables support things like unique/SKU filtering in Express.
Adds required methods to actual REST controllers.
Responsible for serializing an attribute key for use in the key selector component.
Responsible for retrieving attribute values from an object and serializing them.
Responsible for retrieving attribute values from objects and serializing them.
Responsible for serializing attribute sets for use in the key selector component.
Interface that all the classes that handle the search index of attribute keys must implement.
Attribute controllers should implement this interface if they support importing/exporting to/from multiple plain text fields.
The interface that any object thay may have attributes must implement.
Factory class for creating and retrieving instances of the Attribute type entity.
Handles adding and removing keys from attribute sets.
Attribute controllers should implement this interface if they support importing/exporting to/from plain text.
Handles adding and removing keys from attribute sets.
Factory class for creating and retrieving instances of the Attribute type entity.
Class CommunityServiceFactory A simple factory class for creating community authentication services
A port of \Concrete\Controller\Backend\UserInterface\Block::getBlockToEdit functionality that can be more easily included in different situations
A port of \Concrete\Controller\Dialog\Block::validateBlock functionality that can be more easily included in different situations
Work with the rendered view of a block.
This command is used by the in-page board instance rule scheduler. At this point, the instance rule has already been created, but it doesn't have a slot yet, or a start date/time/timezone. So this command is responsible primarily for setting those attributes, and setting the particular slot for the rule (which also puts it out of "draft" mode.)
Simple object to tie a board instance to a set of a InstanceItem objects. These get decreased over time as the board slots are filled out.
Joins content objects to a template and slot number. A simple object that we can use to store values BEFORE we actually populate block content and save items to the database.
Actually responsible for grouping selected content object collections with the proper template. This is then joined back to the slot object.
Joins a content slot to all content objects that could be present in it. This is then filtered by board rules into the actual ContentObjectCollection objects passed to the PlannedSlotTemplate object.
Responsible for filtering slot templates down to the appropriate ones given design criteria on the board, total content slots in templates, etc.
Holds a collection of RenderedSlot objects, each bound to a particular slot for easy rendering.
Holds a collection of RenderedSlot objects, each bound to a particular slot for easy rendering.
Responsible for locating and rendering summary templates.
Simple cache driver that enables doctrine to use c5's caching library.
Class LaminasCacheDriver Adapter class to hook Laminas's cache into Concrete's cache.
Base class for the three caching layers present in Concrete5:
- ExpensiveCache
- ObjectCache
- RequestCache
A cache store that has the ability to be flushed
Class ExpensiveCache This cache stores data that is expensive to build that will see a performance boost if stored on disk.
Class ExpensiveCache This cache stores data about where files are located in concrete5.
Class RequestCache Cache that only lives for the current request. This cache level is not configurable.
Manages opcaches.
Class RedisPageCache
Interface that all captcha controllers must implement.
Interface that captcha controllers .
Interface that configurable captcha controllers can implement to let users customize the captcha.
Captcha controller used when there's no active captcha library.
Batch builder object for use before the batch is actually dispatched and converted into an entity.
Responsible for presenting all loaded Concrete\Core\Command\Task\Input\FieldInterface fields to the actual task system.
An output class that discards output sent to it.
This interface declares awareness of task output.
A trait used with OutputAwareInterface
Receives a task and a command, and synchronously executes the command. On complete, returns the response.
Receives a command and asynchronously executes it on a process.
Methods useful for working with Task objects.
Methods useful for working with Task sets.
A loader that delegates method calls to multiple other loaders
A file loader specific to default core file loading.
Redis config service provider.
Class Liaison.
base command class Large swaths of this class have been copied from illuminate/config 5.2 and 5.5 so you may refer to their documentation for some things.
Adds commands to the console
Interface to flag an object as being aware of the symfony console components.
A trait that provides awareness of the console to objects
Concrete's output style.
Console command parser This was taken directly from illuminate/console
Base class for all the controllers.
Class ControllerResolver.
Adds specific Dashboard endpoints for viewing an entity's results and advanced search.
Adds viewing, creation, update and deletion to a page.
Adds listing of dashboard express entries to a page.
Adds specific Dashboard endpoints for viewing an entity's results and advanced search.
Adds multisite checking to a Dashboard page controller. Note: This must be used from within a Dashboard page controller.
Class ConversationService Currently manages tracking review aggregates
Base class for all the conversations frontend controllers.
A class that holds operations performed on both request and response cookies.
A League CSV formatter to tackle CSV Formula Injection.
Get an instance of a CSV Writer.
PDO implementation of the Connection interface.
Helper class to work with database time zones.
PDO MySql driver.
The PDO implementation of the Statement interface.
EntityManagerConfigFactory Responsible for bootstrapping the core concrete5 entity manager (Concrete\Core\Entity) and the application level entity manager. Sets the stage for the package entity manager once its time for them to come online.
Interface for EntityManagerConfig factories
Each Doctrine MappingDriver must be wrapped by this class, so all Drivers can be loaded correctly during the bootstrap of the application Each new Doctrine MappingDriver must also be wrapped in a new instance of this class
Specify a namespace for a Doctrine ORM driver, as well as what kind of mapping driver it should be.
The standard package entity manager provider. If the package enables legacy namespaces, the provider simply creates a namespace at Concrete\Package\PackageHandle\Src, and considers all classes found at package/package_handle/src potential entities. If the legacy namespace is not enabled, we look for entities at Concrete\Package\PackageHandle\Entity, which maps to packages/package_handle/src/Entity. Additionally, by default any additional autoloader registries are all considered possible entity locations and namespaces.
Implement this in your package controller if you'd like to provide a custom entity manager.
Anything implementing the Provider interface is able to delivery one or more entity manager drivers. Currently the Concrete\Core\Package\Package class (extended by all package controllers) is the only object that implements this interface.
A simple, standard package provider; provide a Concrete\Core\Package\Package controller, and a path (or array of paths) to PHP entity classes. This uses the annotation driver.
Use this provider if you wish to store your entity metadata in XML files.
Use this provider if you wish to store your entity metadata in YAML files.
Class Device A representation of a device.
Class Device A representation of a device.
Interface that all rich-text editors must implement.
Entity representing a thumbnail type.
Entity representing the association between a thumbnail type and file sets.
Represents a version of a file.
Represent Geolocator library.
Handles joining a page object to template objects. Every time a new page version is approved we rebuild this association against the page (much like the PagePath object). This doesn't join directly to the HTML of template, but to the template object only.
Represent an IP Access Control Category.
Represent an IP Access Control Event.
Represent an IP Access Control Range.
Represents a site locale.
Class StackUsageRecord
Class StackUsageRecord
Class ErrorHandler.
Represents an error that can be safely shown to users.
Class to clone express entities.
A Writer class for Express Entry objects
This is a simple registry class to codify all the core features used by the asset system. Features listed in here are provided in some capacity by the core. Fundamental features like pages, files and users aren't used by the block feature system, because it's assumed the core will always have these available. However, they may be used in the future with a fully modular installation procedure.
Denotes that a particular block controller uses features, and allows the block controller to specify which features it requires to function. This allows blocks like the calendar, for example, to specify that they require the Calendar feature to function, which lets them use the feature fallback if the current theme doesn't support those features.
Decorator class around Laminas\Feed\Reader\Entry\Rss that adds sanitization
The result of file import.
Class ExternalFileEntry
Class ExternalFileProviderFactory Get ahold of existing external file providers and create new ones.
Service class for the File entity
Helper class for bitmap image formats.
Class AtomicThumbnailStream Outputs a stream of thumbnails in an atomic way. This ensures a thumbnail will only be built on a single thread at a time
Interface ThumbnailerInterface An interface for classes tasked with creating thumbnails. This interace requires imagine.
Handles regular and retina thumbnails. e.g. Each thumbnail type has two versions of itself the regular one and the 2x one.
A class to be used to import files into the application file manager.
Options to be used when importing a file.
Represents a file being imported.
A seervice class to manage data in the "incoming" folder.
File helper.
Wrapper for ZIP functions.
Represents a file set.
Implementations of this interface will provide their own path in the event that
Class StorageLocation
Class StorageLocationFactory Get ahold of existing storage locations and create new ones.
An inspector to process FLV (Flash Video) files.
An inspector to process image files.
Abstract class that all the file inspectors must extend.
Helper elements for validating uploaded and existing files in Concrete.
An object-oriented wrapper for core element functionality, with support for events, locators, controllers and elements.
Class Icon
A simple class for registering context to view bindings, in the event that certain contexts ought to deliver different views. (Used by Express Attribute Key View vs Form).
A picker for DestinationPicker that allows users specify an email address.
A picker for DestinationPicker that allows users specify an external URL.
A picker for DestinationPicker that allows users specify a concrete5 file.
A picker for DestinationPicker that allows users specify no value.
A picker for DestinationPicker that allows users specify a concrete5 page.
Helpful functions for working with forms. Includes HTML input tags and the like.
Helper functions to use with validating submitting forms.
Interface AsyncCommandInterface Marks a command as asynchronous when used with the default bus.
This is a convenience superclass. You do NOT have to use this in order to use the command bus. This command will automatically provide a handler for you in the same namespace as your command.
Deprecated. Use Concrete\Core\Filesystem\FileLocator instead.
Class EnvironmentDetector.
Useful functions for getting paths for concrete5 items.
A PSR-4 compatible class loader.
Abstract repetition class This class is used to define and match against various time windows.
Default HTTP Runner.
Extending this class allows groups of services to be registered at once.
Opens a modal window to show the details about a particular Finding.
A simple trait to use when you're working with a class that's only property to serialize is "class" and it has nothing to set in the denormlize method.
A more severe version of the StandardGrader - all the behavior is the same but warnings count for 10 and any alerts at all result in a zero-failure.
Helpful search methods
Helper class to render a Font Awesome 5 icon.
Functions to help with using HTML. Does not include form elements - those have their own helper.
Heavily based on BinaryFileResponse represents an HTTP response delivering a file.
Class ApiLoggerMiddleware
Middleware for applying state changes to the application
Middleware for adding and deleting cookies to an http response.
A middleware delegate for dispatching a request and returning a response.
Middleware for applying frame options
A middleware delegate for running the next middleware
The default stack used to keep track of middleware and process requests
Guzzle HTTP message factory. Credits to https://github.com/Majkl578/symfony-guzzle-psr7-bridge
An object that represents a particular request to the Concrete-powered website. The request object then determines what is being requested, based on the path, and presents itself to the rest of the dispatcher (which loads the page, etc...).
An object that represents a particular request to the Concrete-powered website. The request object then determines what is being requested, based on the path, and presents itself to the rest of the dispatcher (which loads the page, etc...).
Interface for the checks to be performed against the connection before installing concrete5 but after the configuration has been specified.
Interface for the checks to be performed before installing concrete5 but after the configuration has been specified.
Interface for the checks to be performed before installing concrete5.
The result of a precondition check.
Service class for installation preconditions.
Interface for the checks to be performed before installing concrete5 that need a web environment.
Wrapper class for our batching specifically for use with jobs to minimize backward compatibility headaches.
A wrapper class for data coming into processQueueItem so transitioning to the version 9 queue is mostly pain-free.
Class Avatar.
An object that allows a filtered list of files to be returned.
This is deprecated. It will be removed. Use Core::make('image/thumbnailer') to grab the current class instead.
An object that allows a filtered list of pages to be returned.
An object that allows a filtered list of users to be returned.
The core translator adapter factory is a wrapper factory that abstracts the translator creation based on the passed locale. By default, a translator instance will be created through the LaminasTranslatorAdapterFactory.
Translation loader that loads the concrete5 core translations for the Laminas translation adapter.
Translation loader that loads the package translations for the Laminas translation adapter.
Translation loader that loads the site interface translations for the Laminas translation adapter.
Translator adapter that wraps the Laminas translator to provide the translator methods needed in concrete5.
Provides a factory method to create translator objects for the Laminas translator.
Translator adapter that wraps the plain translator to provide the translator methods needed in concrete5.
Provides a factory method to create translator objects for the plain translator.
Abstract translation loader provides general methods needed in most translation loader implementations.
Translation loaders provide a standardized way to load new translations into the translator adapters.
Basic implementation of the TranslationLoaderRepositoryInterface.
Translation loader repositories provide a way to store multiple translation loaders.
Translator adapter factories provide factory method for creating a new translator adapter.
Translator adapters wrap the functionality of a specific translator class into a format that can be used within the concrete5 context.
Basic implementation of the TranslatorAdapterRepositoryInterface.
Translator adapter repository can store any number of translator adapters.
An interface for making complex log entries
Log entry for users being added to groups
Log entry for users being removed from groups
Log entry for group actions
Log entry for group actions for a user
Log entry for permission assignments
Log entry for user login attempts
Log entry for user actions
Interface LoggerAwareInterface
Trait LoggerAwareTrait A trait used with LoggerAwareInterface
A processor for adding the Concrete user into the extra log info
A processor for packing $_SERVER info into the extra log info
This class holds the configurable addresses for outgoing emails.
This interface declares awareness of the message bus.
A trait used with MessageBusAwareInterface
This class is used to send responses when using app-powered message consumption. This is the default because it relies on zero configuration but you really should use the CLI messenger:consume command instead.
Messages with this stamp applied will never be sent to an async sender. Useful for working with messages consumed via the console.
A decorator for the default Doctrine Transport Connection.
A convenient wrapper for all of the various objects that comprise a Symfony Messenger Transport.
Class NavigationModifier
Used by all core events that want to interact with Mercure. Translates event names into topics, etc.
Responsible for translating a Concrete server event object into something the Mercure Hub can work with natively
All topics that work with the core CMS should use this. It's just a convenience method so that we don't have to always remember and pass our canonical URL
Package dependency failure.
Package dependency failure: a package doesn't want another package.
Package dependency failure: a package can't be installed since it requires another package that's not installed.
Package dependency failure: an installed package can't be uninstalled since it's required by another package.
Package dependency failure: a package requires specific versions of another package.