下面列出了javax.persistence.criteria.Order#javax.persistence.criteria.Predicate 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public List<String> listByUnitRecordDateString(List<String> unitName, String sDate) throws Exception {
if (unitName == null || unitName.size() == 0) {
logger.error(new UnitNamesEmptyException());
return null;
}
EntityManager em = this.entityManagerContainer().get(StatisticUnitForDay.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<StatisticUnitForDay> root = cq.from(StatisticUnitForDay.class);
Predicate p = root.get(StatisticUnitForDay_.unitName).in(unitName);
if (sDate == null || sDate.isEmpty()) {
logger.error(new StatisticDateEmptyException());
} else {
p = cb.and(p, cb.equal(root.get(StatisticUnitForDay_.statisticDate), sDate));
}
cq.select(root.get(StatisticUnitForDay_.id));
return em.createQuery(cq.where(p)).setMaxResults(62).getResultList();
}
Data loadData(Business business, Work work) throws Exception {
EntityManager em = business.entityManagerContainer().get(Item.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Item> cq = cb.createQuery(Item.class);
Root<Item> root = cq.from(Item.class);
Predicate p = cb.equal(root.get(Item_.bundle), work.getJob());
p = cb.and(p, cb.equal(root.get(Item_.itemCategory), ItemCategory.pp));
List<Item> list = em.createQuery(cq.where(p)).getResultList();
if (list.isEmpty()) {
return new Data();
} else {
JsonElement jsonElement = itemConverter.assemble(list);
if (jsonElement.isJsonObject()) {
return gson.fromJson(jsonElement, Data.class);
} else {
/* 如果不是Object强制返回一个Map对象 */
return new Data();
}
}
}
public List<String> listSubjectIdsBySection( String sectionId, Integer maxResults ) throws Exception {
if( sectionId == null || sectionId.isEmpty() ){
throw new Exception( "sectionId is null!" );
}
EntityManager em = this.entityManagerContainer().get(BBSSubjectInfo.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery( String.class );
Root<BBSSubjectInfo> root = cq.from(BBSSubjectInfo.class);
Predicate p = cb.equal( root.get(BBSSubjectInfo_.sectionId), sectionId);
cq.select( root.get(BBSSubjectInfo_.id) );
if( maxResults == null || maxResults == 0 ){
return em.createQuery(cq.where(p)).getResultList();
}else{
return em.createQuery(cq.where(p)).setMaxResults( maxResults ).getResultList();
}
}
protected void applyPredicateToCriteria(AbstractQuery<?> query) {
Predicate predicate = parsePredicate(junction);
if (predicate != null) {
query.where(predicate);
}
predicate = parsePredicate(having);
if (predicate != null) {
query.having(predicate);
}
if (query instanceof CriteriaQuery) {
if (!CollectionUtils.isEmpty(orders)) {
((CriteriaQuery<?>) query).orderBy(orders);
}
}
}
public static void processGreaterOperator(CriteriaBuilder cb, List<Predicate> predicates, Filter filter,
Expression filterExpr) {
Object value = filter.getValue();
if (value instanceof Date) {
Timestamp timestamp = new Timestamp(((Date) value).getTime());
predicates.add(cb.greaterThan(filterExpr, timestamp));
} else if (value instanceof String) {
if (filterExpr.getJavaType().equals(Timestamp.class)) {
java.util.Date date = DateUtils.convertToTimestamp((String) value);
predicates.add(cb.greaterThan(filterExpr, new Timestamp(date.getTime())));
} else {
predicates.add(cb.greaterThan(filterExpr, (String) value));
}
} else if (value instanceof Number) {
if (value instanceof Integer) predicates.add(cb.greaterThan(filterExpr, (Integer) value));
if (value instanceof Long) predicates.add(cb.greaterThan(filterExpr, (Long) value));
if (value instanceof Float) predicates.add(cb.greaterThan(filterExpr, (Float) value));
if (value instanceof Double) predicates.add(cb.greaterThan(filterExpr, (Double) value));
}
}
@Override
public List<UserVO> list(String login, String loginPattern,
Integer role, Integer status,
String sortField, boolean sortOrderAsc,
Integer take, Integer skip) {
CriteriaBuilder cb = criteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> from = cq.from(User.class);
Predicate[] predicates = CriteriaHelper.userListPredicates(cb, from, ofNullable(login), ofNullable(loginPattern), ofNullable(role), ofNullable(status));
cq.where(predicates);
CriteriaHelper.order(cb, cq, from, ofNullable(sortField), Boolean.TRUE.equals(sortOrderAsc));
TypedQuery<User> query = createQuery(cq);
cacheQuery(query, of(CacheConfig.refresh()));
ofNullable(take).ifPresent(query::setMaxResults);
ofNullable(skip).ifPresent(query::setFirstResult);
return query.getResultList().stream().map(User::convertToVo).collect(Collectors.toList());
}
private List<NameValueCountPair> listActivityNamePair(Business business, EffectivePerson effectivePerson)
throws Exception {
EntityManager em = business.entityManagerContainer().get(Task.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Task> root = cq.from(Task.class);
Predicate p = cb.equal(root.get(Task_.person), effectivePerson.getDistinguishedName());
cq.select(root.get(Task_.activityName)).where(p).distinct(true);
List<String> os = em.createQuery(cq).getResultList();
List<NameValueCountPair> wos = new ArrayList<>();
for (String str : os) {
if (StringUtils.isNotEmpty(str)) {
NameValueCountPair o = new NameValueCountPair();
o.setValue(str);
o.setName(str);
wos.add(o);
}
}
SortTools.asc(wos, "name");
return wos;
}
private void cleanupPromptErrorLog() throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
EntityManager em = emc.get(PromptErrorLog.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<PromptErrorLog> root = cq.from(PromptErrorLog.class);
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_MONTH, -7);
Predicate p = cb.not(cb.greaterThan(root.get(PromptErrorLog_.createTime), cal.getTime()));
cq.select(root.get(PromptErrorLog_.id)).where(p);
List<String> list = em.createQuery(cq).getResultList();
for (int i = 0; i < list.size(); i++) {
if (i % 100 == 0) {
emc.beginTransaction(PromptErrorLog.class);
}
PromptErrorLog o = emc.find(list.get(i), PromptErrorLog.class);
emc.remove(o);
if ((i % 100 == 99) || (i == (list.size() - 1))) {
emc.commit();
}
}
}
}
/**
* 根据工作信息ID，获取工作干系人信息ID列表
*
* @param workId
* @return
* @throws Exception
*/
// @MethodDescribe( "根据工作信息ID，用户身份，获取工作干系人信息ID列表" )
public List<String> listByWorkIdAndUserIdentity(String workId, String userIdentity, List<String> statuses)
throws Exception {
EntityManager em = this.entityManagerContainer().get(OkrWorkPerson.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<OkrWorkPerson> root = cq.from(OkrWorkPerson.class);
Predicate p = cb.equal(root.get(OkrWorkPerson_.workId), workId);
if (userIdentity != null && !userIdentity.isEmpty()) {
p = cb.and(p, cb.equal(root.get(OkrWorkPerson_.employeeIdentity), userIdentity));
}
if (statuses != null && statuses.size() > 0) {
p = cb.and(p, root.get(OkrWorkPerson_.status).in(statuses));
}
cq.select(root.get(OkrWorkPerson_.id));
return em.createQuery(cq.where(p)).getResultList();
}
public List<AttendanceCycles> getCyclesFromDetailWithDateSplit( String empName, Date startDate, Date endDate ) throws Exception{
if( startDate == null || startDate == null ){
return null;
}
EntityManager em = this.entityManagerContainer().get( AttendanceDetail.class );
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<AttendanceCycles> cq = cb.createQuery(AttendanceCycles.class);
Root<AttendanceDetail> root = cq.from( AttendanceDetail.class);
Predicate p = cb.between( root.get(AttendanceDetail_.recordDate), startDate, endDate);
p = cb.and( p, cb.equal( root.get(AttendanceDetail_.empName), empName));
List<Selection<?>> selectionList = new ArrayList<Selection<?>>();
selectionList.add(root.get(AttendanceDetail_.cycleYear ));
selectionList.add(root.get(AttendanceDetail_.cycleMonth ));
cq.distinct(true).multiselect(selectionList);
return em.createQuery(cq.where(p)).getResultList();
}
private List<NameValueCountPair> groupByCreatorUnit(Business business, Predicate predicate) throws Exception {
EntityManager em = business.entityManagerContainer().get(Task.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
Root<Task> root = cq.from(Task.class);
Path<String> pathCreatorUnit = root.get(Task_.creatorUnit);
cq.multiselect(pathCreatorUnit, cb.count(root)).where(predicate).groupBy(pathCreatorUnit);
List<Tuple> os = em.createQuery(cq).getResultList();
List<NameValueCountPair> list = new ArrayList<>();
NameValueCountPair pair = null;
for (Tuple o : os) {
pair = new NameValueCountPair();
pair.setName(o.get(pathCreatorUnit));
pair.setValue(o.get(pathCreatorUnit));
pair.setCount(o.get(1, Long.class));
list.add(pair);
}
return list.stream().sorted(Comparator.comparing(NameValueCountPair::getCount).reversed())
.collect(Collectors.toList());
}
public Long getWorkTotalByCenterId(String identity, List<String> status, String processIdentity) throws Exception {
if (identity == null || identity.isEmpty()) {
throw new Exception("identity is null.");
}
if (status == null || status.isEmpty()) {
throw new Exception("status is null.");
}
EntityManager em = this.entityManagerContainer().get(OkrWorkPerson.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<OkrWorkPerson> root = cq.from(OkrWorkPerson.class);
Predicate p = root.get(OkrWorkPerson_.status).in(status);
p = cb.and(p, cb.equal(root.get(OkrWorkPerson_.employeeIdentity), identity));
if (processIdentity != null && !processIdentity.isEmpty()) {
p = cb.and(p, cb.equal(root.get(OkrWorkPerson_.processIdentity), processIdentity));
}
// 查询总数
cq.select(cb.count(root));
return em.createQuery(cq.where(p)).getSingleResult();
}
public List<String> listByUnitDayDate(String name, String date) throws Exception {
if (name == null || name.isEmpty()) {
logger.error(new UnitNamesEmptyException());
return null;
}
EntityManager em = this.entityManagerContainer().get(StatisticUnitForDay.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<StatisticUnitForDay> root = cq.from(StatisticUnitForDay.class);
Predicate p = cb.equal(root.get(StatisticUnitForDay_.unitName), name);
if (date == null || date.isEmpty()) {
logger.error(new StatisticDateEmptyException());
} else {
p = cb.and(p, cb.equal(root.get(StatisticUnitForDay_.statisticDate), date));
}
cq.select(root.get(StatisticUnitForDay_.id));
return em.createQuery(cq.where(p)).setMaxResults(62).getResultList();
}
public static Specification<Conference> inProgressConferences() {
return new Specification<Conference>() {
@Override
public Predicate toPredicate(Root<Conference> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
Expression<Timestamp> currentTimestamp = cb.currentTimestamp();
return cb.and(
cb.greaterThan(root.get("endedDate").as(Date.class),
currentTimestamp), cb.lessThan(
root.get("startedDate").as(Date.class),
currentTimestamp));
}
};
}
/**
* 根据中心工作ID，查询所有的干系人姓名
*
* @param centerId
* @param identity
* 干系人身份
* @return
* @throws Exception
*/
// @MethodDescribe( "根据中心工作ID，查询所有的干系人身份" )
public List<String> listDistinctIdentityNameByCenterId(String centerId, String identity) throws Exception {
if (centerId == null || centerId.isEmpty()) {
logger.warn("centerId is null!");
return null;
}
EntityManager em = this.entityManagerContainer().get(OkrWorkPerson.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<OkrWorkPerson> root = cq.from(OkrWorkPerson.class);
cq.distinct(true).select(root.get(OkrWorkPerson_.employeeIdentity));
Predicate p = cb.equal(root.get(OkrWorkPerson_.centerId), centerId);
if (identity != null && !identity.isEmpty()) {
p = cb.and(p, cb.equal(root.get(OkrWorkPerson_.processIdentity), identity));
}
return em.createQuery(cq.where(p)).setMaxResults(2000).getResultList();
}
/**
* 根据组织列表，统计年月，计算组织内所有员工出勤天数总和
* @param unitName
* @param sYear
* @param sMonth
* @return
* @throws Exception
*/
public Double sumAttendanceDayCountByUnitYearAndMonth( List<String> unitName, String sYear, String sMonth) throws Exception{
if( unitName == null || unitName.size() == 0 ){
logger.error( new UnitNamesEmptyException() );
return null;
}
EntityManager em = this.entityManagerContainer().get( StatisticPersonForMonth.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Double> cq = cb.createQuery(Double.class);
Root<StatisticPersonForMonth> root = cq.from( StatisticPersonForMonth.class);
//查询总数
cq.select( cb.sum( root.get(StatisticPersonForMonth_.onDutyDayCount) ) );
Predicate p = root.get(StatisticPersonForMonth_.unitName).in( unitName );
if( sYear == null || sYear.isEmpty() ){
logger.error( new StatisticYearEmptyException() );
}else{
p = cb.and( p, cb.equal( root.get(StatisticPersonForMonth_.statisticYear), sYear));
}
if( sMonth == null || sMonth.isEmpty() ){
logger.error( new StatisticMonthEmptyException() );
}else{
p = cb.and( p, cb.equal( root.get(StatisticPersonForMonth_.statisticMonth), sMonth));
}
return em.createQuery(cq.where(p)).getSingleResult();
}
/**
* 根据组织名称，统计年月，统计顶层组织所有人员异常打卡次数总和
* @param unitName
* @param cycleYear
* @param cycleMonth
* @return
* @throws Exception
*/
public Long sumAbNormalDutyCountByUnitYearAndMonth(List<String> unitName, String sYear, String sMonth) throws Exception{
if( unitName == null || unitName.size() == 0 ){
logger.error( new UnitNamesEmptyException() );
return null;
}
EntityManager em = this.entityManagerContainer().get( StatisticUnitForMonth.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<StatisticUnitForMonth> root = cq.from( StatisticUnitForMonth.class);
//查询总数
cq.select( cb.sum( root.get(StatisticUnitForMonth_.abNormalDutyCount) ) );
Predicate p = root.get(StatisticUnitForMonth_.unitName).in( unitName );
if( sYear == null || sYear.isEmpty() ){
logger.error( new StatisticYearEmptyException() );
}else{
p = cb.and( p, cb.equal( root.get(StatisticUnitForMonth_.statisticYear), sYear));
}
if( sMonth == null || sMonth.isEmpty() ){
logger.error( new StatisticMonthEmptyException() );
}else{
p = cb.and( p, cb.equal( root.get(StatisticUnitForMonth_.statisticMonth), sMonth));
}
return em.createQuery(cq.where(p)).getSingleResult();
}
private AppInfo getAppInfoWithAlias(Business business, String alias) throws Exception {
if (StringUtils.isEmpty(alias)) {
return null;
}
EntityManager em = business.entityManagerContainer().get(AppInfo.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<AppInfo> cq = cb.createQuery(AppInfo.class);
Root<AppInfo> root = cq.from(AppInfo.class);
Predicate p = cb.equal( root.get(AppInfo_.appAlias ), alias);
List<AppInfo> os = em.createQuery(cq.select(root).where(p).distinct(true)).getResultList();
if (os.size() == 1) {
return os.get(0);
} else {
return null;
}
}
public Long getCompletedWorkCountByCenterId(String centerId, List<String> status) throws Exception {
if( centerId == null || centerId.isEmpty() ){
throw new Exception( "centerId is null." );
}
if( status == null || status.isEmpty() ){
throw new Exception( "status is null." );
}
EntityManager em = this.entityManagerContainer().get( OkrWorkBaseInfo.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<OkrWorkBaseInfo> root = cq.from( OkrWorkBaseInfo.class);
Predicate p = root.get( OkrWorkBaseInfo_.status ).in( status );
p = cb.and( p, cb.equal( root.get( OkrWorkBaseInfo_.centerId ), centerId));
p = cb.and( p, cb.equal( root.get( OkrWorkBaseInfo_.workProcessStatus ), "已完成"));
//查询总数
cq.select( cb.count( root ) );
return em.createQuery(cq.where(p)).getSingleResult();
}
/**
* 根据员工，打卡日期月，统计请假天数
* @param unitNames
* @param recordDate
* @return
* @throws Exception
*/
public Double sumOnSelfHolidayDaysByUnitAndDate( List<String> unitNames, String recordDate ) throws Exception{
if( unitNames == null || unitNames.size() == 0 ){
logger.error( new UnitNamesEmptyException() );
return null;
}
EntityManager em = this.entityManagerContainer().get( AttendanceDetail.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Double> cq = cb.createQuery(Double.class);
Root<AttendanceDetail> root = cq.from( AttendanceDetail.class);
Predicate p = root.get( AttendanceDetail_.unitName ).in( unitNames );
p = cb.and( p, cb.equal( root.get( AttendanceDetail_.recordStatus ), 1));
if( recordDate == null || recordDate.isEmpty() ){
logger.error( new RecordDateEmptyException() );
}else{
p = cb.and( p, cb.equal( root.get( AttendanceDetail_.recordDateString ), recordDate));
}
//查询总数
cq.select( cb.sum( root.get( AttendanceDetail_.getSelfHolidayDays ) ) );
return em.createQuery(cq.where(p)).getSingleResult();
}
private <T extends JpaObject> String idleAliasWithPortal(Business business, String portalId, String alias,
Class<T> cls, String excludeId) throws Exception {
if (StringUtils.isEmpty(alias)) {
return "";
}
List<String> list = new ArrayList<>();
list.add(alias);
for (int i = 1; i < 99; i++) {
list.add(alias + String.format("%02d", i));
}
list.add(StringTools.uniqueToken());
EntityManager em = business.entityManagerContainer().get(cls);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<T> root = cq.from(cls);
Predicate p = root.get("alias").in(list);
p = cb.and(p, cb.equal(root.get("portal"), portalId));
if (StringUtils.isNotEmpty(excludeId)) {
p = cb.and(p, cb.notEqual(root.get(JpaObject.id_FIELDNAME), excludeId));
}
cq.select(root.get("alias")).where(p);
List<String> os = em.createQuery(cq).getResultList();
list = ListUtils.subtract(list, os);
return list.get(0);
}
private List<String> list(Business business, Boolean cleanWork, Boolean cleanWorkCompleted, Boolean cleanCms)
throws Exception {
EntityManager em = business.entityManagerContainer().get(Entry.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Entry> root = cq.from(Entry.class);
Predicate p = cb.disjunction();
if (BooleanUtils.isTrue(cleanWork)) {
p = cb.or(p, cb.equal(root.get(Entry_.type), Entry.TYPE_WORK));
}
if (BooleanUtils.isTrue(cleanWorkCompleted)) {
p = cb.or(p, cb.equal(root.get(Entry_.type), Entry.TYPE_WORKCOMPLETED));
}
if (BooleanUtils.isTrue(cleanCms)) {
p = cb.or(p, cb.equal(root.get(Entry_.type), Entry.TYPE_CMS));
}
cq.select(root.get(Entry_.id)).where(p);
List<String> os = em.createQuery(cq).setMaxResults(BATCHSIZE).getResultList();
return os;
}
public MindVersionInfo getLatestVersionWithMind(String mindId) throws Exception {
if( StringUtils.isEmpty( mindId ) ){
new Exception("脑图ID为空，无法查询版本信息！");
}
EntityManager em = this.entityManagerContainer().get(MindVersionInfo.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<MindVersionInfo> cq = cb.createQuery(MindVersionInfo.class);
Root<MindVersionInfo> root = cq.from(MindVersionInfo.class);
Predicate p = cb.equal( root.get(MindVersionInfo_.mindId) , mindId);
cq.orderBy( cb.desc( root.get( MindVersionInfo_.updateTime ) ) );
List<MindVersionInfo> versions = em.createQuery(cq.where(p)).setMaxResults(1).getResultList();
if(ListTools.isNotEmpty( versions )) {
return versions.get(0);
}
return null;
}
private Long countExpiredTaskTask(Business business, DateRange dateRange, String applicationId, String processId,
String activityId, List<String> units, String person) throws Exception {
EntityManager em = business.entityManagerContainer().get(Task.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<Task> root = cq.from(Task.class);
Predicate p = cb.between(root.get(Task_.expireTime), dateRange.getStart(), dateRange.getEnd());
if (!StringUtils.equals(applicationId, StandardJaxrsAction.EMPTY_SYMBOL)) {
p = cb.and(p, cb.equal(root.get(Task_.application), applicationId));
}
if (!StringUtils.equals(processId, StandardJaxrsAction.EMPTY_SYMBOL)) {
p = cb.and(p, cb.equal(root.get(Task_.process), processId));
}
if (!StringUtils.equals(activityId, StandardJaxrsAction.EMPTY_SYMBOL)) {
p = cb.and(p, cb.equal(root.get(Task_.activity), activityId));
}
if (ListTools.isNotEmpty(units)) {
p = cb.and(p, root.get(Task_.unit).in(units));
}
if (!StringUtils.equals(person, StandardJaxrsAction.EMPTY_SYMBOL)) {
p = cb.and(p, cb.equal(root.get(Task_.person), person));
}
cq.select(cb.count(root)).where(p);
return em.createQuery(cq).getSingleResult();
}
public Long countByTask(String taskId) throws Exception {
if( StringUtils.isEmpty( taskId ) ) {
throw new Exception("task id can not be empty!");
}
EntityManager em = this.entityManagerContainer().get( Review.class );
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<Review> root = cq.from(Review.class);
Predicate p = cb.equal( root.get(Review_.taskId), taskId );
cq.select(cb.count(root)).where(p);
return em.createQuery(cq).getSingleResult();
}
/**
* <p>
* A method for retrieving individual entity instances.
* </p>
* @param id entity id
* @return
*/
@GET
@Path("/{id:[0-9][0-9]*}")
@Produces(MediaType.APPLICATION_JSON)
public T getSingleInstance(@PathParam("id") Long id) {
final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
final CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityClass);
Root<T> root = criteriaQuery.from(entityClass);
Predicate condition = criteriaBuilder.equal(root.get("id"), id);
criteriaQuery.select(criteriaBuilder.createQuery(entityClass).getSelection()).where(condition);
return entityManager.createQuery(criteriaQuery).getSingleResult();
}
private Collection<String> listProcessFromTaskCompleted(Business business, DateRange dateRange,
ApplicationStub applicationStub) throws Exception {
EntityManagerContainer emc = business.entityManagerContainer();
EntityManager em = emc.get(TaskCompleted.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<TaskCompleted> root = cq.from(TaskCompleted.class);
Predicate p = cb.between(root.get(TaskCompleted_.startTime), dateRange.getStart(), dateRange.getEnd());
p = cb.and(p, cb.equal(root.get(TaskCompleted_.application), applicationStub.getValue()));
cq.select(root.get(TaskCompleted_.process)).distinct(true).where(p);
List<String> list = em.createQuery(cq).getResultList();
return list;
}
@Override
public Page<Role> paging(Pageable pageable, String name) {
Page<Role> page = roleRepository.findAll((root, query, builder) -> {
Predicate predicate = builder.conjunction();
if (StringUtils.isNoneBlank(name)) {
predicate.getExpressions().add(
builder.like(root.get("name"), "%" + name + "%"));
}
query.orderBy(builder.desc(root.get("id")));
return predicate;
}, pageable);
return page;
}
public List<StatisticUnitForMonth> list(List<String> ids) throws Exception {
if( ids == null || ids.size() == 0 ){
return new ArrayList<StatisticUnitForMonth>();
}
EntityManager em = this.entityManagerContainer().get(StatisticUnitForMonth.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<StatisticUnitForMonth> cq = cb.createQuery(StatisticUnitForMonth.class);
Root<StatisticUnitForMonth> root = cq.from(StatisticUnitForMonth.class);
Predicate p = root.get(StatisticUnitForMonth_.id).in(ids);
return em.createQuery(cq.where(p)).getResultList();
}
@Override
public Predicate getPredicate(Root<Issue> root, CriteriaBuilder builder) {
Collection<Long> fixedIssueNumbers = build.getFixedIssueNumbers();
if (!fixedIssueNumbers.isEmpty()) {
return builder.and(
builder.equal(root.get(Issue.PROP_PROJECT), build.getProject()),
root.get(Issue.PROP_NUMBER).in(fixedIssueNumbers));
} else {
return builder.disjunction();
}
}