Subversion Repositories SmartDukaan

        package in.shop2020.mobileapi.serving.controllers;

import in.shop2020.mobileapi.serving.pojos.RedirectPojo;
import in.shop2020.mobileapi.serving.services.ContentServingService;
import in.shop2020.mobileapi.serving.utils.PojoPopulator;
import in.shop2020.mobileapi.serving.utils.SnippetType;
import in.shop2020.model.v1.catalog.CatalogService.Client;
import in.shop2020.model.v1.catalog.Item;
import in.shop2020.model.v1.user.Cart;
import in.shop2020.model.v1.user.Line;
import in.shop2020.model.v1.user.PromotionException;
import in.shop2020.model.v1.user.PromotionService;
import in.shop2020.model.v1.user.ShoppingCartException;
import in.shop2020.model.v1.user.UserContextService;
import in.shop2020.thrift.clients.CatalogClient;
import in.shop2020.thrift.clients.PromotionClient;
import in.shop2020.thrift.clients.UserClient;

import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.struts2.interceptor.ParameterAware;
import org.apache.thrift.TException;

import com.google.gson.Gson;

public class CartController extends BaseController implements ParameterAware{
    
    private static final long serialVersionUID = 1L;
    private static Logger log = Logger.getLogger(Class.class);
    Map<String, String[]> reqparams = null;
    
    private int variationId = 0;
    private String totalamount;
    
    private String errorMsg = "";
    private String cartMsg = "";
    
    private String pincode = "110001";
    
    private String couponCode = null;
    
    private String discountedAmount;
    
    private long itemId;
    private String insuranceResult;
    
    private boolean toInsure;
    
    
    private long id; //CartId
    private String cartPojoJson;
    private long quantity;
    private int insuranceType;
    
    public CartController(){
        super();
    }
    
    public String index() {
        if(id != -1){
            try {
                UserContextService.Client userClient = (new UserClient()).getClient();
                List<String> cartResponse  = userClient.validateCart(id, -1);
                if (!"".equals(cartResponse.get(0))) {
                    errorMsg = cartResponse.get(0);
                }
                if(StringUtils.isNotEmpty(cartResponse.get(1))) {
                    addActionMessage(cartResponse.get(1));
                }
                log.info("Cart Change/EMI Message rcvd from the service is:" + errorMsg);
                
                Cart cart = userClient.getCurrentCart(userinfo.getUserId());
                String pincode = "110001";
                UserClient usc = new UserClient();
                if(!cart.isSetAddressId()) {
                    try {
                        pincode = usc.getClient().getDefaultPincode(userinfo.getUserId());
                    } catch(Exception e) {
                        log.error("Unable to get default pincode for userId : " + userinfo.getUserId(), e);
                    }
                } else {
                    try {
                        pincode = usc.getClient().getAddressById(cart.getAddressId()).getPin();
                    } catch(Exception e) {
                        log.error("Unable to get address for addressId : " + cart.getAddressId(), e);
                    }   
                }
                Boolean needInuranceInfo = false;
                for(Line line : cart.getLines()) {
                        log.info("Insurer is set: " + String.valueOf(line.getInsurer()>0));
                        if(line.getInsurer()>0){
                                long defaultAddressId = usc.getClient().getDefaultAddressId(userinfo.getUserId());
                                log.info(defaultAddressId);
                                needInuranceInfo = !userClient.isInsuranceDetailPresent(defaultAddressId);
                                log.info("Need insurance: " + needInuranceInfo);
                                break;
                        }
                }
                
                cartPojoJson = new Gson().toJson(PojoPopulator.getCartPojo(cart, errorMsg, pincode, needInuranceInfo));
                log.info(cartPojoJson);
            } catch (Exception e) {
                // This exception can be ignored for showing the cart. Not so
                // innocent when this occurs at the time of checkout or when the
                // user is proceeding to pay.
                log.warn("Unable to validate the cart: ", e);
            }
        }
        return "index";
    }

    public String create() {
        RedirectPojo rp = new RedirectPojo();
        rp.setRedirectUrl("");
        try {
                //NotificationPojo np = new NotificationPojo();
            UserClient userServiceClient = new UserClient();
            UserContextService.Client userClient = userServiceClient.getClient();
            cartMsg = userClient.addItemToCart(id, itemId, 1, -1);
            if (!("".equals(cartMsg))) {
                String emailId = this.request.getParameter("email");
                log.info("QuesyString" + this.request.getParameterMap().toString());
                        if(emailId==null || emailId.equals("")){
                                rp.setMessage("Item is currently out of stock");
                        } else {        
                                try {
                                CatalogClient catalogClientService;
                                        catalogClientService = new CatalogClient();
                                        in.shop2020.model.v1.catalog.CatalogService.Client client = catalogClientService.getClient();
                                        client.addProductNotification(itemId, emailId);
                                        log.debug("Got product notification for product: " + itemId + "  from user: " + emailId );
                                        rp.setMessage("You will be notified when product is avaliable");
                                } catch (Exception e) {
                                        rp.setMessage("Error occurred while adding to notificiation");
                                        log.error("Exception while adding product notification for item: " + itemId + " and email: " + emailId, e);
                                }
                                
                        }
            } else {
                rp.setRedirectUrl("cart");
            }
        } catch (TException e) {
            log.error("Unable to create or add to cart because of: ", e);
            errorMsg = "Unable to add to cart. Please try again.";
        } catch (Exception e) {
            log.error("Unable to create or add to cart because of: ", e);
            errorMsg = "Unable to add to cart. Please try again.";
        }
        cartPojoJson = new Gson().toJson(rp);
        return "index";
    }       


    // DELETE /entity
    public String destroy() {
        if(id > 0)  {
            try {
                UserClient userContextServiceClient = new UserClient();
                in.shop2020.model.v1.user.UserContextService.Client userClient = userContextServiceClient.getClient();

                userClient.deleteItemFromCart(id, itemId);
                return index();
            } catch (ShoppingCartException e) {
                log.error("Unable to delete item from cart: ", e);
                errorMsg = "Unable to delete item. Please try again.";
            } catch (TException e) {
                log.error("Unable to delete item from cart: ", e);
                errorMsg = "Unable to delete item. Please try again.";
            } catch (Exception e) {
                log.error("Unable to delete item from cart: ", e);
                errorMsg = "Unable to delete item. Please try again.";
            }
        }
        return index();
    }
    
    //PUT
    public String update() {
        if(quantity <= 0)   {
            log.info("Not valid item quantity. Unable to change item quantity.");
            errorMsg = "Invalid item quantity";
        } else  {
            if(updateItemQuantityInCart(id, itemId, quantity))    {
                return index();
            }
        }
        return index();
    }
    
    private boolean updateItemQuantityInCart(long cartId, long itemId, long quantity){
        try {
            UserClient userContextServiceClient = new UserClient();
            in.shop2020.model.v1.user.UserContextService.Client userClient = userContextServiceClient.getClient();

            userClient.addItemToCart(cartId, itemId, quantity, -1);
            return true;
        } catch (ShoppingCartException e) {
            log.error("Unable to update the item quantity in the cart: ", e);
            errorMsg = "Unable to change quantity. Please try again.";
        } catch (TException e) {
            log.error("Unable to update the item quantity in the cart: ", e);
            errorMsg = "Unable to change quantity. Please try again.";
        } catch (Exception e) {
            log.error("Unable to update the item quantity in the cart: ", e);
            errorMsg = "Unable to change quantity. Please try again.";
        }
        return false;
    }
           
    public String insureItem() {
        insuranceResult = "";
        try {
            UserContextService.Client usc = new UserClient().getClient();
            if(usc.insureItem(itemId, id, toInsure, insuranceType)) {
                setInsuranceResult("SUCCESS");
            } else {
                setInsuranceResult("FAILURE");
            }
        } catch (Exception e) {
            log.error("Unable to insure item : " + itemId + " for cart : " + id, e);
            setInsuranceResult("FAILURE");
        }
        return "insurance-result";
    }
    
    public String edit()  {
        String action = request.getParameter("action");
        UserClient userServiceClient = null;
        PromotionClient promotionServiceClient = null;
        try {
            if(action == null || action.isEmpty())  {
                errorMsg = "Invalid Request Action";
                return index();
            }
            String couponCode = request.getParameter("coupon_code");
            
            if (action.equalsIgnoreCase("applycoupon"))   {
                if (couponCode == null || couponCode.isEmpty()) {
                    errorMsg = "Coupon Code field cannot be left empty";
                    return index();
                }
                
                promotionServiceClient = new PromotionClient();
                PromotionService.Client promotionClient = promotionServiceClient.getClient();
                
                promotionClient.applyCoupon(couponCode, id);
                
            }
            else if (action.equals("removecoupon"))    {
                userServiceClient = new UserClient();
                UserContextService.Client userClient = userServiceClient.getClient();
                userClient.removeCoupon(id);
            }
        } catch (PromotionException e) {
            log.info("Invalid coupon: " + e.getMessage());
            errorMsg = "Invalid coupon : " + e.getMessage();
        } catch (Exception e) {
            log.error("Unable to apply or remove coupon", e);
            errorMsg = "Unable to apply or remove coupon";
        }
        return index();
    }
    
    public String changeAddress() {
        long addressId;
        if(request.getParameter("addressId") == null || request.getParameter("addressId").isEmpty()) {
            errorMsg = "Null or empty addressId";
            return index();
        } else {
            addressId = Long.parseLong(request.getParameter("addressId"));
        }
         
        try {
            UserClient usc = new UserClient();
            if(request.getParameter("addressType").equalsIgnoreCase("store")) {
                usc.getClient().addStoreToCart(id, addressId);
            } else if (request.getParameter("addressType").equalsIgnoreCase("home")){
                usc.getClient().addAddressToCart(id, addressId);
            } else {
                errorMsg = "Invalid addressType. It can only be set to home or store.";
            }
        } catch(Exception e) {
            log.error("Unable to change address", e);
        }
        return index();
    }

    public long getItemId(){
        return this.itemId;
    }
    
    public void setItemId(long itemId){
        this.itemId = itemId;
    }
    
    public String getTotalAmount() {
        return totalamount;
    }
    
    public String getPinCode() {
        return pincode;
    }
    
    public String getCouponCode()  {
        return couponCode;
    }
    
    public String getDiscountedAmount()   {
        return discountedAmount;
    }
    
    public String getErrorMsg()    {
        return errorMsg;
    }
    
//    public long getNumberOfItems(){
//        return userinfo.getTotalItems();
//    }

    public String getCartMsg(){
        if(cartMsg.equals("")){
            return null;
        }
        return cartMsg;
    }
    
    public String getSnippets(){
        String snippets = "";
        CatalogClient csc;
        try {
            csc = new CatalogClient();
            List<Long> similarItems = csc.getClient().getSimilarItemsCatalogIds(0, 4, itemId);
            for(Long catalogId: similarItems){
                snippets = snippets + ContentServingService.getSnippet(SnippetType.WIDGET_SNIPPET, catalogId+"", -1);
            }
        } catch (Exception e) {
            log.error("Unable to initialise Catalogservice Client");
        }       
        return snippets;
    }
    
    @Override
    public void setParameters(Map<String, String[]> parameters) {
        this.reqparams = parameters;    
    }
    
//    @Override
//    public String getHeaderSnippet() {
//        String url = request.getQueryString();
//        if (url == null) {
//            url = "";
//        } else {
//            url = "?" + url;
//        }
//        url = request.getRequestURI() + url;
//        return pageLoader.getHeaderHtml(userinfo.isLoggedIn(), userinfo.getEmail(), userinfo.getTotalItems(), url , 0, false);
//    }
    
//    public boolean isUserLoggedIn() {
//        return userinfo.isLoggedIn();
//    }
    
    public void setVariationId(String uri)  {
        if (uri.equals("/cart1"))   {
            this.variationId = 1;
        }
    }
    
    public int getVariationId() {
        return this.variationId;
    }
    
    public String getActionMessage(){
        if(cartMsg.contains("out of stock")){
            return "Notify me when this product is in stock.";
        }else {
            return "Notify me when this product is available.";
        }
    }
    
    public String getOfferNote(){
        String note = null;
        if(cartMsg.contains("out of stock")){
            return note;
        }
        else {
            try {
                CatalogClient catalogServiceClient = new CatalogClient();
                Client catalogClient = catalogServiceClient.getClient();
                Item it = catalogClient.getItem(itemId);
                note = it.getBestDealText();
            } catch (Exception e)  {
                log.error("Unable to get the offertext because of: ", e);
            }
        }
        return note;
    }

    public String getInsuranceResult() {
        return insuranceResult;
    }

    public void setInsuranceResult(String insuranceResult) {
        this.insuranceResult = insuranceResult;
    }

    public void setToInsure(boolean toInsure) {
        this.toInsure = toInsure;
    }

    public boolean getToInsure() {
        return toInsure;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }


    public void setCartPojoJson(String cartPojoJson) {
        this.cartPojoJson = cartPojoJson;
    }


    public String getCartPojoJson() {
        return cartPojoJson;
    }

    public void setQuantity(long quantity) {
        this.quantity = quantity;
    }

    public long getQuantity() {
        return quantity;
    }

    public int getInsuranceType() {
        return insuranceType;
    }

    public void setInsuranceType(int insuranceType) {
        this.insuranceType = insuranceType;
    }
}