Examples with GenericEntityException org.apache.ofbiz.entity.GenericEntityException used on opensource projects

Example 46 with GenericEntityException

use of org.apache.ofbiz.entity.GenericEntityException in project ofbiz-framework by apache.

the class SubscriptionServices method processExtendSubscriptionByProduct.

public static Map<String, Object> processExtendSubscriptionByProduct(DispatchContext dctx, Map<String, ? extends Object> context) throws GenericServiceException {
    Delegator delegator = dctx.getDelegator();
    LocalDispatcher dispatcher = dctx.getDispatcher();
    String productId = (String) context.get("productId");
    Integer qty = (Integer) context.get("quantity");
    Locale locale = (Locale) context.get("locale");
    if (qty == null) {
        qty = Integer.valueOf(1);
    }
    Timestamp orderCreatedDate = (Timestamp) context.get("orderCreatedDate");
    if (orderCreatedDate == null) {
        orderCreatedDate = UtilDateTime.nowTimestamp();
    }
    try {
        List<GenericValue> productSubscriptionResourceList = EntityQuery.use(delegator).from("ProductSubscriptionResource").where("productId", productId).cache(true).filterByDate(orderCreatedDate, "fromDate", "thruDate", "purchaseFromDate", "purchaseThruDate").queryList();
        if (productSubscriptionResourceList.size() == 0) {
            Debug.logError("No ProductSubscriptionResource found for productId: " + productId, module);
            return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ProductSubscriptionResourceNotFound", UtilMisc.toMap("productId", productId), locale));
        }
        for (GenericValue productSubscriptionResource : productSubscriptionResourceList) {
            Long useTime = productSubscriptionResource.getLong("useTime");
            Integer newUseTime = Integer.valueOf(0);
            if (useTime != null) {
                newUseTime = Integer.valueOf(useTime.intValue() * qty.intValue());
            }
            Map<String, Object> subContext = UtilMisc.makeMapWritable(context);
            subContext.put("useTime", newUseTime);
            subContext.put("useTimeUomId", productSubscriptionResource.get("useTimeUomId"));
            subContext.put("useRoleTypeId", productSubscriptionResource.get("useRoleTypeId"));
            subContext.put("subscriptionResourceId", productSubscriptionResource.get("subscriptionResourceId"));
            subContext.put("automaticExtend", productSubscriptionResource.get("automaticExtend"));
            subContext.put("canclAutmExtTime", productSubscriptionResource.get("canclAutmExtTime"));
            subContext.put("canclAutmExtTimeUomId", productSubscriptionResource.get("canclAutmExtTimeUomId"));
            subContext.put("gracePeriodOnExpiry", productSubscriptionResource.get("gracePeriodOnExpiry"));
            subContext.put("gracePeriodOnExpiryUomId", productSubscriptionResource.get("gracePeriodOnExpiryUomId"));
            Map<String, Object> ctx = dctx.getModelService("processExtendSubscription").makeValid(subContext, ModelService.IN_PARAM);
            Map<String, Object> processExtendSubscriptionResult = dispatcher.runSync("processExtendSubscription", ctx);
            if (ServiceUtil.isError(processExtendSubscriptionResult)) {
                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ProductSubscriptionByProductError", UtilMisc.toMap("productId", productId), locale), null, null, processExtendSubscriptionResult);
            }
        }
    } catch (GenericEntityException e) {
        Debug.logError(e, e.toString(), module);
        return ServiceUtil.returnError(e.toString());
    }
    return ServiceUtil.returnSuccess();
}

Example 47 with GenericEntityException

use of org.apache.ofbiz.entity.GenericEntityException in project ofbiz-framework by apache.

the class SubscriptionServices method processExtendSubscription.

public static Map<String, Object> processExtendSubscription(DispatchContext dctx, Map<String, ? extends Object> context) {
    Delegator delegator = dctx.getDelegator();
    LocalDispatcher dispatcher = dctx.getDispatcher();
    Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
    String partyId = (String) context.get("partyId");
    String subscriptionResourceId = (String) context.get("subscriptionResourceId");
    String inventoryItemId = (String) context.get("inventoryItemId");
    String roleTypeId = (String) context.get("useRoleTypeId");
    GenericValue userLogin = (GenericValue) context.get("userLogin");
    Integer useTime = (Integer) context.get("useTime");
    String useTimeUomId = (String) context.get("useTimeUomId");
    String alwaysCreateNewRecordStr = (String) context.get("alwaysCreateNewRecord");
    Locale locale = (Locale) context.get("locale");
    boolean alwaysCreateNewRecord = !"N".equals(alwaysCreateNewRecordStr);
    GenericValue lastSubscription = null;
    try {
        Map<String, String> subscriptionFindMap = UtilMisc.toMap("partyId", partyId, "subscriptionResourceId", subscriptionResourceId);
        // if this subscription is attached to something the customer owns, filter by that too
        if (UtilValidate.isNotEmpty(inventoryItemId)) {
            subscriptionFindMap.put("inventoryItemId", inventoryItemId);
        }
        List<GenericValue> subscriptionList = EntityQuery.use(delegator).from("Subscription").where(subscriptionFindMap).queryList();
        // DEJ20070718 DON'T filter by date, we want to consider all subscriptions: List listFiltered = EntityUtil.filterByDate(subscriptionList, true);
        List<GenericValue> listOrdered = EntityUtil.orderBy(subscriptionList, UtilMisc.toList("-fromDate"));
        if (listOrdered.size() > 0) {
            lastSubscription = listOrdered.get(0);
        }
    } catch (GenericEntityException e) {
        return ServiceUtil.returnError(e.toString());
    }
    GenericValue newSubscription = null;
    if (lastSubscription == null || alwaysCreateNewRecord) {
        newSubscription = delegator.makeValue("Subscription");
        newSubscription.set("subscriptionResourceId", subscriptionResourceId);
        newSubscription.set("partyId", partyId);
        newSubscription.set("roleTypeId", roleTypeId);
        newSubscription.set("productId", context.get("productId"));
        newSubscription.set("orderId", context.get("orderId"));
        newSubscription.set("orderItemSeqId", context.get("orderItemSeqId"));
        newSubscription.set("automaticExtend", context.get("automaticExtend"));
        newSubscription.set("canclAutmExtTimeUomId", context.get("canclAutmExtTimeUomId"));
        newSubscription.set("canclAutmExtTime", context.get("canclAutmExtTime"));
    } else {
        newSubscription = lastSubscription;
    }
    newSubscription.set("inventoryItemId", inventoryItemId);
    Timestamp thruDate = lastSubscription != null ? (Timestamp) lastSubscription.get("thruDate") : null;
    // set the fromDate, one way or another
    if (thruDate == null) {
        // no thruDate? start with NOW
        thruDate = nowTimestamp;
        newSubscription.set("fromDate", nowTimestamp);
    } else {
        // month and buy another month, we want that second month to start now and not last year
        if (thruDate.before(nowTimestamp)) {
            thruDate = nowTimestamp;
        }
        newSubscription.set("fromDate", thruDate);
    }
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(thruDate);
    int[] times = UomWorker.uomTimeToCalTime(useTimeUomId);
    if (times != null) {
        calendar.add(times[0], (useTime.intValue() * times[1]));
    } else {
        Debug.logWarning("Don't know anything about useTimeUomId [" + useTimeUomId + "], defaulting to month", module);
        calendar.add(Calendar.MONTH, useTime);
    }
    thruDate = new Timestamp(calendar.getTimeInMillis());
    newSubscription.set("thruDate", thruDate);
    Map<String, Object> result = ServiceUtil.returnSuccess();
    try {
        if (lastSubscription != null && !alwaysCreateNewRecord) {
            Map<String, Object> updateSubscriptionMap = dctx.getModelService("updateSubscription").makeValid(newSubscription, ModelService.IN_PARAM);
            updateSubscriptionMap.put("userLogin", EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").queryOne());
            Map<String, Object> updateSubscriptionResult = dispatcher.runSync("updateSubscription", updateSubscriptionMap);
            result.put("subscriptionId", updateSubscriptionMap.get("subscriptionId"));
            if (ServiceUtil.isError(updateSubscriptionResult)) {
                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ProductSubscriptionUpdateError", UtilMisc.toMap("subscriptionId", updateSubscriptionMap.get("subscriptionId")), locale), null, null, updateSubscriptionResult);
            }
        } else {
            Map<String, Object> ensurePartyRoleMap = new HashMap<>();
            if (UtilValidate.isNotEmpty(roleTypeId)) {
                ensurePartyRoleMap.put("partyId", partyId);
                ensurePartyRoleMap.put("roleTypeId", roleTypeId);
                ensurePartyRoleMap.put("userLogin", userLogin);
                Map<String, Object> createPartyRoleResult = dispatcher.runSync("ensurePartyRole", ensurePartyRoleMap);
                if (ServiceUtil.isError(createPartyRoleResult)) {
                    return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ProductSubscriptionPartyRoleCreationError", UtilMisc.toMap("subscriptionResourceId", subscriptionResourceId), locale), null, null, createPartyRoleResult);
                }
            }
            Map<String, Object> createSubscriptionMap = dctx.getModelService("createSubscription").makeValid(newSubscription, ModelService.IN_PARAM);
            createSubscriptionMap.put("userLogin", EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").queryOne());
            Map<String, Object> createSubscriptionResult = dispatcher.runSync("createSubscription", createSubscriptionMap);
            if (ServiceUtil.isError(createSubscriptionResult)) {
                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ProductSubscriptionCreateError", UtilMisc.toMap("subscriptionResourceId", subscriptionResourceId), locale), null, null, createSubscriptionResult);
            }
            result.put("subscriptionId", createSubscriptionResult.get("subscriptionId"));
        }
    } catch (GenericEntityException | GenericServiceException e) {
        return ServiceUtil.returnError(e.toString());
    }
    return result;
}

Example 48 with GenericEntityException

use of org.apache.ofbiz.entity.GenericEntityException in project ofbiz-framework by apache.

the class ProductUtilServices method attachProductFeaturesToCategory.

public static Map<String, Object> attachProductFeaturesToCategory(DispatchContext dctx, Map<String, ? extends Object> context) {
    Delegator delegator = dctx.getDelegator();
    String productCategoryId = (String) context.get("productCategoryId");
    String doSubCategoriesStr = (String) context.get("doSubCategories");
    Locale locale = (Locale) context.get("locale");
    String errMsg = null;
    // default to true
    boolean doSubCategories = !"N".equals(doSubCategoriesStr);
    Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
    Set<String> productFeatureTypeIdsToExclude = new HashSet<>();
    String excludeProp = EntityUtilProperties.getPropertyValue("prodsearch", "attach.feature.type.exclude", delegator);
    if (UtilValidate.isNotEmpty(excludeProp)) {
        List<String> typeList = StringUtil.split(excludeProp, ",");
        productFeatureTypeIdsToExclude.addAll(typeList);
    }
    Set<String> productFeatureTypeIdsToInclude = null;
    String includeProp = EntityUtilProperties.getPropertyValue("prodsearch", "attach.feature.type.include", delegator);
    if (UtilValidate.isNotEmpty(includeProp)) {
        List<String> typeList = StringUtil.split(includeProp, ",");
        if (typeList.size() > 0) {
            productFeatureTypeIdsToInclude = UtilMisc.makeSetWritable(typeList);
        }
    }
    try {
        attachProductFeaturesToCategory(productCategoryId, productFeatureTypeIdsToInclude, productFeatureTypeIdsToExclude, delegator, doSubCategories, nowTimestamp);
    } catch (GenericEntityException e) {
        Map<String, String> messageMap = UtilMisc.toMap("errMessage", e.toString());
        errMsg = UtilProperties.getMessage(resourceError, "productutilservices.error_in_attachProductFeaturesToCategory", messageMap, locale);
        Debug.logError(e, errMsg, module);
        return ServiceUtil.returnError(errMsg);
    }
    return ServiceUtil.returnSuccess();
}

Example 49 with GenericEntityException

use of org.apache.ofbiz.entity.GenericEntityException in project ofbiz-framework by apache.

the class ProductUtilServices method removeCategoryMembersOfDiscProducts.

/**
 * for all disc products, remove from category memberships
 */
public static Map<String, Object> removeCategoryMembersOfDiscProducts(DispatchContext dctx, Map<String, ? extends Object> context) {
    Delegator delegator = dctx.getDelegator();
    Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
    Locale locale = (Locale) context.get("locale");
    String errMsg = null;
    EntityCondition condition = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.LESS_THAN_EQUAL_TO, nowTimestamp)), EntityOperator.AND);
    try (EntityListIterator eli = EntityQuery.use(delegator).from("Product").where(condition).queryIterator()) {
        GenericValue product = null;
        int numSoFar = 0;
        while ((product = eli.next()) != null) {
            String productId = product.getString("productId");
            List<GenericValue> productCategoryMemberList = EntityQuery.use(delegator).from("ProductCategoryMember").where("productId", productId).queryList();
            if (productCategoryMemberList.size() > 0) {
                for (GenericValue productCategoryMember : productCategoryMemberList) {
                    // coded this way rather than a removeByAnd so it can be easily changed...
                    productCategoryMember.remove();
                }
                numSoFar++;
                if (numSoFar % 500 == 0) {
                    Debug.logInfo("Removed category members for " + numSoFar + " sales discontinued products.", module);
                }
            }
        }
        Debug.logInfo("Completed - Removed category members for " + numSoFar + " sales discontinued products.", module);
    } catch (GenericEntityException e) {
        Map<String, String> messageMap = UtilMisc.toMap("errMessage", e.toString());
        errMsg = UtilProperties.getMessage(resourceError, "productutilservices.entity_error_running_removeCategoryMembersOfDiscProducts", messageMap, locale);
        Debug.logError(e, errMsg, module);
        return ServiceUtil.returnError(errMsg);
    }
    return ServiceUtil.returnSuccess();
}

Example 50 with GenericEntityException

use of org.apache.ofbiz.entity.GenericEntityException in project ofbiz-framework by apache.

the class ProductUtilServices method makeStandAloneFromSingleVariantVirtuals.

public static Map<String, Object> makeStandAloneFromSingleVariantVirtuals(DispatchContext dctx, Map<String, ? extends Object> context) {
    Delegator delegator = dctx.getDelegator();
    LocalDispatcher dispatcher = dctx.getDispatcher();
    GenericValue userLogin = (GenericValue) context.get("userLogin");
    Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
    Locale locale = (Locale) context.get("locale");
    String errMsg = null;
    Debug.logInfo("Starting makeStandAloneFromSingleVariantVirtuals", module);
    DynamicViewEntity dve = new DynamicViewEntity();
    dve.addMemberEntity("PVIRT", "Product");
    dve.addMemberEntity("PVA", "ProductAssoc");
    dve.addViewLink("PVIRT", "PVA", Boolean.FALSE, UtilMisc.toList(new ModelKeyMap("productId", "productId")));
    dve.addAlias("PVIRT", "productId", null, null, null, Boolean.TRUE, null);
    dve.addAlias("PVIRT", "salesDiscontinuationDate", null, null, null, null, null);
    dve.addAlias("PVA", "productAssocTypeId", null, null, null, null, null);
    dve.addAlias("PVA", "fromDate", null, null, null, null, null);
    dve.addAlias("PVA", "thruDate", null, null, null, null, null);
    dve.addAlias("PVA", "productIdToCount", "productIdTo", null, null, null, "count-distinct");
    EntityCondition condition = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("productAssocTypeId", EntityOperator.EQUALS, "PRODUCT_VARIANT"), EntityCondition.makeCondition(EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.GREATER_THAN, nowTimestamp))), EntityOperator.AND);
    EntityCondition havingCond = EntityCondition.makeCondition("productIdToCount", EntityOperator.EQUALS, Long.valueOf(1));
    EntityQuery eq = EntityQuery.use(delegator).select("productId", "productIdToCount").from(dve).where(condition).having(havingCond);
    try (EntityListIterator eliOne = eq.queryIterator()) {
        List<GenericValue> valueList = eliOne.getCompleteList();
        Debug.logInfo("Found " + valueList.size() + " virtual products with one variant to turn into a stand alone product.", module);
        int numWithOneOnly = 0;
        for (GenericValue value : valueList) {
            // has only one variant period, is it valid? should already be discontinued if not
            String productId = value.getString("productId");
            List<GenericValue> paList = EntityQuery.use(delegator).from("ProductAssoc").where("productId", productId, "productAssocTypeId", "PRODUCT_VARIANT").filterByDate().queryList();
            // verify the query; tested on a bunch, looks good
            if (paList.size() != 1) {
                Debug.logInfo("Virtual product with ID " + productId + " should have 1 assoc, has " + paList.size(), module);
            } else {
                // for all virtuals with one variant move all info from virtual to variant and remove virtual, make variant as not a variant
                dispatcher.runSync("mergeVirtualWithSingleVariant", UtilMisc.<String, Object>toMap("productId", productId, "removeOld", Boolean.TRUE, "userLogin", userLogin));
                numWithOneOnly++;
                if (numWithOneOnly % 100 == 0) {
                    Debug.logInfo("Made " + numWithOneOnly + " virtual products with only one valid variant stand-alone products.", module);
                }
            }
        }
        EntityCondition conditionWithDates = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("productAssocTypeId", EntityOperator.EQUALS, "PRODUCT_VARIANT"), EntityCondition.makeCondition(EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("salesDiscontinuationDate", EntityOperator.GREATER_THAN, nowTimestamp)), EntityCondition.makeCondition("fromDate", EntityOperator.LESS_THAN_EQUAL_TO, nowTimestamp), EntityCondition.makeCondition(EntityCondition.makeCondition("thruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("thruDate", EntityOperator.GREATER_THAN_EQUAL_TO, nowTimestamp))), EntityOperator.AND);
        eq = EntityQuery.use(delegator).select("productId", "productIdToCount").from(dve).where(conditionWithDates).having(havingCond);
        try (EntityListIterator eliMulti = eq.queryIterator()) {
            List<GenericValue> valueMultiList = eliMulti.getCompleteList();
            Debug.logInfo("Found " + valueMultiList.size() + " virtual products with one VALID variant to pull the variant from to make a stand alone product.", module);
            int numWithOneValid = 0;
            for (GenericValue value : valueMultiList) {
                // has only one valid variant
                String productId = value.getString("productId");
                List<GenericValue> paList = EntityQuery.use(delegator).from("ProductAssoc").where("productId", productId, "productAssocTypeId", "PRODUCT_VARIANT").filterByDate().queryList();
                // verify the query; tested on a bunch, looks good
                if (paList.size() != 1) {
                    Debug.logInfo("Virtual product with ID " + productId + " should have 1 assoc, has " + paList.size(), module);
                } else {
                    // for all virtuals with one valid variant move info from virtual to variant, put variant in categories from virtual, remove virtual from all categories but leave "family" otherwise intact, mark variant as not a variant
                    dispatcher.runSync("mergeVirtualWithSingleVariant", UtilMisc.<String, Object>toMap("productId", productId, "removeOld", Boolean.FALSE, "userLogin", userLogin));
                    numWithOneValid++;
                    if (numWithOneValid % 100 == 0) {
                        Debug.logInfo("Made " + numWithOneValid + " virtual products with one valid variant stand-alone products.", module);
                    }
                }
            }
            Debug.logInfo("Found virtual products with one valid variant: " + numWithOneValid + ", with one variant only: " + numWithOneOnly, module);
        } catch (GenericEntityException e) {
            Map<String, String> messageMap = UtilMisc.toMap("errMessage", e.toString());
            errMsg = UtilProperties.getMessage(resourceError, "productutilservices.entity_error_running_makeStandAloneFromSingleVariantVirtuals", messageMap, locale);
            Debug.logError(e, errMsg, module);
            return ServiceUtil.returnError(errMsg);
        }
    } catch (GenericEntityException | GenericServiceException e) {
        Map<String, String> messageMap = UtilMisc.toMap("errMessage", e.toString());
        errMsg = UtilProperties.getMessage(resourceError, "productutilservices.entity_error_running_makeStandAloneFromSingleVariantVirtuals", messageMap, locale);
        Debug.logError(e, errMsg, module);
        return ServiceUtil.returnError(errMsg);
    }
    return ServiceUtil.returnSuccess();
}