in applications/order/src/main/java/org/apache/ofbiz/order/shoppingcart/ShoppingCartEvents.java [171:701]
public static String addToCart(HttpServletRequest request, HttpServletResponse response) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
LocalDispatcher dispatcher = (LocalDispatcher) request.getAttribute("dispatcher");
ShoppingCart cart = getCartObject(request);
ShoppingCartHelper cartHelper = new ShoppingCartHelper(delegator, dispatcher, cart);
String controlDirective = null;
Map<String, Object> result = null;
String productId = null;
String parentProductId = null;
String itemType = null;
String itemDescription = null;
String productCategoryId = null;
String priceStr = null;
BigDecimal price = null;
String quantityStr = null;
BigDecimal quantity = BigDecimal.ZERO;
String reservStartStr = null;
String reservEndStr = null;
Timestamp reservStart = null;
Timestamp reservEnd = null;
String reservLengthStr = null;
BigDecimal reservLength = null;
String reservPersonsStr = null;
BigDecimal reservPersons = null;
String accommodationMapId = null;
String accommodationSpotId = null;
String shipBeforeDateStr = null;
String shipAfterDateStr = null;
String reserveAfterDateStr = null;
Timestamp shipBeforeDate = null;
Timestamp shipAfterDate = null;
Timestamp reserveAfterDate = null;
String numberOfDay = null;
// not used right now: Map attributes = null;
String catalogId = CatalogWorker.getCurrentCatalogId(request);
Locale locale = UtilHttp.getLocale(request);
// Get the parameters as a MAP, remove the productId and quantity params.
Map<String, Object> paramMap = UtilHttp.getCombinedMap(request);
String itemGroupNumber = (String) paramMap.get("itemGroupNumber");
// Get shoppingList info if passed
String shoppingListId = (String) paramMap.get("shoppingListId");
String shoppingListItemSeqId = (String) paramMap.get("shoppingListItemSeqId");
if (paramMap.containsKey("ADD_PRODUCT_ID")) {
productId = (String) paramMap.remove("ADD_PRODUCT_ID");
} else if (paramMap.containsKey("add_product_id")) {
Object object = paramMap.remove("add_product_id");
try {
productId = (String) object;
} catch (ClassCastException e) {
List<String> productList = UtilGenerics.cast(object);
productId = productList.get(0);
}
}
if (paramMap.containsKey("PRODUCT_ID")) {
parentProductId = (String) paramMap.remove("PRODUCT_ID");
} else if (paramMap.containsKey("product_id")) {
parentProductId = (String) paramMap.remove("product_id");
}
Debug.logInfo("adding item product " + productId, MODULE);
Debug.logInfo("adding item parent product " + parentProductId, MODULE);
if (paramMap.containsKey("ADD_CATEGORY_ID")) {
productCategoryId = (String) paramMap.remove("ADD_CATEGORY_ID");
} else if (paramMap.containsKey("add_category_id")) {
productCategoryId = (String) paramMap.remove("add_category_id");
}
if (productCategoryId != null && productCategoryId.isEmpty()) {
productCategoryId = null;
}
if (paramMap.containsKey("ADD_ITEM_TYPE")) {
itemType = (String) paramMap.remove("ADD_ITEM_TYPE");
} else if (paramMap.containsKey("add_item_type")) {
itemType = (String) paramMap.remove("add_item_type");
}
if (UtilValidate.isEmpty(productId)) {
// before returning error; check make sure we aren't adding a special item type
if (UtilValidate.isEmpty(itemType)) {
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR, "cart.addToCart.noProductInfoPassed", locale));
return "success"; // not critical return to same page
}
} else {
try {
String pId = ProductWorker.findProductId(delegator, productId);
if (pId != null) {
productId = pId;
}
} catch (Throwable e) {
Debug.logWarning(e, MODULE);
}
}
// check for an itemDescription
if (paramMap.containsKey("ADD_ITEM_DESCRIPTION")) {
itemDescription = (String) paramMap.remove("ADD_ITEM_DESCRIPTION");
} else if (paramMap.containsKey("add_item_description")) {
itemDescription = (String) paramMap.remove("add_item_description");
}
if (itemDescription != null && itemDescription.isEmpty()) {
itemDescription = null;
}
// Get the ProductConfigWrapper (it's not null only for configurable items)
ProductConfigWrapper configWrapper = null;
configWrapper = ProductConfigWorker.getProductConfigWrapper(productId, cart.getCurrency(), request);
if (configWrapper != null) {
if (paramMap.containsKey("configId")) {
try {
configWrapper.loadConfig(delegator, (String) paramMap.remove("configId"));
} catch (Exception e) {
Debug.logWarning(e, "Could not load configuration", MODULE);
}
} else {
// The choices selected by the user are taken from request and set in the wrapper
ProductConfigWorker.fillProductConfigWrapper(configWrapper, request);
}
if (!configWrapper.isCompleted()) {
// The configuration is not valid
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.configureProductBeforeAddingToCart", locale));
return "product";
}
// load the Config Id
ProductConfigWorker.storeProductConfigWrapper(configWrapper, delegator);
}
//Check for virtual products
if (ProductWorker.isVirtual(delegator, productId)) {
if ("VV_FEATURETREE".equals(ProductWorker.getProductVirtualVariantMethod(delegator, productId))) {
// get the selected features.
List<String> selectedFeatures = new LinkedList<>();
request.getParameterMap().forEach((name, values) -> {
if (name.startsWith("FT")) {
selectedFeatures.add(values[0]);
}
});
// check if features are selected
if (UtilValidate.isEmpty(selectedFeatures)) {
request.setAttribute("paramMap", paramMap);
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.chooseVariationBeforeAddingToCart", locale));
return "product";
}
String variantProductId = ProductWorker.getVariantFromFeatureTree(productId, selectedFeatures, delegator);
if (UtilValidate.isNotEmpty(variantProductId)) {
productId = variantProductId;
} else {
request.setAttribute("paramMap", paramMap);
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.incompatibilityVariantFeature", locale));
return "product";
}
} else {
request.setAttribute("paramMap", paramMap);
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.chooseVariationBeforeAddingToCart", locale));
return "product";
}
}
// get the override price
if (paramMap.containsKey("PRICE")) {
priceStr = (String) paramMap.remove("PRICE");
} else if (paramMap.containsKey("price")) {
priceStr = (String) paramMap.remove("price");
}
if (priceStr == null) {
priceStr = "0"; // default price is 0
}
if ("ASSET_USAGE_OUT_IN".equals(ProductWorker.getProductTypeId(delegator, productId))) {
if (paramMap.containsKey("numberOfDay")) {
numberOfDay = (String) paramMap.remove("numberOfDay");
reservStart = UtilDateTime.addDaysToTimestamp(UtilDateTime.nowTimestamp(), 1);
reservEnd = UtilDateTime.addDaysToTimestamp(reservStart, Integer.parseInt(numberOfDay));
}
}
// get the renting data
if ("ASSET_USAGE".equals(ProductWorker.getProductTypeId(delegator, productId))
|| "ASSET_USAGE_OUT_IN".equals(ProductWorker.getProductTypeId(delegator, productId))) {
if (paramMap.containsKey("reservStart")) {
reservStartStr = (String) paramMap.remove("reservStart");
if (reservStartStr.length() == 10) {
reservStartStr += " 00:00:00.000000000"; // should have format: yyyy-mm-dd hh:mm:ss.fffffffff
}
if (!reservStartStr.isEmpty()) {
try {
reservStart = java.sql.Timestamp.valueOf(reservStartStr);
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing Reservation start string: "
+ reservStartStr, MODULE);
reservStart = null;
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR, "cart.addToCart.rental.startDate", locale));
return "error";
}
} else {
reservStart = null;
}
}
if (paramMap.containsKey("reservEnd")) {
reservEndStr = (String) paramMap.remove("reservEnd");
if (reservEndStr.length() == 10) {
reservEndStr += " 00:00:00.000000000"; // should have format: yyyy-mm-dd hh:mm:ss.fffffffff
}
if (!reservEndStr.isEmpty()) {
try {
reservEnd = java.sql.Timestamp.valueOf(reservEndStr);
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing Reservation end string: " + reservEndStr, MODULE);
reservEnd = null;
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR, "cart.addToCart.rental.endDate", locale));
return "error";
}
} else {
reservEnd = null;
}
}
if (reservStart != null && reservEnd != null) {
reservLength = new BigDecimal(UtilDateTime.getInterval(reservStart, reservEnd)).divide(new BigDecimal("86400000"), GEN_ROUNDING);
}
if (reservStart != null && paramMap.containsKey("reservLength")) {
reservLengthStr = (String) paramMap.remove("reservLength");
// parse the reservation Length
try {
reservLength = (BigDecimal) ObjectType.simpleTypeOrObjectConvert(reservLengthStr, "BigDecimal", null, locale);
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing reservation length string: "
+ reservLengthStr, MODULE);
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"OrderReservationLengthShouldBeAPositiveNumber", locale));
return "error";
}
}
if (reservStart != null && paramMap.containsKey("reservPersons")) {
reservPersonsStr = (String) paramMap.remove("reservPersons");
// parse the number of persons
try {
reservPersons = (BigDecimal) ObjectType.simpleTypeOrObjectConvert(reservPersonsStr, "BigDecimal", null, locale);
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing reservation number of persons string: " + reservPersonsStr, MODULE);
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR, "OrderNumberOfPersonsShouldBeOneOrLarger", locale));
return "error";
}
}
//check for valid rental parameters
if (UtilValidate.isEmpty(reservStart) && UtilValidate.isEmpty(reservLength) && UtilValidate.isEmpty(reservPersons)) {
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.enterBookingInforamtionBeforeAddingToCart", locale));
return "product";
}
//check accommodation for reservations
if ((paramMap.containsKey("accommodationMapId")) && (paramMap.containsKey("accommodationSpotId"))) {
accommodationMapId = (String) paramMap.remove("accommodationMapId");
accommodationSpotId = (String) paramMap.remove("accommodationSpotId");
}
}
// get the quantity
if (paramMap.containsKey("QUANTITY")) {
quantityStr = (String) paramMap.remove("QUANTITY");
} else if (paramMap.containsKey("quantity")) {
quantityStr = (String) paramMap.remove("quantity");
}
if (UtilValidate.isEmpty(quantityStr)) {
quantityStr = "1"; // default quantity is 1
}
// parse the price
try {
price = (BigDecimal) ObjectType.simpleTypeOrObjectConvert(priceStr, "BigDecimal", null, locale);
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing price string: " + priceStr, MODULE);
price = null;
}
// parse the quantity
try {
quantity = (BigDecimal) ObjectType.simpleTypeOrObjectConvert(quantityStr, "BigDecimal", null, locale);
//For quantity we should test if we allow to add decimal quantity for this product an productStore :
// if not and if quantity is in decimal format then return error.
if (!ProductWorker.isDecimalQuantityOrderAllowed(delegator, productId, cart.getProductStoreId())) {
BigDecimal remainder = quantity.remainder(BigDecimal.ONE);
if (remainder.compareTo(BigDecimal.ZERO) != 0) {
request.setAttribute("_ERROR_MESSAGE_", UtilProperties.getMessage(RES_ERROR,
"cart.addToCart.quantityInDecimalNotAllowed", locale));
return "error";
}
quantity = quantity.setScale(0, UtilNumber.getRoundingMode("order.rounding"));
} else {
quantity = quantity.setScale(UtilNumber.getBigDecimalScale("order.decimals"), UtilNumber.getRoundingMode("order.rounding"));
}
} catch (Exception e) {
Debug.logWarning(e, "Problems parsing quantity string: " + quantityStr, MODULE);
quantity = BigDecimal.ONE;
}
// get the selected amount
String selectedAmountStr = null;
if (paramMap.containsKey("ADD_AMOUNT")) {
selectedAmountStr = (String) paramMap.remove("ADD_AMOUNT");
} else if (paramMap.containsKey("add_amount")) {
selectedAmountStr = (String) paramMap.remove("add_amount");
}
// parse the amount
BigDecimal amount = null;
if (UtilValidate.isNotEmpty(selectedAmountStr)) {
try {
amount = (BigDecimal) ObjectType.simpleTypeOrObjectConvert(selectedAmountStr, "BigDecimal", null, locale);
} catch (Exception e) {
Debug.logWarning(e, "Problem parsing amount string: " + selectedAmountStr, MODULE);
amount = null;
}
} else {
amount = BigDecimal.ZERO;
}
// check for required amount
if ((ProductWorker.isAmountRequired(delegator, productId)) && (amount == null || amount.doubleValue() == 0.0)) {
request.setAttribute("product_id", productId);
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage(RES_ERROR, "cart.addToCart.enterAmountBeforeAddingToCart", locale));
return "product";
}
// get the ship before date (handles both yyyy-mm-dd input and full timestamp)
shipBeforeDateStr = (String) paramMap.remove("shipBeforeDate");
if (UtilValidate.isNotEmpty(shipBeforeDateStr)) {
if (shipBeforeDateStr.length() == 10) {
shipBeforeDateStr += " 00:00:00.000";
}
try {
shipBeforeDate = java.sql.Timestamp.valueOf(shipBeforeDateStr);
} catch (IllegalArgumentException e) {
Debug.logWarning(e, "Bad shipBeforeDate input: " + e.getMessage(), MODULE);
shipBeforeDate = null;
}
}
// get the ship after date (handles both yyyy-mm-dd input and full timestamp)
shipAfterDateStr = (String) paramMap.remove("shipAfterDate");
if (UtilValidate.isNotEmpty(shipAfterDateStr)) {
if (shipAfterDateStr.length() == 10) {
shipAfterDateStr += " 00:00:00.000";
}
try {
shipAfterDate = java.sql.Timestamp.valueOf(shipAfterDateStr);
} catch (IllegalArgumentException e) {
Debug.logWarning(e, "Bad shipAfterDate input: " + e.getMessage(), MODULE);
shipAfterDate = null;
}
}
// get the reserve after date (handles both yyyy-mm-dd input and full timestamp)
reserveAfterDateStr = (String) paramMap.remove("reserveAfterDate");
if (UtilValidate.isNotEmpty(reserveAfterDateStr)) {
if (reserveAfterDateStr.length() == 10) {
reserveAfterDateStr += " 00:00:00.000";
}
try {
reserveAfterDate = java.sql.Timestamp.valueOf(reserveAfterDateStr);
} catch (IllegalArgumentException e) {
Debug.logWarning(e, "Bad reserveAfterDate input: " + e.getMessage(), MODULE);
reserveAfterDate = null;
}
}
// check for an add-to cart survey
List<String> surveyResponses = null;
if (productId != null) {
String productStoreId = ProductStoreWorker.getProductStoreId(request);
List<GenericValue> productSurvey = ProductStoreWorker.getProductSurveys(delegator, productStoreId, productId,
"CART_ADD", parentProductId);
if (UtilValidate.isNotEmpty(productSurvey)) {
// TODO: implement multiple survey per product
GenericValue survey = EntityUtil.getFirst(productSurvey);
String surveyResponseId = (String) request.getAttribute("surveyResponseId");
if (surveyResponseId != null) {
surveyResponses = UtilMisc.toList(surveyResponseId);
} else {
String origParamMapId = UtilHttp.stashParameterMap(request);
Map<String, Object> surveyContext = UtilMisc.<String, Object>toMap("_ORIG_PARAM_MAP_ID_", origParamMapId);
GenericValue userLogin = cart.getUserLogin();
String partyId = null;
if (userLogin != null) {
partyId = userLogin.getString("partyId");
}
String formAction = "/additemsurvey";
String nextPage = RequestHandler.getOverrideViewUri(request.getPathInfo());
if (nextPage != null) {
formAction = formAction + "/" + nextPage;
}
ProductStoreSurveyWrapper wrapper = new ProductStoreSurveyWrapper(survey, partyId, surveyContext);
request.setAttribute("surveyWrapper", wrapper);
request.setAttribute("surveyAction", formAction); // will be used as the form action of the survey
return "survey";
}
}
}
if (surveyResponses != null) {
paramMap.put("surveyResponses", surveyResponses);
}
GenericValue productStore = ProductStoreWorker.getProductStore(request);
if (productStore != null) {
String addToCartRemoveIncompat = productStore.getString("addToCartRemoveIncompat");
String addToCartReplaceUpsell = productStore.getString("addToCartReplaceUpsell");
try {
if ("Y".equals(addToCartRemoveIncompat)) {
List<GenericValue> productAssocs = null;
EntityCondition cond = EntityCondition.makeCondition(UtilMisc.toList(
EntityCondition.makeCondition(EntityCondition.makeCondition("productId", EntityOperator.EQUALS, productId),
EntityOperator.OR, EntityCondition.makeCondition("productIdTo", EntityOperator.EQUALS, productId)),
EntityCondition.makeCondition("productAssocTypeId", EntityOperator.EQUALS, "PRODUCT_INCOMPATABLE")), EntityOperator.AND);
productAssocs = EntityQuery.use(delegator).from("ProductAssoc").where(cond).filterByDate().queryList();
List<String> productList = new LinkedList<>();
for (GenericValue productAssoc : productAssocs) {
if (productId.equals(productAssoc.getString("productId"))) {
productList.add(productAssoc.getString("productIdTo"));
continue;
}
if (productId.equals(productAssoc.getString("productIdTo"))) {
productList.add(productAssoc.getString("productId"));
continue;
}
}
for (ShoppingCartItem sci : cart) {
if (productList.contains(sci.getProductId())) {
try {
cart.removeCartItem(sci, dispatcher);
} catch (CartItemModifyException e) {
Debug.logError(e.getMessage(), MODULE);
}
}
}
}
if ("Y".equals(addToCartReplaceUpsell)) {
List<GenericValue> productList = null;
productList = EntityQuery.use(delegator).select("productId").from("ProductAssoc").where("productIdTo", productId,
"productAssocTypeId", "PRODUCT_UPGRADE").queryList();
if (productList != null) {
for (ShoppingCartItem sci : cart) {
if (productList.parallelStream().anyMatch(p -> sci.getProductId().equals(p.getString("productId")))) {
try {
cart.removeCartItem(sci, dispatcher);
} catch (CartItemModifyException e) {
Debug.logError(e.getMessage(), MODULE);
}
}
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e.getMessage(), MODULE);
}
}
// check for alternative packing
if (ProductWorker.isAlternativePacking(delegator, productId, parentProductId)) {
GenericValue parentProduct = null;
try {
parentProduct = EntityQuery.use(delegator).from("Product").where("productId", parentProductId).queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, "Error getting parent product", MODULE);
}
BigDecimal piecesIncluded = BigDecimal.ZERO;
if (parentProduct != null) {
piecesIncluded = new BigDecimal(parentProduct.getLong("piecesIncluded"));
quantity = quantity.multiply(piecesIncluded);
}
}
// Translate the parameters and add to the cart
result = cartHelper.addToCart(catalogId, shoppingListId, shoppingListItemSeqId, productId, productCategoryId,
itemType, itemDescription, price, amount, quantity, reservStart, reservLength, reservPersons,
accommodationMapId, accommodationSpotId,
shipBeforeDate, shipAfterDate, reserveAfterDate, configWrapper, itemGroupNumber, paramMap, parentProductId);
controlDirective = processResult(result, request);
Integer itemId = (Integer) result.get("itemId");
if (UtilValidate.isNotEmpty(itemId)) {
request.setAttribute("itemId", itemId);
}
try {
GenericValue product = EntityQuery.use(delegator).from("Product").where("productId", productId).queryOne();
//Reset shipment method information in cart only if shipping applies on product.
if (UtilValidate.isNotEmpty(product) && ProductWorker.shippingApplies(product)) {
for (int shipGroupIndex = 0; shipGroupIndex < cart.getShipGroupSize(); shipGroupIndex++) {
String shipContactMechId = cart.getShippingContactMechId(shipGroupIndex);
if (UtilValidate.isNotEmpty(shipContactMechId)) {
cart.setShipmentMethodTypeId(shipGroupIndex, null);
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Error getting product" + e.getMessage(), MODULE);
}
// Determine where to send the browser
if (controlDirective.equals(ERROR)) {
return "error";
}
if (cart.viewCartOnAdd()) {
return "viewcart";
}
request.setAttribute("_EVENT_MESSAGE_", UtilProperties.getMessage("OrderUiLabels", "ItemAddedSuccessfully",
UtilMisc.toMap("productId", productId), UtilHttp.getLocale(request)));
return "success";
}