Example usage for org.hibernate.criterion Restrictions gt

List of usage examples for org.hibernate.criterion Restrictions gt

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. gt

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions gt.

Prototype

public static SimpleExpression gt(String propertyName, Object value)

Source Link

Document

Apply a "greater than" constraint to the named property

Usage

From source file:com.jgeppert.struts2.jquery.grid.showcase.action.JsonOrdersAction.java

License:Apache License

public String execute() {
    log.debug("Page " + getPage() + " Rows " + getRows() + " Sorting Order " + getSord() + " Index Row :"
            + getSidx());/*from   w w  w .ja v a2  s .co  m*/
    log.debug("Search :" + searchField + " " + searchOper + " " + searchString);

    // Calcalate until rows ware selected
    int to = (rows * page);

    // Calculate the first row to read
    int from = to - rows;

    // Criteria to Build SQL
    DetachedCriteria criteria = DetachedCriteria.forClass(Orders.class);

    if (id != null) {
        criteria.createAlias("customer", "c");
        criteria.add(Restrictions.eq("c.customernumber", id));
    }

    // Handle Search
    if (searchField != null) {
        if (searchField.equals("customernumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("ordernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("ordernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("ordernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("ordernumber", searchValue));
        } else if (searchField.equals("status") || searchField.equals("comments")) {
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq(searchField, searchString));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne(searchField, searchString));
            else if (searchOper.equals("bw"))
                criteria.add(Restrictions.like(searchField, searchString + "%"));
            else if (searchOper.equals("cn"))
                criteria.add(Restrictions.like(searchField, "%" + searchString + "%"));
        }
        if (searchField.equals("customer")) {
            Integer searchValue = Integer.parseInt(searchString);
            criteria.createAlias("customer", "c");

            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("c.customernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("c.customernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("c.customernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("c.customernumber", searchValue));
        }
    }

    // Count Orders
    records = ordersDao.countByCriteria(criteria);

    // Reset count Projection
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.ROOT_ENTITY);

    // Handle Order By
    if (sidx != null && !sidx.equals("")) {
        if (!sidx.equals("customer")) {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc(sidx));
            else
                criteria.addOrder(Order.desc(sidx));
        } else {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc("customer.customernumber"));
            else
                criteria.addOrder(Order.desc("customer.customernumber"));
        }
    }

    // Get Customers by Criteria
    gridModel = ordersDao.findByCriteria(criteria, from, rows);

    // Set to = max rows
    if (to > records)
        to = records;

    // Calculate total Pages
    total = (int) Math.ceil((double) records / (double) rows);

    return SUCCESS;
}

From source file:com.jgeppert.struts2.jquery.grid.showcase.action.JsonTableAction.java

License:Apache License

public String execute() {
    log.debug("Page " + getPage() + " Rows " + getRows() + " Sorting Order " + getSord() + " Index Row :"
            + getSidx());//w w  w .  ja  v  a2 s  . c om
    log.debug("Search :" + searchField + " " + searchOper + " " + searchString);

    // Calcalate until rows ware selected
    int to = (rows * page);

    // Calculate the first row to read
    int from = to - rows;

    // Criteria to Build SQL
    DetachedCriteria criteria = DetachedCriteria.forClass(Customers.class);

    // Handle Search
    if (searchField != null) {
        if (searchField.equals("customernumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("customernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("customernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("customernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("customernumber", searchValue));
        } else if (searchField.equals("country") || searchField.equals("city")
                || searchField.equals("addressLine1") || searchField.equals("contactfirstname")
                || searchField.equals("contactlastname") || searchField.equals("customername")) {
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq(searchField, searchString));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne(searchField, searchString));
            else if (searchOper.equals("bw"))
                criteria.add(Restrictions.like(searchField, searchString + "%"));
            else if (searchOper.equals("cn"))
                criteria.add(Restrictions.like(searchField, "%" + searchString + "%"));
        } else if (searchField.equals("creditlimit")) {
            Double searchValue = Double.parseDouble(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("creditlimit", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("creditlimit", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("creditlimit", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("creditlimit", searchValue));
        }
        if (searchField.equals("employeenumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            criteria.createAlias("salesemployee", "se");

            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("se.employeenumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("se.employeenumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("se.employeenumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("se.employeenumber", searchValue));
        }
    }

    // Count Customers
    records = customersDao.countByCriteria(criteria);

    // Reset count Projection
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.ROOT_ENTITY);

    // Handle Order By
    if (sidx != null && !sidx.equals("")) {
        if (!sidx.equals("employeenumber")) {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc(sidx));
            else
                criteria.addOrder(Order.desc(sidx));
        } else {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc("salesemployee.employeenumber"));
            else
                criteria.addOrder(Order.desc("salesemployee.employeenumber"));
        }
    }

    // Get Customers by Criteria
    gridModel = customersDao.findByCriteria(criteria, from, rows);

    // Set to = max rows
    if (to > records)
        to = records;

    // Calculate total Pages
    total = (int) Math.ceil((double) records / (double) rows);

    return SUCCESS;
}

From source file:com.jubination.model.dao.ClientDAOImpl.java

@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
public List fetchEntities(String paramVal) {
    List list = null;// www  .  j a  va  2 s .  c  om

    switch (paramVal) {

    case "PendingMinusOne":
        session = getSessionFactory().getCurrentSession();
        Criteria criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.lt("l.count", 0), Restrictions.isNull("l.followUpDate"),
                Restrictions.gt("l.leadId", "50000")));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingInProgress":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.createAlias("l.call", "call");
        criteria.add(Restrictions.and(Restrictions.le("l.count", 0), Restrictions.gt("l.leadId", "50000"),
                Restrictions.eq("call.Status", "in-progress")));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingAndNotified":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.or(Restrictions.and(

                Restrictions.ge("l.count", 1), Restrictions.eq("l.followUpDate", ""),
                Restrictions.isNull("l.followUpDate")),

                Restrictions.and(Restrictions.ge("l.count", 1), Restrictions.ne("l.followUpDate", ""),
                        Restrictions.isNotNull("l.followUpDate"),
                        Restrictions.le("l.followUpDate",
                                new SimpleDateFormat("yyyy-MM-dd").format(new Date()))),
                Restrictions.eq("l.followUpDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date())))

        );
        criteria.addOrder(Order.desc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;

    case "Pending":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.and(Restrictions.ge("l.count", 1),
                Restrictions.isNull("l.missedAppointment"), Restrictions.isNull("l.followUpDate"))));

        criteria.addOrder(Order.asc("l.count"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();

            }
        }
        break;
    case "Notified":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(
                Restrictions.or(
                        Restrictions.and(
                                Restrictions
                                        .and(Restrictions.ge("l.count", 1),
                                                Restrictions.and(
                                                        Restrictions.le("l.followUpDate",
                                                                new SimpleDateFormat("yyyy-MM-dd")
                                                                        .format(new Date())),
                                                        Restrictions.gt("l.followUpDate", "2016-01-01"))),
                                Restrictions.isNull("l.missedAppointment")),
                        Restrictions.and(
                                Restrictions.eq("l.followUpDate",
                                        new SimpleDateFormat("yyyy-MM-dd").format(new Date())),
                                Restrictions.eq("l.leadStatus", "Follow up/Call back"))));
        criteria.addOrder(Order.asc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingMA":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.ge("l.count", 1),
                Restrictions.eq("l.missedAppointment", true), Restrictions.isNull("l.followUpDate")));

        criteria.addOrder(Order.desc("l.count"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "NotifiedMA":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class);
        criteria.createAlias("lead", "l");
        criteria.add(Restrictions.and(
                Restrictions.and(Restrictions.ge("l.count", 1),
                        Restrictions.and(
                                Restrictions.le("l.followUpDate",
                                        new SimpleDateFormat("yyyy-MM-dd").format(new Date())),
                                Restrictions.gt("l.followUpDate", "2016-01-01"))),
                Restrictions.eq("l.missedAppointment", true)));
        criteria.addOrder(Order.asc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;

    case "Overnight":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class);
        criteria.add(Restrictions.eq("overnight", true));
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
            client.getLead().size();
        }
        break;

    default:

        break;
    }
    if (list != null) {
        System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" + list.size() + "$$$" + paramVal);
    }

    System.out.println(
            "READ CLIENT WITH INNER ELEMENTS WITH STATUS :::::::::::::::::::::::::::::::::::::::::::::::CHECK");
    return list;

}

From source file:com.klistret.cmdb.utility.hibernate.XPathCriteria.java

License:Open Source License

/**
 * /*w  w  w.j a  va 2  s  . co m*/
 * @param predicate
 * @return
 */
protected Criterion getRestriction(Expr predicate, HibernateStep context) {
    logger.debug("Adding restrictions by predicate to context [{}]", context);

    switch (predicate.getType()) {
    case Or:
        /**
         * Recursively breaks down the OrExpr by translating on the first
         * and second operands
         */
        if (((OrExpr) predicate).getOperands().size() != 2)
            throw new ApplicationException(
                    String.format("OrExpr expression [%s] expects 2 operands", predicate));

        return Restrictions.or(getRestriction(((OrExpr) predicate).getOperands().get(0), context),
                getRestriction(((OrExpr) predicate).getOperands().get(1), context));
    case And:
        /**
         * Recursively breaks down the AndExpr by translating on the first
         * and second operands
         */
        if (((AndExpr) predicate).getOperands().size() != 2)
            throw new ApplicationException(
                    String.format("AndExpr expression [%s] expects 2 operands", predicate));

        return Restrictions.and(getRestriction(((AndExpr) predicate).getOperands().get(0), context),
                getRestriction(((AndExpr) predicate).getOperands().get(1), context));
    case Comparison:
        /**
         * Find the literal
         */
        LiteralExpr literal = getLiteralOperand(((ComparisonExpr) predicate).getOperands());

        /**
         * Find the relative path making a Hibernate relative path
         */
        RelativePathExpr rpe = getRelativePathOperand(((ComparisonExpr) predicate).getOperands());
        HibernateRelativePath hRPath = process(rpe, context);
        build(hRPath);

        HibernateStep last = hRPath.getLastHibernateStep();

        /**
         * Property name with alias prefix
         */
        String alias = last.getPrevious() == null ? aliasCache.get(context.getPath())
                : aliasCache.get(last.getPrevious().getPath());
        String propertyName = alias == null ? last.getName() : String.format("%s.%s", alias, last.getName());

        /**
         * Paths with XML properties (always the last step if present)
         * return a XPath restriction.
         */
        if (hRPath.hasXML()) {
            if (!hRPath.isTruncated())
                throw new ApplicationException(String.format(
                        "Predicate relative path ending in an XML property [%s] must be truncated", last));

            /**
             * Last Hibernate step of the Hibernate path marks the property
             * which the restriction acts on.
             */
            StepExpr step = (StepExpr) last.getStep();

            /**
             * A new XPath is created from the last step downwards till the
             * step prior to the ending step.
             */
            String xpath = null;
            for (int depth = step.getDepth(); depth < step.getRelativePath().getDepth() - 1; depth++) {
                Expr expr = step.getRelativePath().getExpr(depth);
                xpath = xpath == null ? expr.getXPath() : String.format("%s/%s", xpath, expr.getXPath());
            }

            Step ending = (Step) step.getRelativePath().getLastExpr();

            /**
             * A new comparison is generated
             */
            List<Expr> operands = new ArrayList<Expr>();
            operands.add(ending);
            operands.add(literal);

            xpath = String.format("%s[%s]", xpath,
                    ComparisonExpr.getXPath(((ComparisonExpr) predicate).getOperator(), operands, false));
            xpath = String.format("%s%s", context.getBaseExpression().getProlog(), xpath);

            PathExpression other = new PathExpression(xpath);
            return new XPathRestriction(propertyName, (Step) other.getRelativePath().getFirstExpr());
        }

        if (((StepExpr) last.getStep()).hasPredicates())
            throw new ApplicationException(String.format(
                    "Comparisons against Hibernate properties may not have an underlying step [] with predicates",
                    last.getStep()));

        logger.debug("Predicate is comparison [{}] against property [{}]",
                ((ComparisonExpr) predicate).getOperator().name(), propertyName);

        switch (((ComparisonExpr) predicate).getOperator()) {
        case ValueEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.eq(propertyName, literal.getValue().getJavaValue());
        case ValueGreaterThan:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.gt(propertyName, literal.getValue().getJavaValue());
        case ValueGreaterThanOrEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.ge(propertyName, literal.getValue().getJavaValue());
        case ValueLessThan:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.lt(propertyName, literal.getValue().getJavaValue());
        case ValueLessThanOrEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.le(propertyName, literal.getValue().getJavaValue());
        case ValueNotEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.ne(propertyName, literal.getValue().getJavaValue());
        case GeneralEquals:
            /**
             * If atomic (not a sequence) then the 'in' restriction is not
             * usable (defaults to 'eq' restriction) since the argument is
             * an array of objects.
             */
            if (literal.isAtomic()) {
                logger.debug("Value: {}", literal.getValue().getJavaValue());
                return Restrictions.eq(propertyName, literal.getValue().getJavaValue());
            }

            logger.debug("Values: {}", literal.getValues());

            Object[] javaValues = new Object[literal.getValues().length];
            for (int index = 0; index < literal.getValues().length; index++)
                javaValues[index] = ((com.klistret.cmdb.utility.saxon.Value) literal.getValues()[index])
                        .getJavaValue();

            return Restrictions.in(propertyName, javaValues);
        case Matches:
            if (((ComparisonExpr) predicate).getOperands().size() != 2)
                throw new ApplicationException(
                        String.format("Matches function [%s] expects 2 operands", predicate));

            logger.debug("Value: {}", literal.getValue().getText());
            return Restrictions.ilike(propertyName, literal.getValue().getText(), MatchMode.EXACT);
        case Exists:
            if (((ComparisonExpr) predicate).getOperands().size() != 1)
                throw new ApplicationException(
                        String.format("Exists function [%s] expects only 1 operand", predicate));

            return Restrictions.isNotNull(propertyName);
        case Empty:
            if (((ComparisonExpr) predicate).getOperands().size() != 1)
                throw new ApplicationException(
                        String.format("Empty function [%s] expects only 1 operand", predicate));

            return Restrictions.isNull(propertyName);
        default:
            throw new ApplicationException(
                    String.format("Unexpected comparison operator [%s] handling predicates",
                            ((ComparisonExpr) predicate).getOperator()));
        }

    default:
        throw new ApplicationException(String.format("Unexpected expr [%s] type for predicate", predicate));
    }
}

From source file:com.kodemore.hibernate.criteria.KmAbstractCriteria.java

License:Open Source License

public void addGreaterThan(String property, Object value) {
    _add(Restrictions.gt(property, value));
}

From source file:com.krawler.common.util.BuildCriteria.java

License:Open Source License

private static Criterion getCriteriaByCondition(Object value, Integer criteriaVal, String propertyname) {
    Criterion Criteriaobj;/*from   ww w . j ava 2 s .c  o  m*/

    switch (criteriaVal) {
    case ISNOTNULL:
        Criteriaobj = Restrictions.isNotNull(propertyname);
        break;
    case NOTIN:
        String[] strArr = String.valueOf(value).split(",");
        List ls = Arrays.asList(strArr);
        Criteriaobj = Restrictions.not(Restrictions.in(propertyname, ls));
        break;
    case LIKE:
        Criteriaobj = Restrictions.or(Restrictions.like(propertyname, value + "%"),
                Restrictions.like(propertyname, "% " + value + "%"));
        break;
    case LE:
        Criteriaobj = Restrictions.le(propertyname, value);
        break;
    case GE:
        Criteriaobj = Restrictions.ge(propertyname, value);
        break;
    case ISNULL:
        Criteriaobj = Restrictions.isNull(propertyname);
        break;
    case IN:
        strArr = String.valueOf(value).split(",");
        ls = Arrays.asList(strArr);
        Criteriaobj = Restrictions.in(propertyname, ls);
        break;
    case NE:
        Criteriaobj = Restrictions.ne(propertyname, value);
        break;
    case LT:
        Criteriaobj = Restrictions.lt(propertyname, value);
        break;
    case GT:
        Criteriaobj = Restrictions.gt(propertyname, value);
        break;
    case EQ:
    default:
        Criteriaobj = Restrictions.eq(propertyname, value);
        break;
    }
    return Criteriaobj;
}

From source file:com.lakeside.data.sqldb.PageBaseDao.java

License:Apache License

/**
 * ??Criterion,./*  ww w . j  av  a2 s  .com*/
 */
protected Criterion buildPropertyFilterCriterion(final String propertyName, final Object propertyValue,
        final MatchType matchType) {
    Assert.hasText(propertyName, "propertyName?");
    Criterion criterion = null;
    try {

        //?MatchTypecriterion
        if (MatchType.EQ.equals(matchType)) {
            criterion = Restrictions.eq(propertyName, propertyValue);
        } else if (MatchType.LIKE.equals(matchType)) {
            criterion = Restrictions.like(propertyName, (String) propertyValue, MatchMode.ANYWHERE);
        } else if (MatchType.LE.equals(matchType)) {
            criterion = Restrictions.le(propertyName, propertyValue);
        } else if (MatchType.LT.equals(matchType)) {
            criterion = Restrictions.lt(propertyName, propertyValue);
        } else if (MatchType.GE.equals(matchType)) {
            criterion = Restrictions.ge(propertyName, propertyValue);
        } else if (MatchType.GT.equals(matchType)) {
            criterion = Restrictions.gt(propertyName, propertyValue);
        }
    } catch (Exception e) {
        throw ReflectionUtils.convertReflectionExceptionToUnchecked(e);
    }
    return criterion;
}

From source file:com.llaf.elementos.model.DAOUsuario.java

public String obtenerPorNOmbre(String nombre) throws Exception {
    SessionFactory factory = HIbernateUtilidades.getSessionFactory();
    Session sesion = factory.openSession();
    Transaction tranza = sesion.beginTransaction();

    Criteria cri = sesion.createCriteria(Usuarios.class).add(Restrictions.like("nombre", nombre + "%"));
    Criteria cri2 = sesion.createCriteria(Usuarios.class).add(Restrictions.eq("nombre", nombre));
    Criteria cri3 = sesion.createCriteria(Usuarios.class).add(Restrictions.between("edad", 18, 40))
            .addOrder(Order.asc("nombre"));
    Criteria cri4 = sesion.createCriteria(Usuarios.class).add(Restrictions.lt("sueldo", new Integer(4000)));
    Criteria cri5 = sesion.createCriteria(Usuarios.class).add(Restrictions.gt("sueldo", new Integer(4000)));

    ArrayList<Usuarios> usuarios = (ArrayList<Usuarios>) cri.list();

    ObjectMapper mapper = new ObjectMapper();

    Map<String, ArrayList<Usuarios>> singletonMap = Collections.singletonMap("usuarios", usuarios);

    tranza.commit();/*from  w ww.  jav a  2  s  . c o m*/
    sesion.close();

    return mapper.writeValueAsString(singletonMap);
}

From source file:com.lm.lic.manager.hibernate.LicenseDAO.java

License:Open Source License

public Integer findNumInUseLicenses(String isvId, String prodId, String prodDefId, String storeId,
        String platformId, Date startDate, Date endDate) {
    Integer numLics = 0;/*from   www.  ja v  a2s  . c o  m*/
    try {

        Long lisvid = null;
        if (StringUtils.hasText(isvId))
            lisvid = Long.parseLong(isvId);

        Long lpid = null;
        if (StringUtils.hasText(prodId))
            lpid = Long.parseLong(prodId);

        Long lppid = null;
        if (StringUtils.hasText(prodDefId))
            lppid = Long.parseLong(prodDefId);

        Long lsid = null;
        if (StringUtils.hasText(storeId))
            lsid = Long.parseLong(storeId);

        Long lfid = null;
        if (StringUtils.hasText(platformId))
            lfid = Long.parseLong(platformId);

        Criteria criteria = getSession().createCriteria(License.class);

        criteria.add(Restrictions.eq("isv.id", lisvid));

        Criteria prodCriteria = criteria.createCriteria("product");

        // If the child product is specified, this supercedes the wider selection of the product
        // definition.
        // Only check for htye product definition if the child product was not selected.
        if (lpid != null)
            criteria.add(Restrictions.eq("product.id", lpid));
        else if (lppid != null)
            prodCriteria.add(Restrictions.eq("productDef.id", lppid));

        if (lsid != null)
            prodCriteria.add(Restrictions.eq("listingStore.id", lsid));

        if (lfid != null)
            prodCriteria.add(Restrictions.eq("platform.id", lfid));

        criteria.add(Restrictions.eq("inUse", true));
        criteria.add(Restrictions.eq("decom", false));

        if (startDate != null && endDate != null)
            criteria.add(Restrictions.between(TIME_ACTIVATED, startDate, endDate));
        else {
            if (startDate != null)
                criteria.add(Restrictions.gt(TIME_ACTIVATED, startDate));
            if (endDate != null)
                criteria.add(Restrictions.lt(TIME_ACTIVATED, endDate));
        }

        criteria.setProjection(Projections.rowCount());
        numLics = (Integer) criteria.list().get(0);
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return numLics;
}

From source file:com.lm.lic.manager.hibernate.LicenseDAO.java

License:Open Source License

public Integer findNumIssuedLicenses(String isvId, String prodId, String prodDefId, String storeId,
        String platformId, Date startDate, Date endDate) {
    Integer numLics = 0;/*from   w  w w. j a  va2  s.  c  o m*/
    try {

        Long lisvid = null;
        if (StringUtils.hasText(isvId))
            lisvid = Long.parseLong(isvId);

        Long lpid = null;
        if (StringUtils.hasText(prodId))
            lpid = Long.parseLong(prodId);

        Long lppid = null;
        if (StringUtils.hasText(prodDefId))
            lppid = Long.parseLong(prodDefId);

        Long lsid = null;
        if (StringUtils.hasText(storeId))
            lsid = Long.parseLong(storeId);

        Long lfid = null;
        if (StringUtils.hasText(platformId))
            lfid = Long.parseLong(platformId);

        Criteria criteria = getSession().createCriteria(License.class);

        criteria.add(Restrictions.eq("isv.id", lisvid));

        Criteria prodCriteria = criteria.createCriteria("product");

        // If the child product is specified, this supercedes the wider selection of the product
        // definition.
        // Only check for htye product definition if the child product was not selected.
        if (lpid != null)
            criteria.add(Restrictions.eq("product.id", lpid));
        else if (lppid != null)
            prodCriteria.add(Restrictions.eq("productDef.id", lppid));

        if (lsid != null)
            prodCriteria.add(Restrictions.eq("listingStore.id", lsid));

        if (lfid != null)
            prodCriteria.add(Restrictions.eq("platform.id", lfid));

        criteria.add(Restrictions.eq("inUse", true));
        // criteria.add(Restrictions.eq("decom", false));

        if (startDate != null && endDate != null)
            criteria.add(Restrictions.between(TIME_ACTIVATED, startDate, endDate));
        else {
            if (startDate != null)
                criteria.add(Restrictions.gt(TIME_ACTIVATED, startDate));
            if (endDate != null)
                criteria.add(Restrictions.lt(TIME_ACTIVATED, endDate));
        }

        criteria.setProjection(Projections.rowCount());
        numLics = (Integer) criteria.list().get(0);
    } catch (RuntimeException re) {
        log.error("find by property name failed", re);
        throw re;
    }
    return numLics;
}