Example usage for org.hibernate.criterion Restrictions isNull

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

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

Introduction

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

Prototype

public static Criterion isNull(String propertyName)

Source Link

Document

Apply an "is null" constraint to the named property

Usage

From source file:gov.nih.nci.caarray.validation.UniqueConstraintValidator.java

License:BSD License

/**
 * {@inheritDoc}//from w  w w  .  j a v  a  2s . co  m
 */
@SuppressWarnings({ "PMD.CyclomaticComplexity", "PMD.ExcessiveMethodLength" })
public boolean isValid(final Object o) {
    UnfilteredCallback unfilteredCallback = new UnfilteredCallback() {
        public Object doUnfiltered(Session s) {
            FlushMode fm = s.getFlushMode();
            try {
                s.setFlushMode(FlushMode.MANUAL);
                Class<?> classWithConstraint = findClassDeclaringConstraint(
                        hibernateHelper.unwrapProxy(o).getClass());
                Criteria crit = s.createCriteria(classWithConstraint);
                ClassMetadata metadata = hibernateHelper.getSessionFactory()
                        .getClassMetadata(classWithConstraint);
                for (UniqueConstraintField field : uniqueConstraint.fields()) {
                    Object fieldVal = metadata.getPropertyValue(o, field.name(), EntityMode.POJO);
                    if (fieldVal == null) {
                        if (field.nullsEqual()) {
                            // nulls are equal, so add it to to criteria
                            crit.add(Restrictions.isNull(field.name()));
                        } else {
                            // nulls are never equal, so uniqueness is automatically satisfied
                            return true;
                        }
                    } else {
                        // special casing for entity-type properties - only include them in the criteria if they are
                        // already
                        // persistent
                        // otherwise, short-circuit the process and return true immediately since if the
                        // entity-type property
                        // is not persistent then it will be a new value and thus different from any currently in 
                        // the db, thus satisfying uniqueness
                        ClassMetadata fieldMetadata = hibernateHelper.getSessionFactory()
                                .getClassMetadata(hibernateHelper.unwrapProxy(fieldVal).getClass());
                        if (fieldMetadata == null
                                || fieldMetadata.getIdentifier(fieldVal, EntityMode.POJO) != null) {
                            crit.add(Restrictions.eq(field.name(),
                                    ReflectHelper.getGetter(o.getClass(), field.name()).get(o)));
                        } else {
                            return true;
                        }
                    }
                }
                // if object is already persistent, then add condition to exclude it matching itself
                Object id = metadata.getIdentifier(o, EntityMode.POJO);
                if (id != null) {
                    crit.add(Restrictions.ne(metadata.getIdentifierPropertyName(), id));
                }

                int numMatches = crit.list().size();
                return numMatches == 0;
            } finally {
                s.setFlushMode(fm);
            }
        }
    };
    return (Boolean) hibernateHelper.doUnfiltered(unfilteredCallback);

}

From source file:gr.abiss.calipso.domain.ColumnHeading.java

License:Open Source License

/**
 * this routine is a massive if-then construct that acts as a factory for
 * the right implementation of the responsibilities defined in the
 * "Processor" class (above) based on the type of ColumnHeading - the right
 * implementation will be returned. having everything in one place below,
 * makes it easy to maintain, as the logic of each of the methods are
 * closely interdependent for a given column type for e.g. the kind of
 * hibernate criteria needed depends on what is made available on the UI
 */// ww w. j a v a 2s  .  c o  m
private Processor getProcessor() {
    if (isField()) {
        switch (field.getName().getType()) {
        // ==============================================================

        case 1:
        case 2:
        case 3:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    final Fragment fragment = new Fragment("fragParent", "multiSelect", container);
                    //final Map<String, String> options = field.getOptions();
                    List<CustomAttributeLookupValue> lookupValues = calipsoService.findLookupValues(space,
                            field.getName().getText());
                    // TODO: create a leaf-node only finder method in calipso service
                    List<CustomAttributeLookupValue> leafLookupValues = new LinkedList<CustomAttributeLookupValue>();

                    // leaf selection only for now
                    for (CustomAttributeLookupValue val : lookupValues) {
                        if (CollectionUtils.isEmpty(val.getChildren())) {
                            leafLookupValues.add(val);
                        }
                    }
                    lookupValues = null;

                    final CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values", leafLookupValues,
                            new IChoiceRenderer<CustomAttributeLookupValue>() {

                                @Override
                                public Object getDisplayValue(CustomAttributeLookupValue object) {
                                    return fragment.getString(object.getNameTranslationResourceKey());
                                }

                                @Override
                                public String getIdValue(CustomAttributeLookupValue object, int index) {
                                    return object.getId() + "";
                                }
                            });
                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValueList()) {
                        List values = filterCriteria.getValues();
                        List<Integer> keys = new ArrayList<Integer>(values.size());
                        for (Object o : values) {
                            if (o instanceof CustomAttributeLookupValue) {
                                CustomAttributeLookupValue val = (CustomAttributeLookupValue) o;
                                keys.add(NumberUtils.createInteger(val.getId() + ""));
                            } else {
                                keys.add(NumberUtils.createInteger(o + ""));
                            }
                        }
                        criteria.add(Restrictions.in(getNameText(), keys));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValueList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueListFromQueryString(s);
                }
            };
        // ==============================================================
        case 4: // decimal number
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(EQ, NOT_EQ, GT, LT, BETWEEN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "textField", container);
                    TextField textField = new TextField("value", Double.class);
                    textField.setModel(new PropertyModel(filterCriteria, "value"));
                    fragment.add(textField);
                    if (filterCriteria.getExpression() == BETWEEN) {
                        TextField textField2 = new TextField("value2", Double.class);
                        textField2.setModel(new PropertyModel(filterCriteria, "value2"));
                        fragment.add(textField2);
                    } else {
                        fragment.add(new WebMarkupContainer("value2").setVisible(false));
                    }
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        Object value = filterCriteria.getValue();
                        switch (filterCriteria.getExpression()) {
                        case EQ:
                            criteria.add(Restrictions.eq(getNameText(), value));
                            break;
                        case NOT_EQ:
                            criteria.add(Restrictions.not(Restrictions.eq(name.text, value)));
                            break;
                        case GT:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            break;
                        case LT:
                            criteria.add(Restrictions.lt(getNameText(), value));
                            break;
                        case BETWEEN:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            criteria.add(Restrictions.lt(getNameText(), filterCriteria.getValue2()));
                            break;
                        default:
                        }
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(Double.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, Double.class);
                }

            };
        // ==============================================================
        case 6: // date
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(EQ, NOT_EQ, GT, LT, BETWEEN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "dateField", container);
                    DateField calendar = new DateField("value",
                            new PropertyModel(filterCriteria, "value")/*,
                                                                      false*/);
                    fragment.add(calendar);
                    if (filterCriteria.getExpression() == BETWEEN) {
                        DateField calendar2 = new DateField("value2",
                                new PropertyModel(filterCriteria, "value2")/*,
                                                                           false*/);
                        fragment.add(calendar2);
                    } else {
                        fragment.add(new WebMarkupContainer("value2").setVisible(false));
                    }
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        Object value = filterCriteria.getValue();
                        switch (filterCriteria.getExpression()) {
                        case EQ:
                            criteria.add(Restrictions.eq(getNameText(), value));
                            break;
                        case NOT_EQ:
                            criteria.add(Restrictions.not(Restrictions.eq(getNameText(), value)));
                            break;
                        case GT:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            break;
                        case LT:
                            criteria.add(Restrictions.lt(getNameText(), value));
                            break;
                        case BETWEEN:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            criteria.add(Restrictions.lt(getNameText(), filterCriteria.getValue2()));
                            break;
                        default:
                        }
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(Date.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, Date.class);
                }
            };
        // ==============================================================
        case 5: // free text
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        // TODO:
        case 10:// organization
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        // TODO:
        case 11:// file
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        case 200:// attachment
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        case 20:// is user
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };

        case 25:// is user
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        case 100: // Assignable spaces (move to space)
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "multiSelect", container);
                    final Map<String, String> options = field.getOptions();
                    List<String> keys = null;
                    if (options != null) {
                        keys = new ArrayList(options.keySet()); // bound
                        // value
                    } else {
                        keys = new ArrayList();
                    }

                    List<Space> spaces = new LinkedList<Space>();
                    for (String key : keys) {
                        // spaces.add(ComponentUtils.getJtrac(c).loadSpace(Long.parseLong(key)));
                        spaces.add(calipsoService.loadSpace(Long.parseLong(key)));
                    } // for
                    CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values", spaces,
                            new IChoiceRenderer<Space>() {
                                private static final long serialVersionUID = 1L;

                                @Override
                                public Object getDisplayValue(Space o) {
                                    logger.info("Option for space: " + o);
                                    String name = o.getName();
                                    return name != null ? name : o.getId();
                                }

                                @Override
                                public String getIdValue(Space o, int index) {
                                    return o.getId() + "";
                                }
                            });

                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValueList()) {
                        List values = filterCriteria.getValues();
                        criteria.add(Restrictions.in(getNameText(), values));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValueList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueListFromQueryString(s);
                }
            };
        // ==============================================================
        default:
            throw new RuntimeException("Unknown Column Heading " + name);
        }
    } else { // this is not a custom field but one of the "built-in" columns
        switch (name) {
        // ==============================================================
        case ID:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(EQ);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        // should never come here for criteria: see
                        // ItemSearch#getRefId()
                        throw new RuntimeException("should not come here for 'id'");
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        // ==============================================================
        case SUMMARY:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        criteria.add(Restrictions.ilike(getNameText(), (String) filterCriteria.getValue(),
                                MatchMode.ANYWHERE));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };
        // ==============================================================
        case DETAIL:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(CONTAINS);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    return getTextFieldFragment(container);
                }

                void addRestrictions(DetachedCriteria criteria) {
                    // do nothing, 'detail' already processed, see:
                    // ItemSearch#getSearchText()
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(String.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, String.class);
                }
            };

        // ==============================================================
        case STATUS:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "multiSelect", container);
                    // status selectable only when context space is not null
                    // final Map<Integer, String> options =
                    // space.getMetadata().getStatesMap();
                    final Map<Integer, String> options;
                    if (space == null) {
                        options = State.getSpecialStates();
                    } else {
                        options = space.getMetadata().getStatesMap();
                    }
                    options.remove(State.NEW);
                    CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values",
                            new ArrayList(options.keySet()), new IChoiceRenderer() {
                                public Object getDisplayValue(Object o) {
                                    return options.get(o);
                                }

                                public String getIdValue(Object o, int i) {
                                    return o.toString();
                                }
                            });
                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValueList()) {
                        criteria.add(Restrictions.in(getNameText(), filterCriteria.getValues()));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValueList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    //logger.info("loadFromQueryString: "+s);
                    setStatusListFromQueryString(s);
                }
            };
        // ==============================================================
        case ASSIGNED_TO:
        case LOGGED_BY:
        case REPORTED_BY:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN, IS_NULL);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "multiSelect", container);
                    List<User> users = null;
                    if (space == null) {
                        users = calipsoService.findUsersForUser(user);
                    } else {
                        users = calipsoService.findUsersForSpace(space.getId());
                    }
                    CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values", users,
                            new IChoiceRenderer() {
                                public Object getDisplayValue(Object o) {
                                    return ((User) o).getFullName();
                                }

                                public String getIdValue(Object o, int i) {
                                    return ((User) o).getId() + "";
                                }
                            });
                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValueList()) {
                        criteria.add(Restrictions.in(getNameText(), filterCriteria.getValues()));
                    } else if (filterIsNullExpression()) {
                        criteria.add(Restrictions.isNull(getNameText()));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromUserList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setUserListFromQueryString(s, calipsoService);
                }
            };
        // ==============================================================

        case ASSET_TYPE:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "multiSelect", container);

                    List<AssetType> assetTypes = calipsoService.findAllAssetTypes();
                    CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values", assetTypes,
                            new IChoiceRenderer() {
                                public Object getDisplayValue(Object o) {
                                    return ((AssetType) o).getName();
                                }

                                public String getIdValue(Object o, int i) {
                                    return String.valueOf(((AssetType) o).getId());
                                }
                            });
                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));

                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValueList()) {
                        criteria.createAlias("assets", "assets");
                        criteria.add(Restrictions.in("assets.assetType", filterCriteria.getValues()));
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromAssetTypeList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setAssetTypeListFromQueryString(s, user, calipsoService);
                }
            };
        // ==============================================================
        case TIME_STAMP:
        case DUE_TO:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(BETWEEN, GT, LT, EQ, NOT_EQ);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "dateField", container);
                    DateField calendar = new DateField("value",
                            new PropertyModel(filterCriteria, "value")/*,
                                                                      false*/);
                    fragment.add(calendar);
                    if (filterCriteria.getExpression() == BETWEEN) {
                        DateField calendar2 = new DateField("value2",
                                new PropertyModel(filterCriteria, "value2")/*,
                                                                           false*/);
                        fragment.add(calendar2);
                    } else {
                        fragment.add(new WebMarkupContainer("value2").setVisible(false));
                    }
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        Object value = filterCriteria.getValue();
                        switch (filterCriteria.getExpression()) {
                        case EQ:
                            criteria.add(Restrictions.eq(getNameText(), value));
                            break;
                        case NOT_EQ:
                            criteria.add(Restrictions.not(Restrictions.eq(getNameText(), value)));
                            break;
                        case GT:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            break;
                        case LT:
                            criteria.add(Restrictions.lt(getNameText(), value));
                            break;
                        case BETWEEN:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            criteria.add(Restrictions.lt(getNameText(), filterCriteria.getValue2()));
                            break;
                        default:
                        }
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(Date.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, Date.class);
                }
            };
        // ==============================================================
        case SPACE:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(IN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "multiSelect", container);
                    List<Space> spaces = new ArrayList(user.getSpaces());
                    CheckBoxMultipleChoice choice = new CheckBoxMultipleChoice("values", spaces,
                            new IChoiceRenderer() {
                                public Object getDisplayValue(Object o) {
                                    return ((Space) o).getName();
                                }

                                public String getIdValue(Object o, int i) {
                                    return ((Space) o).getId() + "";
                                }
                            });
                    fragment.add(choice);
                    choice.setModel(new PropertyModel(filterCriteria, "values"));
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    // already handled space as special case, see
                    // ItemSearch#getSelectedSpaces()
                }

                String getAsQueryString() {
                    return getQueryStringFromSpaceList();
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setSpaceListFromQueryString(s, user, calipsoService);
                }
            };

        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        case TOTAL_RESPONSE_TIME:
        case TIME_FROM_CREATION_TO_FIRST_REPLY:
        case TIME_FROM_CREATION_TO_CLOSE:
            return new ProcessorCustom() {
                private Class validationClass = null;

                List<Expression> getValidFilterExpressions() {
                    return getAsList(BETWEEN, GT, LT);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "effortField", container);
                    WebMarkupContainer days = new WebMarkupContainer("days");

                    if (name.equals(TOTAL_RESPONSE_TIME)) {
                        validationClass = Double.class;
                    } else {
                        validationClass = Long.class;
                    }

                    TextField textField = new TextField("value", validationClass);
                    days.add(textField);
                    // textField.setModel(new PropertyModel(this,
                    // "filterCriteria.value"));
                    textField.setModel(new PropertyModel(filterCriteria, "value"));
                    fragment.add(days);

                    WebMarkupContainer days2 = new WebMarkupContainer("days2");
                    if (filterCriteria.getExpression() == BETWEEN) {
                        TextField textField2 = new TextField("value2", validationClass);
                        days2.add(textField2);
                        // textField2.setModel(new PropertyModel(this,
                        // "filterCriteria.value2"));
                        textField2.setModel(new PropertyModel(filterCriteria, "value2"));
                    } // if
                    else {
                        fragment.add(new WebMarkupContainer("value2").setVisible(false));
                        days2.setVisible(false);
                    } // else
                    fragment.add(days2);
                    // fragment.setVisible(isVisible());
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                }

                void addRestrictions(CustomCriteria customCriteria) {
                    if (filterHasValue()) {
                        String criteriaObjectClass = null;
                        if (validationClass != null) {
                            criteriaObjectClass = validationClass.getCanonicalName();
                        } // if

                        Object value = filterCriteria.getValue();
                        Object value2 = filterCriteria.getValue2();

                        Double v1 = new Double(value.toString());
                        value = v1 * 86400;// In Seconds
                        switch (filterCriteria.getExpression()) {
                        case GT:
                            customCriteria.add(name.getText(), CustomCriteria.GT, value.toString(),
                                    criteriaObjectClass);
                            break;
                        case LT:
                            customCriteria.add(name.getText(), CustomCriteria.LT, value.toString(),
                                    criteriaObjectClass);
                            break;
                        case BETWEEN:
                            Double v2 = new Double(value2.toString());
                            value2 = v2 * 86400; // In Seconds
                            customCriteria.add(name.getText(), CustomCriteria.GET, value.toString(),
                                    criteriaObjectClass);
                            customCriteria.add(name.getText(), CustomCriteria.LET, value2.toString(),
                                    criteriaObjectClass);
                            break;
                        default:
                        }
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(Long.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, Long.class);
                }
            };

        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        case PLANNED_EFFORT:
            return new Processor() {
                List<Expression> getValidFilterExpressions() {
                    return getAsList(EQ, NOT_EQ, GT, LT, BETWEEN);
                }

                Fragment getFilterUiFragment(MarkupContainer container, User user, Space space,
                        CalipsoService calipsoService) {
                    Fragment fragment = new Fragment("fragParent", "effortField2", container);
                    EffortField effortField = new EffortField("value",
                            new PropertyModel(filterCriteria, "value"), false);
                    fragment.add(effortField);
                    if (filterCriteria.getExpression() == BETWEEN) {
                        EffortField effortField2 = new EffortField("value2",
                                new PropertyModel(filterCriteria, "value2"), false);
                        fragment.add(new WebMarkupContainer("and"));
                        fragment.add(effortField2);
                    } else {
                        fragment.add(new WebMarkupContainer("and").setVisible(false));
                        fragment.add(new WebMarkupContainer("value2").setVisible(false));
                    }
                    return fragment;
                }

                void addRestrictions(DetachedCriteria criteria) {
                    if (filterHasValue()) {
                        Object value = filterCriteria.getValue();
                        switch (filterCriteria.getExpression()) {
                        case EQ:
                            criteria.add(Restrictions.eq(getNameText(), value));
                            break;
                        case NOT_EQ:
                            criteria.add(Restrictions.not(Restrictions.eq(getNameText(), value)));
                            break;
                        case GT:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            break;
                        case LT:
                            criteria.add(Restrictions.lt(getNameText(), value));
                            break;
                        case BETWEEN:
                            criteria.add(Restrictions.gt(getNameText(), value));
                            criteria.add(Restrictions.lt(getNameText(), filterCriteria.getValue2()));
                            break;
                        default:
                        }
                    }
                }

                String getAsQueryString() {
                    return getQueryStringFromValue(Integer.class);
                }

                void loadFromQueryString(String s, User user, CalipsoService calipsoService) {
                    setValueFromQueryString(s, Integer.class);
                }
            };

        // ==============================================================
        default:
            throw new RuntimeException("Unknown Column Heading " + name);
        }
    }
}

From source file:grails.orm.HibernateCriteriaBuilder.java

License:Apache License

public org.grails.datastore.mapping.query.api.Criteria isNull(String property) {
    String propertyName = calculatePropertyName(property);
    addToCriteria(Restrictions.isNull(propertyName));
    return this;

}

From source file:grails.orm.HibernateCriteriaBuilder.java

License:Apache License

@SuppressWarnings("rawtypes")
@Override//w  ww .j a  va 2s .  co  m
public Object invokeMethod(String name, Object obj) {
    Object[] args = obj.getClass().isArray() ? (Object[]) obj : new Object[] { obj };

    if (paginationEnabledList && SET_RESULT_TRANSFORMER_CALL.equals(name) && args.length == 1
            && args[0] instanceof ResultTransformer) {
        resultTransformer = (ResultTransformer) args[0];
        return null;
    }

    if (isCriteriaConstructionMethod(name, args)) {
        if (criteria != null) {
            throwRuntimeException(new IllegalArgumentException("call to [" + name + "] not supported here"));
        }

        if (name.equals(GET_CALL)) {
            uniqueResult = true;
        } else if (name.equals(SCROLL_CALL)) {
            scroll = true;
        } else if (name.equals(COUNT_CALL)) {
            count = true;
        } else if (name.equals(LIST_DISTINCT_CALL)) {
            resultTransformer = CriteriaSpecification.DISTINCT_ROOT_ENTITY;
        }

        createCriteriaInstance();

        // Check for pagination params
        if (name.equals(LIST_CALL) && args.length == 2) {
            paginationEnabledList = true;
            orderEntries = new ArrayList<Order>();
            invokeClosureNode(args[1]);
        } else {
            invokeClosureNode(args[0]);
        }

        if (resultTransformer != null) {
            criteria.setResultTransformer(resultTransformer);
        }
        Object result;
        if (!uniqueResult) {
            if (scroll) {
                result = criteria.scroll();
            } else if (count) {
                criteria.setProjection(Projections.rowCount());
                result = criteria.uniqueResult();
            } else if (paginationEnabledList) {
                // Calculate how many results there are in total. This has been
                // moved to before the 'list()' invocation to avoid any "ORDER
                // BY" clause added by 'populateArgumentsForCriteria()', otherwise
                // an exception is thrown for non-string sort fields (GRAILS-2690).
                criteria.setFirstResult(0);
                criteria.setMaxResults(Integer.MAX_VALUE);
                criteria.setProjection(Projections.rowCount());
                int totalCount = ((Number) criteria.uniqueResult()).intValue();

                // Restore the previous projection, add settings for the pagination parameters,
                // and then execute the query.
                if (projectionList != null && projectionList.getLength() > 0) {
                    criteria.setProjection(projectionList);
                } else {
                    criteria.setProjection(null);
                }
                for (Order orderEntry : orderEntries) {
                    criteria.addOrder(orderEntry);
                }
                if (resultTransformer == null) {
                    criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
                } else if (paginationEnabledList) {
                    // relevant to GRAILS-5692
                    criteria.setResultTransformer(resultTransformer);
                }
                // GRAILS-7324 look if we already have association to sort by
                Map argMap = (Map) args[0];
                final String sort = (String) argMap.get(GrailsHibernateUtil.ARGUMENT_SORT);
                if (sort != null) {
                    boolean ignoreCase = true;
                    Object caseArg = argMap.get(GrailsHibernateUtil.ARGUMENT_IGNORE_CASE);
                    if (caseArg instanceof Boolean) {
                        ignoreCase = (Boolean) caseArg;
                    }
                    final String orderParam = (String) argMap.get(GrailsHibernateUtil.ARGUMENT_ORDER);
                    final String order = GrailsHibernateUtil.ORDER_DESC.equalsIgnoreCase(orderParam)
                            ? GrailsHibernateUtil.ORDER_DESC
                            : GrailsHibernateUtil.ORDER_ASC;
                    int lastPropertyPos = sort.lastIndexOf('.');
                    String associationForOrdering = lastPropertyPos >= 0 ? sort.substring(0, lastPropertyPos)
                            : null;
                    if (associationForOrdering != null && aliasMap.containsKey(associationForOrdering)) {
                        addOrder(criteria, aliasMap.get(associationForOrdering) + "."
                                + sort.substring(lastPropertyPos + 1), order, ignoreCase);
                        // remove sort from arguments map to exclude from default processing.
                        @SuppressWarnings("unchecked")
                        Map argMap2 = new HashMap(argMap);
                        argMap2.remove(GrailsHibernateUtil.ARGUMENT_SORT);
                        argMap = argMap2;
                    }
                }
                GrailsHibernateUtil.populateArgumentsForCriteria(grailsApplication, targetClass, criteria,
                        argMap);
                PagedResultList pagedRes = new PagedResultList(criteria.list());

                // Updated the paged results with the total number of records calculated previously.
                pagedRes.setTotalCount(totalCount);
                result = pagedRes;
            } else {
                result = criteria.list();
            }
        } else {
            result = GrailsHibernateUtil.unwrapIfProxy(criteria.uniqueResult());
        }
        if (!participate) {
            hibernateSession.close();
        }
        return result;
    }

    if (criteria == null)
        createCriteriaInstance();

    MetaMethod metaMethod = getMetaClass().getMetaMethod(name, args);
    if (metaMethod != null) {
        return metaMethod.invoke(this, args);
    }

    metaMethod = criteriaMetaClass.getMetaMethod(name, args);
    if (metaMethod != null) {
        return metaMethod.invoke(criteria, args);
    }
    metaMethod = criteriaMetaClass.getMetaMethod(GrailsClassUtils.getSetterName(name), args);
    if (metaMethod != null) {
        return metaMethod.invoke(criteria, args);
    }

    if (isAssociationQueryMethod(args) || isAssociationQueryWithJoinSpecificationMethod(args)) {
        final boolean hasMoreThanOneArg = args.length > 1;
        Object callable = hasMoreThanOneArg ? args[1] : args[0];
        int joinType = hasMoreThanOneArg ? (Integer) args[0] : CriteriaSpecification.INNER_JOIN;

        if (name.equals(AND) || name.equals(OR) || name.equals(NOT)) {
            if (criteria == null) {
                throwRuntimeException(
                        new IllegalArgumentException("call to [" + name + "] not supported here"));
            }

            logicalExpressionStack.add(new LogicalExpression(name));
            invokeClosureNode(callable);

            LogicalExpression logicalExpression = logicalExpressionStack
                    .remove(logicalExpressionStack.size() - 1);
            addToCriteria(logicalExpression.toCriterion());

            return name;
        }

        if (name.equals(PROJECTIONS) && args.length == 1 && (args[0] instanceof Closure)) {
            if (criteria == null) {
                throwRuntimeException(
                        new IllegalArgumentException("call to [" + name + "] not supported here"));
            }

            projectionList = Projections.projectionList();
            invokeClosureNode(callable);

            if (projectionList != null && projectionList.getLength() > 0) {
                criteria.setProjection(projectionList);
            }

            return name;
        }

        final PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(targetClass, name);
        if (pd != null && pd.getReadMethod() != null) {
            ClassMetadata meta = sessionFactory.getClassMetadata(targetClass);
            Type type = meta.getPropertyType(name);
            if (type.isAssociationType()) {
                String otherSideEntityName = ((AssociationType) type)
                        .getAssociatedEntityName((SessionFactoryImplementor) sessionFactory);
                Class oldTargetClass = targetClass;
                targetClass = sessionFactory.getClassMetadata(otherSideEntityName)
                        .getMappedClass(EntityMode.POJO);
                if (targetClass.equals(oldTargetClass) && !hasMoreThanOneArg) {
                    joinType = CriteriaSpecification.LEFT_JOIN; // default to left join if joining on the same table
                }
                associationStack.add(name);
                final String associationPath = getAssociationPath();
                createAliasIfNeccessary(name, associationPath, joinType);
                // the criteria within an association node are grouped with an implicit AND
                logicalExpressionStack.add(new LogicalExpression(AND));
                invokeClosureNode(callable);
                aliasStack.remove(aliasStack.size() - 1);
                if (!aliasInstanceStack.isEmpty()) {
                    aliasInstanceStack.remove(aliasInstanceStack.size() - 1);
                }
                LogicalExpression logicalExpression = logicalExpressionStack
                        .remove(logicalExpressionStack.size() - 1);
                if (!logicalExpression.args.isEmpty()) {
                    addToCriteria(logicalExpression.toCriterion());
                }
                associationStack.remove(associationStack.size() - 1);
                targetClass = oldTargetClass;

                return name;
            }
        }
    } else if (args.length == 1 && args[0] != null) {
        if (criteria == null) {
            throwRuntimeException(new IllegalArgumentException("call to [" + name + "] not supported here"));
        }

        Object value = args[0];
        Criterion c = null;
        if (name.equals(ID_EQUALS)) {
            return eq("id", value);
        }

        if (name.equals(IS_NULL) || name.equals(IS_NOT_NULL) || name.equals(IS_EMPTY)
                || name.equals(IS_NOT_EMPTY)) {
            if (!(value instanceof String)) {
                throwRuntimeException(new IllegalArgumentException(
                        "call to [" + name + "] with value [" + value + "] requires a String value."));
            }
            String propertyName = calculatePropertyName((String) value);
            if (name.equals(IS_NULL)) {
                c = Restrictions.isNull(propertyName);
            } else if (name.equals(IS_NOT_NULL)) {
                c = Restrictions.isNotNull(propertyName);
            } else if (name.equals(IS_EMPTY)) {
                c = Restrictions.isEmpty(propertyName);
            } else if (name.equals(IS_NOT_EMPTY)) {
                c = Restrictions.isNotEmpty(propertyName);
            }
        }

        if (c != null) {
            return addToCriteria(c);
        }
    }

    throw new MissingMethodException(name, getClass(), args);
}

From source file:helpers.OrgHelper.java

public static boolean checkSpordiscExists(String sport, String disc) {//sve popuni, dobro radi
    Session session = HibernateUtil.getSessionFactory().openSession();
    Transaction tr = null;//w  w  w  .j a v a2  s .c o  m
    boolean res = false;
    Spordisc sd = null;
    try {
        tr = session.beginTransaction();

        Criteria criteria = session.createCriteria(Spordisc.class)
                .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

        if (disc == null) {
            criteria.add(Restrictions.isNull("disciplina"));
        } else if (disc.isEmpty()) {
            criteria.add(Restrictions.isNull("disciplina"));
        } else {
            criteria.add(Restrictions.ilike("disciplina", disc, MatchMode.EXACT));
        }
        criteria.createCriteria("sport").add(Restrictions.ilike("naziv", sport));

        sd = (Spordisc) criteria.uniqueResult();

        tr.commit();
        if (sd != null) {
            res = true;
        }

    } catch (HibernateException e) {
        if (tr != null) {
            tr.rollback();
        }
    } finally {
        session.close();
    }
    return res;
}

From source file:io.github.jonestimd.finance.dao.hibernate.HibernateDao.java

License:Open Source License

protected Criterion nullableEquals(String propertyName, Object value) {
    return value == null ? Restrictions.isNull(propertyName) : Restrictions.eq(propertyName, value);
}

From source file:io.github.jonestimd.finance.dao.hibernate.TransactionCategoryDaoImpl.java

License:Open Source License

public TransactionCategory getTransactionCategory(final String... codes) {
    Criteria criteria = getSession().createCriteria(TransactionCategory.class);
    criteria.add(Restrictions.eq(TransactionCategory.CODE, codes[codes.length - 1]));
    criteria.add(Restrictions.eq(TransactionCategory.SECURITY, false));
    for (int i = codes.length - 2; i >= 0; i--) {
        criteria = criteria.createCriteria(TransactionCategory.PARENT);
        criteria.add(Restrictions.eq(TransactionCategory.CODE, codes[i]));
    }//from  w  w  w  . j av a  2 s  . c  o  m
    criteria.add(Restrictions.isNull(TransactionCategory.PARENT));
    return (TransactionCategory) criteria.uniqueResult();
}

From source file:io.github.jonestimd.finance.dao.hibernate.TransactionCategoryDaoImpl.java

License:Open Source License

public TransactionCategory getSecurityAction(String code) {
    return findUnique(TransactionCategory.class, Restrictions.eq(TransactionCategory.CODE, code),
            Restrictions.isNull(TransactionCategory.PARENT),
            Restrictions.eq(TransactionCategory.SECURITY, true));
}

From source file:io.milton.vfs.db.GroupFolder.java

License:Open Source License

public static List<Group> findGroupsInFolder(Organisation org, GroupFolder groupFolder, Session session) {
    Criteria crit = session.createCriteria(Group.class);
    crit.setCacheable(true);//from  ww  w . j  a v a2s .  c o  m
    crit.add(Restrictions.eq("organisation", org));
    crit.add(Restrictions.eq("groupFolder", groupFolder));
    crit.add(Restrictions.isNull("deleted"));
    crit.addOrder(Order.asc("name"));
    return DbUtils.toList(crit, Group.class);
}

From source file:ispyb.server.common.services.sessions.Session3ServiceBean.java

License:Open Source License

private List<Session3VO> findSessionNotProtectedToBeProtected(Date date1, Date date2) {
    Session session = (Session) this.entityManager.getDelegate();
    Criteria crit = session.createCriteria(Session3VO.class);

    crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); // DISTINCT RESULTS !

    Calendar cal = Calendar.getInstance();
    cal.setTime(new Date());
    Integer delayToTrigger = 8;//from  w  w w  .  j  a va2  s.  co m
    Integer windowForTrigger = 14 * 24;

    cal.add(Calendar.HOUR_OF_DAY, -delayToTrigger);
    // launch the protection of sessions which have not been protected during the last 14 days.
    if (date2 == null)
        date2 = cal.getTime();

    if (date1 == null) {
        cal.setTime(date2);
        cal.add(Calendar.HOUR_OF_DAY, -windowForTrigger);
        date1 = cal.getTime();
    }

    if (date1 != null)
        crit.add(Restrictions.ge("lastUpdate", date1));
    if (date2 != null)
        crit.add(Restrictions.le("lastUpdate", date2));

    crit.add(Restrictions.in("beamlineName", beamlinesToProtect));

    crit.add(Restrictions.isNull("protectedData"));

    // account not to protect: opid*, opd*, mxihr*
    Criteria subCrit = crit.createCriteria("proposalVO");

    subCrit.add(Restrictions.not(Restrictions.in("code", account_not_to_protect)));

    crit.addOrder(Order.asc("lastUpdate"));

    List<Session3VO> listNotProtected = crit.list();
    LOG.info("find not protected sessions between " + date1 + " and  " + date2);
    if (listNotProtected != null) {
        String sessionsIds = "";
        for (Iterator iterator = listNotProtected.iterator(); iterator.hasNext();) {
            Session3VO session3vo = (Session3VO) iterator.next();
            sessionsIds = sessionsIds + ", " + session3vo.getSessionId();
        }
        LOG.info(listNotProtected.size() + " sessions found : " + sessionsIds);
    }

    return listNotProtected;
}