@SuppressWarnings("unchecked")
public static Predicate[] deviceListPredicates(
CriteriaBuilder cb,
Root<Device> from,
Optional<String> name,
Optional<String> namePattern,
Optional<String> status,
Optional<Long> networkId,
Optional<String> networkName,
Optional<Long> deviceClassId,
Optional<String> deviceClassName,
Optional<String> deviceClassVersion,
Optional<HivePrincipal> principal) {
final List<Predicate> predicates = new LinkedList<>();
name.ifPresent(n -> predicates.add(cb.equal(from.<String>get("name"), n)));
namePattern.ifPresent(np -> predicates.add(cb.like(from.<String>get("name"), np)));
status.ifPresent(s -> predicates.add(cb.equal(from.<String>get("status"), s)));
final Join<Device, Network> networkJoin = (Join) from.fetch("network", JoinType.LEFT);
networkId.ifPresent(nId -> predicates.add(cb.equal(networkJoin.<Long>get("id"), nId)));
networkName.ifPresent(
nName -> predicates.add(cb.equal(networkJoin.<String>get("name"), nName)));
final Join<Device, DeviceClass> dcJoin = (Join) from.fetch("deviceClass", JoinType.LEFT);
deviceClassId.ifPresent(dcId -> predicates.add(cb.equal(dcJoin.<Long>get("id"), dcId)));
deviceClassName.ifPresent(
dcName -> predicates.add(cb.equal(dcJoin.<String>get("name"), dcName)));
deviceClassVersion.ifPresent(
dcVersion -> predicates.add(cb.equal(dcJoin.<String>get("version"), dcVersion)));
predicates.addAll(deviceSpecificPrincipalPredicates(cb, from, principal));
return predicates.toArray(new Predicate[predicates.size()]);
}
public static Predicate[] accessKeyListPredicates(
CriteriaBuilder cb,
Root<AccessKey> from,
Long userId,
Optional<String> labelOpt,
Optional<String> labelPatten,
Optional<Integer> typeOpt) {
List<Predicate> predicates = new LinkedList<>();
Join user = (Join) from.fetch("user", JoinType.LEFT);
predicates.add(cb.equal(user.get("id"), userId));
if (labelPatten.isPresent()) {
labelPatten.ifPresent(pattern -> predicates.add(cb.like(from.get("label"), pattern)));
} else {
labelOpt.ifPresent(label -> predicates.add(cb.equal(from.get("label"), label)));
}
typeOpt.ifPresent(type -> predicates.add(cb.equal(from.get("type"), type)));
return predicates.toArray(new Predicate[predicates.size()]);
}
@SuppressWarnings("unchecked")
private static List<Predicate> deviceSpecificPrincipalPredicates(
CriteriaBuilder cb, Root<Device> from, Optional<HivePrincipal> principal) {
final List<Predicate> predicates = new LinkedList<>();
final Join<Device, Network> networkJoin = (Join) from.fetch("network", JoinType.LEFT);
final Join<Device, Network> usersJoin = (Join) networkJoin.fetch("users", JoinType.LEFT);
from.fetch("deviceClass", JoinType.LEFT); // need this fetch to populate deviceClass
principal.ifPresent(
p -> {
User user = p.getUser();
if (user == null && p.getKey() != null) {
user = p.getKey().getUser();
}
if (user != null && !user.isAdmin()) {
predicates.add(cb.equal(usersJoin.<Long>get("id"), user.getId()));
}
if (p.getDevice() != null) {
predicates.add(cb.equal(from.<Long>get("id"), p.getDevice().getId()));
}
if (p.getKey() != null) {
for (AccessKeyBasedFilterForDevices extraFilter :
AccessKeyBasedFilterForDevices.createExtraFilters(p.getKey().getPermissions())) {
if (extraFilter.getDeviceGuids() != null) {
predicates.add(from.<String>get("guid").in(extraFilter.getDeviceGuids()));
}
if (extraFilter.getNetworkIds() != null) {
predicates.add(networkJoin.<Long>get("id").in(extraFilter.getNetworkIds()));
}
}
}
});
return predicates;
}
public long getCardinality(Join join, BindingSet bindings) {
long card1 = getCardinality(join.getLeftArg(), bindings);
long card2 = getCardinality(join.getRightArg(), bindings);
double sel = 0.5;
return (long) (card1 * card2 * sel);
}
@Override
public List<VeteranAssessment> searchVeteranAssessmentForExport(
Integer clinicanId,
Integer createdByUserId,
Integer programId,
Date fromAssessmentDate,
Date toAssessmentDate,
Integer veteranId,
List<Integer> programIdList) {
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<VeteranAssessment> criteriaQuery =
criteriaBuilder.createQuery(VeteranAssessment.class);
Root<VeteranAssessment> veteranAssessmentRoot = criteriaQuery.from(VeteranAssessment.class);
Join<VeteranAssessment, AssessmentStatus> assessmentStatusJoin =
veteranAssessmentRoot.join("assessmentStatus");
List<Predicate> criteriaList = new ArrayList<Predicate>();
// only include assessments in the appropriate state
Expression<Integer> statusExp = assessmentStatusJoin.get("assessmentStatusId");
Predicate statusPredicate = statusExp.in(getExportAssessmentStates());
criteriaList.add(statusPredicate);
if (clinicanId != null) {
Join<VeteranAssessment, User> clinicianJoin = veteranAssessmentRoot.join("clinician");
criteriaList.add(criteriaBuilder.equal(clinicianJoin.get("userId"), clinicanId));
}
if (createdByUserId != null) {
Join<VeteranAssessment, User> createdByUserJoin = veteranAssessmentRoot.join("createdByUser");
criteriaList.add(criteriaBuilder.equal(createdByUserJoin.get("userId"), createdByUserId));
}
if (fromAssessmentDate != null) {
criteriaList.add(
criteriaBuilder.greaterThan(
veteranAssessmentRoot.<Date>get("dateCreated"), fromAssessmentDate));
}
if (toAssessmentDate != null) {
criteriaList.add(
criteriaBuilder.lessThanOrEqualTo(
veteranAssessmentRoot.<Date>get("dateCreated"), toAssessmentDate));
}
if (veteranId != null) {
Join<VeteranAssessment, Veteran> veteranJoin = veteranAssessmentRoot.join("veteran");
criteriaList.add(criteriaBuilder.equal(veteranJoin.get("veteranId"), veteranId));
}
if (programId != null) {
// criteriaList.add(criteriaBuilder.equal(programJoin.get("programId"), programId));
if (programIdList == null) {
programIdList = new ArrayList<Integer>();
}
programIdList.add(programId);
}
if (programIdList != null && programIdList.size() > 0) {
Join<VeteranAssessment, Program> programJoin = veteranAssessmentRoot.join("program");
Expression<Integer> exp = programJoin.get("programId");
Predicate programIdPredicate = exp.in(programIdList);
criteriaList.add(programIdPredicate);
}
criteriaQuery.select(veteranAssessmentRoot);
criteriaQuery.where(criteriaBuilder.and(criteriaList.toArray(new Predicate[0])));
@SuppressWarnings("rawtypes")
Expression orderByPath = veteranAssessmentRoot.get("veteranAssessmentId");
criteriaQuery.orderBy(criteriaBuilder.desc(orderByPath));
// Generate the query based on the criteria.
TypedQuery<VeteranAssessment> query = entityManager.createQuery(criteriaQuery);
List<VeteranAssessment> veteranAssessments = query.getResultList();
return veteranAssessments;
}
@Override
public SearchResult<VeteranAssessment> searchVeteranAssessment(
Integer veteranAssessmentId,
Integer veteranId,
Integer programId,
Integer clinicanId,
Integer createdByUserId,
Date fromAssessmentDate,
Date toAssessmentDate,
List<Integer> programIdList,
SearchAttributes searchAttributes) {
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<VeteranAssessment> criteriaQuery =
criteriaBuilder.createQuery(VeteranAssessment.class);
Root<VeteranAssessment> veteranAssessmentRoot = criteriaQuery.from(VeteranAssessment.class);
Join<VeteranAssessment, AssessmentStatus> assessmentStatusJoin =
veteranAssessmentRoot.join("assessmentStatus");
Join<VeteranAssessment, Veteran> veteranJoin = veteranAssessmentRoot.join("veteran");
Join<VeteranAssessment, Program> programJoin = veteranAssessmentRoot.join("program");
Join<VeteranAssessment, User> clinicianJoin = veteranAssessmentRoot.join("clinician");
Join<VeteranAssessment, User> createdByUserJoin = veteranAssessmentRoot.join("createdByUser");
List<Predicate> criteriaList = new ArrayList<Predicate>();
if (veteranAssessmentId != null) {
criteriaList.add(
criteriaBuilder.equal(
veteranAssessmentRoot.get("veteranAssessmentId"), veteranAssessmentId));
}
if (veteranId != null) {
criteriaList.add(criteriaBuilder.equal(veteranJoin.get("veteranId"), veteranId));
}
if (programId != null) {
criteriaList.add(criteriaBuilder.equal(programJoin.get("programId"), programId));
}
if (clinicanId != null) {
criteriaList.add(criteriaBuilder.equal(clinicianJoin.get("userId"), clinicanId));
}
if (createdByUserId != null) {
criteriaList.add(criteriaBuilder.equal(createdByUserJoin.get("userId"), createdByUserId));
}
if (fromAssessmentDate != null) {
criteriaList.add(
criteriaBuilder.greaterThanOrEqualTo(
veteranAssessmentRoot.<Date>get("dateUpdated"), fromAssessmentDate));
}
if (toAssessmentDate != null) {
criteriaList.add(
criteriaBuilder.lessThanOrEqualTo(
veteranAssessmentRoot.<Date>get("dateUpdated"), toAssessmentDate));
}
if (programIdList != null && programIdList.size() > 0) {
Expression<Integer> exp = programJoin.get("programId");
Predicate programIdPredicate = exp.in(programIdList);
criteriaList.add(programIdPredicate);
}
criteriaQuery.select(veteranAssessmentRoot);
criteriaQuery.where(criteriaBuilder.and(criteriaList.toArray(new Predicate[0])));
// Set default order by field and then check if one was passed to us.
@SuppressWarnings("rawtypes")
Expression orderByPath = veteranAssessmentRoot.get("veteranAssessmentId");
if (StringUtils.isNotBlank(searchAttributes.getSortColumn())) {
if (searchAttributes.getSortColumn().equalsIgnoreCase("programName")) {
orderByPath = programJoin.get("name");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("clinicianName")) {
orderByPath = clinicianJoin.get("lastName");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("createdBy")) {
orderByPath = createdByUserJoin.get("lastName");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("createDate")) {
orderByPath = veteranAssessmentRoot.get("dateCreated");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("assessmentDate")) {
orderByPath = veteranAssessmentRoot.get("dateUpdated");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("completeDate")) {
orderByPath = veteranAssessmentRoot.get("dateCompleted");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("veteranId")) {
orderByPath = veteranJoin.get("veteranId");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("veteranName")) {
orderByPath = veteranJoin.get("lastName");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("assessmentStatusName")) {
orderByPath = assessmentStatusJoin.get("name");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("ssnLastFour")) {
orderByPath = veteranJoin.get("ssnLastFour");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("duration")) {
orderByPath = veteranAssessmentRoot.get("duration");
} else if (searchAttributes.getSortColumn().equalsIgnoreCase("percentComplete")) {
orderByPath = veteranAssessmentRoot.get("percentComplete");
}
}
if (searchAttributes.getSortDirection() == SortDirection.SORT_DESCENDING) {
criteriaQuery.orderBy(criteriaBuilder.desc(orderByPath));
} else {
criteriaQuery.orderBy(criteriaBuilder.asc(orderByPath));
}
// Generate the query based on the criteria.
TypedQuery<VeteranAssessment> query = entityManager.createQuery(criteriaQuery);
SearchResult<VeteranAssessment> searchResult = new SearchResult<VeteranAssessment>();
// Get the total count. Not a very efficient way....
Integer totalCount = query.getResultList().size();
searchResult.setTotalNumRowsFound(totalCount);
// Now get only the page.
query.setFirstResult(searchAttributes.getRowStartIndex());
query.setMaxResults(searchAttributes.getPageSize());
List<VeteranAssessment> veteranAssessments = query.getResultList();
searchResult.setResultList(veteranAssessments);
return searchResult;
}
@Override
public StorageResults visit(Select select) {
// TMDM-4654: Checks if entity has a composite PK.
Set<ComplexTypeMetadata> compositeKeyTypes = new HashSet<ComplexTypeMetadata>();
// TMDM-7496: Search should include references to reused types
Collection<ComplexTypeMetadata> types =
new HashSet<ComplexTypeMetadata>(select.accept(new SearchTransitiveClosure()));
for (ComplexTypeMetadata type : types) {
if (type.getKeyFields().size() > 1) {
compositeKeyTypes.add(type);
}
}
if (!compositeKeyTypes.isEmpty()) {
StringBuilder message = new StringBuilder();
Iterator it = compositeKeyTypes.iterator();
while (it.hasNext()) {
ComplexTypeMetadata compositeKeyType = (ComplexTypeMetadata) it.next();
message.append(compositeKeyType.getName());
if (it.hasNext()) {
message.append(',');
}
}
throw new FullTextQueryCompositeKeyException(message.toString());
}
// Removes Joins and joined fields.
List<Join> joins = select.getJoins();
if (!joins.isEmpty()) {
Set<ComplexTypeMetadata> joinedTypes = new HashSet<ComplexTypeMetadata>();
for (Join join : joins) {
joinedTypes.add(join.getRightField().getFieldMetadata().getContainingType());
}
for (ComplexTypeMetadata joinedType : joinedTypes) {
types.remove(joinedType);
}
List<TypedExpression> filteredFields = new LinkedList<TypedExpression>();
for (TypedExpression expression : select.getSelectedFields()) {
if (expression instanceof Field) {
FieldMetadata fieldMetadata = ((Field) expression).getFieldMetadata();
if (joinedTypes.contains(fieldMetadata.getContainingType())) {
TypeMapping mapping =
mappings.getMappingFromDatabase(fieldMetadata.getContainingType());
filteredFields.add(
new Alias(
new StringConstant(StringUtils.EMPTY),
mapping.getUser(fieldMetadata).getName()));
} else {
filteredFields.add(expression);
}
} else {
filteredFields.add(expression);
}
}
selectedFields.clear();
selectedFields.addAll(filteredFields);
}
// Handle condition
Condition condition = select.getCondition();
if (condition == null) {
throw new IllegalArgumentException("Expected a condition in select clause but got 0.");
}
// Create Lucene query (concatenates all sub queries together).
FullTextSession fullTextSession = Search.getFullTextSession(session);
Query parsedQuery = select.getCondition().accept(new LuceneQueryGenerator(types));
// Create Hibernate Search query
Set<Class> classes = new HashSet<Class>();
for (ComplexTypeMetadata type : types) {
String className = ClassCreator.getClassName(type.getName());
try {
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
classes.add(contextClassLoader.loadClass(className));
} catch (ClassNotFoundException e) {
throw new RuntimeException("Could not find class '" + className + "'.", e);
}
}
FullTextQuery fullTextQuery =
fullTextSession.createFullTextQuery(
parsedQuery, classes.toArray(new Class<?>[classes.size()]));
// Very important to leave this null (would disable ability to search across different types)
fullTextQuery.setCriteriaQuery(null);
fullTextQuery.setSort(Sort.RELEVANCE); // Default sort (if no order by specified).
query =
EntityFinder.wrap(
fullTextQuery,
(HibernateStorage) storage,
session); // ensures only MDM entity objects are returned.
// Order by
for (OrderBy current : select.getOrderBy()) {
current.accept(this);
}
// Paging
Paging paging = select.getPaging();
paging.accept(this);
pageSize = paging.getLimit();
boolean hasPaging = pageSize < Integer.MAX_VALUE;
if (!hasPaging) {
return createResults(query.scroll(ScrollMode.FORWARD_ONLY));
} else {
return createResults(query.list());
}
}