Example usage for org.hibernate.criterion Restrictions not

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

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

Introduction

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

Prototype

public static Criterion not(Criterion expression)

Source Link

Document

Return the negation of an expression

Usage

From source file:org.goobi.production.flow.statistics.hibernate.FilterHelper.java

License:Open Source License

/**
 * Filter processes by workpiece./*from w w w  .ja v  a 2 s  .  c o m*/
 *
 * @param tok
 *            part of filter string to use
 */
protected static void filterWorkpiece(Conjunction con, String tok, boolean negate) {
    /* filter according signature */
    String[] ts = tok.substring(tok.indexOf(":") + 1).split(":");
    if (!negate) {
        if (ts.length > 1) {
            con.add(Restrictions.and(Restrictions.like("werkeig.value", "%" + ts[1] + "%"),
                    Restrictions.like("werkeig.title", "%" + ts[0] + "%")));
        } else {

            con.add(Restrictions.like("werkeig.value", "%" + ts[0] + "%"));
        }
    } else {
        if (ts.length > 1) {
            con.add(Restrictions.not(Restrictions.and(Restrictions.like("werkeig.value", "%" + ts[1] + "%"),
                    Restrictions.like("werkeig.title", "%" + ts[0] + "%"))));
        } else {

            con.add(Restrictions.not(Restrictions.like("werkeig.value", "%" + ts[0] + "%")));
        }
    }
}

From source file:org.goobi.production.flow.statistics.hibernate.FilterHelper.java

License:Open Source License

/**
 * This method builds a criteria depending on a filter string and some other
 * parameters passed on along the initial criteria. The filter is parsed and
 * depending on which data structures are used for applying filtering
 * restrictions conjunctions are formed and collect the restrictions and
 * then will be applied on the corresponding criteria. A criteria is only
 * added if needed for the presence of filters applying to it.
 *
 * @param inFilter/*from   w  w w  . ja v a 2  s .  c om*/
 *            String
 * @param crit
 *            PaginatingCriteria object
 * @param isTemplate
 *            Boolean
 * @param returnParameters
 *            Object containing values which need to be set and returned to
 *            UserDefinedFilter
 * @param userAssignedStepsOnly
 *            Boolean
 * @param stepOpenOnly
 *            boolean
 * @return String used to pass on error messages about errors in the filter
 *         expression
 */
public static String criteriaBuilder(Session session, String inFilter, PaginatingCriteria crit,
        Boolean isTemplate, Parameters returnParameters, Boolean stepOpenOnly, Boolean userAssignedStepsOnly,
        boolean clearSession) {

    if (ConfigCore.getBooleanParameter("DatabaseAutomaticRefreshList", true) && clearSession) {
        session.clear();
    }
    // for ordering the lists there are some
    // criteria, which needs to be added even no
    // restrictions apply, to avoid multiple analysis
    // of the criteria it is only done here once and
    // to set flags which are subsequently used
    Boolean flagSteps = false;
    Boolean flagProcesses = false;
    @SuppressWarnings("unused")
    Boolean flagSetCritProjects = false;
    String filterPrefix = "";
    if (crit.getClassName().equals(Process.class.getName())) {
        flagProcesses = true;
        filterPrefix = "steps.";
    }

    if (crit.getClassName().equals(Task.class.getName())) {
        flagSteps = true;
    }

    // keeping a reference to the passed criteria
    Criteria inCrit = crit;
    @SuppressWarnings("unused")
    Criteria critProject = null;
    Criteria critProcess = null;

    // to collect and return feedback about erroneous use of filter
    // expressions
    String message = "";

    StrTokenizer tokenizer = new StrTokenizer(inFilter, ' ', '\"');

    // conjunctions collecting conditions
    Conjunction conjWorkPiece = null;
    Conjunction conjProjects = null;
    Conjunction conjSteps = null;
    Conjunction conjProcesses = null;
    Conjunction conjTemplates = null;
    Conjunction conjUsers = null;
    Conjunction conjProcessProperties = null;
    Conjunction conjBatches = null;

    // this is needed if we filter processes
    if (flagProcesses) {
        conjProjects = Restrictions.conjunction();
        limitToUserAccessRights(conjProjects);
        // in case nothing is set here it needs to be removed again
        // happens if user has admin rights
        if (conjProjects.toString().equals("()")) {
            conjProjects = null;
            flagSetCritProjects = true;
        }
    }

    // this is needed if we filter steps
    if (flagSteps) {
        conjSteps = Restrictions.conjunction();
        limitToUserAssignedSteps(conjSteps, stepOpenOnly, userAssignedStepsOnly);
        // in case nothing is set here conjunction needs to be set to null
        // again
        if (conjSteps.toString().equals("()")) {
            conjSteps = null;
        }
    }

    // this is needed for the template filter (true) and the undefined
    // processes filter (false) in any other case it needs to be null
    if (isTemplate != null) {
        conjProcesses = Restrictions.conjunction();
        if (!isTemplate) {
            conjProcesses.add(Restrictions.eq("template", Boolean.FALSE));
        } else {
            conjProcesses.add(Restrictions.eq("template", Boolean.TRUE));
        }
    }

    // this is needed for evaluating a filter string
    while (tokenizer.hasNext()) {
        String tok = tokenizer.nextToken().trim();
        String tokLowerCase = tok.toLowerCase(Locale.GERMANY);

        if (tokLowerCase.startsWith(FilterString.PROCESSPROPERTY)
                || tokLowerCase.startsWith(FilterString.PROZESSEIGENSCHAFT)) {
            if (conjProcessProperties == null) {
                conjProcessProperties = Restrictions.conjunction();
            }
            FilterHelper.filterProcessProperty(conjProcessProperties, tok, false);
        }
        // search over steps
        // original filter, is left here for compatibility reason
        // doesn't fit into new keyword scheme
        else if (tokLowerCase.startsWith(FilterString.STEP) || tokLowerCase.startsWith(FilterString.SCHRITT)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + createHistoricFilter(conjSteps, tok, flagSteps);

        } else if (tokLowerCase.startsWith(FilterString.STEPINWORK)
                || tokLowerCase.startsWith(FilterString.SCHRITTINARBEIT)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.INWORK, false,
                    filterPrefix));

            // new keyword stepLocked implemented
        } else if (tokLowerCase.startsWith(FilterString.STEPLOCKED)
                || tokLowerCase.startsWith(FilterString.SCHRITTINARBEIT)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.LOCKED, false,
                    filterPrefix));

            // new keyword stepOpen implemented
        } else if (tokLowerCase.startsWith(FilterString.STEPOPEN)
                || tokLowerCase.startsWith(FilterString.SCHRITTOFFEN)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.OPEN, false,
                    filterPrefix));

            // new keyword stepDone implemented
        } else if (tokLowerCase.startsWith(FilterString.STEPDONE)
                || tokLowerCase.startsWith(FilterString.SCHRITTABGESCHLOSSEN)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.DONE, false,
                    filterPrefix));

            // new keyword stepDoneTitle implemented, replacing so far
            // undocumented
        } else if (tokLowerCase.startsWith(FilterString.STEPDONETITLE)
                || tokLowerCase.startsWith(FilterString.ABGESCHLOSSENERSCHRITTTITEL)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            String stepTitel = tok.substring(tok.indexOf(":") + 1);
            FilterHelper.filterStepName(conjSteps, stepTitel, TaskStatus.DONE, false, filterPrefix);

        } else if ((tokLowerCase.startsWith(FilterString.STEPDONEUSER)
                || tokLowerCase.startsWith(FilterString.ABGESCHLOSSENERSCHRITTBENUTZER))
                && ConfigCore.getBooleanParameter("withUserStepDoneSearch")) {
            if (conjUsers == null) {
                conjUsers = Restrictions.conjunction();
            }
            FilterHelper.filterStepDoneUser(conjUsers, tok);
        } else if (tokLowerCase.startsWith(FilterString.STEPAUTOMATIC)
                || tokLowerCase.startsWith(FilterString.SCHRITTAUTOMATISCH)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            FilterHelper.filterAutomaticSteps(conjSteps, tok, flagSteps);
        } else if (tokLowerCase.startsWith(FilterString.PROJECT)
                || tokLowerCase.startsWith(FilterString.PROJEKT)) {
            if (conjProjects == null) {
                conjProjects = Restrictions.conjunction();
            }
            FilterHelper.filterProject(conjProjects, tok, false);

        } else if (tokLowerCase.startsWith(FilterString.TEMPLATE)
                || tokLowerCase.startsWith(FilterString.VORLAGE)) {
            if (conjTemplates == null) {
                conjTemplates = Restrictions.conjunction();
            }
            FilterHelper.filterScanTemplate(conjTemplates, tok, false);

        } else if (tokLowerCase.startsWith(FilterString.ID)) {
            if (conjProcesses == null) {
                conjProcesses = Restrictions.conjunction();
            }
            FilterHelper.filterIds(conjProcesses, tok);

        } else if (tokLowerCase.startsWith(FilterString.PROCESS)
                || tokLowerCase.startsWith(FilterString.PROZESS)) {
            if (conjProcesses == null) {
                conjProcesses = Restrictions.conjunction();
            }
            conjProcesses
                    .add(Restrictions.like("title", "%" + "proc:" + tok.substring(tok.indexOf(":") + 1) + "%"));
        } else if (tokLowerCase.startsWith(FilterString.BATCH)
                || tokLowerCase.startsWith(FilterString.GRUPPE)) {
            if (conjBatches == null) {
                conjBatches = Restrictions.conjunction();
            }
            int value = Integer.parseInt(tok.substring(tok.indexOf(":") + 1));
            conjBatches.add(Restrictions.eq("bat.id", value));
        } else if (tokLowerCase.startsWith(FilterString.WORKPIECE)
                || tokLowerCase.startsWith(FilterString.WERKSTUECK)) {
            if (conjWorkPiece == null) {
                conjWorkPiece = Restrictions.conjunction();
            }
            FilterHelper.filterWorkpiece(conjWorkPiece, tok, false);

        } else if (tokLowerCase.startsWith("-" + FilterString.PROCESSPROPERTY)
                || tokLowerCase.startsWith("-" + FilterString.PROZESSEIGENSCHAFT)) {
            if (conjProcessProperties == null) {
                conjProcessProperties = Restrictions.conjunction();
            }
            FilterHelper.filterProcessProperty(conjProcessProperties, tok, true);
        }

        else if (tokLowerCase.startsWith("-" + FilterString.STEPINWORK)
                || tokLowerCase.startsWith("-" + FilterString.SCHRITTINARBEIT)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.INWORK, true,
                    filterPrefix));

            // new keyword stepLocked implemented
        } else if (tokLowerCase.startsWith("-" + FilterString.STEPLOCKED)
                || tokLowerCase.startsWith("-" + FilterString.SCHRITTGESPERRT)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.LOCKED, true,
                    filterPrefix));

            // new keyword stepOpen implemented
        } else if (tokLowerCase.startsWith("-" + FilterString.STEPOPEN)
                || tokLowerCase.startsWith("-" + FilterString.SCHRITTOFFEN)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.OPEN, true,
                    filterPrefix));

            // new keyword stepDone implemented
        } else if (tokLowerCase.startsWith("-" + FilterString.STEPDONE)
                || tokLowerCase.startsWith("-" + FilterString.SCHRITTABGESCHLOSSEN)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            message = message + (createStepFilters(returnParameters, conjSteps, tok, TaskStatus.DONE, true,
                    filterPrefix));

            // new keyword stepDoneTitle implemented, replacing so far
            // undocumented
        } else if (tokLowerCase.startsWith("-" + FilterString.STEPDONETITLE)
                || tokLowerCase.startsWith("-" + FilterString.ABGESCHLOSSENERSCHRITTTITEL)) {
            if (conjSteps == null) {
                conjSteps = Restrictions.conjunction();
            }
            String stepTitel = tok.substring(tok.indexOf(":") + 1);
            FilterHelper.filterStepName(conjSteps, stepTitel, TaskStatus.DONE, true, filterPrefix);

        } else if (tokLowerCase.startsWith("-" + FilterString.PROJECT)
                || tokLowerCase.startsWith("-" + FilterString.PROJEKT)) {
            if (conjProjects == null) {
                conjProjects = Restrictions.conjunction();
            }
            FilterHelper.filterProject(conjProjects, tok, true);

        } else if (tokLowerCase.startsWith("-" + FilterString.TEMPLATE)
                || tokLowerCase.startsWith("-" + FilterString.VORLAGE)) {
            if (conjTemplates == null) {
                conjTemplates = Restrictions.conjunction();
            }
            FilterHelper.filterScanTemplate(conjTemplates, tok, true);

        } else if (tokLowerCase.startsWith("-" + FilterString.WORKPIECE)
                || tokLowerCase.startsWith("-" + FilterString.WERKSTUECK)) {
            if (conjWorkPiece == null) {
                conjWorkPiece = Restrictions.conjunction();
            }
            FilterHelper.filterWorkpiece(conjWorkPiece, tok, true);

        } else if (tokLowerCase.startsWith("-")) {

            if (conjProcesses == null) {
                conjProcesses = Restrictions.conjunction();
            }

            conjProcesses.add(Restrictions.not(Restrictions.like("title", "%" + tok.substring(1) + "%")));

        } else {

            /* standard-search parameter */
            if (conjProcesses == null) {
                conjProcesses = Restrictions.conjunction();
            }

            conjProcesses.add(IlikeExpression.ilike("title", "*" + tok + "*", '!'));
        }
    }

    if (conjProcesses != null || flagSteps) {
        if (!flagProcesses) {

            critProcess = crit.createCriteria("process", "proc");

            if (conjProcesses != null) {
                critProcess.add(conjProcesses);
            }
        } else {
            if (conjProcesses != null) {
                inCrit.add(conjProcesses);
            }
        }
    }

    if (flagSteps) {

        critProject = critProcess.createCriteria("project", "proj");

        if (conjProjects != null) {
            inCrit.add(conjProjects);
        }
    } else {
        inCrit.createCriteria("project", "proj");
        if (conjProjects != null) {
            inCrit.add(conjProjects);
        }
    }

    if (conjSteps != null) {
        if (!flagSteps) {
            crit.createCriteria("tasks", "steps");
            crit.add(conjSteps);
        } else {
            inCrit.add(conjSteps);
        }
    }

    if (conjTemplates != null) {
        if (flagSteps) {
            critProcess.createCriteria("templates", "vorl");
            critProcess.createAlias("vorl.eigenschaften", "vorleig");
            critProcess.add(conjTemplates);
        } else {
            crit.createCriteria("templates", "vorl");
            crit.createAlias("vorl.eigenschaften", "vorleig");
            inCrit.add(conjTemplates);
        }
    }

    if (conjProcessProperties != null) {
        if (flagSteps) {
            critProcess.createAlias("proc.eigenschaften", "prozesseig");
            critProcess.add(conjProcessProperties);
        } else {

            inCrit.createAlias("properties", "prozesseig");
            inCrit.add(conjProcessProperties);
        }
    }

    if (conjWorkPiece != null) {
        if (flagSteps) {
            critProcess.createCriteria("workpiece", "werk");
            critProcess.createAlias("werk.eigenschaften", "werkeig");
            critProcess.add(conjWorkPiece);
        } else {
            inCrit.createCriteria("workpiece", "werk");
            inCrit.createAlias("werk.eigenschaften", "werkeig");
            inCrit.add(conjWorkPiece);
        }
    }
    if (conjUsers != null) {
        if (flagSteps) {
            critProcess.createCriteria("processingUser", "processingUser");
            critProcess.add(conjUsers);
        } else {
            inCrit.createAlias("steps.processingUser", "processingUser");
            inCrit.add(conjUsers);
        }
    }
    if (conjBatches != null) {
        if (flagSteps) {
            critProcess.createCriteria("batches", "bat");
            critProcess.add(conjBatches);
        } else {
            crit.createCriteria("batches", "bat");
            inCrit.add(conjBatches);
        }
    }
    return message;
}

From source file:org.goobi.production.flow.statistics.hibernate.FilterHelper.java

License:Open Source License

/**
 * Create historic filer./*from w w w  .  j a v a 2 s.  c o m*/
 *
 * @param conjSteps
 *            Conjunction object
 * @param filterPart
 *            String
 * @return empty string
 */
private static String createHistoricFilter(Conjunction conjSteps, String filterPart, Boolean stepCriteria) {
    /* filtering by a certain minimal status */
    Integer stepReihenfolge;

    String stepTitle = filterPart.substring(filterPart.indexOf(":") + 1);
    // if the criteria is build on steps the table need not be identified
    String tableIdentifier;
    if (stepCriteria) {
        tableIdentifier = "";
    } else {
        tableIdentifier = "steps.";
    }
    try {
        stepReihenfolge = Integer.parseInt(stepTitle);
    } catch (NumberFormatException e) {
        stepTitle = filterPart.substring(filterPart.indexOf(":") + 1);
        if (stepTitle.startsWith("-")) {
            stepTitle = stepTitle.substring(1);
            conjSteps.add(Restrictions.and(
                    Restrictions.not(Restrictions.like(tableIdentifier + "title", "%" + stepTitle + "%")),
                    Restrictions.ge(tableIdentifier + "processingStatus", TaskStatus.OPEN.getValue())));
            return "";
        } else {
            conjSteps.add(Restrictions.and(Restrictions.like(tableIdentifier + "title", "%" + stepTitle + "%"),
                    Restrictions.ge(tableIdentifier + "processingStatus", TaskStatus.OPEN.getValue())));
            return "";
        }
    }
    conjSteps.add(Restrictions.and(Restrictions.eq(tableIdentifier + "ordering", stepReihenfolge),
            Restrictions.ge(tableIdentifier + "processingStatus", TaskStatus.OPEN.getValue())));
    return "";
}

From source file:org.grails.datastore.gorm.hibernate.query.HibernateQuery.java

License:Apache License

@Override
public Junction negation() {
    final org.hibernate.criterion.Disjunction disjunction = Restrictions.disjunction();
    criteria.add(Restrictions.not(disjunction));

    return new HibernateJunction(disjunction);
}

From source file:org.headsupdev.agile.storage.HibernateStorage.java

License:Open Source License

protected Criteria getProjectCriteria(Session session, boolean disabled, Set<String> ids) {
    Criteria criteria = session.createCriteria(Project.class);
    criteria.add(Restrictions.not(Restrictions.eq("id", Project.ALL_PROJECT_ID)));
    criteria.add(Restrictions.isNull("parent"));

    if (!disabled) {
        criteria.add(Restrictions.or(Restrictions.isNull("disabled"), Restrictions.eq("disabled", false)));
    }//  ww w. j  a  va 2 s.  c  o m

    if (ids != null) {
        criteria.add(Restrictions.in("id", ids));
    }

    criteria.addOrder(Order.asc("name"));
    return criteria;
}

From source file:org.hoteia.qalingo.core.dao.ProductDao.java

License:Apache License

public List<ProductSku> findProductSkusNotInThisVirtualCatalogCategoryId(final Long categoryId,
        Object... params) {//w  w  w  . j  a va  2s.  c  om
    Criteria criteriaSubListId = createDefaultCriteria(ProductSku.class);
    criteriaSubListId.createAlias("catalogCategoryVirtualProductSkuRels", "catalogCategoryProductSkuRel",
            JoinType.LEFT_OUTER_JOIN);
    criteriaSubListId
            .add(Restrictions.eq("catalogCategoryProductSkuRel.pk.catalogCategoryVirtual.id", categoryId));
    //        criteriaSubListId.setProjection(Projections.property("id"));

    @SuppressWarnings("unchecked")
    List<ProductSku> subProductSkus = criteriaSubListId.list();

    List<Long> productSkuIds = new ArrayList<Long>();
    for (Iterator<ProductSku> iterator = subProductSkus.iterator(); iterator.hasNext();) {
        ProductSku productSku = (ProductSku) iterator.next();
        productSkuIds.add(productSku.getId());
    }

    Criteria criteria = createDefaultCriteria(ProductSku.class);
    handleSpecificProductSkuFetchMode(criteria, params);
    criteria.add(Restrictions.not(Restrictions.in("id", productSkuIds)));

    criteria.addOrder(Order.asc("id"));

    @SuppressWarnings("unchecked")
    List<ProductSku> productSkus = criteria.list();
    return productSkus;
}

From source file:org.hsqldb.hibernate.geomajas.layer.hibernate.CriteriaVisitor.java

License:Open Source License

/** {@inheritDoc} */
public Object visit(Not filter, Object userData) {
    Criterion c = (Criterion) filter.getFilter().accept(this, userData);
    return Restrictions.not(c);
}

From source file:org.hsqldb.hibernate.geomajas.layer.hibernate.CriteriaVisitor.java

License:Open Source License

/** {@inheritDoc} */
public Object visit(ExcludeFilter filter, Object userData) {
    return Restrictions.not(Restrictions.conjunction());
}

From source file:org.hyperic.hq.authz.server.session.AuthzSubjectDAO.java

License:Open Source License

public Collection findAll_order(boolean isRoot, String col, boolean asc, Collection excludes) {
    Criteria criteria = createCriteria();

    if (isRoot) {
        Disjunction disjunctions = Restrictions.disjunction();
        disjunctions.add(Restrictions.eq("system", Boolean.FALSE));
        disjunctions.add(Restrictions.eq("id", AuthzConstants.rootSubjectId));
        criteria.add(disjunctions);/*from  w ww .  j av  a2s .c  om*/
    } else {
        criteria.add(Restrictions.eq("system", Boolean.FALSE));
    }

    criteria.addOrder(asc ? Order.asc(col) : Order.desc(col));

    if (excludes != null && excludes.size() > 0) {
        criteria.add(Restrictions.not(Restrictions.in("id", excludes)));
    }

    return criteria.list();

}

From source file:org.infoglue.calendar.controllers.EventController.java

License:Open Source License

/**
 * Gets a list of all events available for a particular user.
 * @return List of Event/*from  w  w w . j  a  va  2  s  .  c om*/
 * @throws Exception
 */

public Set getEventList(java.util.Calendar startDate, java.util.Calendar endDate, String userName, List roles,
        List groups, Integer stateId, boolean includeLinked, boolean includeEventsCreatedByUser,
        Session session) throws Exception {
    List result = new ArrayList();

    if (includeLinked == true) {
        String rolesSQL = getRoleSQL(roles);
        log.info("groups:" + groups.size());
        String groupsSQL = getGroupsSQL(groups);
        log.info("groupsSQL:" + groupsSQL);
        String sql = "select c from Calendar c, Role cr, Group g where cr.calendar = c AND g.calendar = c "
                + (rolesSQL != null ? " AND cr.name IN " + rolesSQL : "")
                + (groupsSQL != null ? " AND g.name IN " + groupsSQL : "") + " order by c.id";
        //String sql = "select distinct c from Calendar c, Role cr, Group g where cr.calendar = c AND g.calendar = c " + (rolesSQL != null ? " AND cr.name IN " + rolesSQL : "") + (groupsSQL != null ? " AND g.name IN " + groupsSQL : "") + " order by c.id";
        log.info("sql:" + sql);
        Query q = session.createQuery(sql);
        setRoleNames(0, q, roles);
        setGroupNames(roles.size(), q, groups);
        List calendars = q.list();

        Object[] calendarIdArray = new Object[calendars.size()];

        int i = 0;
        Iterator calendarsIterator = calendars.iterator();
        while (calendarsIterator.hasNext()) {
            Calendar calendar = (Calendar) calendarsIterator.next();
            log.info("calendar: " + calendar.getName());
            calendarIdArray[i] = calendar.getId();
            i++;
        }

        if (calendarIdArray.length > 0) {
            Criteria criteria = session.createCriteria(Event.class);
            criteria.add(Restrictions.eq("stateId", stateId));
            criteria.add(Expression.gt("endDateTime", startDate));
            criteria.addOrder(Order.asc("startDateTime"));

            /*
            criteria.add(Expression.gt("endDateTime", endDate));
            criteria.add(Expression.lt("startDateTime", startDate));
            */
            criteria.createCriteria("owningCalendar")
                    .add(Restrictions.not(Restrictions.in("id", calendarIdArray)));

            criteria.createCriteria("calendars").add(Restrictions.in("id", calendarIdArray));

            result = criteria.list();
        }

    } else {
        String rolesSQL = getRoleSQL(roles);
        log.info("groups:" + groups.size());
        String groupsSQL = getGroupsSQL(groups);
        log.info("groupsSQL:" + groupsSQL);
        String sql = "select event from Event event, Calendar c, Role cr, Group g where event.owningCalendar = c AND cr.calendar = c AND g.calendar = c AND event.stateId = ? AND event.endDateTime >= ? "
                + (rolesSQL != null ? " AND cr.name IN " + rolesSQL : "")
                + (groupsSQL != null ? " AND g.name IN " + groupsSQL : "") + " order by event.startDateTime";
        //String sql = "select distinct event from Event event, Calendar c, Role cr, Group g where event.owningCalendar = c AND cr.calendar = c AND g.calendar = c AND event.stateId = ? AND event.endDateTime >= ? " + (rolesSQL != null ? " AND cr.name IN " + rolesSQL : "") + (groupsSQL != null ? " AND g.name IN " + groupsSQL : "") + " order by event.startDateTime";
        log.info("sql:" + sql);
        Query q = session.createQuery(sql);
        q.setInteger(0, stateId.intValue());
        q.setCalendar(1, startDate);
        log.info("startDate:" + startDate.getTime());
        setRoleNames(2, q, roles);
        /*
        q.setCalendar(1, startDate);
        q.setCalendar(2, endDate);
        setRoleNames(3, q, roles);
        */
        setGroupNames(roles.size() + 2, q, groups);

        result = q.list();
    }

    log.info("result:" + result.size());

    Set set = new LinkedHashSet();
    set.addAll(result);

    if (includeEventsCreatedByUser) {
        Criteria criteria = session.createCriteria(Event.class);
        criteria.add(Restrictions.eq("stateId", stateId));
        criteria.add(Restrictions.eq("creator", userName));
        criteria.add(Expression.gt("endDateTime", startDate));
        criteria.addOrder(Order.asc("startDateTime"));

        /*
        criteria.add(Expression.gt("endDateTime", endDate));
        criteria.add(Expression.lt("startDateTime", startDate));
        */

        set.addAll(criteria.list());
    }
    List sortedList = new ArrayList();
    sortedList.addAll(set);

    Collections.sort(sortedList, new EventComparator());
    set.clear();

    set.addAll(sortedList);

    return set;
}