com.exxonmobile.ace.hybris.storefront.controllers.pages.CartPageController.java Source code

Java tutorial

Introduction

Here is the source code for com.exxonmobile.ace.hybris.storefront.controllers.pages.CartPageController.java

Source

/*
 * [y] hybris Platform
 *
 * Copyright (c) 2000-2013 hybris AG
 * All rights reserved.
 *
 * This software is the confidential and proprietary information of hybris
 * ("Confidential Information"). You shall not disclose such Confidential
 * Information and shall use it only in accordance with the terms of the
 * license agreement you entered into with hybris.
 * 
 *  
 */
package com.exxonmobile.ace.hybris.storefront.controllers.pages;

import de.hybris.platform.acceleratorservices.controllers.page.PageType;
import de.hybris.platform.b2bacceleratorfacades.order.B2BCartFacade;
import de.hybris.platform.cms2.exceptions.CMSItemNotFoundException;
import de.hybris.platform.commercefacades.order.data.CartData;
import de.hybris.platform.commercefacades.order.data.CartModificationData;
import de.hybris.platform.commercefacades.order.data.CartRestorationData;
import de.hybris.platform.commercefacades.order.data.OrderEntryData;
import de.hybris.platform.commerceservices.order.CommerceCartModificationException;
import de.hybris.platform.servicelayer.session.SessionService;
import com.exxonmobile.ace.hybris.facades.flow.impl.SessionOverrideB2BCheckoutFlowFacade;
import com.exxonmobile.ace.hybris.storefront.annotations.RequireHardLogIn;
import com.exxonmobile.ace.hybris.storefront.breadcrumb.ResourceBreadcrumbBuilder;
import com.exxonmobile.ace.hybris.storefront.constants.WebConstants;
import com.exxonmobile.ace.hybris.storefront.controllers.ControllerConstants;
import com.exxonmobile.ace.hybris.storefront.controllers.util.GlobalMessages;
import com.exxonmobile.ace.hybris.storefront.forms.UpdateQuantityForm;
import com.exxonmobile.ace.hybris.storefront.variants.VariantSortStrategy;

import java.util.Collections;
import java.util.List;

import javax.annotation.Resource;
import javax.validation.Valid;

import org.apache.log4j.Logger;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

/**
 * Controller for cart page
 */
@Controller
@Scope("tenant")
@RequestMapping(value = "/cart")
public class CartPageController extends AbstractPageController {
    protected static final Logger LOG = Logger.getLogger(CartPageController.class);

    private static final String CART_CMS_PAGE = "cartPage";

    private static final String CONTINUE_URL = "continueUrl";

    @Resource(name = "b2bCartFacade")
    private B2BCartFacade cartFacade;

    @Resource(name = "sessionService")
    private SessionService sessionService;

    @Resource(name = "simpleBreadcrumbBuilder")
    private ResourceBreadcrumbBuilder resourceBreadcrumbBuilder;

    @Resource(name = "variantSortStrategy")
    private VariantSortStrategy variantSortStrategy;

    @RequestMapping(method = RequestMethod.GET)
    public String showCart(final Model model) throws CMSItemNotFoundException {
        prepareDataForPage(model);
        return ControllerConstants.Views.Pages.Cart.CartPage;
    }

    @RequestMapping(value = "/checkout", method = RequestMethod.GET)
    @RequireHardLogIn
    public String cartCheck(final Model model, final RedirectAttributes redirectModel)
            throws CommerceCartModificationException {
        SessionOverrideB2BCheckoutFlowFacade.resetSessionOverrides();

        if (!cartFacade.hasSessionCart() || cartFacade.getSessionCart().getEntries().isEmpty()) {
            LOG.info("Missing or empty cart");

            // No session cart or empty session cart. Bounce back to the cart page.
            return REDIRECT_PREFIX + "/cart";
        }
        if (validateCart(redirectModel)) {
            return REDIRECT_PREFIX + "/cart";
        }

        // Redirect to the start of the checkout flow to begin the checkout process
        // We just redirect to the generic '/checkout' page which will actually select the checkout flow
        // to use. The customer is not necessarily logged in on this request, but will be forced to login
        // when they arrive on the '/checkout' page.
        return REDIRECT_PREFIX + "/checkout";
    }

    protected boolean validateCart(final RedirectAttributes redirectModel)
            throws CommerceCartModificationException {
        // Validate the cart
        final List<CartModificationData> modifications = cartFacade.validateCartData();
        if (!modifications.isEmpty()) {
            redirectModel.addFlashAttribute("validationData", modifications);

            // Invalid cart. Bounce back to the cart page.
            return true;
        }
        return false;
    }

    @RequestMapping(value = "/update", method = RequestMethod.POST)
    @RequireHardLogIn
    public String updateCartQuantities(@RequestParam("entryNumber") final long entryNumber, final Model model,
            @Valid final UpdateQuantityForm form, final BindingResult bindingResult,
            final RedirectAttributes redirectModel) throws CMSItemNotFoundException {
        if (bindingResult.hasErrors()) {
            for (final ObjectError error : bindingResult.getAllErrors()) {
                if (error.getCode().equals("typeMismatch")) {
                    GlobalMessages.addErrorMessage(model, "basket.error.quantity.invalid");
                } else {
                    GlobalMessages.addErrorMessage(model, error.getDefaultMessage());
                }
            }
        } else if (cartFacade.getSessionCart().getEntries() != null) {
            try {
                final CartModificationData cartModification = cartFacade.updateCartEntry(entryNumber,
                        form.getQuantity().longValue());
                if (cartModification.getQuantity() == form.getQuantity().longValue()) {
                    // Success

                    if (cartModification.getQuantity() == 0) {
                        // Success in removing entry
                        GlobalMessages.addFlashMessage(redirectModel, GlobalMessages.CONF_MESSAGES_HOLDER,
                                "basket.page.message.remove");
                    } else {
                        // Success in update quantity
                        GlobalMessages.addFlashMessage(redirectModel, GlobalMessages.CONF_MESSAGES_HOLDER,
                                "basket.page.message.update");
                    }
                } else {
                    // Less than successful
                    GlobalMessages.addFlashMessage(redirectModel, GlobalMessages.ERROR_MESSAGES_HOLDER,
                            "basket.information.quantity.reducedNumberOfItemsAdded."
                                    + cartModification.getStatusCode());
                }

                // Redirect to the cart page on update success so that the browser doesn't re-post again
                return REDIRECT_PREFIX + "/cart";
            } catch (final CommerceCartModificationException ex) {
                LOG.warn("Couldn't update product with the entry number: " + entryNumber + ".", ex);
            }
        }

        prepareDataForPage(model);
        return ControllerConstants.Views.Pages.Cart.CartPage;
    }

    protected void createProductList(final Model model) throws CMSItemNotFoundException {
        final CartData cartData = cartFacade.getSessionCart();
        reverseCartProductsOrder(cartData.getEntries());
        if (cartData.getEntries() != null && !cartData.getEntries().isEmpty()) {

            //TODO add a call to group multidimensional products in cartFacade "cartFacade.groupMultiDimensionalProducts(cartData, variantSortStrategy);"

            for (final OrderEntryData entry : cartData.getEntries()) {
                final UpdateQuantityForm uqf = new UpdateQuantityForm();
                uqf.setQuantity(entry.getQuantity());
                model.addAttribute("updateQuantityForm" + entry.getEntryNumber(), uqf);
            }
        }

        model.addAttribute("cartData", cartData);

        storeCmsPageInModel(model, getContentPageForLabelOrId(CART_CMS_PAGE));
        setUpMetaDataForContentPage(model, getContentPageForLabelOrId(CART_CMS_PAGE));
    }

    protected void reverseCartProductsOrder(final List<OrderEntryData> entries) {
        if (entries != null) {
            Collections.reverse(entries);
        }
    }

    protected void prepareDataForPage(final Model model) throws CMSItemNotFoundException {
        final String continueUrl = (String) getSessionService().getAttribute(WebConstants.CONTINUE_URL);
        model.addAttribute(CONTINUE_URL, (continueUrl != null && !continueUrl.isEmpty()) ? continueUrl : ROOT);

        final CartRestorationData restorationData = (CartRestorationData) sessionService
                .getAttribute(WebConstants.CART_RESTORATION);
        model.addAttribute("restorationData", restorationData);

        createProductList(model);
        model.addAttribute(WebConstants.BREADCRUMBS_KEY,
                resourceBreadcrumbBuilder.getBreadcrumbs("breadcrumb.cart"));
        model.addAttribute("pageType", PageType.CART.name());
    }
}