com.broadleafcommerce.data.tracking.core.service

Class RsqlMappableCrudEntityHelper

java.lang.Object

com.broadleafcommerce.data.tracking.core.service.RsqlMappableCrudEntityHelper

public class RsqlMappableCrudEntityHelper
extends Object

Helper class responsible for providing additional support for RSQL filtering for business domain services. This service is intended to be used in support of RsqlMappableCrudEntityService.

Typically, it is sufficient to extend BaseRsqlMappableCrudEntityService in order to gain access to this helper; however, if a service implementation spans several repository types, it is recommend to inject this class instead. In such a case, this helper also provides access to a MappableCrudEntityHelper bean.

 @Service
 public class DefaultMyService<P extends MyPayload> implements MyService<P> {

    private final RsqlMappableCrudEntityService<MyPayload> helper;
    private final MyRepository repository;

    public DefaultMyService(MyRepository repository, DomainMapperManager mapper) {
        this.helper = new RsqlMappableCrudEntityService(repository, mapper);
        this repository = repository;
    }

 }
 

Author:

Jeff Fischer

Constructor Summary

Constructors

Constructor and Description
RsqlMappableCrudEntityHelper(MappableCrudEntityHelper crudEntityHelper, List<RsqlQueryTransformer> rsqlQueryTransformers)

Method Summary

Modifier and Type	Method and Description
<D,R extends org.springframework.data.repository.CrudRepository<D,String> & MappableRsqlFilterExecutor<D>> R	castToRsqlRepository(org.springframework.data.repository.CrudRepository<D,String> repository) Since most of the methods in the service require a repository that implements both CrudRepository and MappableRsqlFilterExecutor, this method provides a convenient way to handle that casting.
MappableCrudEntityHelper	getCrudEntityHelper() Provides access to the internal MappableCrudEntityHelper so as to avoid having to inject it again.
protected List<RsqlQueryTransformer>	getRsqlQueryTransformers()
<P,D,R extends MappableRsqlFilterExecutor<D>> org.springframework.data.domain.Page<P>	readAll(cz.jirutka.rsql.parser.ast.Node filters, org.springframework.data.domain.Pageable pageable, R repository) Retrieve all domain instances using a structured query string to drive the query criteria.
<P,D,R extends MappableRsqlFilterExecutor<D>> List<P>	readAll(cz.jirutka.rsql.parser.ast.Node filters, R repository) Retrieve all domain instances using a structured query string to drive the query criteria.
<P,D,R extends MappableRsqlFilterExecutor<D>> org.springframework.data.domain.Page<P>	readAll(cz.jirutka.rsql.parser.ast.Node filters, org.springframework.data.domain.Sort sort, org.springframework.data.domain.Pageable pageable, R repository) Retrieve all domain instances using a structured query string to drive the query criteria.
<P,D,R extends MappableRsqlFilterExecutor<D>> List<P>	readAll(cz.jirutka.rsql.parser.ast.Node filters, org.springframework.data.domain.Sort sort, R repository) Retrieve all domain instances using a structured query string to drive the query criteria.
cz.jirutka.rsql.parser.ast.Node	transform(cz.jirutka.rsql.parser.ast.Node filters, com.broadleafcommerce.common.extension.DomainTypeAware repository) Transforms filters from properties that target a projection into ones that apply to a backing repository provider domain object

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RsqlMappableCrudEntityHelper

public RsqlMappableCrudEntityHelper(MappableCrudEntityHelper crudEntityHelper,
                                    List<RsqlQueryTransformer> rsqlQueryTransformers)

Method Detail

readAll

public <P,D,R extends MappableRsqlFilterExecutor<D>> List<P> readAll(@NonNull
                                                                     cz.jirutka.rsql.parser.ast.Node filters,
                                                                     @Nullable
                                                                     org.springframework.data.domain.Sort sort,
                                                                     @NonNull
                                                                     R repository)

Retrieve all domain instances using a structured query string to drive the query criteria. The filters string is parsed by an internal implementation and the result is added to the query before executing the fetch against the persistence store. See FilterParser for more information.

This version also accepts a formatted sort string that declares the sorting characteristics for the query.

Parameters:

filters - the RSQL Node used to restrict result, must not be null

sort - The string containing the structured list of sorts to apply

repository - A repository that implements MappableRsqlFilterExecutor to perform the persistence operation

Returns:

The list of narrowed, sorted entities

readAll

public <P,D,R extends MappableRsqlFilterExecutor<D>> List<P> readAll(@NonNull
                                                                     cz.jirutka.rsql.parser.ast.Node filters,
                                                                     @NonNull
                                                                     R repository)

Retrieve all domain instances using a structured query string to drive the query criteria. The filters string is parsed by an internal implementation and the result is added to the query before executing the fetch against the persistence store. See FilterParser for more information.

Parameters:

filters - the RSQL Node used to restrict result, must not be null

repository - A repository that implements MappableRsqlFilterExecutor to perform the persistence operation

Returns:

The list of narrowed, sorted entities

readAll

public <P,D,R extends MappableRsqlFilterExecutor<D>> org.springframework.data.domain.Page<P> readAll(@NonNull
                                                                                                     cz.jirutka.rsql.parser.ast.Node filters,
                                                                                                     @Nullable
                                                                                                     org.springframework.data.domain.Sort sort,
                                                                                                     @NonNull
                                                                                                     org.springframework.data.domain.Pageable pageable,
                                                                                                     @NonNull
                                                                                                     R repository)

Retrieve all domain instances using a structured query string to drive the query criteria. The filters string is parsed by an internal implementation and the result is added to the query before executing the fetch against the persistence store. See FilterParser for more information.

This version also accepts a Sort to apply to the result set

Parameters:

filters - the RSQL Node used to restrict result, must not be null

sort - sort to apply to the query

pageable - may be Pageable.unpaged(), must not be null.

repository - A repository that implements MappableRsqlFilterExecutor to perform the persistence operation

Returns:

The subset (page) of narrowed entities

readAll

public <P,D,R extends MappableRsqlFilterExecutor<D>> org.springframework.data.domain.Page<P> readAll(@NonNull
                                                                                                     cz.jirutka.rsql.parser.ast.Node filters,
                                                                                                     @NonNull
                                                                                                     org.springframework.data.domain.Pageable pageable,
                                                                                                     @NonNull
                                                                                                     R repository)

Retrieve all domain instances using a structured query string to drive the query criteria. The filters string is parsed by an internal implementation and the result is added to the query before executing the fetch against the persistence store. See FilterParser for more information.

Parameters:

filters - the RSQL Node used to restrict result, must not be null

pageable - may be Pageable.unpaged(), must not be null.

repository - A repository that implements MappableRsqlFilterExecutor to perform the persistence operation

Returns:

The subset (page) of narrowed entities

transform

@NonNull
public cz.jirutka.rsql.parser.ast.Node transform(@Nullable
                                                          cz.jirutka.rsql.parser.ast.Node filters,
                                                          @NonNull
                                                          com.broadleafcommerce.common.extension.DomainTypeAware repository)

Transforms filters from properties that target a projection into ones that apply to a backing repository provider domain object

Parameters:

filters - RSQL filters targeting a projection domain

repository - A DomainTypeAware implementing repository from which to glean entity information for the transformation

Returns:

null if filters is null, otherwise an RSQL query suitable for targeting a repository domain object.

See Also:

RsqlQueryTransformer

castToRsqlRepository

public final <D,R extends org.springframework.data.repository.CrudRepository<D,String> & MappableRsqlFilterExecutor<D>> R castToRsqlRepository(org.springframework.data.repository.CrudRepository<D,String> repository)

Since most of the methods in the service require a repository that implements both CrudRepository and MappableRsqlFilterExecutor, this method provides a convenient way to handle that casting.

Type Parameters:

D - a domain type

R - used to do the multi-interface check.

Parameters:

repository - Since most services that use this helper will use CrudRepository (or an extension thereof), this method expects that as the argument.

Returns:

A CrudRepository that also implements MappableRsqlFilterExecutor cast in such a way as to allow type checking for both interfaces for use with this service's methods.

getCrudEntityHelper

@NonNull
public MappableCrudEntityHelper getCrudEntityHelper()

Provides access to the internal MappableCrudEntityHelper so as to avoid having to inject it again.

Returns:

the internal MappableCrudEntityHelper

See Also:

MappableCrudEntityHelper

getRsqlQueryTransformers

@NonNull
protected List<RsqlQueryTransformer> getRsqlQueryTransformers()