Represents a single template block. Parts are represented as array and concatenated with newlines on render.
Collects additional code parts which should be added to specific blocks upon rendering. Code parts can be added on a global level or restricted to a specific site.
Exposes parts of the Piwik SitesManager API
Builds a list of all available Piwik reports which should be shown in reports panel. A ReportConfig references an iframe URL with a title. Additional reports can be added by adding them in the GENERATE_REPORTS event.
Fetches and caches available widget data (stored by site ID and language) from the Piwik API. This is used to show a list of widgets inside the Pimcore admin and to generate iframe URLs to single widgets.
Represents an analytics site config key which is either just "default" without an associated site or a combination of a site with its config key "site_
Tagging interface defining controller as admin controller.
Tagging interface used to protect certain controllers from brute force attacks
Controllers implementing this interface will be double-checked for admin authentication.
Handles all "new" extensions as of pimcore 5 (bundles, new areabrick layout) and pipes legacy extension requests to legacy controller when the legacy bundle is enabled.
end point for object related data.
end point for document related data.
Contains actions to gather information about the API. The /user endpoint is used in tests.
Adds all services with the tags "pimcore_admin.serializer.encoder" and "pimcore_admin.serializer.normalizer" as encoders and normalizers to the Admin Serializer service.
Adds configuration for gdpr data provider
Handles double authentication check for pimcore controllers after the firewall did to make sure the admin interface is not accessible on configuration errors. Unauthenticated routes are not double-checked (e.g. login).
This response serializes its data through the admin serializer (with reference loop handling) instead of calling json_encode. This is to make sure we have consistent responses with
new JsonResponsein admin controllers.
As pimcore needs the user information when encoding the password, every user gets his own encoder instance with a user object. If user is no pimcore user, fall back to default implementation.
Checks if there's an existing admin session and stores its token on the security token storage.
Handle logout. This was originally implemented as LogoutHandler, but wasn't triggered as the token was empty at call time in LogoutListener::handle was called. As the logout success handler is always triggered it is now implemented as success handler.
Resolves the current pimcore user from the token storage.
Proxy user to pimcore model and expose roles as ROLE_* array. If we can safely change the roles on the user model this proxy can be removed and the UserInterface can directly be implemented on the model.
We're calling the valid user check in pre and post auth as it is cheap and we're also dealing with pre authenticated tokens.
Loads user either from token storage (when inside admin firewall) or directly from session and keeps it in cache. This is mainly needed from event listeners outside the admin firewall to access the user object without needing to open the session multiple times.
See original CacheCollectorPass in FrameworkBundle. This injects our core Pimcore cache into the cache collector.
The debug.stopwatch service is always defined, so we can't just add it to services if defined. This only adds the stopwatch to services if the debug flag is set.
Our migration commands and installers rely on Doctrine Migrations, but don't demand to activate the migrations bundle.
The application logger has a dependency on the monolog.processor.psr_log_message service which is only registered conditionally by the monolog bundle (depending on if a handler using the PSR log message processor is registered). As the application logger fails if the processor service is missing, we register it conditionally here.
Adds tagged navigation renderers to navigation helper
Adds a setPimcoreContextResolver() call on event listeners implementing PimcoreContextResolverAwareInterface.
Sets a pimcore.service_controllers parameter which contains all controllers registered as service as an id => class mapping. Controllers are recognized if they match one of the following:
Adds a call to set the PHP templating engine to all helpers implementing TemplatingEngineAwareHelperInterface
Overrides the core web debug toolbar listener
Handles block state for sub requests (saves parent state and restores it after request completes)
If a contentTemplate attribute was set on the request (done by router when building a document route), extract the value and set it on the Template annotation. This handles custom template files being configured on documents.
If no document was found on the active request (not set by router or by initiator of a sub-request), try to find and set a fallback document:
Adds Meta Data entries of document to HeadMeta view helper
Modifies responses for editmode
Handles element setup logic from request. Basically this does what the init() method on the ZF frontend controller did.
Runs before dynamic routing kicks in and resolves site + handles redirects
Sets canonical headers for hardlink documents
Handles the attributes set by TemplateControllerInterface and injects them into the Template annotation which is then processed by SensioFrameworkExtraBundle. This allows us to add view auto-rendering without depending on annotations.
Disables the web debug toolbar for frontend requests by admins (iframes inside admin interface)
Interface for cart implementations of online shop framework
Interface for cart item implementations of online shop framework
Sample implementation for delivery address
Sample implementation for delivery date
Interface for checkout step implementations of online shop framework
Resolves default config or worker in case only config or worker is set
Helper for getting possible group by values based on different column groups
Helper Class for setting up a product list utilizing the filter service based on a filter definition and set filter parameters
Interface for environment implementations of online shop framework
Builds attributes from config. Getters and interpreters are scoped service locators containing only the configured getters/interpreters.
Default implementation for fact finder as product index backend
Default implementation for FINDOLOGIC as product index backend
Tenant configuration for a simple mysql product index implementation. It is used by the default tenant.
Sample implementation for sub-tenants based on mysql.
Default configuration for elastic search as product index implementation.
Interface for IndexService Tenant Configurations
Interface for IndexService Tenant Configurations using elastic search as index
Interface for IndexService Tenant Configurations using factfinder as index
Interface for IndexService Tenant Configurations using findologic as index
Interface for IndexService Tenant Configurations with mockup implementations
Interface for IndexService Tenant Configurations using mysql as index
Configuration for the optimized mysql product index implementation.
Interface for getter of product index columns which consider sub object ids and tenant configs
Implementation of product list which works based on the product index of the online shop framework
Implementation of product list which works based on the product index of the online shop framework
Interface for product list which works based on the product index of the online shop framework
Provides worker functionality for batch preparing data and updating index
provides worker functionality for mockup cache and central store table
Interface for IndexService workers which support batch processing of index data preparation and index updating
Interface for IndexService workers
Abstract base class for pimcore objects who should be used as product categories in the online shop framework
Abstract base class for filter definition pimcore objects
Abstract base class for filter definition type field collections
Abstract base class for order pimcore objects
Abstract base class for order item pimcore objects
Abstract base class for payment information field collection
Abstract base class for pimcore objects who should be used as products in the online shop framework
Abstract base class for pimcore objects who should be used as set products in the online shop framework
Class for product entry of a set product - container for product and quantity
Abstract base class for voucher token type field collections
Abstract base class for filter definition type field collections for category filter
Abstract base class for offer pimcore objects
Abstract base class for offer item pimcore objects
Abstract base class for pimcore objects who should be used as custom products in the offer tool
Class AbstractListItem template method pattern
Base filter for LIKE queries. For simple queries you'll just need to override the getConditionColumn() method and return the query part coming before LIKE.
Search filter with flexible column definition
Interface for checkout payment provider
Class OGone Payment integration for Ingenico OGone
Attribute info for attribute price system
Price system which caches created price info objects per product and request
Interface for prices returned by price modifcators
Interface for price implementations of online shop framework
Interface for PriceInfo implementations of online shop framework
Base implementation for a lazy loading price info
Adds a gift product to the given cart
Interface to identify product discount actions
Takes an object (e.g. a product, an order) and transforms it into a normalized tracking object (e.g. a ProductAction or a Transaction).
This value object is used throughout the ecommerce framework to represent a price value.
This acts as facade for the actual cache implementation and exists primarily for BC reasons.
Core pimcore cache handler with logic handling deferred save on shutdown (specialized for internal pimcore use). This explicitely does not expose a PSR-6 API but is intended for internal use from Pimcore\Cache or directly. Actual cache calls are forwarded to a PSR-6 cache implementation though.
Determines if the full page cache should be disabled due to session (started session containing data).
Redis2 item pool with tagging and LUA support.
Merges an updated composer.json schema from an update into the existing one, optionally normalizing it via normalizer implementations.
Normalizes the composer.json config after merging it from an update. This can include removing invalid configs or package names as the merge process is only additive.
Makes sure only endroid/qr-code is in the list of dependencies (was renamed from the obsolete endroid/qrcode).
Removes the config.platform.php: 7.0 entry which was shipped with early Pimcore 5 versions and leads to Symfony not being updated further than 3.3.6
Locates configs from bundles if Resources/config/pimcore exists.
Provides a property based interface to an array.
Handles writing/merging report config and emitting an event on config save.
Base command class setting up some defaults (e.g. the ignore-maintenance-mode switch and the VarDumper component).
Base class for plugins providing CLI commands.
The console application
Implements a ConsoleOutput with configurable output. Useful when needing to catch both output and error output in a buffered output.
Helper class to use the Symfony\VarDumper component from CLI commands
Adds support for type hinting controller actions against
Document $documentand getting the current document.
This service exists as integration point between legacy module/controller/action <-> new bundle/controller/action and to handle default bundle/controller/action in case it is not configured.
Provides bundle/controller/action/template selection options which can be used to configure controller + template for documents or static routes.
Allows to set HTTP headers on the response via annotation. The annotation will be processed by ResponseHeaderListener which will set the HTTP headers on the response.
Same annotation as Template, but defaults to the php engine
Simple integration into the profiler timeline by adding events to the debug stopwatch. Usage:
Service locator exposing all of its services as collection
Simple value object containing both name and real name of a block.
Keeps track of the current block nesting level and index (will be used from editables to build their hierarchical tag name).
Handles block state (current block level, current block index). This is the data which previously was handled in Registry pimcore_tag_block_current and pimcore_tag_block_numeration.
Represents a block element (block, areablock)
Represents all document editables (blocks + other editables)
This listener is not intended to be always registered on the dispatcher, but instead is added manually when needed in the MigrateTagNamingStrategy CLI command. The listener collects all rendered tag names and creates a matching new tag name mapping which can be used to perform tag name migrations after rendering a document.
Determines if a response can be cached.
Trait for all events handling responses. Taken from GetResponseEvent.
Exposes a simple getVersion() implementation by looking up the installed versions via ocramius/package-versions which is generated on composer install. This trait can be used by using it from a bundle class and implementing getComposerPackageName() to return the name of the composer package to lookup.
Helper trait exposing static isEnabled() and isInstalled() methods for bundles which can be used to check bundle state from non-service definitions (e.g. class definitions).
Base brick with template autoloading capabilities.
Bricks implementing this interface auto-resolve view and edit templates if has*Template properties are set.
Lazily loads a state if no state is set. When a feature toggle state is requested and no value is registered, the feature manager will delegate initialization to its registered initializers to provide a default state. As soon as there is a state for a specific feature, initializers won't be called anymore.
Formats json strings used for php < 5.4 because the json_encode doesn't supports the flags JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE in these versions
Defines a bundle which has dependencies on other bundles. When adding a DependentBundle to the collection, the collection will call the static method to register additional bundles.
Creates needed pimcore directories when warming up the cache
Builds public web path for a resource saved in Resources/public of a bundle
Gets/sets and guesses pimcore context (admin, default) from request. The guessing is implemented in PimcoreContextGuesser and matches the request against a list of paths and routes which are exposed via config.
This stack can be used to collect responses to be sent from parts which cannot directly influence the request-response cycle (e.g. templating parts). For example this is used to read responses from an areabrick's action() method which is pushed to this stack.
Loads implementations from a fixed name => className map
Core implementation loader delegating to a list of registered loaders
Iterates an array of namespace prefixes and tries to load classes by namespace.
Formatting service for dates, times and numbers
Make sure you add this processor when using the ApplicationLoggerDb handler as is prepares data to be written by the handler. This replicates the functionalty implemented in ApplicationLogger, but makes it available when using the ApplicationLoggerDb handler in a pure PSR-3 handler context configured as monolog channel handler instead of the ApplicationLogger class.
Configuration for bundle install/uninstall operations handling only a single migration which delegates changes to the bundle installer.
Used in migrations handling something else than DB migrations (e.g. changing class definitions). As a normal doctrine migration does not know about the dry-run switch (SQL is simply not executed), we need to pass the dry-run state to the migration itself.
This migration is executed when a bundle is about to be installed/uninstalled and is built in conjunction with InstallConfiguration and InstallVersion.
Doctrine migrations by default output a warning if no SQL queries were run during a migration. This is perfectly OK for only DB-based migrations, but might happen if a migration changes class definitions which handle their SQL updates implicitely. If a migration implements this interface and doesSqlMigrations() returns false, the warning will be omitted.
TODO: Refactor - this class is very similar to the parent one so probably we can try to refactor parent and have better results here also
Value object containing properties needed while matching document routes.
Normalizes autogenerated admin routes to pimcore_admin_ and pimcore_api_ prefixes
A custom router implementation handling pimcore static routes.
Password encoding and verification for Pimcore objects and admin users is implemented on the user object itself.
Encoder factory keeping a dedicated encoder instance per user object. This is needed as Pimcore Users and user objects containing Password field definitions handle their encoding logic by themself. The user aware encoder delegates encoding and verification to the user object.
User provider loading users from pimcore objects. To load users, the provider needs to know which kind of users to load (className) and which field to query for the username (usernameField).
Handles a collection of session configurators.
URL generator specific to documents with site support.
Filters document if it is a site root, but doesn't match the current site. This used to exclude sites from the default section.
Basic generator for all kinds of elements supporting pluggable filters (= exclude elements) and processors (= enrich generated URL).
Filters element based on the sitemaps_exclude and sitemaps_exclude_children properties.
Context which is passed to every filter/processor
Adds modification date from element modification date.
Adds change frequency and priority entries based on document properties.
A simple absolute URL generator accepting a path and generating absolute URLs for the current request context. Parts of the URL (e.g. host or scheme) can be influenced by passing them as options.
Defines a component which depends on data providers. Currently supported for
Loads geolocation from GeoIP (IP to geo database).
Loads geolocation (only coordinates and optional altitude) from either browser geolocation delivered as cookie or from geoip lookup as fallback.
Handles target groups configured on the document settings panel. If a document has configured target groups, the assign_target_group will be manually called for that target group before starting to match other conditions.
Removes cookie storage cookies from cached response (only from the response object, not from the client's browser).
Interface for override handlers which can influence the debug toolbar form and override targeting data based on form results.
Makes sure a page visit is counted only once per request.
Stores data as cookie in the client's browser
Extends core decoder and decodes to array instead of object.
NOTE: using this save handler is inherently insecure and can open vulnerabilities by injecting malicious data into the client cookie. Use only for testing!
Implements a 2-step storage handling a primary storage which needs a visitor ID (e.g. external DB) and a fallback storage which is able to save data without a visitor ID (e.g. session or cookie).
This defines the interface for a persistent targeting storage (e.g. Session). The targeting storage needs to define by itself if it needs a unique visitor ID to store data and fetch if from the visitor info itself.
Similar to the TokenStorage for user objects, this contains the current visitorInfo valid for the current request.
Shortcuts available as $this->method() on the engine
Helper for passing data between otherwise segregated Views. It's called Placeholder to make its typical usage obvious, but can be used just as easily for non-Placeholder things. That said, the support for this is only guaranteed to effect subsequently rendered templates, and of course Layouts.
Registry for placeholder containers
Symfony PHP engine with pimcore additions:
Times the time spent to render a template. This is the same class as the core TimedPhpEngine, but extends our custom PHP engine.
Runs the assets:install command with the settings configured in composer.json
Standard RestClient working with a Guzzle client
Simple helpers that do not need a dedicated extension
Delegates calls to PHP templating helpers. Use this only with templating helpers which do not rely on PHP rendering!
The spaceless tag only removes spaces between HTML elements. This removes all newlines in a block and is suited for a simple minification of CSS/JS assets.