| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.ofbiz.order.shoppingcart; |
| |
| import java.math.BigDecimal; |
| import java.sql.Timestamp; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.GeneralException; |
| import org.apache.ofbiz.base.util.ObjectType; |
| import org.apache.ofbiz.base.util.StringUtil; |
| import org.apache.ofbiz.base.util.UtilDateTime; |
| import org.apache.ofbiz.base.util.UtilFormatOut; |
| import org.apache.ofbiz.base.util.UtilGenerics; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilNumber; |
| import org.apache.ofbiz.base.util.UtilProperties; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.entity.Delegator; |
| import org.apache.ofbiz.entity.GenericEntityException; |
| import org.apache.ofbiz.entity.GenericValue; |
| import org.apache.ofbiz.entity.condition.EntityCondition; |
| import org.apache.ofbiz.entity.condition.EntityExpr; |
| import org.apache.ofbiz.entity.condition.EntityFunction; |
| import org.apache.ofbiz.entity.condition.EntityOperator; |
| import org.apache.ofbiz.entity.util.EntityQuery; |
| import org.apache.ofbiz.entity.util.EntityTypeUtil; |
| import org.apache.ofbiz.entity.util.EntityUtil; |
| import org.apache.ofbiz.entity.util.EntityUtilProperties; |
| import org.apache.ofbiz.order.finaccount.FinAccountHelper; |
| import org.apache.ofbiz.order.order.OrderChangeHelper; |
| import org.apache.ofbiz.order.order.OrderReadHelper; |
| import org.apache.ofbiz.order.shoppingcart.product.ProductPromoWorker; |
| import org.apache.ofbiz.order.shoppingcart.shipping.ShippingEvents; |
| import org.apache.ofbiz.order.thirdparty.paypal.ExpressCheckoutEvents; |
| import org.apache.ofbiz.party.contact.ContactHelper; |
| import org.apache.ofbiz.party.contact.ContactMechWorker; |
| import org.apache.ofbiz.product.store.ProductStoreWorker; |
| import org.apache.ofbiz.service.GenericServiceException; |
| import org.apache.ofbiz.service.LocalDispatcher; |
| import org.apache.ofbiz.service.ModelService; |
| import org.apache.ofbiz.service.ServiceUtil; |
| |
| /** |
| * A facade over the ShoppingCart to simplify the relatively complex |
| * processing required to create an order in the system. |
| */ |
| public class CheckOutHelper { |
| |
| public static final String module = CheckOutHelper.class.getName(); |
| public static final String resource_error = "OrderErrorUiLabels"; |
| |
| public static final int scale = UtilNumber.getBigDecimalScale("order.decimals"); |
| public static final int rounding = UtilNumber.getBigDecimalRoundingMode("order.rounding"); |
| |
| protected LocalDispatcher dispatcher = null; |
| protected Delegator delegator = null; |
| protected ShoppingCart cart = null; |
| |
| public CheckOutHelper(LocalDispatcher dispatcher, Delegator delegator, ShoppingCart cart) { |
| this.delegator = delegator; |
| this.dispatcher = dispatcher; |
| this.cart = cart; |
| } |
| |
| public Map<String, Object> setCheckOutShippingAddress(String shippingContactMechId) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> result; |
| String errMsg = null; |
| |
| if (UtilValidate.isNotEmpty(this.cart)) { |
| errorMessages.addAll(setCheckOutShippingAddressInternal(shippingContactMechId)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.no_items_in_cart", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| if (errorMessages.size() == 1) { |
| result = ServiceUtil.returnError(errorMessages.get(0).toString()); |
| } else if (errorMessages.size() > 0) { |
| result = ServiceUtil.returnError(errorMessages); |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| |
| return result; |
| } |
| |
| private List<String> setCheckOutShippingAddressInternal(String shippingContactMechId) { |
| List<String> errorMessages = new ArrayList<String>(); |
| String errMsg = null; |
| |
| // set the shipping address |
| if (UtilValidate.isNotEmpty(shippingContactMechId)) { |
| this.cart.setAllShippingContactMechId(shippingContactMechId); |
| } else if (cart.shippingApplies()) { |
| // only return an error if shipping is required for this purchase |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.select_shipping_destination", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| return errorMessages; |
| } |
| |
| public Map<String, Object> setCheckOutShippingOptions(String shippingMethod, String shippingInstructions, |
| String orderAdditionalEmails, String maySplit, String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> result; |
| String errMsg = null; |
| |
| if (UtilValidate.isNotEmpty(this.cart)) { |
| errorMessages.addAll(setCheckOutShippingOptionsInternal(shippingMethod, shippingInstructions, |
| orderAdditionalEmails, maySplit, giftMessage, isGift, internalCode, shipBeforeDate, shipAfterDate)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.no_items_in_cart", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| if (errorMessages.size() == 1) { |
| result = ServiceUtil.returnError(errorMessages.get(0).toString()); |
| } else if (errorMessages.size() > 0) { |
| result = ServiceUtil.returnError(errorMessages); |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| |
| return result; |
| } |
| |
| private List<String> setCheckOutShippingOptionsInternal(String shippingMethod, String shippingInstructions, String orderAdditionalEmails, |
| String maySplit, String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate) { |
| List<String> errorMessages = new ArrayList<String>(); |
| String errMsg = null; |
| |
| // set the general shipping options |
| if (UtilValidate.isNotEmpty(shippingMethod)) { |
| int delimiterPos = shippingMethod.indexOf('@'); |
| String shipmentMethodTypeId = null; |
| String carrierPartyId = null; |
| |
| if (delimiterPos > 0) { |
| shipmentMethodTypeId = shippingMethod.substring(0, delimiterPos); |
| carrierPartyId = shippingMethod.substring(delimiterPos + 1); |
| } |
| |
| this.cart.setAllShipmentMethodTypeId(shipmentMethodTypeId); |
| this.cart.setAllCarrierPartyId(carrierPartyId); |
| } else if (cart.shippingApplies()) { |
| // only return an error if shipping is required for this purchase |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.select_shipping_method", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| // set the shipping instructions |
| this.cart.setAllShippingInstructions(shippingInstructions); |
| |
| if (UtilValidate.isNotEmpty(maySplit)) { |
| cart.setAllMaySplit(Boolean.valueOf(maySplit)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.select_splitting_preference", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| // set the gift message |
| this.cart.setAllGiftMessage(giftMessage); |
| |
| if (UtilValidate.isNotEmpty(isGift)) { |
| cart.setAllIsGift(Boolean.valueOf(isGift)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error, "checkhelper.specify_if_order_is_gift", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| // interal code |
| this.cart.setInternalCode(internalCode); |
| |
| if (UtilValidate.isNotEmpty(shipBeforeDate)) { |
| if (UtilValidate.isDate(shipBeforeDate)) { |
| cart.setShipBeforeDate(UtilDateTime.toTimestamp(shipBeforeDate)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error, "checkhelper.specify_if_shipBeforeDate_is_date", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| } |
| |
| if (UtilValidate.isNotEmpty(shipAfterDate)) { |
| if (UtilValidate.isDate(shipAfterDate)) { |
| cart.setShipAfterDate(UtilDateTime.toTimestamp(shipAfterDate)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error, "checkhelper.specify_if_shipAfterDate_is_date", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| } |
| |
| // set any additional notification emails |
| this.cart.setOrderAdditionalEmails(orderAdditionalEmails); |
| |
| return errorMessages; |
| } |
| |
| public Map<String, Object> setCheckOutPayment(Map<String, Map<String, Object>> selectedPaymentMethods, List<String> singleUsePayments, String billingAccountId) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> result; |
| String errMsg = null; |
| |
| if (UtilValidate.isNotEmpty(this.cart)) { |
| errorMessages.addAll(setCheckOutPaymentInternal(selectedPaymentMethods, singleUsePayments, billingAccountId)); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.no_items_in_cart", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| if (errorMessages.size() == 1) { |
| result = ServiceUtil.returnError(errorMessages.get(0).toString()); |
| } else if (errorMessages.size() > 0) { |
| result = ServiceUtil.returnError(errorMessages); |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| |
| return result; |
| } |
| |
| public List<String> setCheckOutPaymentInternal(Map<String, Map<String, Object>> selectedPaymentMethods, List<String> singleUsePayments, String billingAccountId) { |
| List<String> errorMessages = new ArrayList<String>(); |
| String errMsg = null; |
| |
| if (singleUsePayments == null) { |
| singleUsePayments = new ArrayList<String>(); |
| } |
| |
| // set the payment method option |
| if (UtilValidate.isNotEmpty(selectedPaymentMethods)) { |
| // clear out the old payments |
| cart.clearPayments(); |
| |
| if (UtilValidate.isNotEmpty(billingAccountId)) { |
| Map<String, Object> billingAccountMap = selectedPaymentMethods.get("EXT_BILLACT"); |
| BigDecimal billingAccountAmt = (BigDecimal)billingAccountMap.get("amount"); |
| // set cart billing account data and generate a payment method containing the amount we will be charging |
| cart.setBillingAccount(billingAccountId, (billingAccountAmt != null ? billingAccountAmt: BigDecimal.ZERO)); |
| // copy the billing account terms as order terms |
| try { |
| List<GenericValue> billingAccountTerms = EntityQuery.use(delegator).from("BillingAccountTerm").where("billingAccountId", billingAccountId).queryList(); |
| if (UtilValidate.isNotEmpty(billingAccountTerms)) { |
| for (GenericValue billingAccountTerm : billingAccountTerms) { |
| // the term is not copied if in the cart a term of the same type is already set |
| if (!cart.hasOrderTerm(billingAccountTerm.getString("termTypeId"))) { |
| cart.addOrderTerm(billingAccountTerm.getString("termTypeId"), billingAccountTerm.getBigDecimal("termValue"), billingAccountTerm.getLong("termDays")); |
| } |
| } |
| } |
| } catch (GenericEntityException gee) { |
| Debug.logWarning("Error copying billing account terms to order terms: " + gee.getMessage(), module); |
| } |
| } else { |
| // remove the billing account from the cart |
| cart.setBillingAccount(null, BigDecimal.ZERO); |
| } |
| |
| // if checkoutPaymentId == EXT_BILLACT, then we have billing account only, so make sure we have enough credit |
| if (selectedPaymentMethods.containsKey("EXT_BILLACT") && selectedPaymentMethods.size() == 1) { |
| BigDecimal accountCredit = this.availableAccountBalance(cart.getBillingAccountId()); |
| BigDecimal amountToUse = cart.getBillingAccountAmount(); |
| |
| // if an amount was entered, check that it doesn't exceed available amount |
| if (amountToUse.compareTo(BigDecimal.ZERO) > 0 && amountToUse.compareTo(accountCredit) > 0) { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.insufficient_credit_available_on_account", |
| (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } else { |
| // otherwise use the available account credit (The user might enter 10.00 for an order worth 20.00 from an account with 30.00. This makes sure that the 30.00 is used) |
| amountToUse = accountCredit; |
| } |
| |
| // check that the amount to use is enough to fulfill the order |
| BigDecimal grandTotal = cart.getGrandTotal(); |
| if (grandTotal.compareTo(amountToUse) > 0) { |
| cart.setBillingAccount(null, BigDecimal.ZERO); // erase existing billing account data |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.insufficient_credit_available_on_account", |
| (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } else { |
| // since this is the only selected payment method, let's make this amount the grand total for convenience |
| amountToUse = grandTotal; |
| } |
| |
| // associate the cart billing account amount and EXT_BILLACT selected payment method with whatever amount we have now |
| // XXX: Note that this step is critical for the billing account to be charged correctly |
| if (amountToUse.compareTo(BigDecimal.ZERO) > 0) { |
| cart.setBillingAccount(billingAccountId, amountToUse); |
| selectedPaymentMethods.put("EXT_BILLACT", UtilMisc.<String, Object>toMap("amount", amountToUse, "securityCode", null)); |
| } |
| } |
| |
| for (String checkOutPaymentId : selectedPaymentMethods.keySet()) { |
| String finAccountId = null; |
| |
| if (checkOutPaymentId.indexOf("|") > -1) { |
| // split type -- ID|Actual |
| String[] splitStr = checkOutPaymentId.split("\\|"); |
| checkOutPaymentId = splitStr[0]; |
| if ("FIN_ACCOUNT".equals(checkOutPaymentId)) { |
| finAccountId = splitStr[1]; |
| } |
| if (Debug.verboseOn()) Debug.logVerbose("Split checkOutPaymentId: " + splitStr[0] + " / " + splitStr[1], module); |
| } |
| |
| // get the selected amount to use |
| BigDecimal paymentAmount = null; |
| String securityCode = null; |
| if (selectedPaymentMethods.get(checkOutPaymentId) != null) { |
| Map<String, Object> checkOutPaymentInfo = selectedPaymentMethods.get(checkOutPaymentId); |
| paymentAmount = (BigDecimal) checkOutPaymentInfo.get("amount"); |
| securityCode = (String) checkOutPaymentInfo.get("securityCode"); |
| } |
| |
| boolean singleUse = singleUsePayments.contains(checkOutPaymentId); |
| ShoppingCart.CartPaymentInfo inf = cart.addPaymentAmount(checkOutPaymentId, paymentAmount, singleUse); |
| if (finAccountId != null) { |
| inf.finAccountId = finAccountId; |
| } |
| if (securityCode != null) { |
| inf.securityCode = securityCode; |
| } |
| } |
| } else if (cart.getGrandTotal().compareTo(BigDecimal.ZERO) != 0) { |
| // only return an error if the order total is not 0.00 |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.select_method_of_payment", |
| (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| return errorMessages; |
| } |
| |
| public Map<String, Object> setCheckOutDates(Timestamp shipBefore, Timestamp shipAfter) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> result = null; |
| String errMsg = null; |
| |
| if (UtilValidate.isNotEmpty(this.cart)) { |
| this.cart.setShipBeforeDate(shipBefore); |
| this.cart.setShipAfterDate(shipAfter); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.no_items_in_cart", |
| (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| if (errorMessages.size() == 1) { |
| result = ServiceUtil.returnError(errorMessages.get(0).toString()); |
| } else if (errorMessages.size() > 0) { |
| result = ServiceUtil.returnError(errorMessages); |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| return result; |
| } |
| |
| |
| public Map<String, Object> setCheckOutOptions(String shippingMethod, String shippingContactMechId, Map<String, Map<String, Object>> selectedPaymentMethods, |
| List<String> singleUsePayments, String billingAccountId, String shippingInstructions, |
| String orderAdditionalEmails, String maySplit, String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> result = null; |
| String errMsg = null; |
| |
| |
| if (UtilValidate.isNotEmpty(this.cart)) { |
| // set the general shipping options and method |
| errorMessages.addAll(setCheckOutShippingOptionsInternal(shippingMethod, shippingInstructions, |
| orderAdditionalEmails, maySplit, giftMessage, isGift, internalCode, shipBeforeDate, shipAfterDate)); |
| |
| // set the shipping address |
| errorMessages.addAll(setCheckOutShippingAddressInternal(shippingContactMechId)); |
| |
| // Recalc shipping costs before setting payment |
| Map<String, Object> shipEstimateMap = ShippingEvents.getShipGroupEstimate(dispatcher, delegator, cart, 0); |
| BigDecimal shippingTotal = (BigDecimal) shipEstimateMap.get("shippingTotal"); |
| if (shippingTotal == null) { |
| shippingTotal = BigDecimal.ZERO; |
| } |
| cart.setItemShipGroupEstimate(shippingTotal, 0); |
| ProductPromoWorker.doPromotions(cart, dispatcher); |
| |
| //Recalc tax before setting payment |
| try { |
| this.calcAndAddTax(); |
| } catch (GeneralException e) { |
| Debug.logError(e, module); |
| } |
| // set the payment method(s) option |
| errorMessages.addAll(setCheckOutPaymentInternal(selectedPaymentMethods, singleUsePayments, billingAccountId)); |
| |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.no_items_in_cart", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| |
| if (errorMessages.size() == 1) { |
| result = ServiceUtil.returnError(errorMessages.get(0).toString()); |
| } else if (errorMessages.size() > 0) { |
| result = ServiceUtil.returnError(errorMessages); |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| |
| return result; |
| } |
| |
| public Map<String, Object> checkGiftCard(Map<String, Object> params, Map<String, Map<String, Object>> selectedPaymentMethods) { |
| List<String> errorMessages = new ArrayList<String>(); |
| Map<String, Object> errorMaps = new HashMap<String, Object>(); |
| Map<String, Object> result = new HashMap<String, Object>(); |
| String errMsg = null; |
| // handle gift card payment |
| if (params.get("addGiftCard") != null) { |
| String gcNum = (String) params.get("giftCardNumber"); |
| String gcPin = (String) params.get("giftCardPin"); |
| String gcAmt = (String) params.get("giftCardAmount"); |
| BigDecimal gcAmount = BigDecimal.ONE.negate(); |
| |
| boolean gcFieldsOkay = true; |
| if (UtilValidate.isEmpty(gcNum)) { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.enter_gift_card_number", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } |
| if (cart.isPinRequiredForGC(delegator)) { |
| // if a PIN is required, make sure the PIN is valid |
| if (UtilValidate.isEmpty(gcPin)) { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.enter_gift_card_pin_number", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } |
| } |
| // See if we should validate gift card code against FinAccount's accountCode |
| if (cart.isValidateGCFinAccount(delegator)) { |
| try { |
| // No PIN required - validate gift card number against account code |
| if (!cart.isPinRequiredForGC(delegator)) { |
| GenericValue finAccount = FinAccountHelper.getFinAccountFromCode(gcNum, delegator); |
| if (finAccount == null) { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.gift_card_does_not_exist", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } else if ((finAccount.getBigDecimal("availableBalance") == null) || |
| !((finAccount.getBigDecimal("availableBalance")).compareTo(FinAccountHelper.ZERO) > 0)) { |
| // if account's available balance (including authorizations) is not greater than zero, then return an error |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.gift_card_has_no_value", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } |
| } |
| // TODO: else case when pin is required - we should validate gcNum and gcPin |
| } catch (GenericEntityException ex) { |
| errorMessages.add(ex.getMessage()); |
| gcFieldsOkay = false; |
| } |
| } |
| |
| if (UtilValidate.isNotEmpty(selectedPaymentMethods)) { |
| if (UtilValidate.isEmpty(gcAmt)) { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.enter_amount_to_place_on_gift_card", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } |
| } |
| if (UtilValidate.isNotEmpty(gcAmt)) { |
| try { |
| gcAmount = new BigDecimal(gcAmt); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.invalid_amount_for_gift_card", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| gcFieldsOkay = false; |
| } |
| } |
| |
| if (gcFieldsOkay) { |
| // store the gift card |
| Map<String, Object> gcCtx = new HashMap<String, Object>(); |
| gcCtx.put("partyId", params.get("partyId")); |
| gcCtx.put("cardNumber", gcNum); |
| if (cart.isPinRequiredForGC(delegator)) { |
| gcCtx.put("pinNumber", gcPin); |
| } |
| gcCtx.put("userLogin", cart.getUserLogin()); |
| Map<String, Object> gcResult = null; |
| try { |
| gcResult = dispatcher.runSync("createGiftCard", gcCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| errorMessages.add(e.getMessage()); |
| } |
| if (gcResult != null) { |
| ServiceUtil.addErrors(errorMessages, errorMaps, gcResult); |
| |
| if (errorMessages.size() == 0 && errorMaps.size() == 0) { |
| // set the GC payment method |
| BigDecimal giftCardAmount = null; |
| if (gcAmount.compareTo(BigDecimal.ZERO) > 0) { |
| giftCardAmount = gcAmount; |
| } |
| String gcPaymentMethodId = (String) gcResult.get("paymentMethodId"); |
| result = ServiceUtil.returnSuccess(); |
| result.put("paymentMethodId", gcPaymentMethodId); |
| result.put("amount", giftCardAmount); |
| } |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problem_with_gift_card_information", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| errorMessages.add(errMsg); |
| } |
| } |
| } else { |
| result = ServiceUtil.returnSuccess(); |
| } |
| |
| // see whether we need to return an error or not |
| if (errorMessages.size() > 0) { |
| result.put(ModelService.ERROR_MESSAGE_LIST, errorMessages); |
| result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_ERROR); |
| } |
| if (errorMaps.size() > 0) { |
| result.put(ModelService.ERROR_MESSAGE_MAP, errorMaps); |
| result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_ERROR); |
| } |
| |
| return result; |
| } |
| |
| public Map<String, Object> createOrder(GenericValue userLogin) { |
| return createOrder(userLogin, null, null, null, false, null, cart.getWebSiteId()); |
| } |
| |
| // Create order event - uses createOrder service for processing |
| public Map<String, Object> createOrder(GenericValue userLogin, String distributorId, String affiliateId, |
| List<GenericValue> trackingCodeOrders, boolean areOrderItemsExploded, String visitId, String webSiteId) { |
| if (this.cart == null) { |
| return null; |
| } |
| String orderId = this.cart.getOrderId(); |
| String supplierPartyId = (String) this.cart.getAttribute("supplierPartyId"); |
| String originOrderId = (String) this.cart.getAttribute("originOrderId"); |
| |
| this.cart.clearAllItemStatus(); |
| |
| BigDecimal grandTotal = this.cart.getGrandTotal(); |
| |
| // store the order - build the context |
| Map<String, Object> context = this.cart.makeCartMap(this.dispatcher, areOrderItemsExploded); |
| |
| //get the TrackingCodeOrder List |
| context.put("trackingCodeOrders", trackingCodeOrders); |
| |
| if (distributorId != null) context.put("distributorId", distributorId); |
| if (affiliateId != null) context.put("affiliateId", affiliateId); |
| |
| context.put("orderId", orderId); |
| context.put("supplierPartyId", supplierPartyId); |
| context.put("grandTotal", grandTotal); |
| context.put("userLogin", userLogin); |
| context.put("visitId", visitId); |
| if (UtilValidate.isEmpty(webSiteId)) { |
| webSiteId = cart.getWebSiteId(); |
| } |
| context.put("webSiteId", webSiteId); |
| context.put("originOrderId", originOrderId); |
| |
| // need the partyId; don't use userLogin in case of an order via order mgr |
| String partyId = this.cart.getPartyId(); |
| String productStoreId = cart.getProductStoreId(); |
| |
| // store the order - invoke the service |
| Map<String, Object> storeResult = null; |
| |
| try { |
| storeResult = dispatcher.runSync("storeOrder", context); |
| orderId = (String) storeResult.get("orderId"); |
| if (UtilValidate.isNotEmpty(orderId)) { |
| this.cart.setOrderId(orderId); |
| if (this.cart.getFirstAttemptOrderId() == null) { |
| this.cart.setFirstAttemptOrderId(orderId); |
| } |
| } |
| } catch (GenericServiceException e) { |
| String service = e.getMessage(); |
| Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("service", service); |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } |
| |
| // check for error message(s) |
| if (ServiceUtil.isError(storeResult)) { |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.did_not_complete_order_following_occurred", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| List<String> resErrorMessages = new LinkedList<String>(); |
| resErrorMessages.add(errMsg); |
| resErrorMessages.add(ServiceUtil.getErrorMessage(storeResult)); |
| return ServiceUtil.returnError(resErrorMessages); |
| } |
| |
| // ---------- |
| // If needed, the production runs are created and linked to the order lines. |
| // |
| List<GenericValue> orderItems = UtilGenerics.checkList(context.get("orderItems")); |
| int counter = 0; |
| for (GenericValue orderItem : orderItems) { |
| String productId = orderItem.getString("productId"); |
| if (productId != null) { |
| try { |
| // do something tricky here: run as the "system" user |
| // that can actually create and run a production run |
| GenericValue permUserLogin = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").cache().queryOne(); |
| GenericValue productStore = ProductStoreWorker.getProductStore(productStoreId, delegator); |
| GenericValue product = EntityQuery.use(delegator).from("Product").where("productId", productId).queryOne(); |
| if (EntityTypeUtil.hasParentType(delegator, "ProductType", "productTypeId", product.getString("productTypeId"), "parentTypeId", "AGGREGATED")) { |
| org.apache.ofbiz.product.config.ProductConfigWrapper config = this.cart.findCartItem(counter).getConfigWrapper(); |
| Map<String, Object> inputMap = new HashMap<String, Object>(); |
| inputMap.put("config", config); |
| inputMap.put("facilityId", productStore.getString("inventoryFacilityId")); |
| inputMap.put("orderId", orderId); |
| inputMap.put("orderItemSeqId", orderItem.getString("orderItemSeqId")); |
| inputMap.put("quantity", orderItem.getBigDecimal("quantity")); |
| inputMap.put("userLogin", permUserLogin); |
| |
| Map<String, Object> prunResult = dispatcher.runSync("createProductionRunFromConfiguration", inputMap); |
| if (ServiceUtil.isError(prunResult)) { |
| Debug.logError(ServiceUtil.getErrorMessage(prunResult) + " for input:" + inputMap, module); |
| } |
| } |
| } catch (GenericEntityException e) { |
| String service = e.getMessage(); |
| Map<String, String> messageMap = UtilMisc.toMap("service", service); |
| String errMsg = "Problem accessing the Product entity"; |
| errMsg = errMsg + UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } catch (GenericServiceException e) { |
| String service = e.getMessage(); |
| Map<String, String> messageMap = UtilMisc.toMap("service", service); |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } catch (Exception e) { |
| String service = e.getMessage(); |
| Map<String, String> messageMap = UtilMisc.toMap("service", service); |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } |
| } |
| counter++; |
| } |
| // ---------- |
| |
| // ---------- |
| // The status of the requirement associated to the shopping cart lines is set to "ordered". |
| // |
| for (ShoppingCartItem shoppingCartItem : this.cart.items()) { |
| String requirementId = shoppingCartItem.getRequirementId(); |
| if (requirementId != null) { |
| try { |
| /* OrderRequirementCommitment records will map which POs which are created from which requirements. With the help of this mapping requirements will be updated to Ordered when POs will be approved. */ |
| Map<String, Object> inputMap = UtilMisc.toMap("userLogin", userLogin, "orderId", orderId, "orderItemSeqId", shoppingCartItem.getOrderItemSeqId(), "requirementId", requirementId, "quantity", shoppingCartItem.getQuantity()); |
| dispatcher.runSync("createOrderRequirementCommitment", inputMap); |
| } catch (GenericServiceException e) { |
| String service = e.getMessage(); |
| Map<String, String> messageMap = UtilMisc.toMap("service", service); |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } catch (Exception e) { |
| String service = e.getMessage(); |
| Map<String, String> messageMap = UtilMisc.toMap("service", service); |
| String errMsg = UtilProperties.getMessage(resource_error, "checkhelper.could_not_create_order_invoking_service", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } |
| } |
| } |
| // ---------- |
| |
| // set the orderId for use by chained events |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("orderId", orderId); |
| result.put("orderAdditionalEmails", this.cart.getOrderAdditionalEmails()); |
| |
| // save the emails to the order |
| List<GenericValue> toBeStored = new LinkedList<GenericValue>(); |
| |
| GenericValue party = null; |
| try { |
| party = EntityQuery.use(delegator).from("Party").where("partyId", partyId).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, UtilProperties.getMessage(resource_error,"OrderProblemsGettingPartyRecord", cart.getLocale()), module); |
| } |
| |
| // create order contact mechs for the email address(s) |
| if (party != null) { |
| Iterator<GenericValue> emailIter = UtilMisc.toIterator(ContactHelper.getContactMechByType(party, "EMAIL_ADDRESS", false)); |
| while (emailIter != null && emailIter.hasNext()) { |
| GenericValue email = emailIter.next(); |
| GenericValue orderContactMech = this.delegator.makeValue("OrderContactMech", |
| UtilMisc.toMap("orderId", orderId, "contactMechId", email.getString("contactMechId"), "contactMechPurposeTypeId", "ORDER_EMAIL")); |
| toBeStored.add(orderContactMech); |
| if (UtilValidate.isEmpty(ContactHelper.getContactMechByPurpose(party, "ORDER_EMAIL", false))) { |
| GenericValue partyContactMechPurpose = this.delegator.makeValue("PartyContactMechPurpose", |
| UtilMisc.toMap("partyId", party.getString("partyId"), "contactMechId", email.getString("contactMechId"), "contactMechPurposeTypeId", "ORDER_EMAIL", "fromDate", UtilDateTime.nowTimestamp())); |
| toBeStored.add(partyContactMechPurpose); |
| } |
| } |
| } |
| |
| // create dummy contact mechs and order contact mechs for the additional emails |
| String additionalEmails = this.cart.getOrderAdditionalEmails(); |
| List<String> emailList = StringUtil.split(additionalEmails, ","); |
| if (emailList == null) emailList = new ArrayList<String>(); |
| for (String email : emailList) { |
| String contactMechId = this.delegator.getNextSeqId("ContactMech"); |
| GenericValue contactMech = this.delegator.makeValue("ContactMech", |
| UtilMisc.toMap("contactMechId", contactMechId, "contactMechTypeId", "EMAIL_ADDRESS", "infoString", email)); |
| |
| GenericValue orderContactMech = this.delegator.makeValue("OrderContactMech", |
| UtilMisc.toMap("orderId", orderId, "contactMechId", contactMechId, "contactMechPurposeTypeId", "ORDER_EMAIL")); |
| toBeStored.add(contactMech); |
| toBeStored.add(orderContactMech); |
| } |
| |
| if (toBeStored.size() > 0) { |
| try { |
| if (Debug.verboseOn()) Debug.logVerbose("To Be Stored: " + toBeStored, module); |
| this.delegator.storeAll(toBeStored); |
| } catch (GenericEntityException e) { |
| // not a fatal error; so just print a message |
| Debug.logWarning(e, UtilProperties.getMessage(resource_error,"OrderProblemsStoringOrderEmailContactInformation", cart.getLocale()), module); |
| } |
| } |
| |
| return result; |
| } |
| |
| public void calcAndAddTax() throws GeneralException { |
| calcAndAddTax(null, false); |
| } |
| |
| public void calcAndAddTax(boolean skipEmptyAddresses) throws GeneralException { |
| calcAndAddTax(null, skipEmptyAddresses); |
| } |
| |
| public void calcAndAddTax(GenericValue shipAddress) throws GeneralException { |
| calcAndAddTax(shipAddress, false); |
| } |
| |
| public void calcAndAddTax(GenericValue shipAddress, boolean skipEmptyAddresses) throws GeneralException { |
| if (UtilValidate.isEmpty(cart.getShippingContactMechId()) && cart.getBillingAddress() == null && shipAddress == null) { |
| return; |
| } |
| |
| int shipGroups = this.cart.getShipGroupSize(); |
| for (int i = 0; i < shipGroups; i++) { |
| ShoppingCart.CartShipInfo csi = cart.getShipInfo(i); |
| Map<Integer, ShoppingCartItem> shoppingCartItemIndexMap = new HashMap<Integer, ShoppingCartItem>(); |
| Map<String, Object> serviceContext = this.makeTaxContext(i, shipAddress, shoppingCartItemIndexMap, cart.getFacilityId(), skipEmptyAddresses); |
| if (skipEmptyAddresses && serviceContext == null) { |
| csi.clearAllTaxInfo(); |
| continue; |
| } |
| List<List<? extends Object>> taxReturn = this.getTaxAdjustments(dispatcher, "calcTax", serviceContext); |
| |
| if (Debug.verboseOn()) Debug.logVerbose("ReturnList: " + taxReturn, module); |
| List<GenericValue> orderAdj = UtilGenerics.checkList(taxReturn.get(0)); |
| List<List<GenericValue>> itemAdj = UtilGenerics.checkList(taxReturn.get(1)); |
| |
| // set the item adjustments |
| if (itemAdj != null) { |
| for (int x = 0; x < itemAdj.size(); x++) { |
| List<GenericValue> adjs = itemAdj.get(x); |
| ShoppingCartItem item = shoppingCartItemIndexMap.get(Integer.valueOf(x)); |
| if (adjs == null) { |
| adjs = new LinkedList<GenericValue>(); |
| } |
| csi.setItemInfo(item, adjs); |
| if (Debug.verboseOn()) Debug.logVerbose("Added item adjustments to ship group [" + i + " / " + x + "] - " + adjs, module); |
| } |
| } |
| |
| // need to manually clear the order adjustments |
| csi.shipTaxAdj.clear(); |
| csi.shipTaxAdj.addAll(orderAdj); |
| } |
| } |
| |
| private Map<String, Object> makeTaxContext(int shipGroup, GenericValue shipAddress, Map<Integer, ShoppingCartItem> shoppingCartItemIndexMap, String originFacilityId, boolean skipEmptyAddresses) { |
| ShoppingCart.CartShipInfo csi = cart.getShipInfo(shipGroup); |
| int totalItems = csi.shipItemInfo.size(); |
| |
| List<GenericValue> product = new ArrayList<GenericValue>(totalItems); |
| List<BigDecimal> amount = new ArrayList<BigDecimal>(totalItems); |
| List<BigDecimal> price = new ArrayList<BigDecimal>(totalItems); |
| List<BigDecimal> quantity = new ArrayList<BigDecimal>(totalItems); |
| List<BigDecimal> shipAmt = new ArrayList<BigDecimal>(totalItems); |
| |
| Iterator<ShoppingCartItem> it = csi.shipItemInfo.keySet().iterator(); |
| for (int i = 0; i < totalItems; i++) { |
| ShoppingCartItem cartItem = it.next(); |
| ShoppingCart.CartShipInfo.CartShipItemInfo itemInfo = csi.getShipItemInfo(cartItem); |
| product.add(i, cartItem.getProduct()); |
| amount.add(i, cartItem.getItemSubTotal(itemInfo.quantity)); |
| price.add(i, cartItem.getBasePrice()); |
| quantity.add(i, cartItem.getQuantity()); |
| shipAmt.add(i, BigDecimal.ZERO); // no per item shipping yet |
| shoppingCartItemIndexMap.put(Integer.valueOf(i), cartItem); |
| } |
| |
| //add promotion adjustments |
| List<GenericValue> allAdjustments = cart.getAdjustments(); |
| BigDecimal orderPromoAmt = OrderReadHelper.calcOrderPromoAdjustmentsBd(allAdjustments); |
| |
| BigDecimal shipAmount = csi.shipEstimate; |
| if (shipAddress == null) { |
| shipAddress = cart.getShippingAddress(shipGroup); |
| } |
| |
| if (shipAddress == null && skipEmptyAddresses) { |
| return null; |
| } |
| |
| // no shipping address; try the billing address |
| if (shipAddress == null) { |
| for (int i = 0; i < cart.selectedPayments(); i++) { |
| ShoppingCart.CartPaymentInfo cpi = cart.getPaymentInfo(i); |
| GenericValue billAddr = cpi.getBillingAddress(delegator); |
| if (billAddr != null) { |
| shipAddress = billAddr; |
| Debug.logInfo("In makeTaxContext no shipping address, but found address with ID [" + shipAddress.get("contactMechId") + "] from payment method.", module); |
| break; |
| } |
| } |
| } |
| |
| if (shipAddress == null) { |
| // face-to-face order; use the facility address |
| if (originFacilityId != null) { |
| GenericValue facilityContactMech = ContactMechWorker.getFacilityContactMechByPurpose(delegator, originFacilityId, UtilMisc.toList("SHIP_ORIG_LOCATION", "PRIMARY_LOCATION")); |
| if (facilityContactMech != null) { |
| try { |
| shipAddress = EntityQuery.use(delegator).from("PostalAddress").where("contactMechId", facilityContactMech.getString("contactMechId")).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| } |
| } |
| } |
| |
| // if shippingAddress is still null then don't calculate tax; it may be an situation where no tax is applicable, or the data is bad and we don't have a way to find an address to check tax for |
| if (shipAddress == null) { |
| Debug.logWarning("Not calculating tax for new order because there is no shipping address, no billing address, and no address on the origin facility [" + originFacilityId + "]", module); |
| } |
| |
| Map<String, Object> serviceContext = UtilMisc.<String, Object>toMap("productStoreId", cart.getProductStoreId()); |
| serviceContext.put("payToPartyId", cart.getBillFromVendorPartyId()); |
| serviceContext.put("billToPartyId", cart.getBillToCustomerPartyId()); |
| serviceContext.put("itemProductList", product); |
| serviceContext.put("itemAmountList", amount); |
| serviceContext.put("itemPriceList", price); |
| serviceContext.put("itemQuantityList", quantity); |
| serviceContext.put("itemShippingList", shipAmt); |
| serviceContext.put("orderShippingAmount", shipAmount); |
| serviceContext.put("shippingAddress", shipAddress); |
| serviceContext.put("orderPromotionsAmount", orderPromoAmt); |
| |
| return serviceContext; |
| } |
| |
| // Calc the tax adjustments. |
| private List<List<? extends Object>> getTaxAdjustments(LocalDispatcher dispatcher, String taxService, Map<String, Object> serviceContext) throws GeneralException { |
| Map<String, Object> serviceResult = null; |
| |
| try { |
| serviceResult = dispatcher.runSync(taxService, serviceContext); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| throw new GeneralException("Problem occurred in tax service (" + e.getMessage() + ")", e); |
| } |
| |
| if (ServiceUtil.isError(serviceResult)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(serviceResult)); |
| } |
| |
| // the adjustments (returned in order) from taxware. |
| List<GenericValue> orderAdj = UtilGenerics.checkList(serviceResult.get("orderAdjustments")); |
| List<List<GenericValue>> itemAdj = UtilGenerics.checkList(serviceResult.get("itemAdjustments")); |
| |
| return UtilMisc.toList(orderAdj, itemAdj); |
| } |
| |
| public Map<String, Object> processPayment(GenericValue productStore, GenericValue userLogin) throws GeneralException { |
| return CheckOutHelper.processPayment(this.cart.getOrderId(), this.cart.getGrandTotal(), this.cart.getCurrency(), productStore, userLogin, false, false, dispatcher, delegator); |
| } |
| |
| public Map<String, Object> processPayment(GenericValue productStore, GenericValue userLogin, boolean faceToFace) throws GeneralException { |
| return CheckOutHelper.processPayment(this.cart.getOrderId(), this.cart.getGrandTotal(), this.cart.getCurrency(), productStore, userLogin, faceToFace, false, dispatcher, delegator); |
| } |
| |
| public Map<String, Object> processPayment(GenericValue productStore, GenericValue userLogin, boolean faceToFace, boolean manualHold) throws GeneralException { |
| return CheckOutHelper.processPayment(this.cart.getOrderId(), this.cart.getGrandTotal(), this.cart.getCurrency(), productStore, userLogin, faceToFace, manualHold, dispatcher, delegator); |
| } |
| |
| public static Map<String, Object> processPayment(String orderId, BigDecimal orderTotal, String currencyUomId, GenericValue productStore, GenericValue userLogin, boolean faceToFace, boolean manualHold, LocalDispatcher dispatcher, Delegator delegator) throws GeneralException { |
| // Get some payment related strings |
| String DECLINE_MESSAGE = productStore.getString("authDeclinedMessage"); |
| String ERROR_MESSAGE = productStore.getString("authErrorMessage"); |
| String RETRY_ON_ERROR = productStore.getString("retryFailedAuths"); |
| if (RETRY_ON_ERROR == null) { |
| RETRY_ON_ERROR = "Y"; |
| } |
| |
| List<GenericValue> allPaymentPreferences = null; |
| try { |
| allPaymentPreferences = EntityQuery.use(delegator).from("OrderPaymentPreference").where("orderId", orderId).queryList(); |
| } catch (GenericEntityException e) { |
| throw new GeneralException("Problems getting payment preferences", e); |
| } |
| |
| // filter out cancelled preferences |
| List<EntityExpr> canExpr = UtilMisc.toList(EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "PAYMENT_CANCELLED")); |
| allPaymentPreferences = EntityUtil.filterByAnd(allPaymentPreferences, canExpr); |
| |
| // check for online payment methods or in-hand payment types with verbal or external refs |
| List<EntityExpr> exprs = UtilMisc.toList(EntityCondition.makeCondition("manualRefNum", EntityOperator.NOT_EQUAL, null)); |
| List<GenericValue> manualRefPaymentPrefs = EntityUtil.filterByAnd(allPaymentPreferences, exprs); |
| if (UtilValidate.isNotEmpty(manualRefPaymentPrefs)) { |
| for (GenericValue opp : manualRefPaymentPrefs) { |
| Map<String, Object> authCtx = new HashMap<String, Object>(); |
| authCtx.put("orderPaymentPreference", opp); |
| if (opp.get("paymentMethodId") == null) { |
| authCtx.put("serviceTypeEnum", "PRDS_PAY_EXTERNAL"); |
| } |
| authCtx.put("processAmount", opp.getBigDecimal("maxAmount")); |
| authCtx.put("authRefNum", opp.getString("manualRefNum")); |
| authCtx.put("authResult", Boolean.TRUE); |
| authCtx.put("userLogin", userLogin); |
| authCtx.put("currencyUomId", currencyUomId); |
| |
| Map<String, Object> authResp = dispatcher.runSync("processAuthResult", authCtx); |
| if (authResp != null && ServiceUtil.isError(authResp)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(authResp)); |
| } |
| |
| // approve the order |
| OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| |
| if ("Y".equalsIgnoreCase(productStore.getString("manualAuthIsCapture"))) { |
| Map<String, Object> captCtx = new HashMap<String, Object>(); |
| captCtx.put("orderPaymentPreference", opp); |
| if (opp.get("paymentMethodId") == null) { |
| captCtx.put("serviceTypeEnum", "PRDS_PAY_EXTERNAL"); |
| } |
| captCtx.put("payToPartyId", productStore.get("payToPartyId")); |
| captCtx.put("captureResult", Boolean.TRUE); |
| captCtx.put("captureAmount", opp.getBigDecimal("maxAmount")); |
| captCtx.put("captureRefNum", opp.getString("manualRefNum")); |
| captCtx.put("userLogin", userLogin); |
| captCtx.put("currencyUomId", currencyUomId); |
| |
| Map<String, Object> capResp = dispatcher.runSync("processCaptureResult", captCtx); |
| if (capResp != null && ServiceUtil.isError(capResp)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(capResp)); |
| } |
| } |
| } |
| } |
| |
| // check for a paypal express checkout needing completion |
| List<EntityExpr> payPalExprs = UtilMisc.toList( |
| EntityCondition.makeCondition("paymentMethodId", EntityOperator.NOT_EQUAL, null), |
| EntityCondition.makeCondition("paymentMethodTypeId", "EXT_PAYPAL") |
| ); |
| List<GenericValue> payPalPaymentPrefs = EntityUtil.filterByAnd(allPaymentPreferences, payPalExprs); |
| if (UtilValidate.isNotEmpty(payPalPaymentPrefs)) { |
| GenericValue payPalPaymentPref = EntityUtil.getFirst(payPalPaymentPrefs); |
| ExpressCheckoutEvents.doExpressCheckout(productStore.getString("productStoreId"), orderId, payPalPaymentPref, userLogin, delegator, dispatcher); |
| } |
| |
| // check for online payment methods needing authorization |
| Map<String, Object> paymentFields = UtilMisc.<String, Object>toMap("statusId", "PAYMENT_NOT_AUTH"); |
| List<GenericValue> onlinePaymentPrefs = EntityUtil.filterByAnd(allPaymentPreferences, paymentFields); |
| |
| // Check the payment preferences; if we have ANY w/ status PAYMENT_NOT_AUTH invoke payment service. |
| // Invoke payment processing. |
| if (UtilValidate.isNotEmpty(onlinePaymentPrefs)) { |
| boolean autoApproveOrder = UtilValidate.isEmpty(productStore.get("autoApproveOrder")) || "Y".equalsIgnoreCase(productStore.getString("autoApproveOrder")); |
| if (orderTotal.compareTo(BigDecimal.ZERO) == 0 && autoApproveOrder) { |
| // if there is nothing to authorize; don't bother |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| |
| // now there should be something to authorize; go ahead |
| Map<String, Object> paymentResult = null; |
| try { |
| // invoke the payment gateway service. |
| paymentResult = dispatcher.runSync("authOrderPayments", |
| UtilMisc.<String, Object>toMap("orderId", orderId, "userLogin", userLogin), 180, false); |
| } catch (GenericServiceException e) { |
| Debug.logWarning(e, module); |
| throw new GeneralException("Error in authOrderPayments service: " + e.toString(), e.getNested()); |
| } |
| if (Debug.verboseOn()) Debug.logVerbose("Finished w/ Payment Service", module); |
| |
| if (paymentResult != null && ServiceUtil.isError(paymentResult)) { |
| throw new GeneralException(ServiceUtil.getErrorMessage(paymentResult)); |
| } |
| |
| |
| if (paymentResult != null && paymentResult.containsKey("processResult")) { |
| // grab the customer messages -- only passed back in the case of an error or failure |
| List<String> messages = UtilGenerics.checkList(paymentResult.get("authResultMsgs")); |
| |
| String authResp = (String) paymentResult.get("processResult"); |
| |
| if (authResp.equals("FAILED")) { |
| // order was NOT approved |
| if (Debug.verboseOn()) Debug.logVerbose("Payment auth was NOT a success!", module); |
| |
| boolean ok = OrderChangeHelper.rejectOrder(dispatcher, userLogin, orderId); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| if (UtilValidate.isEmpty(messages)) { |
| return ServiceUtil.returnError(DECLINE_MESSAGE); |
| } else { |
| return ServiceUtil.returnError(messages); |
| } |
| } else if (authResp.equals("APPROVED")) { |
| // order WAS approved |
| if (Debug.verboseOn()) Debug.logVerbose("Payment auth was a success!", module); |
| |
| // set the order and item status to approved |
| if (autoApproveOrder) { |
| List<GenericValue> productStorePaymentSettingList = EntityQuery.use(delegator).from("ProductStorePaymentSetting") |
| .where("productStoreId", productStore.getString("productStoreId"), "paymentMethodTypeId", "CREDIT_CARD", "paymentService", "cyberSourceCCAuth") |
| .queryList(); |
| if (productStorePaymentSettingList.size() > 0) { |
| String decision = (String) paymentResult.get("authCode"); |
| if (UtilValidate.isNotEmpty(decision)) { |
| if ("ACCEPT".equalsIgnoreCase(decision)) { |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| } else { |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| } else { |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| } |
| } else if (authResp.equals("ERROR")) { |
| // service failed |
| if (Debug.verboseOn()) Debug.logVerbose("Payment auth failed due to processor trouble.", module); |
| if (!faceToFace && "Y".equalsIgnoreCase(RETRY_ON_ERROR)) { |
| // never do this for a face to face purchase regardless of store setting |
| return ServiceUtil.returnSuccess(ERROR_MESSAGE); |
| } else { |
| boolean ok = OrderChangeHelper.cancelOrder(dispatcher, userLogin, orderId); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| if (UtilValidate.isEmpty(messages)) { |
| return ServiceUtil.returnError(ERROR_MESSAGE); |
| } else { |
| return ServiceUtil.returnError(messages); |
| } |
| } |
| } else { |
| // should never happen |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderPleaseContactCustomerServicePaymentReturnCodeUnknown", Locale.getDefault())); |
| } |
| } else { |
| // result returned null == service failed |
| if (Debug.verboseOn()) Debug.logVerbose("Payment auth failed due to processor trouble.", module); |
| if (!faceToFace && "Y".equalsIgnoreCase(RETRY_ON_ERROR)) { |
| // never do this for a face to face purchase regardless of store setting |
| return ServiceUtil.returnSuccess(ERROR_MESSAGE); |
| } else { |
| boolean ok = OrderChangeHelper.cancelOrder(dispatcher, userLogin, orderId); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| return ServiceUtil.returnError(ERROR_MESSAGE); |
| } |
| } |
| } else { |
| // Get the paymentMethodTypeIds - this will need to change when ecom supports multiple payments |
| List<EntityExpr> cashCodPcBaExpr = UtilMisc.toList(EntityCondition.makeCondition("paymentMethodTypeId", EntityOperator.EQUALS, "CASH"), |
| EntityCondition.makeCondition("paymentMethodTypeId", EntityOperator.EQUALS, "EXT_COD"), |
| EntityCondition.makeCondition("paymentMethodTypeId", EntityOperator.EQUALS, "PERSONAL_CHECK"), |
| EntityCondition.makeCondition("paymentMethodTypeId", EntityOperator.EQUALS, "EXT_BILLACT")); |
| List<GenericValue> cashCodPcBaPaymentPreferences = EntityUtil.filterByOr(allPaymentPreferences, cashCodPcBaExpr); |
| |
| if (UtilValidate.isNotEmpty(cashCodPcBaPaymentPreferences) && |
| UtilValidate.isNotEmpty(allPaymentPreferences) && |
| cashCodPcBaPaymentPreferences.size() == allPaymentPreferences.size()) { |
| |
| //if there are Check type, approve the order only if it is face to face |
| List<GenericValue> checkPreferences = EntityUtil.filterByAnd(cashCodPcBaPaymentPreferences, UtilMisc.toMap("paymentMethodTypeId", "PERSONAL_CHECK")); |
| if (UtilValidate.isNotEmpty(checkPreferences)) { |
| if (faceToFace) { |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| // approve this as long as there are only CASH, COD and Billing Account types |
| } else { |
| boolean ok = OrderChangeHelper.approveOrder(dispatcher, userLogin, orderId, manualHold); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see above error"); |
| } |
| } |
| |
| } else { |
| // There is nothing to do, we just treat this as a success |
| } |
| } |
| |
| // check to see if we should auto-invoice/bill |
| if (faceToFace) { |
| if (Debug.verboseOn()) Debug.logVerbose("Face-To-Face Sale - " + orderId, module); |
| CheckOutHelper.adjustFaceToFacePayment(orderId, orderTotal, allPaymentPreferences, userLogin, delegator); |
| boolean ok = OrderChangeHelper.completeOrder(dispatcher, userLogin, orderId); |
| if (Debug.verboseOn()) Debug.logVerbose("Complete Order Result - " + ok, module); |
| if (!ok) { |
| throw new GeneralException("Problem with order change; see error logs"); |
| } |
| } |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| public static void adjustFaceToFacePayment(String orderId, BigDecimal cartTotal, List<GenericValue> allPaymentPrefs, GenericValue userLogin, Delegator delegator) throws GeneralException { |
| BigDecimal prefTotal = BigDecimal.ZERO; |
| if (allPaymentPrefs != null) { |
| for (GenericValue pref : allPaymentPrefs) { |
| BigDecimal maxAmount = pref.getBigDecimal("maxAmount"); |
| if (maxAmount == null) maxAmount = BigDecimal.ZERO; |
| prefTotal = prefTotal.add(maxAmount); |
| } |
| } |
| |
| if (prefTotal.compareTo(cartTotal) > 0) { |
| BigDecimal change = prefTotal.subtract(cartTotal).negate(); |
| GenericValue newPref = delegator.makeValue("OrderPaymentPreference"); |
| newPref.set("orderId", orderId); |
| newPref.set("paymentMethodTypeId", "CASH"); |
| newPref.set("statusId", "PAYMENT_RECEIVED"); |
| newPref.set("maxAmount", change); |
| newPref.set("createdDate", UtilDateTime.nowTimestamp()); |
| if (userLogin != null) { |
| newPref.set("createdByUserLogin", userLogin.getString("userLoginId")); |
| } |
| delegator.createSetNextSeqId(newPref); |
| } |
| } |
| |
| public Map<String, Object> checkOrderBlackList() { |
| if (cart == null) { |
| return ServiceUtil.returnSuccess("success"); |
| } |
| GenericValue shippingAddressObj = this.cart.getShippingAddress(); |
| if (shippingAddressObj == null) { |
| return ServiceUtil.returnSuccess("success"); |
| } |
| String shippingAddress = UtilFormatOut.checkNull(shippingAddressObj.getString("address1")).toUpperCase(); |
| shippingAddress = UtilFormatOut.makeSqlSafe(shippingAddress); |
| List<EntityExpr> exprs = UtilMisc.toList(EntityCondition.makeCondition( |
| EntityCondition.makeCondition(EntityFunction.UPPER_FIELD("blacklistString"), EntityOperator.EQUALS, EntityFunction.UPPER(shippingAddress)), |
| EntityOperator.AND, |
| EntityCondition.makeCondition("orderBlacklistTypeId", EntityOperator.EQUALS, "BLACKLIST_ADDRESS"))); |
| String errMsg=null; |
| |
| List<GenericValue> paymentMethods = this.cart.getPaymentMethods(); |
| for (GenericValue paymentMethod : paymentMethods) { |
| if ((paymentMethod != null) && ("CREDIT_CARD".equals(paymentMethod.getString("paymentMethodTypeId")))) { |
| GenericValue creditCard = null; |
| GenericValue billingAddress = null; |
| try { |
| creditCard = paymentMethod.getRelatedOne("CreditCard", false); |
| if (creditCard != null) |
| billingAddress = creditCard.getRelatedOne("PostalAddress", false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Problems getting credit card from payment method", module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problems_reading_database", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| if (creditCard != null) { |
| String creditCardNumber = UtilFormatOut.checkNull(creditCard.getString("cardNumber")); |
| exprs.add(EntityCondition.makeCondition( |
| EntityCondition.makeCondition("blacklistString", EntityOperator.EQUALS, creditCardNumber), EntityOperator.AND, |
| EntityCondition.makeCondition("orderBlacklistTypeId", EntityOperator.EQUALS, "BLACKLIST_CREDITCARD"))); |
| } |
| if (billingAddress != null) { |
| String address = UtilFormatOut.checkNull(billingAddress.getString("address1").toUpperCase()); |
| address = UtilFormatOut.makeSqlSafe(address); |
| exprs.add(EntityCondition.makeCondition( |
| EntityCondition.makeCondition(EntityFunction.UPPER_FIELD("blacklistString"), EntityOperator.EQUALS, EntityFunction.UPPER(address)), |
| EntityOperator.AND, |
| EntityCondition.makeCondition("orderBlacklistTypeId", EntityOperator.EQUALS, "BLACKLIST_ADDRESS"))); |
| } |
| } |
| } |
| |
| List<GenericValue> blacklistFound = null; |
| if (exprs.size() > 0) { |
| try { |
| blacklistFound = EntityQuery.use(this.delegator).from("OrderBlacklist").where(exprs).queryList(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Problems with OrderBlacklist lookup.", module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problems_reading_database", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| } |
| |
| if (UtilValidate.isNotEmpty(blacklistFound)) { |
| return ServiceUtil.returnFailure(UtilProperties.getMessage(resource_error,"OrderFailed", (cart != null ? cart.getLocale() : Locale.getDefault()))); |
| } else { |
| return ServiceUtil.returnSuccess("success"); |
| } |
| } |
| |
| @Deprecated |
| public Map<String, Object> checkOrderBlacklist(GenericValue userLogin) { |
| return checkOrderBlackList(); |
| } |
| |
| public Map<String, Object> failedBlacklistCheck(GenericValue userLogin, GenericValue productStore) { |
| Map<String, Object> result; |
| String errMsg=null; |
| String REJECT_MESSAGE = productStore.getString("authFraudMessage"); |
| String orderId = this.cart.getOrderId(); |
| |
| try { |
| if (userLogin != null) { |
| // nuke the userlogin |
| userLogin.set("enabled", "N"); |
| userLogin.store(); |
| } else { |
| userLogin = EntityQuery.use(delegator).from("UserLogin").where("userLoginId", "system").cache().queryOne(); |
| } |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.database_error", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| return result; |
| } |
| |
| // set the order/item status - reverse inv |
| OrderChangeHelper.rejectOrder(dispatcher, userLogin, orderId); |
| result = ServiceUtil.returnSuccess(); |
| result.put(ModelService.ERROR_MESSAGE, REJECT_MESSAGE); |
| |
| // wipe the cart and session |
| this.cart.clear(); |
| return result; |
| } |
| |
| public Map<String, Object> checkExternalPayment(String orderId) { |
| Map<String, Object> result; |
| String errMsg = null; |
| // warning there can only be ONE payment preference for this to work |
| // you cannot accept multiple payment type when using an external gateway |
| GenericValue orderHeader = null; |
| try { |
| orderHeader = EntityQuery.use(delegator).from("OrderHeader").where("orderId", orderId).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Problems getting order header", module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problems_getting_order_header", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| return result; |
| } |
| if (orderHeader != null) { |
| List<GenericValue> paymentPrefs = null; |
| try { |
| paymentPrefs = orderHeader.getRelated("OrderPaymentPreference", null, null, false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Problems getting order payments", module); |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problems_getting_payment_preference", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| return result; |
| } |
| if (UtilValidate.isNotEmpty(paymentPrefs)) { |
| if (paymentPrefs.size() > 1) { |
| Debug.logError("Too many payment preferences, you cannot have more then one when using external gateways", module); |
| } |
| GenericValue paymentPreference = EntityUtil.getFirst(paymentPrefs); |
| String paymentMethodTypeId = paymentPreference.getString("paymentMethodTypeId"); |
| if (paymentMethodTypeId.startsWith("EXT_")) { |
| // PayPal with a PaymentMethod is not an external payment method |
| if (!(paymentMethodTypeId.equals("EXT_PAYPAL") && UtilValidate.isNotEmpty(paymentPreference.getString("paymentMethodId")))) { |
| String type = paymentMethodTypeId.substring(4); |
| result = ServiceUtil.returnSuccess(); |
| result.put("type", type.toLowerCase()); |
| return result; |
| } |
| } |
| } |
| result = ServiceUtil.returnSuccess(); |
| result.put("type", "none"); |
| return result; |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.problems_getting_order_header", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| result.put("type", "error"); |
| return result; |
| } |
| } |
| |
| /** |
| * Sets the shipping contact mechanism for a given ship group on the cart |
| * |
| * @param shipGroupIndex The index of the ship group in the cart |
| * @param shippingContactMechId The identifier of the contact |
| * @return A Map conforming to the OFBiz Service conventions containing |
| * any error messages |
| */ |
| public Map<String, Object> finalizeOrderEntryShip(int shipGroupIndex, String shippingContactMechId, String supplierPartyId) { |
| Map<String, Object> result; |
| String errMsg=null; |
| //Verify the field is valid |
| if (UtilValidate.isNotEmpty(shippingContactMechId)) { |
| this.cart.setShippingContactMechId(shipGroupIndex, shippingContactMechId); |
| if (UtilValidate.isNotEmpty(supplierPartyId)) { |
| this.cart.setSupplierPartyId(shipGroupIndex, supplierPartyId); |
| } |
| result = ServiceUtil.returnSuccess(); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.enter_shipping_address", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Sets the options associated with the order for a given ship group |
| * |
| * @param shipGroupIndex The index of the ship group in the cart |
| * @param shippingMethod The shipping method indicating the carrier and |
| * shipment type to use |
| * @param shippingInstructions Any additional handling instructions |
| * @param maySplit "true" or anything else for <code>false</code> |
| * @param giftMessage A message to have included for the recipient |
| * @param isGift "true" or anything else for <code>false</code> |
| * @param internalCode an internal code associated with the order |
| * @return A Map conforming to the OFBiz Service conventions containing |
| * any error messages |
| */ |
| public Map<String, Object> finalizeOrderEntryOptions(int shipGroupIndex, String shippingMethod, String shippingInstructions, String maySplit, |
| String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate, String orderAdditionalEmails) { |
| this.cart.setOrderAdditionalEmails(orderAdditionalEmails); |
| return finalizeOrderEntryOptions(shipGroupIndex, shippingMethod, shippingInstructions, maySplit, giftMessage, isGift, internalCode, shipBeforeDate, shipAfterDate, null, null); |
| } |
| public Map<String, Object> finalizeOrderEntryOptions(int shipGroupIndex, String shippingMethod, String shippingInstructions, String maySplit, |
| String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate, String internalOrderNotes, String shippingNotes, BigDecimal shipEstimate) { |
| this.cart.setItemShipGroupEstimate(shipEstimate, shipGroupIndex); |
| return finalizeOrderEntryOptions(shipGroupIndex, shippingMethod, shippingInstructions, maySplit, giftMessage, isGift, internalCode, shipBeforeDate, shipAfterDate, internalOrderNotes, shippingNotes); |
| } |
| public Map<String, Object> finalizeOrderEntryOptions(int shipGroupIndex, String shippingMethod, String shippingInstructions, String maySplit, |
| String giftMessage, String isGift, String internalCode, String shipBeforeDate, String shipAfterDate, String internalOrderNotes, String shippingNotes) { |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| |
| String errMsg=null; |
| //Verify the shipping method is valid |
| if (UtilValidate.isNotEmpty(shippingMethod)) { |
| int delimiterPos = shippingMethod.indexOf('@'); |
| String shipmentMethodTypeId = null; |
| String carrierPartyId = null; |
| |
| if (delimiterPos > 0) { |
| shipmentMethodTypeId = shippingMethod.substring(0, delimiterPos); |
| carrierPartyId = shippingMethod.substring(delimiterPos + 1); |
| } |
| |
| this.cart.setShipmentMethodTypeId(shipGroupIndex, shipmentMethodTypeId); |
| this.cart.setCarrierPartyId(shipGroupIndex, carrierPartyId); |
| } else { |
| errMsg = UtilProperties.getMessage(resource_error,"checkhelper.select_shipping_method", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| result = ServiceUtil.returnError(errMsg); |
| } |
| |
| //Set the remaining order options |
| this.cart.setShippingInstructions(shipGroupIndex, shippingInstructions); |
| this.cart.setGiftMessage(shipGroupIndex, giftMessage); |
| this.cart.setMaySplit(shipGroupIndex, Boolean.valueOf(maySplit)); |
| this.cart.setIsGift(shipGroupIndex, Boolean.valueOf(isGift)); |
| this.cart.setInternalCode(internalCode); // FIXME: the internalCode is not a ship group field and should be moved outside of this method |
| if (UtilValidate.isNotEmpty(internalOrderNotes)) { |
| this.cart.addInternalOrderNote(internalOrderNotes); |
| } |
| |
| // set ship before date |
| if ((shipBeforeDate != null) && (shipBeforeDate.length() > 8)) { |
| shipBeforeDate = shipBeforeDate.trim(); |
| if (shipBeforeDate.length() < 14) { |
| shipBeforeDate = shipBeforeDate + " " + "00:00:00.000"; |
| } |
| |
| try { |
| this.cart.setShipBeforeDate(shipGroupIndex, (Timestamp) ObjectType.simpleTypeConvert(shipBeforeDate, "Timestamp", null, null)); |
| } catch (Exception e) { |
| errMsg = "Ship Before Date must be a valid date formed "; |
| result = ServiceUtil.returnError(errMsg); |
| } |
| } |
| |
| // set ship after date |
| if ((shipAfterDate != null) && (shipAfterDate.length() > 8)) { |
| shipAfterDate = shipAfterDate.trim(); |
| if (shipAfterDate.length() < 14) { |
| shipAfterDate = shipAfterDate + " " + "00:00:00.000"; |
| } |
| |
| try { |
| this.cart.setShipAfterDate(shipGroupIndex, (Timestamp) ObjectType.simpleTypeConvert(shipAfterDate,"Timestamp", null, null)); |
| } catch (Exception e) { |
| errMsg = "Ship After Date must be a valid date formed "; |
| result = ServiceUtil.returnError(errMsg); |
| } |
| } |
| |
| // Shipping Notes for order will be public |
| if (UtilValidate.isNotEmpty(shippingNotes)) { |
| this.cart.addOrderNote(shippingNotes); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Sets the payment ID to use during the checkout process |
| * |
| * @param checkOutPaymentId The payment ID to be associated with the cart |
| * @return A Map conforming to the OFBiz Service conventions containing |
| * any error messages. |
| */ |
| public Map<String, Object> finalizeOrderEntryPayment(String checkOutPaymentId, BigDecimal amount, boolean singleUse, boolean append) { |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| |
| if (UtilValidate.isNotEmpty(checkOutPaymentId)) { |
| if (!append) { |
| cart.clearPayments(); |
| } |
| cart.addPaymentAmount(checkOutPaymentId, amount, singleUse); |
| } |
| |
| return result; |
| } |
| |
| public static BigDecimal availableAccountBalance(String billingAccountId, LocalDispatcher dispatcher) { |
| if (billingAccountId == null) return BigDecimal.ZERO; |
| try { |
| Map<String, Object> res = dispatcher.runSync("calcBillingAccountBalance", UtilMisc.toMap("billingAccountId", billingAccountId)); |
| BigDecimal availableBalance = (BigDecimal) res.get("accountBalance"); |
| if (availableBalance != null) { |
| return availableBalance; |
| } |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| } |
| return BigDecimal.ZERO; |
| } |
| |
| public BigDecimal availableAccountBalance(String billingAccountId) { |
| return availableAccountBalance(billingAccountId, dispatcher); |
| } |
| |
| public Map<String, BigDecimal> makeBillingAccountMap(List<GenericValue> paymentPrefs) { |
| Map<String, BigDecimal> accountMap = new HashMap<String, BigDecimal>(); |
| if (paymentPrefs != null) { |
| for (GenericValue pp : paymentPrefs) { |
| if (pp.get("billingAccountId") != null) { |
| accountMap.put(pp.getString("billingAccountId"), pp.getBigDecimal("maxAmount")); |
| } |
| } |
| } |
| return accountMap; |
| } |
| |
| public Map<String, Object> validatePaymentMethods() { |
| String errMsg = null; |
| String billingAccountId = cart.getBillingAccountId(); |
| BigDecimal billingAccountAmt = cart.getBillingAccountAmount(); |
| BigDecimal availableAmount = this.availableAccountBalance(billingAccountId); |
| if (billingAccountAmt.compareTo(availableAmount) > 0) { |
| Debug.logError("Billing account " + billingAccountId + " has [" + availableAmount + "] available but needs [" + billingAccountAmt + "] for this order", module); |
| Map<String, String> messageMap = UtilMisc.toMap("billingAccountId", billingAccountId); |
| errMsg = UtilProperties.getMessage(resource_error, "checkevents.not_enough_available_on_account", messageMap, (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| |
| // payment by billing account only requires more checking |
| List<String> paymentMethods = cart.getPaymentMethodIds(); |
| List<String> paymentTypes = cart.getPaymentMethodTypeIds(); |
| if (paymentTypes.contains("EXT_BILLACT") && paymentTypes.size() == 1 && paymentMethods.size() == 0) { |
| if (cart.getGrandTotal().compareTo(availableAmount) > 0) { |
| errMsg = UtilProperties.getMessage(resource_error, "checkevents.insufficient_credit_available_on_account", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| } |
| |
| // validate any gift card balances |
| this.validateGiftCardAmounts(); |
| |
| // update the selected payment methods amount with valid numbers |
| if (paymentMethods != null) { |
| List<String> nullPaymentIds = new ArrayList<String>(); |
| for (String paymentMethodId : paymentMethods) { |
| BigDecimal paymentAmount = cart.getPaymentAmount(paymentMethodId); |
| if (paymentAmount == null || paymentAmount.compareTo(BigDecimal.ZERO) == 0) { |
| if (Debug.verboseOn()) Debug.logVerbose("Found null paymentMethodId - " + paymentMethodId, module); |
| nullPaymentIds.add(paymentMethodId); |
| } |
| } |
| for (String paymentMethodId : nullPaymentIds) { |
| BigDecimal selectedPaymentTotal = cart.getPaymentTotal(); |
| BigDecimal requiredAmount = cart.getGrandTotal(); |
| BigDecimal newAmount = requiredAmount.subtract(selectedPaymentTotal); |
| boolean setOverflow = false; |
| |
| ShoppingCart.CartPaymentInfo info = cart.getPaymentInfo(paymentMethodId); |
| |
| if (Debug.verboseOn()) Debug.logVerbose("Remaining total is - " + newAmount, module); |
| if (newAmount.compareTo(BigDecimal.ZERO) > 0) { |
| info.amount = newAmount; |
| if (Debug.verboseOn()) Debug.logVerbose("Set null paymentMethodId - " + info.paymentMethodId + " / " + info.amount, module); |
| } else { |
| info.amount = BigDecimal.ZERO; |
| if (Debug.verboseOn()) Debug.logVerbose("Set null paymentMethodId - " + info.paymentMethodId + " / " + info.amount, module); |
| } |
| if (!setOverflow) { |
| info.overflow = setOverflow = true; |
| if (Debug.verboseOn()) Debug.logVerbose("Set overflow flag on payment - " + info.paymentMethodId, module); |
| } |
| } |
| } |
| |
| // verify the selected payment method amounts will cover the total |
| BigDecimal reqAmtPreParse = cart.getGrandTotal().subtract(cart.getBillingAccountAmount()); |
| BigDecimal selectedPmnt = cart.getPaymentTotal(); |
| |
| BigDecimal selectedPaymentTotal = selectedPmnt.setScale(scale, rounding); |
| BigDecimal requiredAmount = reqAmtPreParse.setScale(scale, rounding); |
| |
| if (UtilValidate.isNotEmpty(paymentMethods) && requiredAmount.compareTo(selectedPaymentTotal) > 0) { |
| Debug.logError("Required Amount : " + requiredAmount + " / Selected Amount : " + selectedPaymentTotal, module); |
| errMsg = UtilProperties.getMessage(resource_error, "checkevents.payment_not_cover_this_order", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| if (UtilValidate.isNotEmpty(paymentMethods) && requiredAmount.compareTo(selectedPaymentTotal) < 0) { |
| BigDecimal changeAmount = selectedPaymentTotal.subtract(requiredAmount); |
| if (!paymentTypes.contains("CASH")) { |
| Debug.logError("Change Amount : " + changeAmount + " / No cash.", module); |
| errMsg = UtilProperties.getMessage(resource_error, "checkhelper.change_returned_cannot_be_greater_than_cash", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } else { |
| int cashIndex = paymentTypes.indexOf("CASH"); |
| String cashId = paymentTypes.get(cashIndex); |
| BigDecimal cashAmount = cart.getPaymentAmount(cashId); |
| if (cashAmount.compareTo(changeAmount) < 0) { |
| Debug.logError("Change Amount : " + changeAmount + " / Cash Amount : " + cashAmount, module); |
| errMsg = UtilProperties.getMessage(resource_error, "checkhelper.change_returned_cannot_be_greater_than_cash", (cart != null ? cart.getLocale() : Locale.getDefault())); |
| return ServiceUtil.returnError(errMsg); |
| } |
| } |
| } |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| public void validateGiftCardAmounts() { |
| // get the product store |
| GenericValue productStore = ProductStoreWorker.getProductStore(cart.getProductStoreId(), delegator); |
| if (productStore != null && !"Y".equalsIgnoreCase(productStore.getString("checkGcBalance"))) { |
| return; |
| } |
| |
| // get the payment config |
| String paymentConfig = ProductStoreWorker.getProductStorePaymentProperties(delegator, cart.getProductStoreId(), "GIFT_CARD", null, true); |
| String giftCardType = EntityUtilProperties.getPropertyValue(paymentConfig, "", "ofbiz", delegator); |
| String balanceField = null; |
| |
| // get the gift card objects to check |
| for (GenericValue gc : cart.getGiftCards()) { |
| Map<String, Object> gcBalanceMap = null; |
| BigDecimal gcBalance = BigDecimal.ZERO; |
| try { |
| Map<String, Object> ctx = UtilMisc.<String, Object>toMap("userLogin", cart.getUserLogin()); |
| ctx.put("currency", cart.getCurrency()); |
| if ("ofbiz".equalsIgnoreCase(giftCardType)) { |
| balanceField = "balance"; |
| ctx.put("cardNumber", gc.getString("cardNumber")); |
| ctx.put("pinNumber", gc.getString("pinNumber")); |
| gcBalanceMap = dispatcher.runSync("checkGiftCertificateBalance", ctx); |
| } |
| if ("valuelink".equalsIgnoreCase(giftCardType)) { |
| balanceField = "balance"; |
| ctx.put("paymentConfig", paymentConfig); |
| ctx.put("cardNumber", gc.getString("cardNumber")); |
| ctx.put("pin", gc.getString("pinNumber")); |
| gcBalanceMap = dispatcher.runSync("balanceInquireGiftCard", ctx); |
| } |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| } |
| if (gcBalanceMap != null) { |
| BigDecimal bal = (BigDecimal) gcBalanceMap.get(balanceField); |
| if (bal != null) { |
| gcBalance = bal; |
| } |
| } |
| |
| // get the bill-up to amount |
| BigDecimal billUpTo = cart.getPaymentAmount(gc.getString("paymentMethodId")); |
| |
| // null bill-up to means use the full balance || update the bill-up to with the balance |
| if (billUpTo == null || billUpTo.compareTo(BigDecimal.ZERO) == 0 || gcBalance.compareTo(billUpTo) < 0) { |
| cart.addPaymentAmount(gc.getString("paymentMethodId"), gcBalance); |
| } |
| } |
| } |
| } |
