Java BooleanBuilder类代码示例

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@GetMapping("events")
HttpEntity<Resources<?>> events(PagedResourcesAssembler<AbstractEvent<?>> assembler,
		@SortDefault("publicationDate") Pageable pageable,
		@RequestParam(required = false) @DateTimeFormat(iso = ISO.DATE_TIME) LocalDateTime since,
		@RequestParam(required = false) String type) {

	QAbstractEvent $ = QAbstractEvent.abstractEvent;

	BooleanBuilder builder = new BooleanBuilder();

	// Apply date
	Optional.ofNullable(since).ifPresent(it -> builder.and($.publicationDate.after(it)));

	// Apply type
	Optional.ofNullable(type) //
			.flatMap(events::findEventTypeByName) //
			.ifPresent(it -> builder.and($.instanceOf(it)));

	Page<AbstractEvent<?>> result = events.findAll(builder, pageable);

	PagedResources<Resource<AbstractEvent<?>>> resource = assembler.toResource(result, event -> toResource(event));
	resource
			.add(links.linkTo(methodOn(EventController.class).events(assembler, pageable, since, type)).withRel("events"));

	return ResponseEntity.ok(resource);
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
private Predicate buildMapQuery(MapQuery query, MapPath<String, Object, SimplePath<Object>> properties) {

        if (query.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (query.getContainsKey() != null) {
            predicate.and(properties.containsKey(query.getContainsKey()));
        }

        if (query.getContainsValue() != null) {
            predicate.and(properties.containsValue(query.getContainsValue()));
        }

        if (!query.getHas().isEmpty()) {
            for (Iterator<String> iterator = query.getHas().keySet().iterator(); iterator.hasNext();) {
                String key = iterator.next();
                predicate.and(properties.contains(key, query.getHas().get(key)));
            }
        }

        return predicate;
    }
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
private Predicate buildTextQuery(TextQuery txt, StringPath txtfield) {

        if (txt.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (txt.getContains() != null) {
            predicate.and(txtfield.contains(txt.getContains()));
        }

        if (txt.getStartWith() != null) {
            predicate.and(txtfield.startsWith(txt.getStartWith()));
        }

        if (txt.getEndWith() != null) {
            predicate.and(txtfield.endsWith(txt.getEndWith()));
        }

        if (txt.getEquals() != null) {
            predicate.and(txtfield.endsWith(txt.getEquals()));
        }

        return predicate;
    }
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
private Predicate buildAppUserListQuery(StringListQuery query, ListPath<AppUser, QAppUser> list) {

        if (query.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (query.getIn() != null) {
            predicate.and(list.any().id.in(query.getIn()));
        }

        return predicate;
    }
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.GET)
@ApiOperation(value = "Return the user devices", notes = "", response = Device.class, nickname = "getDevices")
@PreAuthorize("@raptorSecurity.list(principal, 'device')")

public ResponseEntity<?> getDevices(
        @AuthenticationPrincipal User currentUser,
        Pageable pageable
) {

    String userId = currentUser.getId();
    if (currentUser.isAdmin()) {
        userId = null;
    }

    QDevice device = new QDevice("device");
    BooleanBuilder predicate = new BooleanBuilder();

    if (userId != null) {
        predicate.and(device.userId.eq(userId));
    }
    
    Page<Device> result = deviceService.search(predicate, pageable);
    
    return ResponseEntity.ok(result);
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@Override
public List<AllocationEntity> findAvailableAllocationEntities(LocalDate dateFrom, LocalDate dateTo) {
	QAllocationEntity allocationEntity = QAllocationEntity.allocationEntity;
	QAccomodation accomodation = QAccomodation.accomodation;
	JPAQueryFactory queryFactory = new JPAQueryFactory(entityManager);
	BooleanBuilder builder = new BooleanBuilder(), doesPeriodsOverlap = new BooleanBuilder();

	doesPeriodsOverlap.and(accomodation.dateFrom.after(dateTo).not())
			.and(accomodation.dateTo.before(dateFrom).not());

	builder.and(allocationEntity.availability.isTrue());
	builder.and(JPAExpressions.selectFrom(accomodation)
			.where(accomodation.in(allocationEntity.accomodations), doesPeriodsOverlap).notExists());

	return queryFactory
			.selectFrom(allocationEntity)
			.where(builder)
			.fetch();
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@Override
public Integer getNumberOfFreePlaces() {
	QAllocationEntity allocationEntity = QAllocationEntity.allocationEntity;
	QAccomodation accomodation = QAccomodation.accomodation;
	JPAQueryFactory queryFactory = new JPAQueryFactory(entityManager);
	BooleanBuilder builder = new BooleanBuilder(),
			isAccomodationInCurrentDate = new BooleanBuilder();
	LocalDate currentDate = new LocalDate();
	
	isAccomodationInCurrentDate.and(accomodation.dateFrom.after(currentDate).not())
	.and(accomodation.dateTo.before(currentDate).not());
	
	builder.and(allocationEntity.availability.isTrue());
	builder.and(JPAExpressions.selectFrom(accomodation)
			.where(accomodation.in(allocationEntity.accomodations), isAccomodationInCurrentDate).notExists());
	
	return queryFactory
			.from(allocationEntity)
			.select(allocationEntity.capacity.sum())
			.where(builder)
			.fetchOne();
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@Override
public void extend(@Nonnull RequirementSearchContext context) {
    QVariableInstanceEntity variableEntity = new QVariableInstanceEntity(variableName);
    RequirementSearchQuery query = context.getQuery();
    RequirementSearchAliases $ = context.getAliases();

    createSelect(variableEntity, context);

    query.leftJoin($.flowInstance.variables, variableEntity).on(variableEntity.name.eq(variableName));

    QuickFilter quickFilter = context.getQuickFilter();
    if (context.getQuickFilter().hasFilter()) {
        BooleanBuilder filterBooleanBuilder = new BooleanBuilder();
        for (FilterToken token : quickFilter.listFilterTokens()) {
            BooleanBuilder tokenBooleanBuilder = new BooleanBuilder();
            for (String filter : token.getAllPossibleMatches()) {
                tokenBooleanBuilder.or(toChar(variableEntity).likeIgnoreCase(filter));
            }
            filterBooleanBuilder.and(tokenBooleanBuilder);
        }
        query.getQuickFilterWhereClause().or(filterBooleanBuilder);
    }
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
public List<FormAttachmentEntity> findFormAttachmentByCodRequirement(Long codRequirement) {
    QRequirementEntity requirement = new QRequirementEntity("requirementEntity");
    QFormRequirementEntity formRequirement = new QFormRequirementEntity("formRequirementEntity");
    QFormEntity form = new QFormEntity("formEntity");
    QDraftEntity currentDraft = new QDraftEntity("draftEntity");
    QFormEntity draftForm = new QFormEntity("draftFormEntity");
    QFormVersionEntity formVersion = new QFormVersionEntity("formVersionEntity");
    QFormAttachmentEntity formAttachment = new QFormAttachmentEntity("formAttachmentEntity");

    return new HibernateQueryFactory(getSession())
            .selectDistinct(formAttachment)
            .from(requirement)
            .innerJoin(requirement.formRequirementEntities, formRequirement)
            .leftJoin(formRequirement.form, form)
            .leftJoin(formRequirement.currentDraftEntity, currentDraft)
            .leftJoin(currentDraft.form, draftForm)
            .from(formVersion)
            .from(formAttachment)
            .where(new BooleanBuilder()
                    .and(formVersion.formEntity.cod.eq(form.cod)
                            .or(formVersion.formEntity.cod.eq(draftForm.cod)))
                    .and(formAttachment.formVersionEntity.cod.eq(formVersion.cod))
                    .and(requirement.cod.eq(codRequirement)))
            .fetch();
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
/**
 * Adds a global contains text filter on the provided attributes.
 * WARNING: this creates a very inefficient query. If you have many entity
 * instances to query, use instead an indexed text search solution for better
 * performance.
 * @param text the text to look for
 * @param query
 * @param globalSearchAttributes the list of attributes to perform the
 *        filter on
 * @return the updated query
 */
protected JPQLQuery<T> applyGlobalSearch(String text, JPQLQuery<T> query,
    Path<?>... globalSearchAttributes) {
  if (text != null && !StringUtils.isEmpty(text) && globalSearchAttributes.length > 0) {
    BooleanBuilder searchCondition = new BooleanBuilder();
    for (int i = 0; i < globalSearchAttributes.length; i++) {
      Path<?> path = globalSearchAttributes[i];
      if (path instanceof StringPath) {
        StringPath stringPath = (StringPath) path;
        searchCondition.or(stringPath.containsIgnoreCase(text));
      } else if (path instanceof NumberExpression) {
        searchCondition.or(((NumberExpression<?>) path).like("%".concat(text).concat("%")));
      }
    }
    return query.where(searchCondition);
  }
  return query;
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@ExtDirectMethod(STORE_READ)
@Transactional(readOnly = true)
public ExtDirectStoreResult<User> read(ExtDirectStoreReadRequest request) {

	JPQLQuery<User> query = this.jpaQueryFactory.selectFrom(QUser.user);
	if (!request.getFilters().isEmpty()) {
		StringFilter filter = (StringFilter) request.getFilters().iterator().next();

		BooleanBuilder bb = new BooleanBuilder();
		bb.or(QUser.user.loginName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.lastName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.firstName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.email.containsIgnoreCase(filter.getValue()));

		query.where(bb);
	}
	query.where(QUser.user.deleted.isFalse());

	QuerydslUtil.addPagingAndSorting(query, request, User.class, QUser.user);
	QueryResults<User> searchResult = query.fetchResults();

	return new ExtDirectStoreResult<>(searchResult.getTotal(),
			searchResult.getResults());
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
@Transactional(readOnly = true)
public List<HarvestPermitAreaDTO> listByClub(final long clubId, final Integer huntingYear) {
    final HuntingClub huntingClub = requireClubWithReadPermission(clubId);

    final BooleanBuilder builder = new BooleanBuilder(QHarvestPermitArea.harvestPermitArea.club.eq(huntingClub));

    if (huntingYear != null) {
        builder.and(QHarvestPermitArea.harvestPermitArea.huntingYear.eq(huntingYear));
    }

    return harvestPermitAreaDTOTransformer.transform(harvestPermitAreaRepository.findAllAsList(builder.getValue()));
}
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
private Predicate buildTextQuery(TextQuery txt, StringPath txtfield) {

        if (txt.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (txt.getContains() != null) {
            predicate.and(txtfield.contains(txt.getContains()));
        }

        if (txt.getStartWith() != null) {
            predicate.and(txtfield.startsWith(txt.getStartWith()));
        }

        if (txt.getEndWith() != null) {
            predicate.and(txtfield.endsWith(txt.getEndWith()));
        }

        if (txt.getEquals() != null) {
            predicate.and(txtfield.endsWith(txt.getEquals()));
        }

        if (!txt.getIn().isEmpty()) {
            predicate.and(txtfield.in(txt.getIn()));
        }

        return predicate;
    }
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
public Predicate getPredicate() {

        QApp app = new QApp("app");

        BooleanBuilder predicate = new BooleanBuilder();

        if (query.getUserId() != null) {
            predicate.and(app.userId.eq(query.getUserId()));
        }

        // id
        Predicate pid = buildTextQuery(query.id, app.id);
        if (pid != null) {
            predicate.and(pid);
        }

        // name
        Predicate pname = buildTextQuery(query.name, app.name);
        if (pname != null) {
            predicate.and(pname);
        }

        // description
        Predicate pdesc = buildTextQuery(query.description, app.description);
        if (pdesc != null) {
            predicate.and(pdesc);
        }

        //users (id)
        Predicate users = buildAppUserListQuery(query.users, app.users);
        if (users != null) {
            predicate.and(users);
        }

        return predicate;
    }
 

import com.querydsl.core.BooleanBuilder; //导入依赖的package包/类
private Predicate buildListQuery(StringListQuery query, ListPath<String, StringPath> list) {

        if (query.isEmpty()) {
            return null;
        }

        BooleanBuilder predicate = new BooleanBuilder();

        if (query.getIn() != null && query.getIn().isEmpty()) {
            predicate.and(list.any().in(query.getIn()));
        }

        return predicate;
    }