entityutil.java

国外的一套开源CRM

            }
            if (include) {
                result.add(value);
            }
        }
        return result;
    }

    /**
     *returns the values that match any of the exprs in list
     *
     *@param values List of GenericValues
     *@param exprs the expressions that must validate to true
     *@return List of GenericValue's that match the values in fields
     */
    public static List filterByOr(List values, List exprs) {
        if (values == null) return null;
        if (exprs == null || exprs.size() == 0) {
            return values;
        }

        List result = new ArrayList();
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            GenericValue value = (GenericValue) iter.next();
            Iterator exprIter = exprs.iterator();
            boolean include = false;

            while (exprIter.hasNext()) {
                EntityExpr expr = (EntityExpr) exprIter.next();
                Object lhs = value.get((String) expr.getLhs());
                Object rhs = expr.getRhs();

                int operatorId = expr.getOperator().getId();
                switch (operatorId) {
                    case EntityOperator.ID_EQUALS:
                        if (EntityComparisonOperator.compareEqual(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_NOT_EQUAL:
                        if (EntityComparisonOperator.compareNotEqual(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_GREATER_THAN:
                        if (EntityComparisonOperator.compareGreaterThanEqualTo(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_GREATER_THAN_EQUAL_TO:
                        if (EntityComparisonOperator.compareGreaterThan(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_LESS_THAN:
                        if (EntityComparisonOperator.compareLessThan(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_LESS_THAN_EQUAL_TO:
                        if (EntityComparisonOperator.compareLessThanEqualTo(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    case EntityOperator.ID_LIKE:
                        if (EntityComparisonOperator.compareLike(lhs, rhs)) {
                            include = true;
                        }
                        break;
                    default:
                        throw new IllegalArgumentException("The " + expr.getOperator().getCode() + " with id " + expr.getOperator().getId() + " operator is not yet supported by filterByOr");
                }
                if (include) break;
            }
            if (include) {
                result.add(value);
            }
        }
        return result;
    }

    /**
     *returns the values in the order specified
     *
     *@param values List of GenericValues
     *@param orderBy The fields of the named entity to order the query by;
     *      optionally add a " ASC" for ascending or " DESC" for descending
     *@return List of GenericValue's in the proper order
     */
    public static List orderBy(Collection values, List orderBy) {
        if (values == null) return null;
        if (values.size() == 0) return new ArrayList();
        if (orderBy == null || orderBy.size() == 0) {
            return new ArrayList(values);
        }

        List result = new ArrayList(values);
        Collections.sort(result, new OrderByComparator(orderBy));
        return result;
    }

    public static List getRelated(String relationName, List values) throws GenericEntityException {
        if (values == null) return null;

        List result = new ArrayList();
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            result.addAll(((GenericValue) iter.next()).getRelated(relationName));
        }
        return result;
    }

    public static List getRelatedCache(String relationName, List values) throws GenericEntityException {
        if (values == null) return null;

        List result = new ArrayList();
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            result.addAll(((GenericValue) iter.next()).getRelatedCache(relationName));
        }
        return result;
    }

    public static List getRelatedByAnd(String relationName, Map fields, List values) throws GenericEntityException {
        if (values == null) return null;

        List result = new ArrayList();
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            result.addAll(((GenericValue) iter.next()).getRelatedByAnd(relationName, fields));
        }
        return result;
    }

    public static List filterByCondition(List values, EntityCondition condition) {
        if (values == null) return null;

        List result = new ArrayList(values.size());
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            GenericValue value = (GenericValue) iter.next();
            if (condition.entityMatches(value)) {
                result.add(value);
            }
        }
        return result;
    }

    public static List filterOutByCondition(List values, EntityCondition condition) {
        if (values == null) return null;

        List result = new ArrayList(values.size());
        Iterator iter = values.iterator();

        while (iter.hasNext()) {
            GenericValue value = (GenericValue) iter.next();
            if (!condition.entityMatches(value)) {
                result.add(value);
            }
        }
        return result;
    }

    static class OrderByComparator implements Comparator {

        private String field;
        private ModelField modelField = null;
        private boolean descending;
        private Comparator next = null;

        OrderByComparator(List orderBy) {
            this(orderBy, 0);
        }

        private OrderByComparator(List orderBy, int startIndex) {
            if (orderBy == null) throw new IllegalArgumentException("orderBy may not be empty");
            if (startIndex >= orderBy.size()) throw new IllegalArgumentException("startIndex may not be greater than or equal to orderBy size");
            String fieldAndDirection = (String) orderBy.get(startIndex);
            String upper = fieldAndDirection.trim().toUpperCase();

            if (upper.endsWith(" DESC")) {
                this.descending = true;
                this.field = fieldAndDirection.substring(0, fieldAndDirection.length() - 5);
            } else if (upper.endsWith(" ASC")) {
                this.descending = false;
                this.field = fieldAndDirection.substring(0, fieldAndDirection.length() - 4);
            } else if (upper.startsWith("-")) {
                this.descending = true;
                this.field = fieldAndDirection.substring(1);
            } else if (upper.startsWith("+")) {
                this.descending = false;
                this.field = fieldAndDirection.substring(1);
            } else {
                this.descending = false;
                this.field = fieldAndDirection;
            }
            if (startIndex + 1 < orderBy.size()) {
                this.next = new OrderByComparator(orderBy, startIndex + 1);
            }// else keep null
        }

        public int compare(java.lang.Object obj, java.lang.Object obj1) {
            int result = compareAsc((GenericEntity) obj, (GenericEntity) obj1);

            if (descending && result != 0) {
                result = -result;
            }
            if ((result == 0) && (next != null)) {
                return next.compare(obj, obj1);
            } else {
                return result;
            }
        }

        private int compareAsc(GenericEntity obj, GenericEntity obj2) {
            if (this.modelField == null) {
                this.modelField = obj.getModelEntity().getField(field);
                if (this.modelField == null) {
                    throw new IllegalArgumentException("The field " + field + " could not be found in the entity " + obj.getEntityName());
                }
            }
            Object value = obj.dangerousGetNoCheckButFast(this.modelField);
            Object value2 = obj2.dangerousGetNoCheckButFast(this.modelField);

            // null is defined as the largest possible value
            if (value == null) return value2 == null ? 0 : 1;
            if (value2 == null) return value == null ? 0 : -1;
            int result = ((Comparable) value).compareTo(value2);

            // if (Debug.infoOn()) Debug.logInfo("[OrderByComparator.compareAsc] Result is " + result + " for [" + value + "] and [" + value2 + "]", module);
            return result;
        }

        public boolean equals(java.lang.Object obj) {
            if ((obj != null) && (obj instanceof OrderByComparator)) {
                OrderByComparator that = (OrderByComparator) obj;

                return this.field.equals(that.field) && (this.descending == that.descending)
                    && UtilValidate.areEqual(this.next, that.next);
            } else {
                return false;
            }
        }
    }

    public static List findDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search) throws GenericEntityException {
        return findDatedInclusionEntity(delegator, entityName, search, UtilDateTime.nowTimestamp());
    }

    public static List findDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search, Timestamp now) throws GenericEntityException {
        EntityCondition searchCondition = new EntityConditionList(UtilMisc.toList(
            new EntityFieldMap(search, EntityOperator.AND),
            EntityUtil.getFilterByDateExpr(now)
        ), EntityOperator.AND);
        return delegator.findByCondition(entityName,searchCondition,null,UtilMisc.toList("-fromDate"));
    }

    public static GenericValue newDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search) throws GenericEntityException {
        return newDatedInclusionEntity(delegator, entityName, search, UtilDateTime.nowTimestamp());
    }

    public static GenericValue newDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search, Timestamp now) throws GenericEntityException {
        List entities = findDatedInclusionEntity(delegator, entityName, search, now);
        if (entities != null && entities.size() > 0) {
            search = null;
            for (int i = 0; i < entities.size(); i++) {
                GenericValue entity = (GenericValue)entities.get(i);
                if (now.equals(entity.get("fromDate"))) {
                    search = new HashMap(entity.getPrimaryKey());
                    entity.remove("thruDate");
                } else {
                    entity.set("thruDate",now);
                }
                entity.store();
            }
            if (search == null) search = new HashMap(EntityUtil.getFirst(entities));
        } else {
            search = new HashMap(search);
        }
        if (now.equals(search.get("fromDate"))) {
            return EntityUtil.getOnly(delegator.findByAnd(entityName, search));
        } else {
            search.put("fromDate",now);
            search.remove("thruDate");
            return delegator.makeValue(entityName, search);
        }
    }

    public static void delDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search) throws GenericEntityException {
        delDatedInclusionEntity(delegator, entityName, search, UtilDateTime.nowTimestamp());
    }

    public static void delDatedInclusionEntity(GenericDelegator delegator, String entityName, Map search, Timestamp now) throws GenericEntityException {
        List entities = findDatedInclusionEntity(delegator, entityName, search, now);
        for (int i = 0; entities != null && i < entities.size(); i++) {
            GenericValue entity = (GenericValue)entities.get(i);
            entity.set("thruDate",now);
            entity.store();
        }
    }
}