private Criteria getHBCriteria(Session session, SearchCriteria criteria) {
   Criteria newCriteria = session.createCriteria(WarrantyInformationType.class);
   if (criteria.getInternalId() != null) {
     newCriteria.add(Restrictions.eq("internalId", criteria.getInternalId()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("internalId")))
     newCriteria.addOrder(Order.asc("internalId"));
   else if ((criteria.descending != null) && (criteria.descending.contains("internalId")))
     newCriteria.addOrder(Order.desc("internalId"));
   if (criteria.getVersion() != null) {
     newCriteria.add(Restrictions.eq("version", criteria.getVersion()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("version")))
     newCriteria.addOrder(Order.asc("version"));
   else if ((criteria.descending != null) && (criteria.descending.contains("version")))
     newCriteria.addOrder(Order.desc("version"));
   if (criteria.getValue() != null) {
     newCriteria.add(Restrictions.eq("value", criteria.getValue()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("value")))
     newCriteria.addOrder(Order.asc("value"));
   else if ((criteria.descending != null) && (criteria.descending.contains("value")))
     newCriteria.addOrder(Order.desc("value"));
   if (criteria.getLanguageID() != null) {
     newCriteria.add(Restrictions.eq("languageID", criteria.getLanguageID()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("languageID")))
     newCriteria.addOrder(Order.asc("languageID"));
   else if ((criteria.descending != null) && (criteria.descending.contains("languageID")))
     newCriteria.addOrder(Order.desc("languageID"));
   return newCriteria;
 }
  public Pager list(String username, int pageSize, int pageNo) {
    Session session = null;
    Pager pager = null;
    try {
      session = HibernateSessionFactory.currentSession();

      Criteria criteria = session.createCriteria(Schedule.class);
      criteria.add(Restrictions.eq("username", username));

      int rowCount =
          ((Long) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
      criteria.setProjection(null);

      int startIndex = pageSize * (pageNo - 1);

      criteria.addOrder(Order.desc("year"));
      criteria.addOrder(Order.desc("month"));
      criteria.addOrder(Order.desc("day"));
      criteria.setFirstResult(startIndex);
      criteria.setMaxResults(pageSize);
      List<?> result = criteria.list();
      pager = new Pager(pageSize, pageNo, rowCount, result);
    } catch (HibernateException e) {
      pager = new Pager(pageSize, pageNo, 0, new ArrayList<Object>());
      throw e;
    } finally {
      HibernateSessionFactory.closeSession();
    }
    return pager;
  }
Exemple #3
0
  public Map<String, Object> lista(Map<String, Object> params) {
    log.debug("Buscando lista de facturas con params {}", params);
    if (params == null) {
      params = new HashMap<>();
    }

    if (!params.containsKey("max")) {
      params.put("max", 10);
    } else {
      params.put("max", Math.min((Integer) params.get("max"), 100));
    }

    if (params.containsKey("pagina")) {
      Long pagina = (Long) params.get("pagina");
      Long offset = (pagina - 1) * (Integer) params.get("max");
      params.put("offset", offset.intValue());
    }

    if (!params.containsKey("offset")) {
      params.put("offset", 0);
    }
    Criteria criteria = currentSession().createCriteria(FacturaAlmacen.class);
    Criteria countCriteria = currentSession().createCriteria(FacturaAlmacen.class);

    if (params.containsKey("almacen")) {
      criteria.createCriteria("almacen").add(Restrictions.idEq(params.get("almacen")));
      countCriteria.createCriteria("almacen").add(Restrictions.idEq(params.get("almacen")));
    }

    if (params.containsKey("filtro")) {
      String filtro = (String) params.get("filtro");
      Disjunction propiedades = Restrictions.disjunction();
      propiedades.add(Restrictions.ilike("folio", filtro, MatchMode.ANYWHERE));
      criteria.add(propiedades);
      countCriteria.add(propiedades);
    }

    if (params.containsKey("order")) {
      String campo = (String) params.get("order");
      if (params.get("sort").equals("desc")) {
        criteria.addOrder(Order.desc(campo));
      } else {
        criteria.addOrder(Order.asc(campo));
      }
    } else {
      criteria.createCriteria("estatus").addOrder(Order.asc("prioridad"));
    }
    criteria.addOrder(Order.desc("fechaModificacion"));

    if (!params.containsKey("reporte")) {
      criteria.setFirstResult((Integer) params.get("offset"));
      criteria.setMaxResults((Integer) params.get("max"));
    }
    params.put("facturas", criteria.list());

    countCriteria.setProjection(Projections.rowCount());
    params.put("cantidad", (Long) countCriteria.list().get(0));

    return params;
  }
  public List getAutoMobileList(
      int startLimit, int endLimit, AutomobileExpense autoMobile, String search_1st_order_by) {
    Session session = sessionFactory.openSession();
    List list = new ArrayList();

    try {
      Criteria criteria = createAutoMobileCriteria(session, autoMobile, "");
      if (StringUtils.isNotBlank(search_1st_order_by)) {
        criteria.addOrder(Order.desc(search_1st_order_by));
      }

      if (StringUtils.isBlank(search_1st_order_by)) {
        criteria.addOrder(Order.desc("automobileExpenseId"));
      }
      criteria.setFirstResult(startLimit);
      criteria.setMaxResults(endLimit);
      list = criteria.list();

    } catch (HibernateException e) {
      e.printStackTrace();
    } finally {
      session.close();
    }
    return list;
  }
 private Criteria getHBCriteria(Session session, SearchCriteria criteria) {
   Criteria newCriteria = session.createCriteria(LanguageCodeContentType.class);
   if (criteria.getInternalId() != null) {
     newCriteria.add(Restrictions.eq("internalId", criteria.getInternalId()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("internalId")))
     newCriteria.addOrder(Order.asc("internalId"));
   else if ((criteria.descending != null) && (criteria.descending.contains("internalId")))
     newCriteria.addOrder(Order.desc("internalId"));
   if (criteria.getVersion() != null) {
     newCriteria.add(Restrictions.eq("version", criteria.getVersion()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("version")))
     newCriteria.addOrder(Order.asc("version"));
   else if ((criteria.descending != null) && (criteria.descending.contains("version")))
     newCriteria.addOrder(Order.desc("version"));
   if (criteria.getLiteral() != null) {
     newCriteria.add(Restrictions.eq("literal", criteria.getLiteral()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("literal")))
     newCriteria.addOrder(Order.asc("literal"));
   else if ((criteria.descending != null) && (criteria.descending.contains("literal")))
     newCriteria.addOrder(Order.desc("literal"));
   if (criteria.getName() != null) {
     newCriteria.add(Restrictions.eq("name", criteria.getName()));
   }
   if ((criteria.ascending != null) && (criteria.ascending.contains("name")))
     newCriteria.addOrder(Order.asc("name"));
   else if ((criteria.descending != null) && (criteria.descending.contains("name")))
     newCriteria.addOrder(Order.desc("name"));
   return newCriteria;
 }
  @Override
  public DetachedCriteria buildCriteria() {

    DetachedCriteria crit = DetachedCriteria.forClass(AccountCreditNote.class);

    if (isNotEmpty(filterModel.getSerial())) {
      crit.add(Restrictions.ilike("this.serial", filterModel.getSerial(), MatchMode.START));
    }

    if (isNotEmpty(filterModel.getReference())) {
      crit.add(Restrictions.ilike("this.reference", filterModel.getReference(), MatchMode.START));
    }

    if (isNotEmpty(filterModel.getCode())) {
      crit.add(Restrictions.ilike("this.code", filterModel.getCode(), MatchMode.START));
    }

    if (filterModel.getBeginDate() != null) {
      crit.add(Restrictions.ge("this.date", filterModel.getBeginDate()));
    }

    if (filterModel.getEndDate() != null) {
      crit.add(Restrictions.le("this.date", filterModel.getEndDate()));
    }

    if (filterModel.getAccount() != null) {
      crit.add(Restrictions.le("this.account", filterModel.getAccount()));
    }

    crit.addOrder(Order.desc("serial"));
    crit.addOrder(Order.desc("date"));

    return crit;
  }
 /** Add order directly to criteria. */
 private static void addOrder(Criteria c, String sort, String order, boolean ignoreCase) {
   if (ORDER_DESC.equals(order)) {
     c.addOrder(ignoreCase ? Order.desc(sort).ignoreCase() : Order.desc(sort));
   } else {
     c.addOrder(ignoreCase ? Order.asc(sort).ignoreCase() : Order.asc(sort));
   }
 }
  /*
   * (non-Javadoc)
   *
   * @see com.changpeng.common.action.AbstractAction#go()
   */
  @Override
  protected String go() throws Exception {
    this.lawyer = this.getLoginUser();
    // TODO Auto-generated method stub
    BasicService basic = (BasicService) getBean("basicService");
    DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Articles.class);
    detachedCriteria.add(Restrictions.eq("type", type));

    if (type == 1) { // 重要通知才搞这个。那个什么帮助就都显示了
      // Criterion province = Restrictions.eq("provinceid",
      // this.getLoginUser().getProvinceid());

      int directunion = this.getLoginUser().getDirectunion();
      SysGroup group = (SysGroup) basic.get(SysGroup.class, directunion);

      detachedCriteria.add(Restrictions.eq("status", 0));
      // 显示我的事务所的通知,显示我的律协的通知,显示我的省律协的通知,显示系统的通只
      // detachedCriteria.add(Restrictions.in("thegroup", new Integer[] {
      // this.getLoginUser().getProvinceunion(),
      // this.getLoginUser().getDirectunion(),
      // this.getLoginUser().getTheoffice(), 0 }));

      Criterion province =
          Restrictions.in(
              "thegroup",
              new Integer[] {
                this.getLoginUser().getProvinceunion(),
                this.getLoginUser().getDirectunion(),
                this.getLoginUser().getTheoffice(),
                0
              });

      Criterion c = Restrictions.eq("provinceid", 0);
      detachedCriteria.add(Restrictions.or(c, province));

      detachedCriteria.addOrder(Order.desc("createtime"));
    }

    // 按现实顺序来
    detachedCriteria.addOrder(Order.desc("listorder"));
    detachedCriteria.addOrder(Order.desc("createtime"));

    this.page = basic.findPageByCriteria(detachedCriteria, pageSize, pageNo);

    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DATE, -1); // 得到前一天
    cal.add(Calendar.MONTH, -1); // 得到前一个月
    long date = cal.getTimeInMillis();
    System.out.println(date);
    // long lastdaya=df.format(new java.util.Date(date));
    // System.out.println(lastdaya);
    lastday = new Timestamp(date);
    System.out.println(lastday);

    // TODO Auto-generated method stub
    return SUCCESS;
  }
Exemple #9
0
  public List<Roles> takeRoles() {
    List<Roles> lst = null;
    String sortType = null;
    try {
      Session session = getSession();
      if (sort != null) {
        if (sort.indexOf('-') != -1) {
          sortType = "asc";
          sort = sort.substring(1);
        } else {
          sortType = "desc";
        }
      }

      Criteria cri = session.createCriteria(Roles.class);

      if (role != null) {

        if (role.getValue() != null && !"".equals(role.getValue())) {
          cri.add(Restrictions.eq("value", role.getValue()));
        }
        if (role.getName() != null && !"".equals(role.getName())) {
          cri.add(Restrictions.eq("name", role.getName()));
        }

        if (isactive != null) {
          cri.add(Restrictions.eq("isactive", "Y"));
        } else {
          cri.add(Restrictions.eq("isactive", "N"));
        }
      }

      if (sort != null) {
        if (sortType != null && sortType.equals("asc")) {
          cri.addOrder(Order.asc(sort).ignoreCase());
        } else if (sortType != null && sortType.equals("desc")) {
          cri.addOrder(Order.desc(sort).ignoreCase());
        }
      } else {
        cri.addOrder(Order.desc("lastUpdate").ignoreCase());
      }
      if (startval >= 0) {
        cri.setFirstResult(startval);
      }
      if (count >= 0) {
        cri.setMaxResults(count);
      }
      lst = cri.list();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    return lst;
  }
  @Override
  protected List<Order> getOrder(SortParam sort) {
    if (sort.getProperty() == null || !sort.getProperty().equals("priority")) {
      return super.getOrder(sort);
    }

    if (sort.isAscending()) {
      return Arrays.asList(Order.asc("priority"), Order.asc("type"));
    } else {
      return Arrays.asList(Order.desc("priority"), Order.desc("type"));
    }
  }
Exemple #11
0
  public Pager findPager(Pager pager, Criteria criteria) {
    Assert.notNull(pager, "pager is required");
    Assert.notNull(criteria, "criteria is required");

    Integer pageNumber = pager.getPageNumber();
    Integer pageSize = pager.getPageSize();
    String searchBy = pager.getSearchBy();
    String keyword = pager.getKeyword();
    String orderBy = pager.getOrderBy();
    Pager.Order order = pager.getOrder();

    if (StringUtils.isNotEmpty(searchBy) && StringUtils.isNotEmpty(keyword)) {
      if (searchBy.contains(".")) {
        String alias = StringUtils.substringBefore(searchBy, ".");
        criteria.createAlias(alias, alias);
      }
      criteria.add(Restrictions.like(searchBy, "%" + keyword + "%"));
    }

    pager.setTotalCount(criteriaResultTotalCount(criteria));

    if (StringUtils.isNotEmpty(orderBy) && order != null) {
      if (order == Pager.Order.asc) {
        criteria.addOrder(Order.asc(orderBy));
      } else {
        criteria.addOrder(Order.desc(orderBy));
      }
    }

    ClassMetadata classMetadata = sessionFactory.getClassMetadata(entityClass);
    if (!StringUtils.equals(orderBy, ORDER_LIST_PROPERTY_NAME)
        && ArrayUtils.contains(classMetadata.getPropertyNames(), ORDER_LIST_PROPERTY_NAME)) {
      criteria.addOrder(Order.asc(ORDER_LIST_PROPERTY_NAME));
      criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME));
      if (StringUtils.isEmpty(orderBy) || order == null) {
        pager.setOrderBy(ORDER_LIST_PROPERTY_NAME);
        pager.setOrder(Pager.Order.asc);
      }
    } else if (!StringUtils.equals(orderBy, CREATE_DATE_PROPERTY_NAME)
        && ArrayUtils.contains(classMetadata.getPropertyNames(), CREATE_DATE_PROPERTY_NAME)) {
      criteria.addOrder(Order.desc(CREATE_DATE_PROPERTY_NAME));
      if (StringUtils.isEmpty(orderBy) || order == null) {
        pager.setOrderBy(CREATE_DATE_PROPERTY_NAME);
        pager.setOrder(Pager.Order.desc);
      }
    }

    criteria.setFirstResult((pageNumber - 1) * pageSize);
    criteria.setMaxResults(pageSize);

    pager.setResult(criteria.list());
    return pager;
  }
 /** 功能:读取分页数据 */
 public PageResult readAllPages(int pageSize, int currentPage, SearchFilter filter) {
   try {
     DetachedCriteria detachedCriteria = DetachedCriteria.forClass(PhotosCover.class);
     detachedCriteria.add(Restrictions.eq("status", EntityStatus.NORMAL));
     detachedCriteria.addOrder(Order.desc("defaults"));
     detachedCriteria.addOrder(Order.desc("createDT"));
     DetachedCriteriaUtil.addSearchFilter(detachedCriteria, filter);
     return baseDAO.findByPages(detachedCriteria, pageSize, currentPage);
   } catch (Exception ex) {
     ex.printStackTrace();
     throw new BaseException("查询所有分页异常");
   }
 }
  /**
   * The 'findConfigurations' function will return a list of configurations based on a search term
   * passed in. The function will search configurations on the following fields configName, orgName
   * and messageTypeName @Table configurations
   *
   * @param searchTerm Will hold the term used search configurations on
   * @return This function will return a list of configuration objects
   */
  @Override
  @SuppressWarnings("unchecked")
  public List<configuration> findConfigurations(String searchTerm) {

    if (searchTerm != "") {
      // get a list of organization id's that match the term passed in
      List<Integer> orgIdList = new ArrayList<Integer>();
      Criteria findOrgs = sessionFactory.getCurrentSession().createCriteria(Organization.class);
      findOrgs.add(Restrictions.like("orgName", "%" + searchTerm + "%"));
      List<Organization> orgs = findOrgs.list();

      for (Organization org : orgs) {
        orgIdList.add(org.getId());
      }

      // get a list of message type id's that match the term passed in
      List<Integer> msgTypeIdList = new ArrayList<Integer>();
      Criteria findMsgTypes = sessionFactory.getCurrentSession().createCriteria(messageType.class);
      findMsgTypes.add(Restrictions.like("name", "%" + searchTerm + "%"));
      List<messageType> msgTypes = findMsgTypes.list();

      for (messageType msgType : msgTypes) {
        msgTypeIdList.add(msgType.getId());
      }

      Criteria criteria = sessionFactory.getCurrentSession().createCriteria(configuration.class);

      if (orgIdList.size() == 0) {
        orgIdList.add(0);
      }
      if (msgTypeIdList.size() == 0) {
        msgTypeIdList.add(0);
      }

      criteria
          .add(
              Restrictions.or(
                  Restrictions.in("orgId", orgIdList),
                  Restrictions.in("messageTypeId", msgTypeIdList)))
          .addOrder(Order.desc("dateCreated"));

      return criteria.list();
    } else {
      Criteria criteria = sessionFactory.getCurrentSession().createCriteria(configuration.class);
      criteria.addOrder(Order.desc("dateCreated"));
      return criteria.list();
    }
  }
 @Override
 public <T extends GettableById> List<T> get(
     Class<T> bookEntityClass,
     int from,
     int to,
     Map<String, List<Criterion>> restrictions,
     OrderByFilter filter) {
   validateTransaction();
   Criteria criteria = getSession().createCriteria(bookEntityClass);
   criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
   criteria.setFirstResult(from);
   if (to != 0) criteria.setMaxResults(to);
   for (String key : restrictions.keySet()) {
     if (key.equals(RestrictionsFields.MAIN_RESTRICTIONS)) {
       for (Criterion restriction : restrictions.get(RestrictionsFields.MAIN_RESTRICTIONS))
         criteria.add(restriction);
     } else if (restrictions.get(key).size() > 0) {
       Criteria c = criteria.createCriteria(key);
       for (Criterion restriction : restrictions.get(key)) c.add(restriction);
     }
   }
   if (filter != null) {
     if (filter.getDirection().equals(OrderByFilter.ASC))
       criteria.addOrder(Order.asc(filter.field));
     else criteria.addOrder(Order.desc(filter.field));
   }
   return criteria.list();
 }
  private void buildOrderClause(
      StringBuilder queryStringBuilder,
      QueryModel queryModel,
      Criteria criteria,
      CriteriaQueryTranslator criteriaQueryTranslator) {
    boolean firstOrderItem = true;

    if (queryModel.getSorts() != null) {
      for (Sort sort : queryModel.getSorts()) {
        if (firstOrderItem) {
          queryStringBuilder.append(" order by ");
        } else {
          queryStringBuilder.append(',');
        }

        Order order =
            sort.getSortDirection() == SortDirection.Ascending
                ? Order.asc(sort.getField())
                : Order.desc(sort.getField());

        queryStringBuilder.append(order.toSqlString(criteria, criteriaQueryTranslator));

        firstOrderItem = false;
      }
    }
  }
  @Override
  public Iterable<T> findUsingQueryModel(QueryModel queryModel) {
    if (accessControlContextProvider == null
        || roleAllowsAccess(queryModel.getAccessControlContext().getRole())) {
      Criteria criteria = buildCriteria(queryModel);

      if (queryModel.getSorts() != null) {
        for (Sort sort : queryModel.getSorts()) {
          criteria.addOrder(
              sort.getSortDirection() == SortDirection.Ascending
                  ? Order.asc(sort.getField())
                  : Order.desc(sort.getField()));
        }
      }

      if (queryModel.getMaxResults() > 0) {
        criteria.setMaxResults(queryModel.getMaxResults());
      }

      if (queryModel.getFirstResult() > 0) {
        criteria.setFirstResult(queryModel.getFirstResult());
      }

      //noinspection unchecked
      return criteria.list();
    } else {
      //noinspection unchecked
      return createEntryBasedQuery(queryModel).list();
    }
  }
Exemple #17
0
  @SuppressWarnings("unchecked")
  public List<Token> findTokens(
      Token search, int first, int pageSize, String sortField, SortOrder sortOrder)
      throws DAOException {
    List<Token> results = null;
    Session session = null;
    try {
      session = getSession();
      Criteria criteria = criteria(session, search);

      criteria.setFirstResult(first);
      criteria.setMaxResults(pageSize);

      if (sortField == null) {
        sortField = "tokenId";
      }

      Order ord =
          (sortOrder == null
                  || sortOrder.equals(SortOrder.UNSORTED)
                  || sortOrder.equals(SortOrder.ASCENDING))
              ? Order.asc(sortField)
              : Order.desc(sortField);
      criteria.addOrder(ord);

      results = criteria.list();
    } catch (Exception e) {
      throw new DAOException(e);
    } finally {
      if (session != null) {
        session.close();
      }
    }
    return results;
  }
 /**
  * Adiciona ordenação a uma criteria.
  *
  * @param propriedade Propriedade utilizada na ordenação.
  * @param ascendente true caso ascendente, false caso descendente.
  * @param criteria Criteria na qual a ordenação será adicionada.
  */
 protected void adicionarOrdenacao(String propriedade, boolean ascendente, Criteria criteria) {
   if (ascendente) {
     criteria.addOrder(Order.asc(propriedade).ignoreCase());
   } else {
     criteria.addOrder(Order.desc(propriedade).ignoreCase());
   }
 }
Exemple #19
0
  private Criteria createCriteriaExactly(
      final Enterprise enterprise,
      final String filter,
      final String orderBy,
      final boolean desc,
      final boolean discardNullEnterprises) {
    Criteria criteria = createCriteria();

    if (enterprise != null) {
      if (discardNullEnterprises) {
        criteria.add(sameEnterprise(enterprise));
      } else {
        criteria.add(sameEnterpriseOrNull(enterprise));
      }

    } else {
      criteria.add(genericRole());
    }

    if (!StringUtils.isEmpty(filter)) {
      criteria.add(filterExactlyBy(filter));
    }

    if (!StringUtils.isEmpty(orderBy)) {
      Order order = Order.asc(orderBy);
      if (desc) {
        order = Order.desc(orderBy);
      }
      criteria.addOrder(order);
      criteria.addOrder(Order.asc(Role.NAME_PROPERTY));
    }

    return criteria;
  }
 @SuppressWarnings("unchecked")
 @Override
 public List<Sales> getPendingSalesBetween(Date startDate, Date endDate) throws Exception {
   Session session = HibernateUtil.startSession();
   Criteria criteria = session.createCriteria(Sales.class);
   criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
   List<Sales> sales = new ArrayList<Sales>();
   try {
     Date lowerBound = DateTool.getTomorrowDate(DateTool.getDateWithoutTime(startDate));
     Date upperBound = DateTool.getDateWithoutTime(endDate);
     sales =
         criteria
             .add(Restrictions.ge("date", lowerBound))
             .add(Restrictions.lt("date", upperBound))
             .add(Restrictions.eq("valid", true))
             .add(Restrictions.isNull("inventorySheetData"))
             .addOrder(Order.desc("date"))
             .list();
   } catch (HibernateException ex) {
     ex.printStackTrace();
   } finally {
     session.close();
   }
   return sales;
 }
  /**
   * bar info query
   *
   * @param global
   * @return
   * @throws JSONException
   */
  public String queryBarInfo(String global) throws JSONException {
    DetachedCriteria dc = DetachedCriteria.forClass(TNavigation.class);
    dc.add(Restrictions.eq("status", 1));
    dc.addOrder(Order.asc("ordinal")).addOrder(Order.desc("updatetime"));

    List<TNavigation> list = super.findByDetachedCriteria(dc);
    List<TBar> rootList = new ArrayList<TBar>();
    for (TNavigation navtion : list) {
      if ("0".equals(navtion.getObjid())) {
        TBar bar = new TBar();
        bar.setName(ActionUtils.getLanStr(navtion.getName(), navtion.getEname(), global));
        bar.setId(navtion.getOid());
        bar.setObjid(navtion.getObjid());

        rootList.add(bar);
      }
    }
    TNavigation record = new TNavigation();
    record.getBarList().add(rootList);
    record = this.convertBar(record, rootList, list, global);

    //		JSONArray itms = (JSONArray) JSONSerializer.toJSON(record.getBarList());
    //		return itms.toString();
    return JSONUtil.serialize(record.getBarList(), null, null, false, false, true);
  }
Exemple #22
0
 /** 创建Criteria对象,带排序字段与升降序字段. */
 public Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
   Assert.hasText(orderBy);
   Criteria criteria = createCriteria(criterions);
   if (isAsc) criteria.addOrder(Order.asc(orderBy));
   else criteria.addOrder(Order.desc(orderBy));
   return criteria;
 }
 @SuppressWarnings("unchecked")
 @Override
 public List<Firma> getAll() {
   Criteria criteria = getSession().createCriteria(Firma.class);
   criteria.addOrder(Order.desc("id"));
   return (List<Firma>) criteria.list();
 }
  public Page<Log> find(Page<Log> page, Map<String, Object> paramMap) {
    DetachedCriteria dc = logDao.createDetachedCriteria();

    Long createById = StringUtils.toLong(paramMap.get("createById"));
    if (createById > 0) {
      dc.add(Restrictions.eq("createBy.id", createById));
    }

    String requestUri = ObjectUtils.toString(paramMap.get("requestUri"));
    if (StringUtils.isNotBlank(requestUri)) {
      dc.add(Restrictions.like("requestUri", "%" + requestUri + "%"));
    }

    String exception = ObjectUtils.toString(paramMap.get("exception"));
    if (StringUtils.isNotBlank(exception)) {
      dc.add(Restrictions.eq("type", Log.TYPE_EXCEPTION));
    }

    Date beginDate = DateUtils.parseDate(paramMap.get("beginDate"));
    if (beginDate == null) {
      beginDate = DateUtils.setDays(new Date(), 1);
      paramMap.put("beginDate", DateUtils.formatDate(beginDate, "yyyy-MM-dd"));
    }
    Date endDate = DateUtils.parseDate(paramMap.get("endDate"));
    if (endDate == null) {
      endDate = DateUtils.addDays(DateUtils.addMonths(beginDate, 1), -1);
      paramMap.put("endDate", DateUtils.formatDate(endDate, "yyyy-MM-dd"));
    }
    dc.add(Restrictions.between("createDate", beginDate, endDate));

    dc.addOrder(Order.desc("id"));
    return logDao.find(page, dc);
  }
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    SessionFactory factory = null;
    Session session = null;
    org.hibernate.Transaction tx = null;

    try {
      factory = HibernateUtil.getSessionFactory();
      session = factory.openSession();
      tx = session.beginTransaction();

      List<Transaction> transactions =
          session.createCriteria(Transaction.class).addOrder(Order.desc("title")).list();

      for (Transaction t : transactions) {
        System.out.println(t.getTitle());
      }

      tx.commit();

    } catch (Exception e) {
      e.printStackTrace();
      tx.rollback();
    } finally {
      session.close();
      factory.close();
    }
  }
Exemple #26
0
 /**
  * 使用检索标准对象分页查询
  *
  * @param detachedCriteria
  * @param page
  * @return
  */
 @SuppressWarnings("unchecked")
 public Page<T> find(Page<T> page, DetachedCriteria detachedCriteria) {
   // get count
   if (!page.isDisabled() && !page.isNotCount()) {
     page.setCount(count(detachedCriteria));
     if (page.getCount() < 1) {
       return page;
     }
   }
   Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
   criteria.setResultTransformer(Criteria.ROOT_ENTITY);
   // set page
   if (!page.isDisabled()) {
     criteria.setFirstResult(page.getFirstResult());
     criteria.setMaxResults(page.getMaxResults());
   }
   // order by
   if (StringUtils.isNotBlank(page.getOrderBy())) {
     for (String order : StringUtils.split(page.getOrderBy(), ",")) {
       String[] o = StringUtils.split(order, " ");
       if (o.length >= 1) {
         criteria.addOrder(Order.asc(o[0]));
       } else if (o.length >= 2) {
         if ("DESC".equals(o[1].toUpperCase())) {
           criteria.addOrder(Order.desc(o[0]));
         } else {
           criteria.addOrder(Order.asc(o[0]));
         }
       }
     }
   }
   page.setList(criteria.list());
   return page;
 }
Exemple #27
0
 @Override
 public Long getTotal(CommentBo bo) {
   Criteria criteria = createRowCountsCriteria(Comment.class);
   initCriteria(criteria, bo);
   criteria.addOrder(Order.desc("createdDatetime"));
   return (Long) criteria.uniqueResult();
 }
 @Override
 public List<ReadingEnergy> getList() {
   @SuppressWarnings("unchecked")
   List<ReadingEnergy> list =
       getSession().createCriteria(ReadingEnergy.class).addOrder(Order.desc("readingDate")).list();
   return list;
 }
 public EnhancedRule setRule(EnhancedRule rule, BlogCommentQuery query) {
   if (query != null) {
     if (query.name != null) {
       rule.add(Restrictions.like("name", query.name, MatchMode.ANYWHERE));
     }
     if (query.content != null) {
       rule.add(Restrictions.like("content", query.content, MatchMode.ANYWHERE));
     }
     if (query.email != null) {
       rule.add(Restrictions.like("email", query.email, MatchMode.ANYWHERE));
     }
     if (query.im != null) {
       rule.add(Restrictions.like("im", query.im, MatchMode.ANYWHERE));
     }
     if (query.ip != null) {
       rule.add(Restrictions.like("ip", query.ip, MatchMode.ANYWHERE));
     }
     if (query.website != null) {
       rule.add(Restrictions.like("website", query.website, MatchMode.ANYWHERE));
     }
     if (query.userId != null) {
       rule.add(Restrictions.eq("user.id", query.userId));
     }
     if (query.blogId != null) {
       rule.add(Restrictions.eq("blog.id", query.blogId));
     }
     if (query.getOrder() != null) {
       rule.addOrder(query.getDesc() ? Order.desc(query.getOrder()) : Order.asc(query.getOrder()));
     }
   }
   return rule;
 }
  /**
   * prepare query based on criteria
   *
   * @param session hib session
   * @return the query
   */
  private Criteria attachCriteriaInfo(Session session) {
    Criteria query = null;

    if (StringUtils.isBlank(this.entityName)) {
      if (StringUtils.isBlank(this.alias)) {
        query = session.createCriteria(this.persistentClass);
      } else {
        query = session.createCriteria(this.persistentClass, alias);
      }
    } else {
      query = session.createCriteria(this.entityName);
    }

    // add criterions
    if (this.criterions != null) {
      query.add(this.criterions);
    }
    boolean secondLevelCaching =
        HibUtils.secondLevelCaching(
            ByCriteriaStatic.this.cacheable, ByCriteriaStatic.this.queryOptions);
    query.setCacheable(secondLevelCaching);

    if (secondLevelCaching) {
      String secondLevelCacheRegion =
          HibUtils.secondLevelCacheRegion(
              ByCriteriaStatic.this.cacheRegion, ByCriteriaStatic.this.queryOptions);
      if (!StringUtils.isBlank(secondLevelCacheRegion)) {
        query.setCacheRegion(secondLevelCacheRegion);
      }
    }

    QuerySort querySort = this.queryOptions == null ? null : this.queryOptions.getQuerySort();
    if (querySort != null) {
      List<QuerySortField> sorts = querySort.getQuerySortFields();

      for (QuerySortField theSort : GrouperUtil.nonNull(sorts)) {

        Order order =
            theSort.isAscending()
                ? Order.asc(theSort.getColumn())
                : Order.desc(theSort.getColumn());

        query.addOrder(order);
      }
    }
    QueryPaging queryPaging = this.queryOptions == null ? null : this.queryOptions.getQueryPaging();
    if (queryPaging != null) {

      // GRP-1024: sql server problems with paging page number when not initted
      if (queryPaging.getFirstIndexOnPage() < 0) {
        query.setFirstResult(0);
      } else {
        query.setFirstResult(queryPaging.getFirstIndexOnPage());
      }

      query.setMaxResults(queryPaging.getPageSize());
    }

    return query;
  }