protected <T, T1, T2> PageRequestId<T> findWithSpecification(
      String requestId,
      EntityManager entityManager,
      Pageable pageable,
      Filter3<T, T1, T2> specification,
      Class<T> type,
      Class<T1> type1,
      Class<T2> type2) {
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    long total;
    {
      CriteriaQuery<Long> cqTotal = builder.createQuery(Long.class);
      Root<T1> root1 = cqTotal.from(type1);
      Root<T2> root2 = cqTotal.from(type2);
      Predicate predicate = specification.toPredicate(root1, root2, cqTotal, builder);
      if (predicate != null) cqTotal.where(predicate);
      cqTotal.select(builder.count(root1));
      total = entityManager.createQuery(cqTotal).getSingleResult();
    }

    CriteriaQuery<T> cq = builder.createQuery(type);
    Root<T1> root1 = cq.from(type1);
    Root<T2> root2 = cq.from(type2);
    Predicate predicate = specification.toPredicate(root1, root2, cq, builder);
    if (predicate != null) cq.where(predicate);
    cq.select(specification.getSelection(root1, root2, cq, builder));
    if (pageable.getSort() != null) {
      List<Order> orders = new LinkedList<Order>();
      for (Iterator<org.springframework.data.domain.Sort.Order> itr = pageable.getSort().iterator();
          itr.hasNext(); ) {
        org.springframework.data.domain.Sort.Order order = itr.next();
        String sx[] = order.getProperty().split("\\.");
        Path<Object> p;
        if (sx[0].equals("t1")) {
          p = root1.get(sx[1]);
        } else if (sx[0].equals("t2")) {
          p = root2.get(sx[1]);
        } else {
          throw new RuntimeException("Invalid order " + U.dump(order));
        }
        for (int i = 2, il = sx.length; i < il; i++) p = p.get(sx[i]);
        if (order.isAscending()) {
          orders.add(builder.asc(p));
        } else {
          orders.add(builder.desc(p));
        }
      }
      cq.orderBy(orders);
    }
    TypedQuery<T> qry = entityManager.createQuery(cq);
    qry.setFirstResult(pageable.getOffset()).setMaxResults(pageable.getPageSize());
    return new PageRequestIdImpl<T>(qry.getResultList(), pageable, total, requestId);
  }
  public String selectAll(TableDescription table, Pageable page) {
    Sort sort = page.getSort() != null ? page.getSort() : sortById(table);

    return format(
        "SELECT t2__.* FROM ( "
            + "SELECT row_number() OVER (ORDER BY %s) AS rn__, t1__.* FROM ( %s ) t1__ "
            + ") t2__ WHERE t2__.rn__ BETWEEN %s AND %s",
        orderByExpression(sort),
        selectAll(table),
        page.getOffset() + 1,
        page.getOffset() + page.getPageSize());
  }
  @Override
  @Transactional(readOnly = true)
  public Page<UserGroupCheck> findAllByPage(Pageable pageable, Long groupId, long total) {
    // TODO use setParameter
    String sql = USER_GROUP_CHECK_QUERY;
    String orderBy = "";
    String sort = "";
    Iterator<Order> i = pageable.getSort().iterator();
    while (i.hasNext()) {
      Order order = i.next();
      orderBy = order.getProperty();
      sort = order.getDirection().name();
    }
    sql = sql.replace(ORDER_BY, orderBy);
    sql = sql.replace(SORT, sort);
    Query query = entityManager.createNativeQuery(sql);
    query.setParameter(GROUP_ID, groupId);
    query.setParameter(LIMIT, pageable.getPageSize());
    query.setParameter(OFFSET, pageable.getOffset());

    List<UserGroupCheck> result = JpaUtil.getResultList(query, UserGroupCheck.class);
    Page<UserGroupCheck> page = new PageImpl<>(result, pageable, total);

    return page;
  }
  protected <T> PageRequestId<T> findWithSpecification(
      String requestId,
      EntityManager entityManager,
      Pageable pageable,
      Filter<T> filter,
      Class<T> type) {
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    long total;
    {
      CriteriaQuery<Long> cqTotal = builder.createQuery(Long.class);
      Root<T> root = cqTotal.from(type);
      if (filter != null) {
        Predicate predicate = filter.toPredicate(root, cqTotal, builder);
        if (predicate != null) cqTotal.where(predicate);
      }
      cqTotal.select(builder.count(root));
      total = entityManager.createQuery(cqTotal).getSingleResult();
    }

    CriteriaQuery<T> cq = builder.createQuery(type);
    Root<T> root = cq.from(type);
    if (filter != null) {
      Predicate predicate = filter.toPredicate(root, cq, builder);
      if (predicate != null) cq.where(predicate);
    }
    cq.select(root);
    if (pageable.getSort() != null) {
      List<Order> orders = new LinkedList<Order>();
      for (Iterator<org.springframework.data.domain.Sort.Order> itr = pageable.getSort().iterator();
          itr.hasNext(); ) {
        org.springframework.data.domain.Sort.Order order = itr.next();
        String sx[] = order.getProperty().split("\\.");
        Path<Object> p = root.get(sx[0]);
        for (int i = 1, il = sx.length; i < il; i++) p = p.get(sx[i]);
        if (order.isAscending()) {
          orders.add(builder.asc(p));
        } else {
          orders.add(builder.desc(p));
        }
      }
      cq.orderBy(orders);
    }
    TypedQuery<T> qry = entityManager.createQuery(cq);
    qry.setFirstResult(pageable.getOffset()).setMaxResults(pageable.getPageSize());
    return new PageRequestIdImpl<T>(qry.getResultList(), pageable, total, requestId);
  }
示例#5
0
  protected Map<String, Object> applyPagination(Map<String, Object> parameter, Pageable pageable) {

    if (pageable == null) return parameter;

    parameter.put(PAGE_OFFSET, pageable.getOffset());
    parameter.put(PAGE_SIZE, pageable.getPageSize());

    return applySorting(parameter, pageable.getSort());
  }
  private Page findBySpecificationAndPredicate(
      DynamicRepositoryInvoker invoker,
      final Specification specification,
      Predicate predicate,
      final Pageable pageable) {
    final List<?> items = findItemsBySpecification(invoker, specification, pageable.getSort());

    return selectPage(newArrayList(filter(items, predicate)), pageable);
  }
 private String getOrderDesc(final Pageable pageable) {
   String result = null;
   Sort sort = pageable.getSort();
   if (sort == null) {
     return result;
   }
   final Iterator<Order> iterator = sort.iterator();
   while (iterator.hasNext()) {
     final Order order = iterator.next();
     order.getProperty();
   }
   return result;
 }
  @Override
  public <C, X> Page<C> findAll(
      Specification<T> spec, Class<C> clazz, Selections<T, C, X> selection, Pageable pageable) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<C> query = builder.createQuery(clazz);
    Root<T> root = query.from(getDomainClass());
    Predicate predicate = spec.toPredicate(root, query, builder);

    if (predicate != null) {
      query.where(predicate);
    }
    query.select(builder.construct(clazz, selection.select(root, query, builder)));
    List<Expression<?>> groupBy = query.getGroupList();
    Predicate having = query.getGroupRestriction();
    if (pageable.getSort() != null) {
      query.orderBy(toOrders(pageable.getSort(), root, builder));
    }
    TypedQuery<C> typeQuery = em.createQuery(query);
    return pageable == null
        ? new PageImpl<>(typeQuery.getResultList())
        : readPage(typeQuery, pageable, spec, selection, groupBy, having);
  }
  @Override
  public <T> Page<T> getPage(Class<T> clazz, Criteria criteria, Pageable pageable) {
    Criteria countCriteria = HibernateTool.copyCriteria(criteria);
    long totalItemCount = count(countCriteria);

    List<T> items =
        find(
            clazz,
            criteria,
            pageable.getPageNumber() * pageable.getPageSize(),
            pageable.getPageSize(),
            CriteriaTool.toOrders(pageable.getSort()).toArray(new Order[0]));
    return new PageImpl<T>(items, pageable, totalItemCount);
  }
示例#10
0
  /**
   * 分页列表显示数据 为了避免由于权限配置不严格,导致未授权的Controller数据操作访问,父类提供protected基础实现,子类根据需要覆写public然后调用基类方法
   *
   * @return JSON集合数据
   */
  @MetaData(value = "查询")
  protected HttpHeaders findByPage() {
    Pageable pageable = PropertyFilter.buildPageableFromHttpRequest(getRequest());
    GroupPropertyFilter groupFilter =
        GroupPropertyFilter.buildGroupFilterFromHttpRequest(entityClass, getRequest());

    String foramt = this.getParameter(PARAM_NAME_FOR_EXPORT_FORMAT);
    if ("xls".equalsIgnoreCase(foramt)) {
      exportXlsForGrid(groupFilter, pageable.getSort());
    } else {
      setModel(this.getEntityService().findByPage(groupFilter, pageable));
    }
    return buildDefaultHttpHeaders();
  }
 @RequiresPermissions("plug:resume:edit")
 @RequestMapping("edit.do")
 public String edit(
     Integer id,
     Integer position,
     @PageableDefaults(sort = "id", sortDir = Direction.DESC) Pageable pageable,
     HttpServletRequest request,
     org.springframework.ui.Model modelMap) {
   Integer siteId = Context.getCurrentSiteId(request);
   Resume bean = service.get(id);
   Map<String, String[]> params = Servlets.getParameterValuesMap(request, Constants.SEARCH_PREFIX);
   RowSide<Resume> side = service.findSide(siteId, params, bean, position, pageable.getSort());
   modelMap.addAttribute("bean", bean);
   modelMap.addAttribute("side", side);
   modelMap.addAttribute("position", position);
   modelMap.addAttribute(OPRT, EDIT);
   return "plug/resume/resume_form";
 }
  @RequestMapping(value = "list", method = RequestMethod.GET)
  public String listFile(
      @RequestParam(value = "path", required = false, defaultValue = "") String path,
      Pageable pageable,
      Model model)
      throws UnsupportedEncodingException {

    path = URLDecoder.decode(path, Constants.ENCODING);

    Sort sort = pageable.getSort();

    String rootPath = sc.getRealPath(ROOT_DIR);

    File currentDirectory = new File(rootPath + File.separator + path);

    Map<Object, Object> current = extractFileInfoMap(currentDirectory, rootPath);
    current.put("name", currentDirectory.getName());

    Map<Object, Object> parent = null;
    if (hasParent(currentDirectory, rootPath)) {
      File parentDirectory = currentDirectory.getParentFile();
      parent = extractFileInfoMap(parentDirectory, rootPath);
      parent.put("name", parentDirectory.getName());
    }

    List<Map<Object, Object>> files = Lists.newArrayList();
    for (File subFile : currentDirectory.listFiles()) {
      files.add(extractFileInfoMap(subFile, rootPath));
    }

    sort(files, sort);

    model.addAttribute("current", current);
    model.addAttribute("parent", parent);
    model.addAttribute("files", files);

    return viewName("list");
  }
  @Override
  public Page<Comment> search(CommentSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb =
        fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Comment.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
      Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
      String[] fields = new String[] {"authorName", "content"};
      MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
      parser.setDefaultOperator(QueryParser.Operator.AND);
      Query query = null;
      try {
        query = parser.parse(request.getKeyword());
      } catch (ParseException e1) {
        try {
          query = parser.parse(QueryParser.escape(request.getKeyword()));
        } catch (ParseException e2) {
          throw new RuntimeException(e2);
        }
      }
      junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
      junction.must(
          qb.keyword().onField("post.language").matching(request.getLanguage()).createQuery());
    }

    if (request.getPostId() != null) {
      junction.must(qb.keyword().onField("post.id").matching(request.getPostId()).createQuery());
    }

    if (request.getApproved() != null) {
      junction.must(qb.keyword().onField("approved").matching(request.getApproved()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria =
        session
            .createCriteria(Comment.class)
            .setFetchMode("post", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = null;
    if (pageable.getSort() != null) {
      if (pageable.getSort().getOrderFor("date") != null) {
        Order order = pageable.getSort().getOrderFor("date");
        sort =
            new Sort(
                new SortField(
                    "date", SortField.Type.STRING, order.getDirection().equals(Direction.DESC)),
                new SortField(
                    "id", SortField.Type.LONG, order.getDirection().equals(Direction.DESC)));
      }
    }

    if (sort == null) {
      sort =
          new Sort(
              new SortField("date", SortField.Type.STRING),
              new SortField("id", SortField.Type.LONG));
    }

    FullTextQuery persistenceQuery =
        fullTextEntityManager
            .createFullTextQuery(searchQuery, Comment.class)
            .setCriteriaQuery(criteria)
            .setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Comment> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
  }
  // 動的条件に一致するEntityを全件検索 するサンプルを元に実装
  //
  // http://terasolunaorg.github.io/guideline/5.0.1.RELEASE/ja/ArchitectureInDetail/DataAccessJpa.html#id21
  @Override
  public Page<Result> findByCriteria(ResultCriteria criteria, Pageable pageable) {

    // collect dynamic conditions.
    final List<String> andConditions = new ArrayList<String>();
    final List<String> joinConditions = new ArrayList<String>();
    final Map<String, Object> bindParameters = new HashMap<String, Object>();

    if (criteria.getStaffId() != null) {
      joinConditions.add("r.resultDetails rd");
      andConditions.add("rd.staff.id = :staffId");
      bindParameters.put("staffId", criteria.getStaffId());
    }

    // TODO result の検索条件はここに書く
    //        if (criteria.getStaffId() != null) {
    //            andConditions.add("d.staffId = :staffId");
    //            bindParameters.put("staffId", criteria.getStaffId());
    //        }

    //        if (!CollectionUtils.isEmpty(criteria.getStatusCodes())) {
    //            andConditions.add("o.status.code IN :statusCodes");
    //            bindParameters.put("statusCodes", criteria.getStatusCodes());
    //        }
    //        if (andConditions.isEmpty()) {
    //            List<Result> Results = Collections.emptyList();
    //            return new PageImpl<Result>(Results, pageable, 0); // (3)
    //        }

    // create dynamic query.
    final StringBuilder queryString = new StringBuilder();
    final StringBuilder countQueryString = new StringBuilder(); // (4)
    final StringBuilder conditionsString = new StringBuilder(); // (4)

    queryString.append("select r FROM Result r ");
    countQueryString.append("SELECT COUNT(r) FROM Result r ");

    // (11)
    // add join conditions.
    for (String joinCondition : joinConditions) {
      conditionsString.append(" JOIN ").append(joinCondition);
    }
    // add conditions.
    Iterator<String> andConditionsIt = andConditions.iterator();
    if (andConditionsIt.hasNext()) {
      conditionsString.append(" WHERE ").append(andConditionsIt.next());
    }
    while (andConditionsIt.hasNext()) {
      conditionsString.append(" AND ").append(andConditionsIt.next());
    }
    queryString.append(conditionsString); // (6)
    countQueryString.append(conditionsString); // (6)

    // add Result by condition.
    // (7)
    String query = QueryUtils.applySorting(queryString.toString(), pageable.getSort(), "r");

    // create typed query.
    final TypedQuery<Long> countQuery =
        entityManager.createQuery(countQueryString.toString(), Long.class); // (8)

    final TypedQuery<Result> findQuery = entityManager.createQuery(query, Result.class);

    // bind parameters.
    for (Map.Entry<String, Object> bindParameter : bindParameters.entrySet()) {
      countQuery.setParameter(bindParameter.getKey(), bindParameter.getValue()); // (8)
      findQuery.setParameter(bindParameter.getKey(), bindParameter.getValue());
    }

    long total = countQuery.getSingleResult().longValue(); // (9)
    List<Result> Results = null;
    if (total != 0) { // (10)
      findQuery.setFirstResult(pageable.getOffset());
      findQuery.setMaxResults(pageable.getPageSize());
      // execute query.
      Results = findQuery.getResultList();
    } else { // (11)
      Results = Collections.emptyList();
    }

    return new PageImpl<Result>(Results, pageable, total); // (12)
  }
示例#15
0
  /**
   * Creates a new {@link TypedQuery} from the given {@link Specification}.
   *
   * @param spec can be {@literal null}.
   * @param pageable can be {@literal null}.
   * @return
   */
  private TypedQuery<M> getQuery(Specification<M> spec, Pageable pageable) {

    Sort sort = pageable == null ? null : pageable.getSort();
    return getQuery(spec, sort);
  }
示例#16
0
  @Override
  public Page<DBObject> findPage(
      String collectionName,
      GroupPropertyFilter groupPropertyFilter,
      Pageable pageable,
      DBObject fields) {

    DB db = mongoClient.getDB(mongoDB);
    DBCollection dbColl = db.getCollection(collectionName);

    BasicDBObject query = new BasicDBObject();
    List<BasicDBObject> andQueries = Lists.newArrayList();
    List<PropertyFilter> filters = groupPropertyFilter.convertToPropertyFilters();
    if (CollectionUtils.isNotEmpty(filters)) {
      // Query and Projection Operators: https://docs.mongodb.org/manual/reference/operator/query/
      for (PropertyFilter filter : filters) {
        Object matchValue = filter.getMatchValue();
        if (matchValue == null) {
          continue;
        }

        String[] propertyNames = filter.getConvertedPropertyNames();
        List<BasicDBObject> orQueries = Lists.newArrayList();
        for (String propertyName : propertyNames) {
          BasicDBObject queryItem = new BasicDBObject();
          orQueries.add(queryItem);
          switch (filter.getMatchType()) {
            case EQ:
              queryItem.put(propertyName, matchValue);
              break;
            case NE:
              queryItem.put(propertyName, new BasicDBObject("$ne", matchValue));
              break;
            case BK:
              List<BasicDBObject> orList = Lists.newArrayList();
              orList.add(new BasicDBObject(propertyName, 0));
              orList.add(new BasicDBObject(propertyName, ""));
              queryItem.put("$or", orList);
              break;
            case NB:
              queryItem.put(propertyName, new BasicDBObject("$regex", ".{1,}"));
              break;
            case NU:
              queryItem.put(propertyName, 0);
              break;
            case NN:
              queryItem.put(propertyName, 1);
              break;
            case CN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", ".*" + matchValue + ".*").append("$options", "i"));
              break;
            case NC:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", ".*" + matchValue + ".*")
                          .append("$options", "i")));
              break;
            case BW:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", "^" + matchValue).append("$options", "i"));
              break;
            case BN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", "^" + matchValue).append("$options", "i")));
              break;
            case EW:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", matchValue + "$").append("$options", "i"));
              break;
            case EN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", matchValue + "$").append("$options", "i")));
              break;
            case BT:
              Assert.isTrue(matchValue.getClass().isArray(), "Match value must be array");
              Object[] matchValues = (Object[]) matchValue;
              Assert.isTrue(matchValues.length == 2, "Match value must have two value");
              List<BasicDBObject> andList = Lists.newArrayList();
              andList.add(new BasicDBObject(propertyName, new BasicDBObject("$gte", matchValue)));
              andList.add(new BasicDBObject(propertyName, new BasicDBObject("$gle", matchValue)));
              queryItem.put("$and", andList);
              break;
            case GT:
              queryItem.put(propertyName, new BasicDBObject("$gt", matchValue));
              break;
            case GE:
              queryItem.put(propertyName, new BasicDBObject("$ge", matchValue));
              break;
            case LT:
              queryItem.put(propertyName, new BasicDBObject("$lt", matchValue));
              break;
            case LE:
              queryItem.put(propertyName, new BasicDBObject("$le", matchValue));
              break;
            case IN:
              queryItem.put(propertyName, new BasicDBObject("$in", matchValue));
              break;
            default:
              throw new UnsupportedOperationException(
                  "Undefined PropertyFilter MatchType: " + filter.getMatchType());
          }
        }
        if (orQueries.size() > 1) {
          andQueries.add(new BasicDBObject("$or", orQueries));
        } else {
          andQueries.add(orQueries.get(0));
        }
      }
      query = new BasicDBObject("$and", andQueries);
    }

    BasicDBObject sort = new BasicDBObject();
    Sort pageSort = pageable.getSort();
    if (pageSort != null) {
      Iterator<Order> orders = pageSort.iterator();
      while (orders.hasNext()) {
        Order order = orders.next();
        String prop = order.getProperty();
        if (order.isAscending()) {
          sort.put(prop, 1);
        } else {
          sort.put(prop, -1);
        }
      }
    }

    DBCursor cur =
        dbColl
            .find(query, fields)
            .sort(sort)
            .skip(pageable.getOffset())
            .limit(pageable.getPageSize());
    List<DBObject> rows = Lists.newArrayList();
    while (cur.hasNext()) {
      DBObject obj = cur.next();
      rows.add(obj);
    }
    Page<DBObject> page = new PageImpl<DBObject>(rows, pageable, dbColl.count(query));
    return page;
  }