Package com.broadleafcommerce.inventory.provider.jpa.repository

Class DefaultJpaCustomizableSkuInventoryRepository<D extends JpaSkuInventory>

  • Type Parameters:
    D -
    All Implemented Interfaces:
    CustomizableSkuInventoryRepository<D>, org.springframework.beans.factory.InitializingBean
    @Transactional(transactionManager="inventoryTransactionManager")
public class DefaultJpaCustomizableSkuInventoryRepository<D extends JpaSkuInventory>
extends Object
implements CustomizableSkuInventoryRepository<D>, org.springframework.beans.factory.InitializingBean
    Spring Data Repository Fragment for providing some custom query logic, especially related to explicit locking and custom queries. Note that most default queries defined by SkuInventoryRepository do not assign locks. These should generally not be used for updates as there is no guarantee about concurrency. Reads that do not assign explicit locks are not guaranteed to be accurate for read or update as another thread may be updating those records concurrently. Read locks are less important because, although you can get unreliable data which may be accurate enough for many applications, the persisted data will be accurate. But, in order to have accurate persisted data in a highly concurrent system, you will need to ensure that write locks are properly applied. However, no read locks are required when having an exact inventory count is not required (where there is some room for inaccuracies).
    Author:
    Kelly Tisdell (ktisdell)
    See Also:
    SkuInventoryRepository, JpaSkuInventoryRepository

    • Constructor Detail

      • DefaultJpaCustomizableSkuInventoryRepository

        public DefaultJpaCustomizableSkuInventoryRepository​(@NonNull
                                                    com.broadleafcommerce.data.tracking.core.TrackableBehaviorUtil behaviorUtil,
                                                    @NonNull
                                                    com.broadleafcommerce.data.tracking.jpa.filtering.fetch.rsql.JpaFiltersCriteriaBuilder criteriaBuilder,
                                                    @NonNull
                                                    List<com.broadleafcommerce.data.tracking.core.service.RsqlQueryTransformer> rsqlQueryTransformers,
                                                    @NonNull
                                                    com.broadleafcommerce.data.tracking.jpa.filtering.fetch.rsql.JpaCriteriaBuilderRsqlVisitor rsqlVisitor)

    • Method Detail

      • findByContextId

        @Policy(operationTypes=READ)
public Optional<D> findByContextId​(String contextId,
                                   com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        Description copied from interface: CustomizableSkuInventoryRepository
        Retrieve a domain instance based on the context id (see Trackable.getContextId()). If a NarrowExecutor implementation was specified via Narrow, the result should be narrowed based on sandbox and catalog state. This overrides the method TrackableRepository.findByContextId(String, ContextInfo). The mixin implementation will provide an exclusive write lock, if applicable, to prevent concurrent modification of SkuInventory records.
        Specified by:
        findByContextId in interface CustomizableSkuInventoryRepository<D extends JpaSkuInventory>
        Parameters:
        contextId - An identifying id
        contextInfo - Request context information around sandbox and multitenant state
        Returns:
        If nothing found, an empty Optional. Otherwise, an Optional containing the narrowed entity.

      • findAllByContextId

        @Policy(operationTypes=READ)
public Iterable<D> findAllByContextId​(Iterable<String> contextIds,
                                      com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        Overrides default TrackableRepository.findByContextId(String, ContextInfo) to add a LockModeType.PESSIMISTIC_WRITE lock. Methods like this are used in update functionality within CrudEntityHelper and BaseCrudEntityService.
        Specified by:
        findAllByContextId in interface CustomizableSkuInventoryRepository<D extends JpaSkuInventory>
        Parameters:
        contextIds - A list of identifying ids
        contextInfo - Request context information around sandbox and multitenant state
        Returns:
        The list of narrowed entities

      • readAllByInventoryLocationId

        public Stream<D> readAllByInventoryLocationId​(String inventoryLocationId,
                                              @Nullable
                                              cz.jirutka.rsql.parser.ast.Node filters,
                                              @Nullable
                                              com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        Description copied from interface: CustomizableSkuInventoryRepository
        Read all Sku Inventories for the specified inventory location id matching the given filters.
        Specified by:
        readAllByInventoryLocationId in interface CustomizableSkuInventoryRepository<D extends JpaSkuInventory>
        Parameters:
        inventoryLocationId - the inventory location id
        filters - additional filters to apply in the query, can be null
        contextInfo - context information surrounding sandboxing and multitenant state
        Returns:
        the Sku Inventories for the specified inventory location id

      • readSummaryAvailability

        public Object[][] readSummaryAvailability​(SkuReferenceFieldType skuReferenceFieldType,
                                          Set<String> skuReferences,
                                          int minQuantity,
                                          Optional<Boolean> shippingLocation,
                                          Optional<Boolean> pickupLocation,
                                          Optional<Boolean> storeLocation,
                                          com.broadleafcommerce.data.tracking.core.context.ContextInfo context)
        Description copied from interface: CustomizableSkuInventoryRepository
        Queries for applications and tenant IDs associated with the requested availability. The response is a an Object array that contains: - skuReference (i.e. typically skuCode, but depends on what is requested by skuReferenceFieldType) - tenantId - applicationId (nullable) This method is pretty specific as it allows the Search Services, for example, to determine, for which SKUs have general availability across tenants and applications, not specific to inventory locations.
        Specified by:
        readSummaryAvailability in interface CustomizableSkuInventoryRepository<D extends JpaSkuInventory>
        Parameters:
        skuReferenceFieldType - The type of fields for which we are search (e.g. SKU_CODE)
        skuReferences - The SKU reference number or code e.g. SkuRef.skuCode
        shippingLocation - Indicates if we want to include availability at shipping locations
        pickupLocation - - Indicates if we want to include availability at pickup locations
        storeLocation - - Indicates if we want to include availability at store locations
        context - the ContextInfo for this request
        Returns:
        An object array, representing the rows and columns from the query

      • isAvailableBySkuReferenceForQuantity

        @Policy(operationTypes=READ)
public boolean isAvailableBySkuReferenceForQuantity​(@NonNull
                                                    String skuReference,
                                                    int quantity,
                                                    @NonNull
                                                    SkuReferenceFieldType skuReferenceFieldType,
                                                    @NonNull
                                                    Optional<Boolean> shippingLocation,
                                                    @NonNull
                                                    Optional<Boolean> pickupLocation,
                                                    @NonNull
                                                    Optional<Boolean> storeLocation,
                                                    @Nullable
                                                    com.broadleafcommerce.data.tracking.core.context.ContextInfo context)
        Description copied from interface: CustomizableSkuInventoryRepository
        Determines if the SkuInventory, identified by skuReference, is available for the specified quantity across one or more InventoryLocations, identified by their allowed fulfillment types. SkuRef is determined by the skuReference argument and the
        Specified by:
        isAvailableBySkuReferenceForQuantity in interface CustomizableSkuInventoryRepository<D extends JpaSkuInventory>
        quantity - - requested quantity
        skuReferenceFieldType - - the type of skuReference being passed in
        shippingLocation - - Optional value represents whether we should query shipping locations. If not present, no filtering will be applied.
        pickupLocation - - Optional value represents whether we should query pickup locations. If not present, no filtering will be applied.
        storeLocation - - Optional value represents whether we should query store locations. If not present, no filtering will be applied.
        Returns:

      • buildInventoryLocationCorrelatedSubQueryPredicate

        protected Optional<javax.persistence.criteria.Predicate> buildInventoryLocationCorrelatedSubQueryPredicate​(javax.persistence.criteria.Root<? extends JpaSkuInventory> root,
                                                                                                           javax.persistence.criteria.CriteriaQuery<? extends JpaSkuInventory> criteriaQuery,
                                                                                                           com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        This creates a subquery that ensures that the associated JpaInventoryLocation record is valid (i.e. that it exists, it is not archived, and it belongs to the same context / tenant as the JpaSkuInventory record). We do this instead of a join to avoid complications around pessimistic locking across tables, as well as to avoid pulling back additional (unnecessary) data in a ManyToOne join that would otherwise require a Hibernate proxy to lazy load the data.
        Parameters:
        root -
        criteriaQuery -
        contextInfo -
        Returns:

      • buildInventoryLocationCorrelatedSubQueryPredicate

        protected Optional<javax.persistence.criteria.Predicate> buildInventoryLocationCorrelatedSubQueryPredicate​(javax.persistence.criteria.Root<?> root,
                                                                                                           javax.persistence.criteria.CriteriaQuery<?> criteriaQuery,
                                                                                                           Optional<Boolean> shippingLocation,
                                                                                                           Optional<Boolean> pickupLocation,
                                                                                                           Optional<Boolean> storeLocation,
                                                                                                           com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        This creates a subquery that ensures that the associated JpaInventoryLocation record is valid (i.e. that it exists, it is not archived, and it belongs to the same context / tenant as the JpaSkuInventory record). We do this instead of a join to avoid complications around pessimistic locking across tables, as well as to avoid pulling back additional (unnecessary) data in a ManyToOne join that would otherwise require a Hibernate proxy to lazy load the data. This also filters based on whether the InventoryLocation is a shippingLocation, pickupLocation, or storeLocation.
        Parameters:
        root -
        criteriaQuery -
        shippingLocation -
        pickupLocation -
        storeLocation -
        contextInfo -
        Returns:

      • buildContextFilterPredicate

        protected Optional<javax.persistence.criteria.Predicate> buildContextFilterPredicate​(javax.persistence.criteria.Path<?> path,
                                                                                     com.broadleafcommerce.data.tracking.core.context.ContextInfo contextInfo)
        Optionally returns basic Predicate for TenantJpaTracking.getTenant() based on the ContextInfo argument. This predicate provides filtering for tenantId and archived flags. Only use this to query or filter Path elements that represent entities that implement Trackable. This is applied to queries for JpaSkuInventory as well as to correlated subqueries for JpaInventoryLocation.
        Parameters:
        path -
        contextInfo -
        Returns:

      • resolveSkuRefFieldName

        protected String resolveSkuRefFieldName​(SkuReferenceFieldType skuRefFieldType)
        Resolves the name of the field that should be used in a Predicate based on the provided SkuReferenceFieldType.
        Parameters:
        skuRefFieldType -
        Returns:

      • setSkuInventoryRepository

        @Autowired
@Lazy
public void setSkuInventoryRepository​(SkuInventoryRepository<D> skuInventoryRepository)

      • afterPropertiesSet

        public void afterPropertiesSet()
                        throws Exception
        Specified by:
        afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean
        Throws:
        Exception

      • getEntityManager

        protected javax.persistence.EntityManager getEntityManager()

      • getNarrowingHelper

        protected com.broadleafcommerce.data.tracking.jpa.filtering.narrow.JpaNarrowingHelper getNarrowingHelper()

      • getBehaviorUtil

        protected com.broadleafcommerce.data.tracking.core.TrackableBehaviorUtil getBehaviorUtil()

      • getCriteriaBuilder

        protected com.broadleafcommerce.data.tracking.jpa.filtering.fetch.rsql.JpaFiltersCriteriaBuilder getCriteriaBuilder()

      • getRsqlQueryTransformers

        protected List<com.broadleafcommerce.data.tracking.core.service.RsqlQueryTransformer> getRsqlQueryTransformers()

      • getRsqlVisitor

        protected com.broadleafcommerce.data.tracking.jpa.filtering.fetch.rsql.JpaCriteriaBuilderRsqlVisitor getRsqlVisitor()