| /******************************************************************************* |
| * 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.shoppinglist; |
| |
| import java.math.BigDecimal; |
| import java.sql.Timestamp; |
| import java.util.Date; |
| import java.util.HashMap; |
| 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.UtilDateTime; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| 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.transaction.TransactionUtil; |
| import org.apache.ofbiz.entity.util.EntityListIterator; |
| 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.order.OrderReadHelper; |
| import org.apache.ofbiz.order.shoppingcart.CartItemModifyException; |
| import org.apache.ofbiz.order.shoppingcart.CheckOutHelper; |
| import org.apache.ofbiz.order.shoppingcart.ItemNotFoundException; |
| import org.apache.ofbiz.order.shoppingcart.ShoppingCart; |
| import org.apache.ofbiz.product.config.ProductConfigWorker; |
| import org.apache.ofbiz.product.config.ProductConfigWrapper; |
| import org.apache.ofbiz.product.product.ProductWorker; |
| import org.apache.ofbiz.product.store.ProductStoreWorker; |
| import org.apache.ofbiz.service.DispatchContext; |
| import org.apache.ofbiz.service.GenericServiceException; |
| import org.apache.ofbiz.service.LocalDispatcher; |
| import org.apache.ofbiz.service.ServiceUtil; |
| import org.apache.ofbiz.service.calendar.RecurrenceInfo; |
| import org.apache.ofbiz.service.calendar.RecurrenceInfoException; |
| |
| import com.ibm.icu.util.Calendar; |
| |
| /** |
| * Shopping List Services |
| */ |
| public class ShoppingListServices { |
| |
| public static final String module = ShoppingListServices.class.getName(); |
| public static final String resource_error = "OrderErrorUiLabels"; |
| |
| public static Map<String, Object> setShoppingListRecurrence(DispatchContext dctx, Map<String, ? extends Object> context) { |
| Delegator delegator = dctx.getDelegator(); |
| Timestamp startDate = (Timestamp) context.get("startDateTime"); |
| Timestamp endDate = (Timestamp) context.get("endDateTime"); |
| Integer frequency = (Integer) context.get("frequency"); |
| Integer interval = (Integer) context.get("intervalNumber"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| if (frequency == null || interval == null) { |
| Debug.logWarning(UtilProperties.getMessage(resource_error,"OrderFrequencyOrIntervalWasNotSpecified", locale), module); |
| return ServiceUtil.returnSuccess(); |
| } |
| |
| if (startDate == null) { |
| switch (frequency.intValue()) { |
| case 5: |
| startDate = UtilDateTime.getWeekStart(UtilDateTime.nowTimestamp(), 0, interval.intValue()); |
| break; |
| case 6: |
| startDate = UtilDateTime.getMonthStart(UtilDateTime.nowTimestamp(), 0, interval.intValue()); |
| break; |
| case 7: |
| startDate = UtilDateTime.getYearStart(UtilDateTime.nowTimestamp(), 0, interval.intValue()); |
| break; |
| default: |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderInvalidFrequencyForShoppingListRecurrence",locale)); |
| } |
| } |
| |
| long startTime = startDate.getTime(); |
| long endTime = 0; |
| if (endDate != null) { |
| endTime = endDate.getTime(); |
| } |
| |
| RecurrenceInfo recInfo = null; |
| try { |
| recInfo = RecurrenceInfo.makeInfo(delegator, startTime, frequency.intValue(), interval.intValue(), -1, endTime); |
| } catch (RecurrenceInfoException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToCreateShoppingListRecurrenceInformation",locale)); |
| } |
| |
| Debug.logInfo("Next Recurrence - " + UtilDateTime.getTimestamp(recInfo.next()), module); |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("recurrenceInfoId", recInfo.getID()); |
| |
| return result; |
| } |
| |
| public static Map<String, Object> createListReorders(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| boolean beganTransaction = false; |
| try { |
| beganTransaction = TransactionUtil.begin(); |
| |
| EntityListIterator eli = null; |
| eli = EntityQuery.use(delegator).from("ShoppingList").where("shoppingListTypeId", "SLT_AUTO_REODR", "isActive", "Y").orderBy("-lastOrderedDate").queryIterator(); |
| |
| if (eli != null) { |
| GenericValue shoppingList; |
| while (((shoppingList = eli.next()) != null)) { |
| Timestamp lastOrder = shoppingList.getTimestamp("lastOrderedDate"); |
| GenericValue recurrenceInfo = null; |
| recurrenceInfo = shoppingList.getRelatedOne("RecurrenceInfo", false); |
| |
| Timestamp startDateTime = recurrenceInfo.getTimestamp("startDateTime"); |
| RecurrenceInfo recurrence = null; |
| if (recurrenceInfo != null) { |
| try { |
| recurrence = new RecurrenceInfo(recurrenceInfo); |
| } catch (RecurrenceInfoException e) { |
| Debug.logError(e, module); |
| } |
| } |
| |
| // check the next recurrence |
| if (recurrence != null) { |
| long next = lastOrder == null ? recurrence.next(startDateTime.getTime()) : recurrence.next(lastOrder.getTime()); |
| Timestamp now = UtilDateTime.nowTimestamp(); |
| Timestamp nextOrder = UtilDateTime.getDayStart(UtilDateTime.getTimestamp(next)); |
| |
| if (nextOrder.after(now)) { |
| continue; |
| } |
| } else { |
| continue; |
| } |
| |
| ShoppingCart listCart = makeShoppingListCart(dispatcher, shoppingList, locale); |
| CheckOutHelper helper = new CheckOutHelper(dispatcher, delegator, listCart); |
| |
| // store the order |
| Map<String, Object> createResp = helper.createOrder(userLogin); |
| if (createResp != null && ServiceUtil.isError(createResp)) { |
| Debug.logError("Cannot create order for shopping list - " + shoppingList, module); |
| } else { |
| String orderId = (String) createResp.get("orderId"); |
| |
| // authorize the payments |
| Map<String, Object> payRes = null; |
| try { |
| payRes = helper.processPayment(ProductStoreWorker.getProductStore(listCart.getProductStoreId(), delegator), userLogin); |
| } catch (GeneralException e) { |
| Debug.logError(e, module); |
| } |
| |
| if (payRes != null && ServiceUtil.isError(payRes)) { |
| Debug.logError("Payment processing problems with shopping list - " + shoppingList, module); |
| } |
| |
| shoppingList.set("lastOrderedDate", UtilDateTime.nowTimestamp()); |
| shoppingList.store(); |
| |
| // send notification |
| try { |
| dispatcher.runAsync("sendOrderPayRetryNotification", UtilMisc.toMap("orderId", orderId)); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| } |
| |
| // increment the recurrence |
| recurrence.incrementCurrentCount(); |
| } |
| } |
| |
| eli.close(); |
| } |
| |
| return ServiceUtil.returnSuccess(); |
| } catch (GenericEntityException e) { |
| try { |
| // only rollback the transaction if we started one... |
| TransactionUtil.rollback(beganTransaction, "Error creating shopping list auto-reorders", e); |
| } catch (GenericEntityException e2) { |
| Debug.logError(e2, "[Delegator] Could not rollback transaction: " + e2.toString(), module); |
| } |
| |
| String errMsg = UtilProperties.getMessage(resource_error, "OrderErrorWhileCreatingNewShoppingListBasedAutomaticReorder", UtilMisc.toMap("errorString", e.toString()), locale); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } finally { |
| try { |
| // only commit the transaction if we started one... this will throw an exception if it fails |
| TransactionUtil.commit(beganTransaction); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Could not commit transaction for creating new shopping list based automatic reorder", module); |
| } |
| } |
| } |
| |
| public static Map<String, Object> splitShipmentMethodString(DispatchContext dctx, Map<String, ? extends Object> context) { |
| String shipmentMethodString = (String) context.get("shippingMethodString"); |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| |
| if (UtilValidate.isNotEmpty(shipmentMethodString)) { |
| int delimiterPos = shipmentMethodString.indexOf('@'); |
| String shipmentMethodTypeId = null; |
| String carrierPartyId = null; |
| |
| if (delimiterPos > 0) { |
| shipmentMethodTypeId = shipmentMethodString.substring(0, delimiterPos); |
| carrierPartyId = shipmentMethodString.substring(delimiterPos + 1); |
| result.put("shipmentMethodTypeId", shipmentMethodTypeId); |
| result.put("carrierPartyId", carrierPartyId); |
| } |
| } |
| return result; |
| } |
| |
| public static Map<String, Object> makeListFromOrder(DispatchContext dctx, Map<String, ? extends Object> context) { |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| Delegator delegator = dctx.getDelegator(); |
| |
| String shoppingListTypeId = (String) context.get("shoppingListTypeId"); |
| String shoppingListId = (String) context.get("shoppingListId"); |
| String orderId = (String) context.get("orderId"); |
| String partyId = (String) context.get("partyId"); |
| |
| Timestamp startDate = (Timestamp) context.get("startDateTime"); |
| Timestamp endDate = (Timestamp) context.get("endDateTime"); |
| Integer frequency = (Integer) context.get("frequency"); |
| Integer interval = (Integer) context.get("intervalNumber"); |
| |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| Locale locale = (Locale) context.get("locale"); |
| |
| boolean beganTransaction = false; |
| try { |
| beganTransaction = TransactionUtil.begin(); |
| |
| GenericValue orderHeader = null; |
| orderHeader = EntityQuery.use(delegator).from("OrderHeader").where("orderId", orderId).queryOne(); |
| |
| if (orderHeader == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToLocateOrder", UtilMisc.toMap("orderId",orderId), locale)); |
| } |
| String productStoreId = orderHeader.getString("productStoreId"); |
| |
| if (UtilValidate.isEmpty(shoppingListId)) { |
| // create a new shopping list |
| if (partyId == null) { |
| partyId = userLogin.getString("partyId"); |
| } |
| |
| Map<String, Object> serviceCtx = UtilMisc.<String, Object>toMap("userLogin", userLogin, "partyId", partyId, |
| "productStoreId", productStoreId, "listName", "List Created From Order #" + orderId); |
| |
| if (UtilValidate.isNotEmpty(shoppingListTypeId)) { |
| serviceCtx.put("shoppingListTypeId", shoppingListTypeId); |
| } |
| |
| Map<String, Object> newListResult = null; |
| try { |
| |
| newListResult = dispatcher.runSync("createShoppingList", serviceCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, "Problems creating new ShoppingList", module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToCreateNewShoppingList",locale)); |
| } |
| |
| // check for errors |
| if (ServiceUtil.isError(newListResult)) { |
| return ServiceUtil.returnError(ServiceUtil.getErrorMessage(newListResult)); |
| } |
| |
| // get the new list id |
| if (newListResult != null) { |
| shoppingListId = (String) newListResult.get("shoppingListId"); |
| } |
| } |
| |
| GenericValue shoppingList = null; |
| shoppingList = EntityQuery.use(delegator).from("ShoppingList").where("shoppingListId", shoppingListId).queryOne(); |
| |
| if (shoppingList == null) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderNoShoppingListAvailable",locale)); |
| } |
| shoppingListTypeId = shoppingList.getString("shoppingListTypeId"); |
| |
| OrderReadHelper orh; |
| try { |
| orh = new OrderReadHelper(orderHeader); |
| } catch (IllegalArgumentException e) { |
| Debug.logError(e, module); |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToLoadOrderReadHelper", UtilMisc.toMap("orderId",orderId), locale)); |
| } |
| |
| List<GenericValue> orderItems = orh.getOrderItems(); |
| for (GenericValue orderItem : orderItems) { |
| String productId = orderItem.getString("productId"); |
| if (UtilValidate.isNotEmpty(productId)) { |
| Map<String, Object> ctx = UtilMisc.<String, Object>toMap("userLogin", userLogin, "shoppingListId", shoppingListId, "productId", |
| orderItem.get("productId"), "quantity", orderItem.get("quantity")); |
| if (EntityTypeUtil.hasParentType(delegator, "ProductType", "productTypeId", ProductWorker.getProductTypeId(delegator, productId), "parentTypeId", "AGGREGATED")) { |
| try { |
| GenericValue instanceProduct = EntityQuery.use(delegator).from("Product").where("productId", productId).queryOne(); |
| String configId = instanceProduct.getString("configId"); |
| ctx.put("configId", configId); |
| String aggregatedProductId = ProductWorker.getInstanceAggregatedId(delegator, productId); |
| //override the instance productId with aggregated productId |
| ctx.put("productId", aggregatedProductId); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| } |
| Map<String, Object> serviceResult = null; |
| try { |
| serviceResult = dispatcher.runSync("createShoppingListItem", ctx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| } |
| if (serviceResult == null || ServiceUtil.isError(serviceResult)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToAddItemToShoppingList",UtilMisc.toMap("shoppingListId",shoppingListId), locale)); |
| } |
| } |
| } |
| |
| if ("SLT_AUTO_REODR".equals(shoppingListTypeId)) { |
| GenericValue paymentPref = EntityUtil.getFirst(orh.getPaymentPreferences()); |
| GenericValue shipGroup = EntityUtil.getFirst(orh.getOrderItemShipGroups()); |
| |
| Map<String, Object> slCtx = new HashMap<String, Object>(); |
| slCtx.put("shipmentMethodTypeId", shipGroup.get("shipmentMethodTypeId")); |
| slCtx.put("carrierRoleTypeId", shipGroup.get("carrierRoleTypeId")); |
| slCtx.put("carrierPartyId", shipGroup.get("carrierPartyId")); |
| slCtx.put("contactMechId", shipGroup.get("contactMechId")); |
| slCtx.put("paymentMethodId", paymentPref.get("paymentMethodId")); |
| slCtx.put("currencyUom", orh.getCurrency()); |
| slCtx.put("startDateTime", startDate); |
| slCtx.put("endDateTime", endDate); |
| slCtx.put("frequency", frequency); |
| slCtx.put("intervalNumber", interval); |
| slCtx.put("isActive", "Y"); |
| slCtx.put("shoppingListId", shoppingListId); |
| slCtx.put("userLogin", userLogin); |
| |
| Map<String, Object> slUpResp = null; |
| try { |
| slUpResp = dispatcher.runSync("updateShoppingList", slCtx); |
| } catch (GenericServiceException e) { |
| Debug.logError(e, module); |
| } |
| |
| if (slUpResp == null || ServiceUtil.isError(slUpResp)) { |
| return ServiceUtil.returnError(UtilProperties.getMessage(resource_error,"OrderUnableToUpdateShoppingListInformation",UtilMisc.toMap("shoppingListId",shoppingListId), locale)); |
| } |
| } |
| |
| Map<String, Object> result = ServiceUtil.returnSuccess(); |
| result.put("shoppingListId", shoppingListId); |
| return result; |
| |
| } catch (GenericEntityException e) { |
| try { |
| // only rollback the transaction if we started one... |
| TransactionUtil.rollback(beganTransaction, "Error making shopping list from order", e); |
| } catch (GenericEntityException e2) { |
| Debug.logError(e2, "[Delegator] Could not rollback transaction: " + e2.toString(), module); |
| } |
| |
| String errMsg = UtilProperties.getMessage(resource_error, "OrderErrorWhileCreatingNewShoppingListBasedOnOrder", UtilMisc.toMap("errorString", e.toString()), locale); |
| Debug.logError(e, errMsg, module); |
| return ServiceUtil.returnError(errMsg); |
| } finally { |
| try { |
| // only commit the transaction if we started one... this will throw an exception if it fails |
| TransactionUtil.commit(beganTransaction); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Could not commit transaction for creating new shopping list based on order", module); |
| } |
| } |
| } |
| /** |
| * Create a new shoppingCart form a shoppingList |
| * @param dispatcher the local dispatcher |
| * @param shoppingList a GenericValue object of the shopping list |
| * @param locale the locale in use |
| * @return returns a new shopping cart form a shopping list |
| */ |
| public static ShoppingCart makeShoppingListCart(LocalDispatcher dispatcher, GenericValue shoppingList, Locale locale) { |
| return makeShoppingListCart(null, dispatcher, shoppingList, locale); } |
| |
| /** |
| * Add a shoppinglist to an existing shoppingcart |
| * |
| * @param listCart the shopping cart list |
| * @param dispatcher the local dispatcher |
| * @param shoppingList a GenericValue object of the shopping list |
| * @param locale the locale in use |
| * @return the modified shopping cart adding the shopping list elements |
| */ |
| public static ShoppingCart makeShoppingListCart(ShoppingCart listCart, LocalDispatcher dispatcher, GenericValue shoppingList, Locale locale) { |
| Delegator delegator = dispatcher.getDelegator(); |
| if (shoppingList != null && shoppingList.get("productStoreId") != null) { |
| String productStoreId = shoppingList.getString("productStoreId"); |
| String currencyUom = shoppingList.getString("currencyUom"); |
| if (currencyUom == null) { |
| GenericValue productStore = ProductStoreWorker.getProductStore(productStoreId, delegator); |
| if (productStore == null) { |
| return null; |
| } |
| currencyUom = productStore.getString("defaultCurrencyUomId"); |
| } |
| if (locale == null) { |
| locale = Locale.getDefault(); |
| } |
| |
| List<GenericValue> items = null; |
| try { |
| items = shoppingList.getRelated("ShoppingListItem", null, UtilMisc.toList("shoppingListItemSeqId"), false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| |
| if (UtilValidate.isNotEmpty(items)) { |
| if (listCart == null) { |
| listCart = new ShoppingCart(delegator, productStoreId, locale, currencyUom); |
| listCart.setOrderPartyId(shoppingList.getString("partyId")); |
| listCart.setAutoOrderShoppingListId(shoppingList.getString("shoppingListId")); |
| } else { |
| if (!listCart.getPartyId().equals(shoppingList.getString("partyId"))) { |
| Debug.logError("CANNOT add shoppingList: " + shoppingList.getString("shoppingListId") |
| + " of partyId: " + shoppingList.getString("partyId") |
| + " to a shoppingcart with a different orderPartyId: " |
| + listCart.getPartyId(), module); |
| return listCart; |
| } |
| } |
| |
| |
| ProductConfigWrapper configWrapper = null; |
| for (GenericValue shoppingListItem : items) { |
| String productId = shoppingListItem.getString("productId"); |
| BigDecimal quantity = shoppingListItem.getBigDecimal("quantity"); |
| Timestamp reservStart = shoppingListItem.getTimestamp("reservStart"); |
| BigDecimal reservLength = null; |
| String configId = shoppingListItem.getString("configId"); |
| |
| if (shoppingListItem.get("reservLength") != null) { |
| reservLength = shoppingListItem.getBigDecimal("reservLength"); |
| } |
| BigDecimal reservPersons = null; |
| if (shoppingListItem.get("reservPersons") != null) { |
| reservPersons = shoppingListItem.getBigDecimal("reservPersons"); |
| } |
| if (UtilValidate.isNotEmpty(productId) && quantity != null) { |
| |
| if (UtilValidate.isNotEmpty(configId)) { |
| configWrapper = ProductConfigWorker.loadProductConfigWrapper(delegator, dispatcher, configId, productId, listCart.getProductStoreId(), null, listCart.getWebSiteId(), listCart.getCurrency(), listCart.getLocale(), listCart.getAutoUserLogin()); |
| } |
| // list items are noted in the shopping cart |
| String listId = shoppingListItem.getString("shoppingListId"); |
| String itemId = shoppingListItem.getString("shoppingListItemSeqId"); |
| Map<String, Object> attributes = UtilMisc.<String, Object>toMap("shoppingListId", listId, "shoppingListItemSeqId", itemId); |
| |
| try { |
| listCart.addOrIncreaseItem(productId, null, quantity, reservStart, reservLength, reservPersons, null, null, null, null, null, attributes, null, configWrapper, null, null, null, dispatcher); |
| } catch (CartItemModifyException e) { |
| Debug.logError(e, "Unable to add product to List Cart - " + productId, module); |
| } catch (ItemNotFoundException e) { |
| Debug.logError(e, "Product not found - " + productId, module); |
| } |
| } |
| } |
| |
| if (listCart.size() > 0) { |
| if (UtilValidate.isNotEmpty(shoppingList.get("paymentMethodId"))) { |
| listCart.addPayment(shoppingList.getString("paymentMethodId")); |
| } |
| if (UtilValidate.isNotEmpty(shoppingList.get("contactMechId"))) { |
| listCart.setAllShippingContactMechId(shoppingList.getString("contactMechId")); |
| } |
| if (UtilValidate.isNotEmpty(shoppingList.get("shipmentMethodTypeId"))) { |
| listCart.setAllShipmentMethodTypeId(shoppingList.getString("shipmentMethodTypeId")); |
| } |
| if (UtilValidate.isNotEmpty(shoppingList.get("carrierPartyId"))) { |
| listCart.setAllCarrierPartyId(shoppingList.getString("carrierPartyId")); |
| } |
| if (UtilValidate.isNotEmpty(shoppingList.getString("productPromoCodeId"))) { |
| listCart.addProductPromoCode(shoppingList.getString("productPromoCodeId"), dispatcher); |
| } |
| } |
| } |
| } |
| return listCart; |
| } |
| |
| public static ShoppingCart makeShoppingListCart(LocalDispatcher dispatcher, String shoppingListId, Locale locale) { |
| Delegator delegator = dispatcher.getDelegator(); |
| GenericValue shoppingList = null; |
| try { |
| shoppingList = EntityQuery.use(delegator).from("ShoppingList").where("shoppingListId", shoppingListId).queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, module); |
| } |
| return makeShoppingListCart(dispatcher, shoppingList, locale); |
| } |
| |
| /** |
| * |
| * Given an orderId, this service will look through all its OrderItems and for each shoppingListItemId |
| * and shoppingListItemSeqId, update the quantity purchased in the ShoppingListItem entity. Used for |
| * tracking how many of shopping list items are purchased. This service is mounted as a seca on storeOrder. |
| * |
| * @param ctx - The DispatchContext that this service is operating in |
| * @param context - Map containing the input parameters |
| * @return Map with the result of the service, the output parameters |
| */ |
| public static Map<String, Object> updateShoppingListQuantitiesFromOrder(DispatchContext ctx, Map<String, ? extends Object> context) { |
| Map<String, Object> result = new HashMap<String, Object>(); |
| Delegator delegator = ctx.getDelegator(); |
| String orderId = (String) context.get("orderId"); |
| try { |
| List<GenericValue> orderItems = EntityQuery.use(delegator).from("OrderItem").where("orderId", orderId).queryList(); |
| for (GenericValue orderItem : orderItems) { |
| String shoppingListId = orderItem.getString("shoppingListId"); |
| String shoppingListItemSeqId = orderItem.getString("shoppingListItemSeqId"); |
| if (UtilValidate.isNotEmpty(shoppingListId)) { |
| GenericValue shoppingListItem = EntityQuery.use(delegator).from("ShoppingListItem").where("shoppingListId", shoppingListId, "shoppingListItemSeqId", shoppingListItemSeqId).queryOne(); |
| if (shoppingListItem != null) { |
| BigDecimal quantityPurchased = shoppingListItem.getBigDecimal("quantityPurchased"); |
| BigDecimal orderQuantity = orderItem.getBigDecimal("quantity"); |
| if (quantityPurchased != null) { |
| shoppingListItem.set("quantityPurchased", orderQuantity.add(quantityPurchased)); |
| } else { |
| shoppingListItem.set("quantityPurchased", orderQuantity); |
| } |
| shoppingListItem.store(); |
| } |
| } |
| } |
| } catch (GenericEntityException gee) { |
| Debug.logInfo("updateShoppingListQuantitiesFromOrder error:"+gee.getMessage(), module); |
| } catch (Exception e) { |
| Debug.logInfo("updateShoppingListQuantitiesFromOrder error:"+e.getMessage(), module); |
| } |
| return result; |
| } |
| |
| public static Map<String,Object> autoDeleteAutoSaveShoppingList(DispatchContext dctx, Map<String, ? extends Object> context) { |
| Delegator delegator = dctx.getDelegator(); |
| LocalDispatcher dispatcher = dctx.getDispatcher(); |
| GenericValue userLogin = (GenericValue) context.get("userLogin"); |
| List<GenericValue> shoppingList = null; |
| try { |
| shoppingList = EntityQuery.use(delegator).from("ShoppingList").where("partyId", null, "shoppingListTypeId", "SLT_SPEC_PURP").queryList(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e.getMessage(), module); |
| } |
| String maxDaysStr = EntityUtilProperties.getPropertyValue("order", "autosave.max.age", "30", delegator); |
| int maxDays = 0; |
| try { |
| maxDays = Integer.parseInt(maxDaysStr); |
| } catch (NumberFormatException e) { |
| Debug.logError(e, "Unable to get maxDays", module); |
| } |
| for (GenericValue sl : shoppingList) { |
| if (maxDays > 0) { |
| Timestamp lastModified = sl.getTimestamp("lastAdminModified"); |
| if (lastModified == null) { |
| lastModified = sl.getTimestamp("lastUpdatedStamp"); |
| } |
| Calendar cal = Calendar.getInstance(); |
| cal.setTimeInMillis(lastModified.getTime()); |
| cal.add(Calendar.DAY_OF_YEAR, maxDays); |
| Date expireDate = cal.getTime(); |
| Date nowDate = new Date(); |
| if (expireDate.equals(nowDate) || nowDate.after(expireDate)) { |
| List<GenericValue> shoppingListItems = null; |
| try { |
| shoppingListItems = sl.getRelated("ShoppingListItem", null, null, false); |
| } catch (GenericEntityException e) { |
| Debug.logError(e.getMessage(), module); |
| } |
| for (GenericValue sli : shoppingListItems) { |
| try { |
| dispatcher.runSync("removeShoppingListItem", UtilMisc.toMap("shoppingListId", sl.getString("shoppingListId"), |
| "shoppingListItemSeqId", sli.getString("shoppingListItemSeqId"), |
| "userLogin", userLogin)); |
| } catch (GenericServiceException e) { |
| Debug.logError(e.getMessage(), module); |
| } |
| } |
| try { |
| dispatcher.runSync("removeShoppingList", UtilMisc.toMap("shoppingListId", sl.getString("shoppingListId"), "userLogin", userLogin)); |
| } catch (GenericServiceException e) { |
| Debug.logError(e.getMessage(), module); |
| } |
| } |
| } |
| } |
| return ServiceUtil.returnSuccess(); |
| } |
| } |
