Examples with GenericServiceException org.apache.ofbiz.service.GenericServiceException used on opensource projects

Example 21 with GenericServiceException

use of org.apache.ofbiz.service.GenericServiceException in project ofbiz-framework by apache.

the class SubscriptionServices method runServiceOnSubscriptionExpiry.

public static Map<String, Object> runServiceOnSubscriptionExpiry(DispatchContext dctx, Map<String, ? extends Object> context) {
    LocalDispatcher dispatcher = dctx.getDispatcher();
    Delegator delegator = dctx.getDelegator();
    Locale locale = (Locale) context.get("locale");
    GenericValue userLogin = (GenericValue) context.get("userLogin");
    Map<String, Object> result = new HashMap<>();
    Map<String, Object> expiryMap = new HashMap<>();
    String gracePeriodOnExpiry = null;
    String gracePeriodOnExpiryUomId = null;
    String subscriptionId = null;
    Timestamp expirationCompletedDate = null;
    try {
        EntityCondition cond1 = EntityCondition.makeCondition("automaticExtend", EntityOperator.EQUALS, "N");
        EntityCondition cond2 = EntityCondition.makeCondition("automaticExtend", EntityOperator.EQUALS, null);
        EntityCondition cond = EntityCondition.makeCondition(UtilMisc.toList(cond1, cond2), EntityOperator.OR);
        List<GenericValue> subscriptionList = null;
        subscriptionList = EntityQuery.use(delegator).from("Subscription").where(cond).queryList();
        if (subscriptionList != null) {
            for (GenericValue subscription : subscriptionList) {
                expirationCompletedDate = subscription.getTimestamp("expirationCompletedDate");
                if (expirationCompletedDate == null) {
                    Calendar currentDate = Calendar.getInstance();
                    currentDate.setTime(UtilDateTime.nowTimestamp());
                    // check if the thruDate + grace period (if provided) is earlier than today's date
                    Calendar endDateSubscription = Calendar.getInstance();
                    int field = Calendar.MONTH;
                    String subscriptionResourceId = subscription.getString("subscriptionResourceId");
                    GenericValue subscriptionResource = null;
                    subscriptionResource = EntityQuery.use(delegator).from("SubscriptionResource").where("subscriptionResourceId", subscriptionResourceId).queryOne();
                    subscriptionId = subscription.getString("subscriptionId");
                    gracePeriodOnExpiry = subscription.getString("gracePeriodOnExpiry");
                    gracePeriodOnExpiryUomId = subscription.getString("gracePeriodOnExpiryUomId");
                    String serviceNameOnExpiry = subscriptionResource.getString("serviceNameOnExpiry");
                    endDateSubscription.setTime(subscription.getTimestamp("thruDate"));
                    if (gracePeriodOnExpiry != null && gracePeriodOnExpiryUomId != null) {
                        if ("TF_day".equals(gracePeriodOnExpiryUomId)) {
                            field = Calendar.DAY_OF_YEAR;
                        } else if ("TF_wk".equals(gracePeriodOnExpiryUomId)) {
                            field = Calendar.WEEK_OF_YEAR;
                        } else if ("TF_mon".equals(gracePeriodOnExpiryUomId)) {
                            field = Calendar.MONTH;
                        } else if ("TF_yr".equals(gracePeriodOnExpiryUomId)) {
                            field = Calendar.YEAR;
                        } else {
                            Debug.logWarning("Don't know anything about gracePeriodOnExpiryUomId [" + gracePeriodOnExpiryUomId + "], defaulting to month", module);
                        }
                        endDateSubscription.add(field, Integer.parseInt(gracePeriodOnExpiry));
                    }
                    if ((currentDate.after(endDateSubscription) || currentDate.equals(endDateSubscription)) && serviceNameOnExpiry != null) {
                        if (userLogin != null) {
                            expiryMap.put("userLogin", userLogin);
                        }
                        if (subscriptionId != null) {
                            expiryMap.put("subscriptionId", subscriptionId);
                        }
                        result = dispatcher.runSync(serviceNameOnExpiry, expiryMap);
                        if (ServiceUtil.isSuccess(result)) {
                            subscription.set("expirationCompletedDate", UtilDateTime.nowTimestamp());
                            delegator.store(subscription);
                            Debug.logInfo("Subscription expired successfully for subscription ID:" + subscriptionId, module);
                        } else if (ServiceUtil.isError(result)) {
                            result = null;
                            Debug.logError("Error expiring subscription while processing with subscriptionId: " + subscriptionId, module);
                        }
                        if (result != null && subscriptionId != null) {
                            Debug.logInfo("Service mentioned in serviceNameOnExpiry called with result: " + ServiceUtil.makeSuccessMessage(result, "", "", "", ""), module);
                        } else if (result == null && subscriptionId != null) {
                            Debug.logError("Subscription couldn't be expired for subscriptionId: " + subscriptionId, module);
                            return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, "ProductSubscriptionCouldntBeExpired", UtilMisc.toMap("subscriptionId", subscriptionId), locale));
                        }
                    }
                }
            }
        }
    } catch (GenericServiceException e) {
        Debug.logError("Error while calling service specified in serviceNameOnExpiry", module);
        return ServiceUtil.returnError(e.toString());
    } catch (GenericEntityException e) {
        Debug.logError(e, module);
    }
    return result;
}

Example 22 with GenericServiceException

use of org.apache.ofbiz.service.GenericServiceException 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 23 with GenericServiceException

use of org.apache.ofbiz.service.GenericServiceException 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();
}

Example 24 with GenericServiceException

use of org.apache.ofbiz.service.GenericServiceException in project ofbiz-framework by apache.

the class ProductStoreWorker method isStoreInventoryRequiredAndAvailable.

/**
 * This method is used in the showcart pages to determine whether or not to show the inventory message and
 * in the productdetail pages to determine whether or not to show the item as out of stock.
 *
 * @param request ServletRequest (or HttpServletRequest of course)
 * @param product GenericValue representing the product in question
 * @param quantity Quantity desired.
 * @param wantRequired If true then inventory required must be true for the result to be true, if false must be false; if null don't care
 * @param wantAvailable If true then inventory avilable must be true for the result to be true, if false must be false; if null don't care
 */
public static boolean isStoreInventoryRequiredAndAvailable(ServletRequest request, GenericValue product, BigDecimal quantity, Boolean wantRequired, Boolean wantAvailable) {
    GenericValue productStore = getProductStore(request);
    if (productStore == null) {
        Debug.logWarning("No ProductStore found, return false for inventory check", module);
        return false;
    }
    if (product == null) {
        Debug.logWarning("No Product passed, return false for inventory check", module);
        return false;
    }
    if (quantity == null)
        quantity = BigDecimal.ONE;
    String productStoreId = productStore.getString("productStoreId");
    LocalDispatcher dispatcher = (LocalDispatcher) request.getAttribute("dispatcher");
    try {
        Boolean requiredOkay = null;
        if (wantRequired != null) {
            Map<String, Object> invReqResult = dispatcher.runSync("isStoreInventoryRequired", UtilMisc.toMap("productStoreId", productStoreId, "productId", product.get("productId"), "product", product, "productStore", productStore));
            if (ServiceUtil.isError(invReqResult)) {
                Debug.logError("Error calling isStoreInventoryRequired service, result is: " + invReqResult, module);
                return false;
            }
            requiredOkay = Boolean.valueOf(wantRequired.booleanValue() == "Y".equals(invReqResult.get("requireInventory")));
        }
        Boolean availableOkay = null;
        if (wantAvailable != null) {
            Map<String, Object> invAvailResult = dispatcher.runSync("isStoreInventoryAvailable", UtilMisc.toMap("productStoreId", productStoreId, "productId", product.get("productId"), "product", product, "productStore", productStore, "quantity", quantity));
            if (ServiceUtil.isError(invAvailResult)) {
                Debug.logError("Error calling isStoreInventoryAvailable service, result is: " + invAvailResult, module);
                return false;
            }
            availableOkay = Boolean.valueOf(wantAvailable.booleanValue() == "Y".equals(invAvailResult.get("available")));
        }
        if ((requiredOkay == null || requiredOkay.booleanValue()) && (availableOkay == null || availableOkay.booleanValue())) {
            return true;
        } else {
            return false;
        }
    } catch (GenericServiceException e) {
        String errMsg = "Fatal error calling inventory checking services: " + e.toString();
        Debug.logError(e, errMsg, module);
        return false;
    }
}

Example 25 with GenericServiceException

use of org.apache.ofbiz.service.GenericServiceException in project ofbiz-framework by apache.

the class ICalConverter method invokeService.

protected static Map<String, Object> invokeService(String serviceName, Map<String, ? extends Object> serviceMap, Map<String, Object> context) {
    LocalDispatcher dispatcher = (LocalDispatcher) context.get("dispatcher");
    Locale locale = (Locale) context.get("locale");
    Map<String, Object> localMap = new HashMap<>();
    try {
        ModelService modelService = null;
        modelService = dispatcher.getDispatchContext().getModelService(serviceName);
        for (ModelParam modelParam : modelService.getInModelParamList()) {
            if (serviceMap.containsKey(modelParam.name)) {
                Object value = serviceMap.get(modelParam.name);
                if (UtilValidate.isNotEmpty(modelParam.type)) {
                    value = ObjectType.simpleTypeConvert(value, modelParam.type, null, null, null, true);
                }
                localMap.put(modelParam.name, value);
            }
        }
    } catch (GeneralException e) {
        String errMsg = UtilProperties.getMessage("WorkEffortUiLabels", "WorkeffortErrorWhileCreatingServiceMapForService", UtilMisc.toMap("serviceName", serviceName), locale);
        Debug.logError(e, errMsg, module);
        return ServiceUtil.returnError(errMsg + e);
    }
    if (context.get("userLogin") != null) {
        localMap.put("userLogin", context.get("userLogin"));
    }
    localMap.put("locale", context.get("locale"));
    try {
        Map<String, Object> result = dispatcher.runSync(serviceName, localMap);
        if (ServiceUtil.isError(result)) {
            return ServiceUtil.returnError(ServiceUtil.getErrorMessage(result));
        }
        return result;
    } catch (GenericServiceException e) {
        String errMsg = UtilProperties.getMessage("WorkEffortUiLabels", "WorkeffortErrorWhileInvokingService", UtilMisc.toMap("serviceName", serviceName), locale);
        Debug.logError(e, errMsg, module);
        return ServiceUtil.returnError(errMsg + e);
    }
}