/**
* From the dialog collects roots and commits to be pushed.
*
* @return roots to be pushed.
*/
private Collection<Root> getRootsToPush() {
final ArrayList<Root> rootsToPush = new ArrayList<Root>();
for (int i = 0; i < myTreeRoot.getChildCount(); i++) {
CheckedTreeNode node = (CheckedTreeNode) myTreeRoot.getChildAt(i);
Root r = (Root) node.getUserObject();
if (r.remoteName == null || r.commits.size() == 0) {
continue;
}
boolean topCommit = true;
for (int j = 0; j < node.getChildCount(); j++) {
if (node.getChildAt(j) instanceof CheckedTreeNode) {
CheckedTreeNode commitNode = (CheckedTreeNode) node.getChildAt(j);
if (commitNode.isChecked()) {
Commit commit = (Commit) commitNode.getUserObject();
if (!topCommit) {
r.commitToPush = commit.revision.asString();
}
rootsToPush.add(r);
break;
}
topCommit = false;
}
}
}
return rootsToPush;
}
@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()]);
}
/**
* Adds ORDER BY ... ASC/DESC to query Mutates provided criteria query
*
* @param sortFieldOpt - field to sort by (field name in JPA Entity class)
* @param asc - true if order should be ASC, false otherwise
*/
public static void order(
CriteriaBuilder cb,
CriteriaQuery<?> cq,
Root<?> from,
Optional<String> sortFieldOpt,
boolean asc) {
sortFieldOpt.ifPresent(
sortField -> {
Order order = asc ? cb.asc(from.get(sortField)) : cb.desc(from.get(sortField));
cq.orderBy(order);
});
}
public static Predicate[] deviceClassListPredicates(
CriteriaBuilder cb,
Root<DeviceClass> from,
Optional<String> name,
Optional<String> namePattern,
Optional<String> version) {
final List<Predicate> predicates = new LinkedList<>();
if (namePattern.isPresent()) {
namePattern.ifPresent(np -> predicates.add(cb.like(from.get("name"), np)));
} else {
name.ifPresent(n -> predicates.add(cb.equal(from.get("name"), n)));
}
version.ifPresent(v -> predicates.add(cb.equal(from.get(DeviceClass.VERSION_COLUMN), v)));
return predicates.toArray(new Predicate[predicates.size()]);
}
static Application findApplication(String name, String version) {
EntityManager em = Stripersist.getEntityManager();
if (name != null) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery q = cb.createQuery(Application.class);
Root<Application> root = q.from(Application.class);
Predicate namePredicate = cb.equal(root.get("name"), name);
Predicate versionPredicate =
version != null ? cb.equal(root.get("version"), version) : cb.isNull(root.get("version"));
q.where(cb.and(namePredicate, versionPredicate));
try {
return (Application) em.createQuery(q).getSingleResult();
} catch (NoResultException nre) {
}
}
return null;
}
public static Predicate[] oAuthClientListPredicates(
CriteriaBuilder cb,
Root<OAuthClient> from,
Optional<String> nameOpt,
Optional<String> namePattern,
Optional<String> domainOpt,
Optional<String> oauthIdOpt) {
List<Predicate> predicates = new LinkedList<>();
if (namePattern.isPresent()) {
namePattern.ifPresent(pattern -> predicates.add(cb.like(from.get("name"), pattern)));
} else {
nameOpt.ifPresent(name -> predicates.add(cb.equal(from.get("name"), name)));
}
domainOpt.ifPresent(domain -> predicates.add(cb.equal(from.get("domain"), domain)));
oauthIdOpt.ifPresent(id -> predicates.add(cb.equal(from.get("oauthId"), id)));
return predicates.toArray(new Predicate[predicates.size()]);
}
public static Predicate[] userListPredicates(
CriteriaBuilder cb,
Root<User> from,
Optional<String> loginOpt,
Optional<String> loginPattern,
Optional<Integer> roleOpt,
Optional<Integer> statusOpt) {
List<Predicate> predicates = new LinkedList<>();
if (loginPattern.isPresent()) {
loginPattern.ifPresent(pattern -> predicates.add(cb.like(from.get("login"), pattern)));
} else {
loginOpt.ifPresent(login -> predicates.add(cb.equal(from.get("login"), login)));
}
roleOpt.ifPresent(role -> predicates.add(cb.equal(from.get("role"), role)));
statusOpt.ifPresent(status -> predicates.add(cb.equal(from.get("status"), status)));
return predicates.toArray(new Predicate[predicates.size()]);
}
/**
* Returns the root of the current context or {@code null}.
*
* @param ctx query context
* @return root
*/
final Value root(final QueryContext ctx) {
final Value v = ctx != null ? ctx.value : null;
// no root specified: return context, if it does not reference a document
// as e.g. happens in //a(b|c)
if (root == null) return v == null || v.type != NodeType.DOC ? v : null;
// root is value: return root
if (root.isValue()) return (Value) root;
// no root reference, no context: return null
if (!(root instanceof Root) || v == null) return null;
// return context sequence or root of current context
return v.size() == 1 ? Root.root(v) : v;
}
public static Predicate[] deviceListPredicates(
CriteriaBuilder cb,
Root<Device> from,
List<String> guids,
Optional<HivePrincipal> principal) {
final List<Predicate> predicates = deviceSpecificPrincipalPredicates(cb, from, principal);
if (guids != null && !guids.isEmpty()) {
predicates.add(from.get(GUID).in(guids));
}
return predicates.toArray(new Predicate[predicates.size()]);
}
public static Predicate[] networkPermissionsPredicates(
CriteriaBuilder cb, Root<?> from, Set<AccessKeyPermission> permissions) {
List<Predicate> predicates = new ArrayList<>();
for (AccessKeyBasedFilterForDevices extraFilter :
AccessKeyBasedFilterForDevices.createExtraFilters(permissions)) {
List<Predicate> filter = new ArrayList<>();
if (extraFilter.getNetworkIds() != null) {
filter.add(from.get("id").in(extraFilter.getNetworkIds()));
}
predicates.add(cb.and(filter.toArray(new Predicate[filter.size()])));
}
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()]);
}
/**
* Creates an array of JPA predicates for networks list query. Add filter predicates for name and
* principal if required. 1) if name is specified adds 'name = ?' predicate 2) if name pattern is
* specified adds 'name like ?' predicate 3) if principal is user of key without ADMIN role adds
* predicate for filtering not assigned networks 4) if principal is key which has permissions only
* to specific networks adds 'network.id in (allowed_networks)' predicates
*
* @return array of above predicates
* @see {@link com.devicehive.service.NetworkService#list(String, String, String, boolean,
* Integer, Integer, HivePrincipal)}
*/
public static Predicate[] networkListPredicates(
CriteriaBuilder cb,
Root<Network> from,
Optional<String> nameOpt,
Optional<String> namePatternOpt,
Optional<HivePrincipal> principalOpt) {
List<Predicate> predicates = new LinkedList<>();
nameOpt.ifPresent(name -> predicates.add(cb.equal(from.get("name"), name)));
namePatternOpt.ifPresent(pattern -> predicates.add(cb.like(from.get("name"), pattern)));
principalOpt
.flatMap(
principal -> {
User user = principal.getUser();
if (user == null && principal.getKey() != null) {
user = principal.getKey().getUser();
}
return ofNullable(user);
})
.ifPresent(
user -> {
if (!user.isAdmin()) {
predicates.add(from.join("users").in(user));
}
});
principalOpt
.map(HivePrincipal::getKey)
.ifPresent(
key ->
predicates.add(
cb.or(networkPermissionsPredicates(cb, from, key.getPermissions()))));
return predicates.toArray(new Predicate[predicates.size()]);
}
/**
* Returns the initial context value of a path or {@code null}.
*
* @param qc query context (may be @code null)
* @return root
*/
private Value initial(final QueryContext qc) {
// current context value
final Value v = qc != null ? qc.value : null;
// no root or context expression: return context
if (root == null || root instanceof Context) return v;
// root reference
if (root instanceof Root) return v != null && v instanceof Item ? Root.root(v) : v;
// root is value: return root
if (root.isValue()) return (Value) root;
// data reference
final Data d = root.data();
if (d != null) return new DBNode(d, 0, Data.ELEM);
// otherwise, return null
return null;
}
@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;
}
@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 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;
}
/**
* Load VCS roots
*
* @param project the project
* @param roots the VCS root list
* @param exceptions the list of of exceptions to use
* @param fetchData if true, the data for remote is fetched.
* @return the loaded information about vcs roots
*/
private static List<Root> loadRoots(
final Project project,
final List<VirtualFile> roots,
final Collection<VcsException> exceptions,
final boolean fetchData) {
final ArrayList<Root> rc = new ArrayList<Root>();
for (VirtualFile root : roots) {
try {
Root r = new Root();
rc.add(r);
r.root = root;
GitBranch b = GitBranch.current(project, root);
if (b != null) {
r.currentBranch = b.getFullName();
r.remoteName = b.getTrackedRemoteName(project, root);
r.remoteBranch = b.getTrackedBranchName(project, root);
if (r.remoteName != null) {
if (fetchData && !r.remoteName.equals(".")) {
GitLineHandler fetch = new GitLineHandler(project, root, GitCommand.FETCH);
fetch.addParameters(r.remoteName, "-v");
Collection<VcsException> exs = GitHandlerUtil.doSynchronouslyWithExceptions(fetch);
exceptions.addAll(exs);
}
GitBranch tracked = b.tracked(project, root);
assert tracked != null : "Tracked branch cannot be null here";
final boolean trackedBranchExists = tracked.exists(root);
if (!trackedBranchExists) {
LOG.info("loadRoots tracked branch " + tracked + " doesn't exist yet");
}
// check what remote commits are not yet merged
if (trackedBranchExists) {
GitSimpleHandler toPull = new GitSimpleHandler(project, root, GitCommand.LOG);
toPull.addParameters(
"--pretty=format:%H", r.currentBranch + ".." + tracked.getFullName());
toPull.setNoSSH(true);
toPull.setStdoutSuppressed(true);
StringScanner su = new StringScanner(toPull.run());
while (su.hasMoreData()) {
if (su.line().trim().length() != 0) {
r.remoteCommits++;
}
}
}
// check what local commits are to be pushed
GitSimpleHandler toPush = new GitSimpleHandler(project, root, GitCommand.LOG);
// if the tracked branch doesn't exist yet (nobody pushed the branch yet), show all
// commits on this branch.
final String revisions =
trackedBranchExists
? tracked.getFullName() + ".." + r.currentBranch
: r.currentBranch;
toPush.addParameters("--pretty=format:%H%x20%ct%x20%at%x20%s%n%P", revisions);
toPush.setNoSSH(true);
toPush.setStdoutSuppressed(true);
StringScanner sp = new StringScanner(toPush.run());
while (sp.hasMoreData()) {
if (sp.isEol()) {
sp.line();
continue;
}
Commit c = new Commit();
c.root = r;
String hash = sp.spaceToken();
String time = sp.spaceToken();
c.revision = new GitRevisionNumber(hash, new Date(Long.parseLong(time) * 1000L));
c.authorTime = sp.spaceToken();
c.message = sp.line();
c.isMerge = sp.line().indexOf(' ') != -1;
r.commits.add(c);
}
}
}
} catch (VcsException e) {
exceptions.add(e);
}
}
return rc;
}
/**
* The entry point into the Parser class.
*
* @param root A RootDoc intstance obtained via the doclet API
* @return A XML (XStream) serializable element, containing everything parsed from javadoc doclet
*/
public static Root ParseRoot(RootDoc root) {
processingStorage = new HashMap<PackageDoc, ParserMediary>();
try {
md5 = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
log.error("unable to acquire MD5 algorithm", e);
return null;
}
rootXml = new Root();
ClassDoc[] allClasses = root.classes();
for (ClassDoc classDoc : allClasses) {
PackageDoc doc = classDoc.containingPackage();
ParserMediary mediary = null;
// the age old 'if I have it pull out existing, if I don't make a new one'
if (processingStorage.containsKey(doc)) {
mediary = processingStorage.get(doc);
} else {
mediary =
new ParserMediary(
doc.name(),
doc.commentText(),
ParseAnnotationInstances(doc.annotations(), doc.name()));
processingStorage.put(doc, mediary);
}
if (classDoc.isIncluded()) {
// dev comment--why do enums show up as ordinary class?
if (classDoc.isOrdinaryClass() || classDoc.isException() || classDoc.isError()) {
mediary.addClass(ParseClass(classDoc));
} else if (classDoc.isEnum()) {
mediary.addEnum(ParseEnum(classDoc));
} else if (isAnnotation(classDoc)) {
mediary.addAnnotation(ParseAnnotation(classDoc));
} else if (classDoc.isInterface()) {
mediary.addInterface(ParseInterface(classDoc));
}
} else {
log.debug("Skipping not-included class " + classDoc.qualifiedName());
}
}
if (processingStorage.size() > 0) {
List list = new ArrayList<Package>();
for (ParserMediary mediary : processingStorage.values()) {
list.add(mediary.wrapup());
}
rootXml.packages = (Package[]) list.toArray(new Package[] {});
} else {
log.warn("No packages found!");
}
return rootXml;
}
public static Predicate[] oAuthGrantsListPredicates(
CriteriaBuilder cb,
Root<OAuthGrant> from,
User user,
Optional<Date> startOpt,
Optional<Date> endOpt,
Optional<String> oAuthIdOpt,
Optional<Integer> typeOpt,
Optional<String> scopeOpt,
Optional<String> redirectUri,
Optional<Integer> accessType) {
List<Predicate> predicates = new LinkedList<>();
if (!user.isAdmin()) {
predicates.add(from.join("user").in(user));
}
startOpt.ifPresent(start -> predicates.add(cb.greaterThan(from.get("timestamp"), start)));
endOpt.ifPresent(end -> predicates.add(cb.lessThan(from.get("timestamp"), end)));
oAuthIdOpt.ifPresent(id -> predicates.add(cb.equal(from.join("client").get("oauthId"), id)));
typeOpt.ifPresent(type -> predicates.add(cb.equal(from.get("type"), type)));
scopeOpt.ifPresent(scope -> predicates.add(cb.equal(from.get("scope"), scope)));
redirectUri.ifPresent(uri -> predicates.add(cb.equal(from.get("redirectUri"), uri)));
accessType.ifPresent(at -> predicates.add(cb.equal(from.get("accessType"), at)));
return predicates.toArray(new Predicate[predicates.size()]);
}