All Classes and Interfaces
Class
Description
Implements behavior shared by auditable listener implementations
This abstract class contains the plumbing that sets up the context for handling a
BroadleafApplicationEvent.Provides no-op implementations to optional methods
Support for any class that wishes to utilize a query miss cache.
This provides a useful mechanism to pre-load/initialize classes that are required by a child class during class transformation,
but that may not have been loaded or initialized by the JVM.
Implements
AbstractEntityDuplicationHelper.getCopyHints() and AbstractEntityDuplicationHelper.addCopyHint(String, String),
using a HashMap as the underlying data structure for storing the hints.Base
ExtensionHandler class that provide basic extension handler properties including
priority (which drives the execution order of handlers) and enabled (which if false informs the
manager to skip this handler).All payment gateway classes that intend to make an external call, either manually
from an HTTP Post or through an SDK which makes its own external call, should
extend this class.
An abstract GeneratedResourceHandler that is capable of responding to a single specified filename and generate
contents for that filename.
Provides common logic for
GenericFilterBean implementations to allow for ignoring behavior based on the presence (or absence)
of a request param.Provides common logic for
OncePerRequestFilter implementations to allow for ignoring behavior based on the presence (or absence)
of a request param.
Contains useful processing code for merge bean post processors.
Modules that need to be configured via the database should extend this.
Contains useful processing code for merge bean post processors.
An abstract tag replacement processor that provides methods to help get resource/bundle information
Default implementation of
SiteServiceExtensionHandlerAn Abstract implementation of the TRCreditCardExtensionHandler.
this interface indicates if the domain objects use additional fields
It is not mandatory, but it is useful in order to process those fields in a generic way when generating JAXB Wrappers
Define whether a new collection member is searched for or constructed.
When viewing entities that implement this interface in the admin, the
AdminMainEntity.getMainEntityName() method will be
invoked to determine the title of the entity to be rendered.This class is specifically used as a temporary workaround for
ConditionalOnAdmin
and ConditionalOnNotAdmin to allow them to work correctly when using
application servers such as JBoss.Adorned target collections are a variant of the basic collection type (@see AdminPresentationCollection).
This annotation is used to describe a simple persistent collection
for use by the admin tool.
This annotation is used to describe a persisted map structure for use in the
admin tool
This annotation is used to describe a member of a Map structure that should be
displayed as a regular field in the admin tool.
This annotation is used to describe an array of map fields that allow map members
to be displayed as regular fields in the admin tool.
Represents a single key value presented to a user in a selectable
list when editing a map value in the admin tool
Represents a override value for a specific admin presentation property.
Allows a non-comprehensive override of admin presentation annotation
property values for a target entity field.
Allows a non-comprehensive override of admin presentation annotation
property values for a target entity field.
Annotation for defining how CRUD operations are performed on an advanced collection in Broadleaf Commerce.
Define whether a new collection member is searched for or constructed.
This
BroadleafClassTransformer changes the name of the Table for an
entity before Hibernate sees it.Deprecated.
This interface is the super interface for all classes that will provide a JAXB unwrapper
around classes.
This interface is the super interface for all classes that will provide a JAXB wrapper
around classes.
Convenient class to hold the Spring application context.
For HTML fields maintained in the admin, redactor allows the user to select images.
Utility class that utilizes NIO support for atomic filesystem move operations.
Merge the attributes of a source and patch node, only adding attributes from
the patch side.
Mark a field to exclude the actual field value change during standard auditing.
MBean registered in JMX to keep track of which persistence units are marked with auto.ddl 'create'.
Allows a module to specify a sql file and some ordering information to use during Hibernate auto import.
Convenience base class which all handler implementations extend.
Responsible for providing the base url for the site / admin applications.
Base class for APIWrapper implementations to inject the EntityConfiguration reference.
This class allows us to round Big Decimals to 2 decimal places, generally for
marshalling purposes.
Ehcache 3 cache event listener for monitoring cache changes using the Big memory hydrated cache.
Jcache cache event listener for monitoring cache changes using the Big memory hydrated cache.
Adds some convenience methods to the Spring AbstractHandlerMapping for
BLC specific HandlerMappings.
Convenience methods for interacting with arrays
Convenience methods for interacting with collections.
Convenience class to facilitate cron interpretation.
Convenience class to facilitate date manipulation.
Utility class used primarily for retrieving fields on domain classes.
Extension manager that holds the list of
BLCICacheExtensionHandler.A
ResourceResolver that replaces the //BLC-SERVLET-CONTEXT and //BLC-SITE-BASEURL"
tokens before serving the BLC.js file.A
ResourceResolver that replaces the //BLC-SERVLET-CONTEXT and //BLC-SITE-BASEURL"
tokens before serving the BLC.js file.Convenience methods for interacting with maps
Deprecated.
this class should not be used to statically retrieve localized messages.
Convenience class to format prices for front-end display.
Convenience methods for interacting with Java number types
Convenience class to payment method data for front-end display.
Convenience methods for interacting with the request
Deprecated.
this class should not be used to statically obtain referenes to properties.
A
ResourceResolver that replaces system properties in BLC-system-property.jsExposes the
BroadleafRequestContext to the Thymeleaf expression contextRepresents a single crumb in a Breadcrumb list
An extensible enumeration of breadcrumb types.
Contains a list of static priority fields for commonly used Breadcrumb elements.
An abstract controller that provides convenience methods and resource declarations for its children
Deprecated.
NO LONGER REQUIRED AND SHOULD NOT BE USED.
Base abstract ApplicationEvent that provides a marker for Broadleaf events and provides a default
context map.
This class is a simple extension to Spring's SimpleApplicationEventMulticaster.
BroadleafApplicationListener<E extends org.springframework.context.ApplicationEvent>
Works in conjection with
org.broadleafcommerce.common.event.BroadleafApplicationEventMulticaster except
the event listener can indicate if the event should be run in a background thread.
Prefixes a default Spring-generated bean name with 'bl', and also uppercases the first character of the default bean name.
Used in conjunction with
SpringBootBootstrappingServletContextListener.A ResourceResolver that handles using the theme as part of the cache key and adds in
support to disable with environment properties.
Wraps Spring's
CachingResourceResolver but adds in support to disable with
environment properties.Main configuration class for the broadleaf-common module
Customized property source for broadleaf-common
Support introduction of customized or additional services to the Hibernate service registry.
Some resource handlers need a valid site, theme, or sandbox to be available when serving request.
Commonly used Broadleaf Controller operations
Specific Spring component to override the default behavior of
CookieLocaleResolver so that the default Broadleaf
Locale looked up in the database is used.Author: jerryocanas
Date: 9/6/12
Author: jerryocanas
Date: 9/6/12
Author: jerryocanas
Date: 9/6/12
Author: jerryocanas Date: 9/6/12
Responsible for returning the currency to use for the current request.
Responsible for returning the currency to use for the current request.
Author: jerryocanas
Date: 9/6/12
Author: jerryocanas
Date: 9/6/12
Utility methods for common currency operations
This is a straight copy of Spring's DefaultResourceResolverChain (as of 4.1.6).
In order for the Broadleaf Administration to display enumerated values with meaningful labels,
enumerations should implement this interface.
Created as a common class for adding property sources to the Spring
Environment.
In non-boot this class should be hooked up in your web.xml as shown below
This is by default added into
META-INF/spring.factories with the EnvironmentPostProcessor key.Base exception class for BroadleafExceptions that understands root cause messages.
This component provides an expression parser, most typically for SPEL expressions.
This is an extension of Spring's User class to provide additional data to the UserDetails interface.
Many components in the Broadleaf Framework can benefit from creating and manipulating temporary files as well
as storing and accessing files in a remote repository (such as AmazonS3).
Extension manager for
BroadleafFileServiceMany components in the Broadleaf Framework can benefit from creating and manipulating temporary files as well
as storing and accessing files in a remote repository (such as AmazonS3).
This is the override of Hibernate transformer that adds filtration based on class/package name to prevernt
parsing unwanted classes
Responsible for returning the Locale to use for the current request.
Responsible for returning the Locale to use for the current request.
Replaces the older BLResourceBundleMessageSource by using a
ReloadableResourceBundleMessageSource
instead.
Provides the ability for modules to register themselves with Broadleaf to be used with
ConditionalOnBroadleafModule and ModulePresentUtil
in order to provide different behavior in inter-module dependencies.List of modules that are known to have declared a
BroadleafModuleRegistration in their spring.factories.Wraps Spring's
PathResourceResolver for ordering purposes.Allow a class transformer to explicitly declare which persistence unit it will influence
This custom dialect will treat all Clob types as if they contain a string instead of an OID.
This controller works in conjunction with the broadleaf-ajax style redirect.
Convenient holder class for various objects to be automatically available on thread local without invoking the various
services yourself
This resolver is responsible for returning the Customer object that is currently present on the request.
By default, we'll resolve the customer from the "customer" attribute on the request.
The BroadleafCurrencyResolver can be implemented to set the currency (e.g.
Responsible for setting up the site and locale used by Broadleaf Commerce components.
Interceptor responsible for setting up the BroadleafRequestContext for the life of the request.
Provides a PostConstruct method that sorts the
ResourceResolver, ResourceTransformer,
or location (Resource) collections based on the Ordered interface.Constants representing out of box Broadleaf Resource Resolvers.
Constants representing out of box Broadleaf Resource Transformer ordering.
Responsible for determining the SandBox to use for the current request.
Responsible for determining the SandBox to use for the current request.
Holder for a folder of properties resources comprised of something like the following on the classpath:
classpath:/runtime-properties/
common.properties
common-shared.properties
[profile].properties
[profile]-shared.properties
This exception resolver can be used to handle exceptions in a user friendly way by displaying an error template.
Controller to generate and retrieve site map files.
Responsible for returning the site used by Broadleaf Commerce for the current request.
MVC configuration required by Broadleaf site to operate correctly.
A BroadleafApplicationEvent used so that we can communicate with the ScheduledJobsAndEvents module without having a dependency on it.
Constant for how the event should be consumed
Which type of worker is qualified to handle the event
Effectively a copy of com.broadleafcommerce.jobsevents.domain.dto.SystemEventDetailDTO
to be used when creating a org.broadleafcommerce.common.event.BroadleafSystemEvent
Responsible for returning the theme used by Broadleaf Commerce for the current request.
Responsible for setting up the theme used by Broadleaf Commerce components.
Responsible for returning the TimeZone to use for the current request.
Responsible for returning the timezone to use for the current request.
Classes that implement this interface will be exposed to the Thymeleaf expression evaluation context.
Wraps Spring's
VersionResourceResolver but adds in support to disable with
environment properties.Generic interface that should be used for processing requests from Servlet Filters, Spring interceptors or Portlet
filters.
Tracks a bundle version name and path/file information for a dynamically created resource bundle.
A
ResourceResolver that is used to serve previously bundled files.Utility class that sets the correct response headers (especially browser cache related headers) using the existing
Spring request pipeline configuration by mimetype.
Provides either dynamic, or cached static compression of response data.
Persistence for some collection fields is managed outside the admin pipeline.
Configuration class for defining cache regions via Java config when either not using ehcache or when jcache.create.cache.forceJavaConfig is true
Simple POJO for storing a String value as a compressed byte array.
Responsible for determining if an entity has been conditionally enabled for loadtime weaving for the enterprise and/or
multitenant modules.
Simple data object to hold direct copy transform config information.
The purpose of this class is to allow the conditional addition or removal of annotations to a target entity based on template class.
Indicates that this bean should not be created unless the broadleaf-open-admin-platform exists on the classpath.
Allows for conditional registration of beans depending only if a particular Broadleaf module is present.
Used to indicate that a class should be instantiated as a bean if ehcache is on the classpath
Used to indicate that a class should be instantiated as a bean if ehcache is missing fromm the classpath
Allows for conditional registration of beans depending only if a particular Broadleaf module is absent.
Indicates that this bean should not be created unless the broadleaf-open-admin-platform does not exists on the classpath.
Configuration items to be used in conjunction with
ValidationConfiguration and used by an instace of
org.broadleafcommerce.openadmin.server.service.persistence.validation.PropertyValidatorAn extendible enumeration of container shape types.
An extendible enumeration of container size types.
ContextVariableNames can be added as a Job or Event detail in order to establish the context.
An extendible enumeration of credit card types.
The following processor will add any Payment Gateway specific Card Type 'codes' to the model if
the gateway requires that a 'Card Type' (e.g.
A service responsible for allowing secure authentication for a user between the admin and site applications.
Marker class that allows the auditable fields to be udpated from either the site or the admin.
A service responsible for allowing secure authentication for a user between the admin and site applications.
Deprecated.
Use
SecurityFilter insteadService that's used to minify CSS
Unfortunately, JAXB doesn't know how to deal with java.util.Currency because it doesn't have a
default constructor.
Simple interface for returning a
PaymentRequestDTO based on the current customer in the system
(like something on threadlocal).Simple interface for returning a
PaymentRequestDTO based on the current order in the system (like something on
threadlocal).Abstract controller that provides convenience methods and resource declarations to facilitate payment gateway
communication between the implementing module and the Spring injected customer profile engine.
The default implementation of this interface is represented in the core Broadleaf framework at
org.broadleafcommerce.core.payment.service.DefaultCustomerPaymentGatewayService.Responsible for generating site map entries.
CustomSiteMapGenerator is controlled by this configuration.
CustomSiteMapGenerator is controlled by this configuration.
Extension handler for resolving templates from the database.
Variable expression that looks up a list of
DataDrivenEnumerationValues based on its enum keyAn extendible enumeration of container shape types.
An extendible enumeration of container shape types.
DTO Class that contains enough information to allow the client site application to generate
the necessary information for a link to an admin screen
This abstract class should be extended by services that provide deep links for specific entities.
Allows an encapsulated way to create caches programmatically from an EhCache
CacheManager.Defines a default ExpiryPolicy for EhCache.
Default utility to access and programmatically create JCache instances via the JCache
CacheManager.Passthrough implementation for the
FrameworkCommonClasspathPropertySource that sets the default orderDefault implementation of
OverridePreCacheService.Adds a default property source to look for a
runtime-environment folder and apply the -shared overriding
mechanics to it.Encapsulates a block of code that should be run at a later time, usually in order to guarantee the proper state
or conditions for its execution.
A HSQL DB dialect specifically for the demo.
This is a utility class that is only meant to be used for testing the BLC demo on HSQLDB.
This is a utility class that is only meant to be used for testing the BLC demo on Oracle.
Command extractor that does Postgres specific logic in order for the DemoSite load scripts to import correctly.
This is a utility class that is only meant to be used for testing the BLC demo on SQL Server.
An extendible enumeration of units of measure types.
This class transformer will copy fields, methods, and interface definitions from a source class to a target class,
based on the xformTemplates map.
Constants for tagging an entity class to receive byte code transformation upon
being loaded by the classloader
An implementation of SupportLoggerAdapter that would disable SupportLogger logging.
Marker interface for a class that is included in one way or another in the multitenant architecture.
Provides utility methods for interacting with dynamic entities
This class serves as a basic iterator for a list of source files to be
merged.
This extensible enumeration controls the field types that are available for users to choose from when creating
FieldDefinitions in the admin tool.
Convenience class to provide dynamic field translations.
Use this merge bean post processor for merging tasks that should take place before the persistence layer is
initialized.
Use this merge bean post processor for collection member removal tasks that should take place before the persistence layer is
initialized.
This class provides an LRUMap structure that defaults to a more efficient ConcurrentHashMap if the
size has not yet been reached.
Ehcache 3 cache event listener for monitoring cache changes using the Ehcache hydrated cache.
JCache cache event listener for monitoring cache changes using the Ehcache hydrated cache.
An extendible enumeration of email property types.
Deprecated.
in favor of
NotificationDispatcherDeprecated.
The EmailTarget interface is used to specify the recipients of the email.
Basic implementation of EmailTarget
Enables
FrameworkController and FrameworkRestController annotations.
Bootstraps Broadleaf admin configuration XML for both servlet and non-servlet.
Bootstraps the Broadleaf root admin configuration XML for only non-servlet beans.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.
Bootstraps Broadleaf admin configuration XML for both servlet and non-servlet beans.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.STOP.
STOP.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.STOP.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.
Bootstraps Broadleaf customer-facing configuration XML for both servlet and non-servlet beans in use with a traditional MVC application.
Bootstraps Broadleaf root site configuration XML for only non-servlet beans.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.
Bootstraps Broadleaf site configuration XML for only servlet beans in use with a traditional MVC application.
We are deliberately leaving off the
Configuration annotation since
this inner class is being included in the Import above, which interprets this as a
Configuration.Enables only
FrameworkController annotations, which are the MVC controllers.Enables only
FrameworkRestController annotations, which are the RESTful controllers.Basic extension point for modules handling encryption.
Defines the state in which sandboxable collections in the Enterprise module should adhere to Broadleaf defined behavior.
Deprecated.
Implement
EntityDuplicationHelper insteadProvides additional metadata and performs final modifications for an entity before persistence.
Creates a production duplicate of an entity.
Allow other modules to contribute to the duplication lifecycle
Manage the interaction between a duplication operation and other modules that wish to contribute to that lifecycle
This class holds information about an entity.
Class that provides guidance to modules that need to react when running in a multi-tenant mode.
ExtensionHandler for methods within
EntityInformationServiceExtension manager that holds the list of
EntityInformationServiceExtensionHandler.Provides a
Runnable implementation that allows the execution of the run() method inside the context of a thread-bound EntityManager.
Used to validate usages of em.find() when querying for a primary key specifically across sibling Multi-Tenant sites.
This class transformer will check to see if there is class that should have been loaded by the
MergePersistenceUnitManager
(meaning, it has an @Entity, @MappedSuperclass or @Embeddable annotation on it and will be inside of a persistence.xml).Allow other modules to provide a parent id for a given entity/id combination
Manage the handling of EntityParentIdServiceExtensionHandlers
An extension handler represents a generic pattern used in BroadleafCommerce when an out-of-box service
with complex logic provides implementation hooks.
The ExtensionManager pattern is intended for out of box components to be extended by Broadleaf modules.
Responsible for exercising a method on an
ExtensionHandler.If a service extension using the
ExtensionManager pattern expects a result from the extension, it should
pass in an instance of this class into the method call.This interface is a lightweight replacement of gateway-specific classes extending AbstractExternalPaymentGatewayCall, and it helps expose some f the QoS inner methods, for testing purposes.
Field Value Configurations are be used in conjunction with the `showIfFieldEquals` option in AdminPresentation
configurations.
Any module within the BLC framework that needs to store and retrieve files from a remote storage such as
Rackspace CloudFiles or AmazonS3 should declare an application file type.
Marker exception that just extends RuntimeException to be used by the
BroadleafFileServiceInterface to be implemented by a FileProvider.
Default implementation of FileServiceProvider that uses the local file system to store files created by Broadleaf
components.
Buffer an HTTP response to the file system, rather than streaming directly to the HTTP caller.
Represents a temporary location on the fileSystem.
Configuration bean that represents a Hibernate filter.
Configuration bean that represents a Hibernate FilterDefinition
For Spring Boot implementations, use the
Ordered interface, in conjunction with these
order values, on any Filter implementation beans instantiated through Spring.Used as a replacement to the HTML
<form> element which adds a CSRF token input field to forms that are submitted
via anything but GET.
A holder for a folder containing a
common.properties file to be added to the Spring Environment in a programmatic way without Spring Boot and with very specific
ordering semantics.Indicates that an annotated class is a "Framework Controller" (default MVC controller).
HandlerMapping to find and map
FrameworkMappings inside FrameworkController and FrameworkRestController classes.This annotation behaves exactly like
RequestMapping except it is used inside FrameworkController and
FrameworkRestController controllers.This class has been copied from spring-webmvc:4.3.7-RELEASE in order to provide URI building functionality for
FrameworkMapping annotations.Indicates that an annotated class is a "Framework REST Controller" (default RESTful controller).
Ensures that any beans registered using this reader have a lower precedence than any beans defined in @Configuration
classes, which otherwise have a lesser /priority than XML resources.
An in memory generated resource.
Provides methods to easily access entities managed by the 'blPU'
PersistenceUnit.CRUD methods for generic entities
Allows for a generic operation that can be executed in a particular context.
Provides a mechanism to allow for retriable logic.
This class serves as a marker interface to indicate that the resource comes from a shared area of the
filesystem.
Javascript minification service implemented using the Google Closure Compiler
This will be used for minification if the Google Closure Compiler dependency is included in the project
Hibernate SPI implementor that harvests metadata about all of the entity classes
Hibernate convenience methods
An extendible enumeration of container shape types.
Enable html minification.
The utility methods in this class provide a way to ignore the currently configured site/catalog contexts and instead
explicitly run operations in the specified context.
A thread local context to store the unique name for this request thread.
Simple bean that can represent a key/value pair used by arbitrary components for the purpose of engaging exclusion behavior.
OpenEntityManagerInViewFilter implementation that can be "ignored" based on state set by SecurityBasedIgnoreFilter.Marker annotation for any field on a sandboxable entity that should not undergo enterprise sandbox config validation
(if applicable).
This class serves to parse any passed in source application context files and
look for the Spring "import" element.
Convenience class providing a 10 minute expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.This handler implementation provides behavior where the child nodes from an
element in the patch document are added to the same node in the source
document.
This handler implementation provides behavior where a list of elements from the
patch document are appended to the same parent element in the source document.
Invocation handler for unit testing byte-weaved classes.
An extensible enumeration of ISO Code Status Types.
This domain object represents the ISO 3166 standard published by the International Organization for Standardization (ISO),
and defines codes for the names of countries, dependent territories, and special areas of geographical interest.
Service that provide methods to look up the
standards published by the International Organization for Standardization (ISO)
StructuredContent data is converted into a DTO since it requires
pre-processing.
Event that may be raised to indicate that items have been fulfilled.
Service that's used to minify Javascript
Helper class for building
Configuration classesPersistence unit post processor for dynamically modifying the persistence unit.
DTO object to represent the configuration of a cache region
Provides the URI to be used for JCache configuration
Generic utility to allow one access to the JCache
CacheManager.This class allows us to override Persistence Unit properties on a per-environment basis.
Used when a controller typically returns a String that represents a view path but would like to return a
JSON response in other scenarios, such as an error case.
Use this merge processor for merging duties that should take place later in the Spring startup lifecycle.
Use this merge processor for collection member removal duties that should take place later in the Spring startup lifecycle.
This handler is responsible for replacing nodes in the source document
with the same nodes from the patch document.
A customization of
JdbcServicesImpl that allows further usage of the sql statement logging.StandardServiceInitiator implementation for introducing the custom JdbcServices implementation
to the Hibernate service registry.A customized
JpaTransactionManager that will send Spring events at key lifecycle points during a transaction.Enumeration describes the type of event that is being logged in the
SupportLogger.lifecycle method.
Created by jfischer
Created by bpolster.
Created by bpolster.
Created by jfischer
Represents a cached translation pair.
Created by bpolster.
Created by bpolster.
Author: jerryocanas
Date: 9/17/12
This class insures that if using the successUrl or failureUrl request
parameter, then the urls are valid and are local to the application
(preventing a user modifying to go somewhere else on login success/failure)
This is not hooked up by default so that Log4j2 is not required.
Specific implementation used with a Log4j2 dependency
Deprecated.
in favor of
Log4j2ManagementBean (following Apache's EOL declaration for log4j 1.x)Defines whether or not a to-one lookup should be rendered in a modal to be selected or
through a pre-populated dropdown.
This is a JAXB wrapper to encapsulate a Map<String, Object>
A null safe media object.
Provides a convenience annotation for declaring a bean merge into an existing collection of beans (presumably a
pre-existing Broadleaf Commerce collection).
This processor is responsible for registering Early/LateStageMergeBeanPostProcessors for
Merge annotated
beans and ensuring the correct prioritization of these post processors.Deprecated.
this has been replaced by invoking the merge cart service explicitly within the cart state request processor
This exception is thrown when a problem is encountered during
the actual merge of the source and patch documents.
All handlers must implement the MergeHandler interface.
This adapter class allows the developer to create a merge handler
instance and only override a subset of the functionality, instead of
having to provide an independent, full implementation of the MergeHandler
interface.
Generic Spring Bean Factory to merge various XML files together and pass them to the JCache
CachingProvider to create a CacheManager.This class manages all xml merge interactions with callers.
This exception is thrown when a problem is encountered during
the MergeManager initialization
Merges jars, class names and mapping file names from several persistence.xml files.
This class provides the xml merging apparatus at a defined XPath merge point in
2 xml documents.
Allows XML beans to be merged together with existing bean definitions rather than always doing a wholesale replacement
When beans are discovered using this reader this will take the previous definition and merge it with the new definition
using
AbstractBeanDefinition.overrideFrom(BeanDefinition).The MetadataMBeanInfoAssembler provided by Spring does not allow the usage of JDK dynamic proxies.
The MetadataNamingStrategy provided by Spring does not allow the usage of JDK dynamic proxies.
This handler is responsible for replacing nodes in the source document
with the same nodes from the patch document.
A
ResourceTransformer that minifies
the resource.An extendible enumeration of container shape types.
A simple bean that when declared in app context will cause a lifecycle
logging message to appear in the logging output.
Utility class that checks for the presence of registered Broadleaf modules.
A Thymeleaf Variable Expression intended to provide various information about the modules enabled for this application.
An extendible enumeration of container shape types.
Condition to use if the Multi-Tenant module is available at runtime
Describes an entity (or @Embeddable) that is able to be cloned for the purpose of multiple tenancy.
Abstract class for copying entities to a new catalog as required during derived catalog propagation.
This
MergeBeanStatusProvider can be utilized by modules that are trying to provide functionality that
is only required when MultiTenant is loaded.Helper class for some common rule functions that can be called from mvel as well as utility functions
to make calling MVEL rules within Broadleaf easier.
Extension handler used for contributions to native Object methods on entity like equals() clone() and hashCode().
This handler is responsible for replacing nodes in the source document
with the same nodes from the patch document.
This handler is responsible for replacing nodes in the source document
with the same nodes from the patch document.
An API for w3c.Nodes manipulation
a simple implementation of the Comparator interface, (applied to the Node class) that uses the value of a given
node attribute as comparison criterion.
MergeHandler implementation that provides merging for the white space
delimited text values of a source and patch node.
This handler is responsible for replacing nodes in the source document
with the same nodes from the patch document.
An implementation of StatisticsServiceLogAdapter that does nothing.
The admin will throw this exception when a query is attempted across multiple class hierarchies
because it is impossible for such a query to produce any results.
Returns null for the Site (typical for non-multi-site implementations of
Broadleaf Commerce.
Returns null for the Site (typical for non-multi-site implementations of
Broadleaf Commerce.
A null implementation of
BroadleafVariableExpressionThis class transformer will do nothing.
Implementation of EmailInfo that will not send an Email.
This null implementation class can be used during development to work around
the need to have a working SMTP service to route emails through.
A NullPageDTO is an object that is used by the PageService caching to indicate a "cache-miss".
Class created for caching misses as some cache implementations, such as Redis, are unable to serialize a proxy (see
AbstractCacheMissAware and SystemPropertiesDaoImpl)Detects whether or not a Broadleaf module has been registered via am
spring.factories entry for BroadleafModuleRegistrationCondition for checking if ehcache is on the classpath
Condition specifying that ehcache is not on the classpath
Convenience class providing a 60 minute expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.Convenience class providing a 1 minute expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.Describes the target of an admin operation.
To be thrown when an optimistic lock is being used to update an entity and the maximum retry count is reached,
causing the update to be aborted.
Utility class for operations on entities that support optimistic locking.
Performs an update operation on an entity within an optimistic lock aware transaction.
Checks if the state of the entity is valid then performs an update operation on an entity within an optimistic
lock aware transaction.
Based on a Spring property value resolving to a boolean, this ClassTransformer will optionally perform
bytecode transformations.
Deprecated.
Describes additional filter parameters used to refine the list of items returned from a query for
a DataDrivenEnumeration
Concrete event that is raised when an order is submitted.
Holder for mapping files (orm.xml) and entity classes to be contributed to the
MergePersistenceUnitManager without being specified directly
in a persistence.xml file.Responsible for compiling the set of
ORMConfigDto and adding the configuration items to a persistence unit.Performs cache item initialization for a specific entity type.
Describes a service capable of maintaining a cache of standard site level overrides.
Page fields must be pre-processed (for example to fix image paths).
The default encryption module simply passes through the decrypt and encrypt text.
when a payment returns in error, this value indicates whether it is a "soft" decline (apt to be retried) or a "hard" one.
Abstract controller that provides convenience methods and resource declarations to facilitate payment gateway
communication between the implementing module and the Spring injected checkout engine.
The default implementation of this interface is represented in the core Broadleaf framework at
oorg.broadleafcommerce.core.payment.service.DefaultPaymentGatewayCheckoutService.The intention of this API is to generate the necessary parameters and fields
needed by the payment gateway's JavaScript library in order to create a tokenization request.
This API is intended to define the specific configuration parameters
that this gateway implementation currently supports.
Each payment gateway module should configure an instance of this.
This represents the main servic bus for grabbing configurations to configured payment gateways to execute service calls
programmatically.
Several payment gateways allow you to manage Customer and Credit Card Information from the gateway allowing
you to create a transaction from the tokenized customer or payment method at a later date.
Several payment gateways allow you to manage Customer and Credit Card Information from the gateway allowing
you to create a transaction from the tokenized customer or payment method at a later date.
A Thymeleaf Variable Expression implementation for Payment Gateway Specific fields.
Certain Payment Integrations allow you to use Fraud Services like Address Verification and Buyer Authentication,
such as PayPal Payments Pro (PayFlow Edition)
Certain Payment Integrations allow you to use a Hosted Solution,
such as PayPal Express and SagePay Form.
This API provides the ability to get the status of a Transaction after it has been submitted to the Gateway.
Gateways/processors support a vast array of different features, and in some cases
a single API will perform several different functions based on the state of the request.
Default Resolver implementation.
This API allows each module to provide its own implementation for rollback.
Some gateways allow you to create a form of recurring billing by creating a subscription profile.
Several Gateways have a method of communication that uses the HTTP Request/Response model
and the client's browser to transmit transaction result information back to the system.
This default implementation encodes the seal using a URL-Safe Base64 encoder
and 'HmacSHA1'
This API is intended to be called by the Checkout Workflow
to confirm all Payments on the order that have not yet been confirmed/finalized.
This is a decoupled interface that provides
the basic functions needed to create the normal BILLABLE Credit Card Transactions
The purpose of this class, is to provide an API that will create
any gateway specific parameters needed for a Transparent Redirect/Silent Order Post etc...
This is designed such that individual payment modules will extend this to add their own type.
This is a utility service that aids in translating the Request Attribute and
Request Parameters to a single String.
This default implementation produces the Request Attributes and Request Paremeters
in JSON notation.
The purpose of this class, is to provide an API that will translate a web response
returned from a Payment Gateway into a PaymentResponseDTO
An extendible enumeration of payment log types.
A DTO that is comprised of all the information that is sent to a Payment Gateway
to complete a transaction.
The DTO object that represents the response coming back from any call to the Gateway.
The PaymentTransactionType is used to represent the types of operations/transactions that could occur against a single payment.
This represents types of payments that can be applied to an order.
Service to help gather the correct
EntityManager or PlatformTransactionManager,
based on a class and TargetModeType.Represents a block of work to execute during a call to
AbstractCacheMissAware.getCachedObject(Class, String, String, PersistentRetrieval, String...)
should a missed cache item not be detected.
Marker annotation indicating that the current class is both an
@Configuration class
and should be executed after any Spring Boot EnableAutoConfiguration.
Deferred import loader that, when used in an {@link @Configuration} class, executes _after_ the set
of Spring
EnableAutoConfiguration classes brought in by the .Loads the given set of classes after Spring's
EnableAutoConfiguration.Utility class for working with proxied entities.
Interface that exposes properties useful for determining if an entity is intended for preview only,
as opposed to standard production entities
Extra logging facility whose design intent is to handle detailed production logging for complex interactions.
Holder for the
ProductionOnlyRequest.CRITERIA constantMarker interface for entity classes whose SITE_DISCRIMINATOR value should be harvested from the
BroadleafRequestContext.currentProfile value
This Thymeleaf variable expression class provides access to runtime configuration properties that are configured
in development.properties, development-shared.properties, etc, for the current environment.
This class is designed to work in both a load-balanced and non load-balanced environment by replacing the existing
default Spring channel processors which do not work in a load balanced environment.
Very similar to the
InsecureChannelProcessor except that instead of relying on only the HttpServletRequest
this also allows
inspection of the X-Forwarded-Proto header to determine if the request is secure.Very similar to the
SecureChannelProcessor except that instead of relying on only the HttpServletRequest this
also allows
inspection of the X-Forwarded-Proto header to determine if the request is secure.Special exception thrown when a problem is encountered while trying to retrieve the original implementation
class for a proxy.
Represents a class containing an MVEL rule and an associated quantity.
Interface for classes annotated with
NamedQueries and NamedNativeQueries.Detects any externally registered
NamedQueries or NamedNativeQueries and adds them to the first detected
entity implementation class for the target persistence unit.Extension handler (generally for DAO usage) that allows contribution to a query (presumably from another module).
Provide a helper component for assigning custom hints during query execution.
Hints available to be leveraged by Broadleaf components for different query result behavior.
Default implementation of
QueryHelper.Helper class for criteria queries.
This WorkOnChange implementation is for a narrow case where the work to be done is simply calling a method on a target object
and passing to that method the changed collection.
Strip a candidate annotation from candidate classes and their fields.
Strip the cache annotation from classes and the class fields
Created by bpolster.
Created by bpolster.
Created by jfischer
Works with the blc:bundle tag.
This service is responsible for interaction with
ResourceBundleProcessor and
ResourcePreloadProcessor to generate bundles for static resources.Service responsible for interacting with YUI-compressor or Google Closure Compiler to minify JS/CSS resources.
Adds <link> tags to the model that preload resources.
Provides extension points for dealing with requests for resources
Keeps track of the resources needed for <blc:bundle> and <blc:bundlepreload> tags so that the list
of files does not need to be duplicated across both tags.
Holds information about bundles used during the current request.
Builder class that holds attributes relevant to resources, namely those that go on <blc:bundle> and
<blc:bundlepreload> tags.
Used in conjunction with
SparselyPopulatedQueryExtensionHandler.Interface indicating that the exception knows how to return the root cause message.
Utility class for working with sandboxable entities.
This class is required mostly as a workaround for an issue in Hibernate.
The workflow code will not persist an entity if the changes detected are limited to fields whose type is assignable
from this interface, and the persistence is being requested for a production record outside of a production deploy
step.
Created by bpolster.
Designed to specifically handle the merge of schemaLocation references.
Sets a request attribute that informs all concerned Broadleaf filters that they should pass the request through and
ignore all normal operation.
Checks the validity of the CSRF token on every POST request.
Form of ServiceException thrown when their is a security
failure while attempting to execute the operation.
CollectionUtils wrapper
to support collection intersection methods needed for rule builder selectize components.Detect inconsistencies between the values in the SEQUENCE_GENERATOR and the primary
keys of the managed tables.
This is a modified version of the ServerCookie implementation taken from
the Apache Tomcat source.
Exception thrown when a
service method fails.An extendible enumeration of service status types.
Delegate standard
ServletOutputStream write calls to standard buffered IO.Represents a class containing an MVEL rule
Created by bpolster.
Control tab layout and grouping for the SiteImpl entity
Used to mark collections for multi-tenancy when the commercial multi-tenant module is loaded.
Represents the columns that get weaved into entities that are marked as site-specific.
Created by bpolster.
Handles creating the various sitemap files.
An enumeration of Sitemap change frequency values
The SiteMapConfiguration is a class that drives the building of the SiteMap.
Sitemap exception
Represents the outcome of a SiteMap generation request.
Responsible for generating site map entries.
Sample URL tag generated and controlled by this configuration.
An extendible enumeration of site map generator types.
Representation the sitemapindex element defined in the schema definition at
http://www.sitemaps.org/schemas/sitemap/0.9.
Reasonsable set of SiteMap URL priorities
Class responsible for generating the SiteMap.xml and related files.
Component responsible for generating a sitemap.
Sample URL entry
http://www.heatclinic.com/hot-sauces
2009-11-07
weekly
0.5
Representation the urlset element defined in the schema definition at
http://www.sitemaps.org/schemas/sitemap/0.9.
Representation of SiteMapURLEntry that can be used to generate an XML element.
Representation the sitemap element defined in the schema definition at
http://www.sitemaps.org/schemas/sitemap/0.9.
An extendible enumeration of order status types.
Most of the methods below return a
Site which is not attached to a Hibernate session (which is what is referred
to as 'non-persistent').
ExtensionHandler for methods within
SiteServiceImplExtension manager that holds the list of
SiteServiceExtensionHandler.An SLF4J implementation of SupportLoggerAdapter that will delegate to the
configured SLF4J logging framework.
Extension handler (generally for DAO usage) that allows contribution to a query (presumably from another module).
A retrieval and caching strategy for translations.
Provides a means for classes that do not normally have access to
a servlet context or application context to be able to obtain
the current Spring ApplicationContext instance.
Bootstraps a Spring Boot application using a ServletContextListener rather than the default of using a ServletContextInitializer.
Capable of logging sql statements
This service is responsible for monitoring key changes in state for a given session.
This exception is thrown when the system detects a request from a "stale" page.
Represents a member of a query result list for a multitenant sparsely populated cache scenario (see
SparselyPopulatedQueryExtensionHandler).Sets a request attribute that informs all Broadleaf Filters that follow NOT to use the HTTP Session.
Interface that denotes whether or not an entity is archived.
Code is largely copied from StackOverflow post made by David Rabinowitz with contributions
by others in the same thread.
Utility used for running transactional operations.
Convenience methods for interacting with Java String types
Scoped as a prototype bean via bl-cms-applicationContext-entity.
Provides a wrapper class that can be used to alter the priority of a structuredcontentdto.
SupportLogger class that provides support for the new SUPPORT log level type.
LogManager class that adds support for retrieving a specialized
Logger instance (SupportLogger).
This DAO enables access to manage system properties that can be stored in the database.
This DAO enables access to manage system properties that can be stored in the database.
Registers the
SystemPropertiesService with the Spring Environment.Hook point for our database-backed properties to the Spring Environment
To change this template use File | Settings | File Templates.
Service that retrieves property settings from the database.
This interface represents a System Property (name/value pair) stored in the database.
Allows the storage and retrieval of System Properties in the database
Default Implementation of SupportLoggerAdapter that sends all support log messages to the console (
System.out).An extendible enumeration of target mode types.
Extension handler (generally for DAO usage) that allows contribution to a query (presumably from another module).
Provides specialized filter and restriction behavior for template-related (MT concept) queries.
Certain objects may have templates that resolve differently based on Broadleaf modules.
Interface used to indicate that an entity contains a path to a preferred display template.
An extendible enumeration of template types
Convenience class providing a 10 minute expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.Created by bpolster.
Stores the path to the theme.
Filter that wraps the HttpServletResponse allowing the encodeURL method to be
overwritten in order to append a Theme reference to the URL.
Convenience class providing a 30 minute expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.This utility class provides methods that simplify thread operations.
Default
TranslationOverrideStrategy.Created by bpolster.
JCache does not provide direct APIs for Per-Mapping expiry.
Provides an abstraction from the current system time.
Specify the attributes of a JOIN that should appear in the TypedQuery.
Specify the attributes of a ORDER BY that should appear in the TypedQuery.
Utilized in conjunction with
TypedQueryBuilder to generate TypedQueries programmatically.POJO for in-progress transaction information.
Allows further customization of
TransactionInfo instances upon transaction begin.Desribes the key transaction lifecycle events being monitored by the system
Custom
SqlStatementLogger that will log sql statements during a transaction with TransactionLifecycleMonitor.Spring event published at key transaction lifecycle points.
Responsible for most of the work related to monitoring and logging transaction state.
An exception whose message can be translated into a message suitable for a user.
An extensible enumeration of entities that have translatable fields.
This domain object represents a translated value for a given property on an entity for a specific locale.
Thread-local cache structure that contains all of the
Translations for a batch of processing.Container for ThreadLocal attributes that relate to Translation.
Provides data access for the
Translation entity.Responsible for setting the necessary attributes on the
TranslationConsiderationContext.Interceptor for use with portlets that calls the
TranslationRequestProcessor.Provides translations at both the standard site catalog and template catalog level, whichever is appropriate.
This processor is responsible for setting up the translation context.
Provide specialized cache population queries for price lists.
TranslationService functionality, primarily in support of TranslationOverrideStrategy instances.The following processor will modify the declared Credit Card Form
and call the Transparent Redirect Service of the configured payment gateway.
This Tuple class can be used when you want to return two elements from a function in a type safe way.
Convenience class providing a 12 hour expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.Convenience class providing a 24 hour expiry policy, along with the ability to override it on a per entry basis when
using a
TimedValueHolder as the cached value.A class that provides for a typed closure that will return a the specified type value from the specified type
A class that provides for a typed predicat
Utility class to construct typed query-language queries.
A class that provides for a typed transformer.
The purpose for this class is to provide an alternate approach to an HQL UPDATE query for batch updates on Hibernate filtered
entities (such as sandboxable and multi-tenant entities).
Describes simple classes that can be assigned a name and value
Created by IntelliJ IDEA.
An extendible enumeration of units of measure types.
Encapsulate some amount of work to perform whenever a change aware collection is modified.
Utility interface for items that wrap an internal, delegate item
Wrapper classes implementing this interface expose their additionalFields, and they can
make use of the utility methods in BaseWrapper to transfer said fields between the wrapper and
the corresponding domain object
CSS minification service implemented using the YUICompressor library
DirectCopyClassTransformerinstead