Java EntityCondition.makeCondition方法代码示例

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public AbstractDatevDataCategory(Delegator delegator, DatevHelper datevHelper) throws DatevException {
    this.delegator = delegator;
    this.datevHelper = datevHelper;

    try {
        EntityCondition datevFieldCommonCond = EntityCondition.makeCondition("dataCategoryId", EntityJoinOperator.EQUALS,
                datevHelper.getDataCategory().getString("dataCategoryId"));

        this.datevFieldDefinitions = EntityQuery.use(delegator).from("DatevFieldDefinition").where(datevFieldCommonCond).queryList();
        this.datevFieldNames = EntityUtil.getFieldListFromEntityList(datevFieldDefinitions, "fieldName", true);
        
        List<String> datevFieldIds = EntityUtil.getFieldListFromEntityList(datevFieldDefinitions, "fieldId", true);
        Map<String, GenericValue> datevFieldMappingsByField = FastMap.newInstance();
        List<GenericValue> datevFieldMappings = EntityQuery.use(delegator).from("DatevFieldMapping").where(datevFieldCommonCond).queryList();
        for (String fieldId : datevFieldIds) {
            datevFieldMappingsByField.put(fieldId, EntityUtil.getFirst(EntityUtil.filterByAnd(datevFieldMappings, UtilMisc.toMap("fieldId", fieldId))));
        }
        this.datevFieldMappingsByField = datevFieldMappingsByField;

        this.datevMetadataFieldsDefinitions = EntityQuery.use(delegator).from("DatevMetadata").queryList();
    } catch (GenericEntityException e) {
        throw new DatevException("Internal error. Cannot initialize DATEV importer tool.", e);
    }
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public void testRemoveByPK() throws Exception {
    flushAndRecreateTree("remove-by-pk");
    //
    // Find all the root nodes,
    // delete them their primary key
    //
    EntityCondition isRoot = EntityCondition.makeCondition(
        EntityCondition.makeCondition("description", EntityOperator.LIKE, "remove-by-pk:%"),
        EntityOperator.AND,
        EntityCondition.makeCondition("primaryParentNodeId", EntityOperator.NOT_EQUAL, GenericEntity.NULL_FIELD)
    );
    List<GenericValue> rootValues = EntityQuery.use(delegator).select("testingNodeId").from("TestingNode").where(isRoot).queryList();

    for (GenericValue value: rootValues) {
        GenericPK pk = value.getPrimaryKey();
        int del = delegator.removeByPrimaryKey(pk);
        assertEquals("Removing Root by primary key", 1, del);
    }

    // no more TestingNode should be in the data base anymore.

    List<GenericValue> testingNodes = EntityQuery.use(delegator).from("TestingNode").where(isRoot).queryList();
    assertEquals("No more TestingNode after removing the roots", 0, testingNodes.size());
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public static List<String> getUserRolesFromList(Delegator delegator, List<String> idList, String partyId, String entityIdFieldName, String partyIdFieldName, String roleTypeIdFieldName, String entityName) throws GenericEntityException {

        EntityExpr expr = EntityCondition.makeCondition(entityIdFieldName, EntityOperator.IN, idList);
        EntityExpr expr2 = EntityCondition.makeCondition(partyIdFieldName, partyId);
        List<GenericValue> roleList = EntityQuery.use(delegator)
                                                 .from(entityName)
                                                 .where(EntityCondition.makeCondition(UtilMisc.toList(expr, expr2)))
                                                 .cache(true)
                                                 .queryList();
        List<GenericValue> roleListFiltered = EntityUtil.filterByDate(roleList);
        Set<String> distinctSet = new HashSet<String>();
        for (GenericValue contentRole: roleListFiltered) {
            String roleTypeId = contentRole.getString(roleTypeIdFieldName);
            distinctSet.add(roleTypeId);
        }
        List<String> distinctList = Arrays.asList(distinctSet.toArray(new String[distinctSet.size()]));
        return distinctList;
    }
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
private static EntityCondition makeUserSecGroupsCond(String userId, Delegator delegator, LocalDispatcher dispatcher) {
    // Get all the user's groups
    List<GenericValue> userSecGroups = CmsDataUtil.findUserLoginSecurityGroupByUserLoginId(delegator, userId);
    
    List<EntityCondition> userSecGroupsConds = new ArrayList<>();
    for(GenericValue userSecGroup : userSecGroups) {
        String groupId = userSecGroup.getString("groupId");
        userSecGroupsConds.add(PageAuthPartyType.GROUP.makeIdCond(groupId));
    }
    
    EntityCondition userSecGroupsCond = null;
    if (!userSecGroupsConds.isEmpty()) {
        // Make an OR condition to select all rows containing any one of the user's groups
        userSecGroupsCond = EntityCondition.makeCondition(userSecGroupsConds, EntityOperator.OR);
        
        // When making this condition, make sure it is exclusive; all other ID identifiers (userId, etc.) must be null for integrity/consistency
        userSecGroupsCond = EntityCondition.makeCondition(userSecGroupsCond, EntityOperator.AND,
                PageAuthPartyType.GROUP.makeAllOthersNullCond()
        );
    }

    return userSecGroupsCond;
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public BigDecimal getItemPickedQuantityBd(GenericValue orderItem) {
    BigDecimal quantityPicked = ZERO;
    EntityConditionList<EntityExpr> pickedConditions = EntityCondition
            .makeCondition(UtilMisc.toList(EntityCondition.makeCondition("orderId", EntityOperator.EQUALS, orderItem.get("orderId")),
                    EntityCondition.makeCondition("orderItemSeqId", EntityOperator.EQUALS, orderItem.getString("orderItemSeqId")),
                    EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "PICKLIST_CANCELLED")), EntityOperator.AND);

    List<GenericValue> picked = null;
    try {
        picked = orderHeader.getDelegator().findList("PicklistAndBinAndItem", pickedConditions, null, null, null, false);
    } catch (GenericEntityException e) {
        Debug.logError(e, module);
        this.orderHeader = null;
    }

    if (picked != null) {
        for (GenericValue pickedItem : picked) {
            BigDecimal issueQty = pickedItem.getBigDecimal("quantity");
            if (issueQty != null) {
                quantityPicked = quantityPicked.add(issueQty).setScale(scale, rounding);
            }
        }
    }
    return quantityPicked.setScale(scale, rounding);
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public static BigDecimal getGlExchangeRateOfPurchaseInvoice(GenericValue paymentApplication) throws GenericEntityException {
    BigDecimal exchangeRate = BigDecimal.ONE;
    Delegator delegator = paymentApplication.getDelegator();
    List andConditions = UtilMisc.toList(
            EntityCondition.makeCondition("glAccountTypeId", "ACCOUNTS_PAYABLE"),
            EntityCondition.makeCondition("debitCreditFlag", "C"),
            EntityCondition.makeCondition("acctgTransTypeId", "PURCHASE_INVOICE"),
            EntityCondition.makeCondition("invoiceId", paymentApplication.getString("invoiceId")));
    EntityCondition whereCondition = EntityCondition.makeCondition(andConditions, EntityJoinOperator.AND);
    GenericValue amounts = EntityQuery.use(delegator).select("origAmount", "amount").from("AcctgTransAndEntries").where(whereCondition).queryFirst();
    if (amounts == null) {
        return exchangeRate;
    }
    BigDecimal origAmount = amounts.getBigDecimal("origAmount");
    BigDecimal amount = amounts.getBigDecimal("amount");
    if (origAmount != null && amount != null && BigDecimal.ZERO.compareTo(origAmount) != 0 && BigDecimal.ZERO.compareTo(amount) != 0 && amount.compareTo(origAmount) != 0) {
        exchangeRate = amount.divide(origAmount, UtilNumber.getBigDecimalScale("ledger.decimals"), UtilNumber.getBigDecimalRoundingMode("invoice.rounding"));
    }
    return exchangeRate;
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public static List<GenericValue> getStateList(Delegator delegator) {
    List<GenericValue> geoList = new LinkedList<GenericValue>();
    EntityCondition condition = EntityCondition.makeCondition(EntityOperator.OR, EntityCondition.makeCondition("geoTypeId", "STATE"), EntityCondition.makeCondition("geoTypeId", "PROVINCE"), EntityCondition.makeCondition("geoTypeId", "TERRITORY"),
            EntityCondition.makeCondition("geoTypeId", "MUNICIPALITY"));
    try {
        geoList = EntityQuery.use(delegator).from("Geo").where(condition).orderBy("geoName").cache(true).queryList();
    } catch (GenericEntityException e) {
        Debug.logError(e, "Cannot lookup State Geos: " + e.toString(), module);
    }
    return geoList;
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
/**
 * Returns all process mapping source paths that are mapped (one way or another) to fall
 * under the /control path.
 * ONLY used if the ControlServlet is not mapped to root.
 * Highly depends on the sourceFromContextRoot flag.
 * Added 2017-11-15.
 */
public List<CmsProcessMapping> getMappingsUnderControl(Delegator delegator, String webSiteId, 
        String controlServletPath, String defaultSourceServletPath, boolean defaultSourceFromContextRoot, boolean useCache) {
    if (controlServletPath == null || controlServletPath.length() < 1) return Collections.emptyList();
    
    EntityCondition cond = EntityCondition.makeCondition(EntityCondition.makeCondition("sourceWebSiteId", webSiteId),
            EntityOperator.AND, 
            makeSourcePathStartsWithControlCond(controlServletPath, defaultSourceServletPath, defaultSourceFromContextRoot));
    
    return CmsProcessMapping.getWorker().findAll(delegator, cond, null, isUseDbCacheStatic(useCache));
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public static void addEntityPkFilterConds(Delegator delegator, String entityName, Collection<String> pkValues, Map<String, EntityCondition> entityCondMap) throws IllegalArgumentException {
    String pkFieldName = EntityInfoUtil.getSinglePkFieldNameStrict(delegator, entityName);
    List<EntityCondition> condList = new ArrayList<>(pkValues.size());
    for(String pkValue : pkValues) {
        condList.add(EntityCondition.makeCondition(pkFieldName, pkValue));
    }
    EntityCondition cond = EntityCondition.makeCondition(condList, EntityOperator.OR);
    addToEntityCondMap(delegator, entityCondMap, entityName, cond);
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
private static EntityCondition buildCountCondition(String fieldName, String fieldValue) {
    List<EntityCondition> orCondList = FastList.newInstance();
    orCondList.add(EntityCondition.makeCondition("thruDate", EntityOperator.GREATER_THAN, UtilDateTime.nowTimestamp()));
    orCondList.add(EntityCondition.makeCondition("thruDate", EntityOperator.EQUALS, null));
    EntityCondition orCond = EntityCondition.makeCondition(orCondList, EntityOperator.OR);

    List<EntityCondition> andCondList = FastList.newInstance();
    andCondList.add(EntityCondition.makeCondition("fromDate", EntityOperator.LESS_THAN, UtilDateTime.nowTimestamp()));
    andCondList.add(EntityCondition.makeCondition(fieldName, EntityOperator.EQUALS, fieldValue));
    andCondList.add(orCond);
    EntityCondition andCond = EntityCondition.makeCondition(andCondList, EntityOperator.AND);

    return andCond;
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public EntityListIterator doQuery(Delegator delegator) {
    // handle the now assembled or and and keyword fixed lists
    this.finishKeywordConstraints();

    if (resultSortOrder != null) {
        resultSortOrder.setSortOrder(this);
    }
    dynamicViewEntity.addAlias("CNT", "contentId", null, null, null, Boolean.valueOf(contentIdGroupBy), null);
    EntityCondition whereCondition = EntityCondition.makeCondition(entityConditionList, EntityOperator.AND);

    // Debug.logInfo("ContentSearch, whereCondition = " + whereCondition.toString(), module);

    EntityListIterator eli = null;
    try {
        // SCIPIO: prevent crash if maxResults == null
        //eli = EntityQuery.use(delegator)
        //        .select(fieldsToSelect).from(dynamicViewEntity)
        //        .where(whereCondition)
        //        .cursorScrollInsensitive()
        //        .distinct()
        //        .maxRows(maxResults)
        //        .queryIterator();
        EntityQuery query = EntityQuery.use(delegator)
                .select(fieldsToSelect).from(dynamicViewEntity)
                .where(whereCondition)
                .cursorScrollInsensitive()
                .distinct();
        if (maxResults != null) {
            query = query.maxRows(maxResults);
        }
        eli = query.queryIterator();
    } catch (GenericEntityException e) {
        Debug.logError(e, "Error in content search", module);
        return null;
    }

    return eli;
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
protected static EntityExpr makeExpr(String fieldName, String value, boolean forceLike) {
    EntityComparisonOperator<?, ?> op = forceLike ? EntityOperator.LIKE : EntityOperator.EQUALS;

    if (value.startsWith("*")) {
        op = EntityOperator.LIKE;
        value = "%" + value.substring(1);
    }
    else if (value.startsWith("%")) {
        op = EntityOperator.LIKE;
    }

    if (value.endsWith("*")) {
        op = EntityOperator.LIKE;
        value = value.substring(0, value.length() - 1) + "%";
    }
    else if (value.endsWith("%")) {
        op = EntityOperator.LIKE;
    }

    if (forceLike) {
        if (!value.startsWith("%")) {
            value = "%" + value;
        }
        if (!value.endsWith("%")) {
            value = value + "%";
        }
    }

    return EntityCondition.makeCondition(fieldName, op, value);
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
static EntityCondition makeFieldPossibleValuesCond(String fieldName, Collection<?> values) {
    //if (values == null || values.isEmpty()) return null;
    List<EntityCondition> condList = new ArrayList<>(values.size());
    for(Object value : values) {
        condList.add(EntityCondition.makeCondition(fieldName, value));
    }
    return EntityCondition.makeCondition(condList, EntityOperator.OR);
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public EntityCondition makeExclusiveNonNullCond() { // All null except this, non-null
    return EntityCondition.makeCondition(
            makeAllOthersNullCond(), 
            EntityOperator.AND,
            this.makeNonNullCond()
        );
}
 

import org.ofbiz.entity.condition.EntityCondition; //导入方法依赖的package包/类
public static List<GenericValue> findDatedInclusionEntity(Delegator delegator, String entityName, Map<String, ? extends Object> search, Timestamp now) throws GenericEntityException {
    EntityCondition searchCondition = EntityCondition.makeCondition(UtilMisc.toList(
            EntityCondition.makeCondition(search), EntityUtil.getFilterByDateExpr(now)));
    return EntityQuery.use(delegator).from(entityName).where(searchCondition).orderBy("-fromDate").queryList();
}