Subversion Repositories SmartDukaan

    '''

    Created on 10-May-2010

    @author: ashish

    '''

    from elixir import *

    from shop2020.clients.CatalogClient import CatalogClient

    from shop2020.clients.InventoryClient import InventoryClient

    from shop2020.clients.LogisticsClient import LogisticsClient

    from shop2020.clients.PromotionClient import PromotionClient

    from shop2020.clients.TransactionClient import TransactionClient

    from shop2020.model.v1 import user

    from shop2020.model.v1.user.impl.Converters import to_t_cart, to_t_line

    from shop2020.model.v1.user.impl.Dataservice import Cart, Line, Address, User, \

        Discount, InsuranceDetails, PrivateDealUser

    from shop2020.thriftpy.logistics.ttypes import LogisticsServiceException, \

        DeliveryType

    from shop2020.thriftpy.model.v1.catalog.ttypes import Item, InsurerType

    from shop2020.thriftpy.model.v1.order.ttypes import Transaction as TTransaction, \

        TransactionStatus as TTransactionStatus, Order as TOrder, LineItem as TLineItem, \

        OrderStatus, OrderSource

    from shop2020.thriftpy.model.v1.user.ttypes import CartStatus, LineStatus, \

        ShoppingCartException, PromotionException, CartPlus

    from shop2020.utils.Utils import to_py_date, to_java_date

    import datetime

    import json

    import math

    import traceback

    def get_cart(userId):

        user = User.get_by(id=userId)

        return user.active_cart

    def get_cart_by_id(id):

        cart = Cart.get_by(id=id)

        return cart

    def create_cart():

        cart = Cart()

        cart.created_on = datetime.datetime.now()

        cart.updated_on = datetime.datetime.now()

        cart.cart_status = CartStatus.ACTIVE

        return cart

    def get_carts_between(start_time, end_time, status):

        init_time = to_py_date(start_time)

        finish_time = to_py_date(end_time)

        query = Cart.query

        if status:

            query = query.filter(Cart.cart_status==status)

        if init_time:

            query = query.filter(Cart.created_on >= init_time)

        if finish_time:

            query = query.filter(Cart.created_on <= finish_time)

        carts = query.all()

        return carts

    def get_line(item_id, cart_id, status, single):

        #get cart first 

        try:

            found_cart = Cart.get_by(id=cart_id)

        except:

            raise ShoppingCartException(101, "cart not found ")

        query = Line.query.filter_by(cart = found_cart, item_id = item_id)

        if status:

            query = query.filter_by(line_status = status)

        else:

            query = query.filter_by(line_status = LineStatus.LINE_ACTIVE)

        try:

            if single:

                return query.one()

            else:

                return query.all()

        except:

            return None

    def add_item_to_cart(cart_id, item_id, quantity, sourceId):

        if not item_id:

            raise ShoppingCartException(101, "item_id cannot be null")

        if not quantity:

            raise ShoppingCartException(101, "quantity cannot be null")    

        cart = Cart.get_by(id = cart_id)    

        if not cart:

            raise ShoppingCartException(101, "no cart attached to this id" + str(cart_id))

        retval = ""

        catalog_client = CatalogClient().get_client()

        item = catalog_client.getItemForSource(item_id, sourceId)

        dataProtectionInsurer = catalog_client.getPrefferedInsurerForItem(item_id,InsurerType._NAMES_TO_VALUES.get("DATA"))

        item_shipping_info = catalog_client.isActive(item_id)

        if not item_shipping_info.isActive:

            return catalog_client.getItemStatusDescription(item_id)

        current_time = datetime.datetime.now()

        cart.updated_on = current_time

        line = get_line(item_id, cart_id, None,True)

        if line:

            #change the quantity only

            line.insuranceAmount = (line.insuranceAmount/line.quantity) * quantity

            line.quantity = quantity

            line.updated_on = current_time

            line.dataProtectionAmount = (line.dataProtectionAmount/line.quantity) * quantity

        else:

            line = Line()

            line.cart = cart

            line.item_id = item_id

            line.quantity = quantity

            line.created_on = current_time

            line.updated_on = current_time

            line.actual_price = item.sellingPrice

            line.line_status = LineStatus.LINE_ACTIVE

            line.insurer = 0

            line.insuranceAmount = 0

            #DATA INSURER IS SET UPON ADD TO CART

            line.dataProtectionInsurer = dataProtectionInsurer

        session.commit()

        return retval

    def delete_item_from_cart(cart_id, item_id):

        if not item_id:

            raise ShoppingCartException(101, "item_id cannot be null")

        cart = Cart.get_by(id = cart_id)

        if not cart:

            raise ShoppingCartException(101, "no cart attached to this id")

        item = get_line(item_id, cart_id, None, True)

        count_deleted_discounts = delete_discounts_for_line(item)

        item.delete()

        current_time = datetime.datetime.now()

        cart.updated_on = current_time

        session.commit()

    def delete_discounts_for_line(item_line):

        count_deleted = Discount.query.filter_by(line = item_line).delete()

        session.commit()

        return count_deleted

    def delete_discounts_from_cart(cart_id, cart = None):

        if cart is None:

            if cart_id is None:

                raise ShoppingCartException(101, 'cart_id and cart, both cannot be null')

            else:

                cart = Cart.get_by(id = cart_id)

        if cart.lines:

            for line in cart.lines:

                delete_discounts_for_line(line)

    def save_discounts(discounts):

        if not discounts:

            raise ShoppingCartException(101, 'discounts be null')

        if len(discounts) > 0:

            cart = Cart.get_by(id = discounts[0].cart_id)

            for t_discount in discounts:

                line = Line.query.filter_by(cart = cart, item_id = t_discount.item_id).first()

                if line is not None:

                    discount = Discount()

                    discount.line = line

                    discount.discount = t_discount.discount

                    discount.quantity = t_discount.quantity

                    session.commit()

    def add_address_to_cart(cart_id, address_id):

        if not cart_id:

            raise ShoppingCartException(101, "cart id cannot be made null")

        if not address_id:

            raise ShoppingCartException(101, "address id cannot be made null")

        cart = get_cart_by_id(cart_id)

        if not cart:

            raise ShoppingCartException(101, "no cart for this id")

        address = Address.get_by(id=address_id)

        if not address:

            raise ShoppingCartException(101, "No address for this id")

        cart.address_id = address_id

        current_time = datetime.datetime.now()

        #cart.updated_on = current_time

        session.commit()

    def add_store_to_cart(cartId, storeId):

        if not cartId:

            raise ShoppingCartException(101, "cart id cannot be made null")

        cart = get_cart_by_id(cartId)

        if not cart:

            raise ShoppingCartException(101, "no cart for this id")

        if storeId:

            cart.pickupStoreId = storeId

        else:

            cart.pickupStoreId = None

        session.commit()

    def apply_coupon_to_cart(t_cart, coupon_code):

        cart = get_cart_by_id(t_cart.id)

        if not cart:

            raise ShoppingCartException(101, "no cart attached to this id")

        pc = PromotionClient().get_client()

        for t_line in t_cart.lines:

            line = Line.query.filter_by(cart = cart).filter_by(item_id = t_line.itemId).one()

            line.discounted_price = None

            if not pc.isGiftVoucher(coupon_code):

                line.discounted_price = t_line.discountedPrice

            #line.dealText = t_line.dealText

            #line.freebieId = t_line.freebieId

        cart.total_price = t_cart.totalPrice

        cart.discounted_price = t_cart.discountedPrice

        cart.coupon_code = coupon_code

        session.commit()

    def remove_coupon(cart_id):

        cart = get_cart_by_id(cart_id)

        if not cart:

            raise ShoppingCartException(101, "no cart attached to this id")

        #Resetting discounted price of each line in cart to Null

        for line in cart.lines:

            line.discounted_price = None

            line.dealText = None

            line.freebieId = None

        delete_discounts_from_cart(cart.id, cart=cart)

        cart.discounted_price = None

        cart.coupon_code = None

        session.commit()

    def commit_cart(cart_id, sessionSource, sessionTime, firstSource, firstSourceTime, userId, schemeId, orderSource):   

        cart = get_cart_by_id(cart_id)   

        #now we have a cart. Need to create a transaction with it

        totalCartVal = 0

        totalshippingCost = 0

        for lineObj in cart.lines:

            totalCartVal += lineObj.actual_price * lineObj.quantity

        txn = TTransaction()

        txn.shoppingCartid = cart_id

        txn.customer_id = userId

        txn.createdOn = to_java_date(datetime.datetime.now())

        txn.transactionStatus = TTransactionStatus.INIT

        txn.statusDescription = "New Order"

        txn.coupon_code = cart.coupon_code

        txn.sessionSource = sessionSource

        txn.sessionStartTime = sessionTime

        txn.firstSource = firstSource

        txn.firstSourceTime = firstSourceTime

        txn.emiSchemeId = schemeId

        privateDealUser = PrivateDealUser.query.filter(PrivateDealUser.id == userId).filter(PrivateDealUser.isActive==True).first()

        if privateDealUser is not None:

            if totalCartVal < 500:

                totalshippingCost = 100

            elif totalCartVal >=500 and totalCartVal<1000:

                totalshippingCost = 50

        txn.totalShippingCost = totalshippingCost

        txnOrders = create_orders(cart, userId, orderSource, totalshippingCost, totalCartVal)

        shippingCostInOrders = 0

        for order in txnOrders:

            shippingCostInOrders = shippingCostInOrders + order.shippingCost

        diff = totalshippingCost - shippingCostInOrders

        if diff > 0:

            txnOrders[0].shippingCost = txnOrders[0].shippingCost + diff

        txn.orders = txnOrders

        transaction_client = TransactionClient().get_client()

        txn_id = transaction_client.createTransaction(txn)

        privateDealUser = PrivateDealUser.query.filter(PrivateDealUser.id == userId).filter(PrivateDealUser.isActive==True).first()

        if privateDealUser is not None and privateDealUser.counter is not None:

            privateDealUser.counter.lastPurchasedOn = datetime.datetime.now()

        session.commit()

        return txn_id

    def create_orders(cart, userId, orderSource, totalshippingCost, totalCartVal):

        cart_lines = cart.lines

        orders = []

        isGv = False

        if cart.coupon_code:

            try:

                pc = PromotionClient().get_client()

                isGv = pc.isGiftVoucher(cart.coupon_code)

            except:

                isGv = False

        insuranceDetails = InsuranceDetails.get_by(addressId = cart.address_id)

        for line in cart_lines:

            if line.line_status == LineStatus.LINE_ACTIVE:

                quantity_remaining_for_order = line.quantity

                for discount in line.discounts:

                    #i = 0

                    #while i < discount.quantity:

                    t_line_item = create_line_item(line, line.actual_price if isGv else (line.actual_price - discount.discount), line.quantity)

                    t_order = create_order(userId, cart.address_id, t_line_item, cart.pickupStoreId, discount.discount if isGv else 0, line.insurer, (line.insuranceAmount/line.quantity), insuranceDetails,line.dataProtectionInsurer,(line.dataProtectionAmount)/line.quantity, orderSource, line.freebieId, totalshippingCost, totalCartVal)

                    orders.append(t_order)

                        #i += 1

                    quantity_remaining_for_order -= discount.quantity

                if quantity_remaining_for_order > 0:

                    t_line_item = create_line_item(line, line.actual_price, quantity_remaining_for_order)

                    t_order = create_order(userId, cart.address_id, t_line_item, cart.pickupStoreId, 0, line.insurer, (line.insuranceAmount/line.quantity), insuranceDetails, line.dataProtectionInsurer,(line.dataProtectionAmount)/line.quantity, orderSource, line.freebieId, totalshippingCost, totalCartVal)

                    orders.append(t_order)

                '''

                i = 0

                while i < quantity_remaining_for_order:

                    t_line_item = create_line_item(line, line.actual_price)

                    t_order = create_order(userId, cart.address_id, t_line_item, cart.pickupStoreId, 0, line.insurer, (line.insuranceAmount/line.quantity), insuranceDetails, line.dataProtectionInsurer,(line.dataProtectionAmount)/line.quantity, orderSource, line.freebieId)

                    orders.append(t_order)

                    i += 1

                '''

        return orders

    def create_order(userId, address_id, t_line_item, pickupStoreId, gvAmount, insurer, insuranceAmount, insuranceDetails, dataProtectionInsurer, dataProtectionAmount, orderSource, freebieId, totalshippingCost, totalCartVal):

        user = User.get_by(id=userId)

        address = Address.get_by(id=address_id)

        t_order = TOrder()

        t_order.customer_id = user.id

        t_order.customer_email = user.email

        t_order.customer_name = address.name

        t_order.customer_pincode = address.pin

        t_order.customer_address1 = address.line_1

        t_order.customer_address2 = address.line_2

        t_order.customer_city = address.city

        t_order.customer_state = address.state

        t_order.customer_mobilenumber = address.phone

        t_order.total_amount = t_line_item.total_price + insuranceAmount + dataProtectionAmount

        t_order.gvAmount = gvAmount

        t_order.total_weight = t_line_item.total_weight

        t_order.lineitems = [t_line_item]

        t_order.status = OrderStatus.PAYMENT_PENDING

        t_order.statusDescription = "Payment Pending"

        t_order.created_timestamp = to_java_date(datetime.datetime.now())

        t_order.pickupStoreId = pickupStoreId 

        t_order.insuranceAmount = insuranceAmount 

        t_order.insurer = insurer

        if insuranceDetails:

            t_order.dob = insuranceDetails.dob

            t_order.guardianName = insuranceDetails.guardianName

        catalog_client = CatalogClient().get_client()

        if freebieId is None:

            freebie_item_id = catalog_client.getFreebieForItem(t_line_item.item_id)

            if freebie_item_id:

                t_order.freebieItemId = freebie_item_id

        else:

            freebie_item_id = None if freebieId == 0 else freebieId  

        t_order.source = orderSource

        t_order.dataProtectionInsurer = dataProtectionInsurer

        t_order.dataProtectionAmount = dataProtectionAmount

        t_order.shippingCost = round((t_line_item.total_price*totalshippingCost)/totalCartVal, 0)

        return t_order

    def create_line_item(line, final_price, quantity=1):

        inventory_client = CatalogClient().get_client()

        item = inventory_client.getItem(line.item_id)

        t_line_item = TLineItem()

        t_line_item.productGroup = item.productGroup

        t_line_item.brand = item.brand

        t_line_item.model_number = item.modelNumber

        if item.color is None or item.color == "NA":

            t_line_item.color = ""

        else:

            t_line_item.color = item.color

        t_line_item.model_name = item.modelName

        t_line_item.extra_info = item.featureDescription

        t_line_item.item_id = item.id

        t_line_item.quantity = quantity

        t_line_item.unit_price = final_price

        t_line_item.total_price = final_price * quantity

        t_line_item.unit_weight = item.weight

        t_line_item.total_weight = item.weight if item.weight is None else item.weight * quantity

        if line.dealText is None:

            t_line_item.dealText = item.bestDealText

        elif line.dealText == '':

            t_line_item.dealText = None

        else:

            t_line_item.dealText = line.dealText

        if item.warrantyPeriod:

            #Computing Manufacturer Warranty expiry date

            today = datetime.date.today()

            expiry_year = today.year + int((today.month + item.warrantyPeriod) / 12)

            expiry_month = (today.month + item.warrantyPeriod) % 12

            try:

                expiry_date = datetime.datetime(expiry_year, expiry_month, today.day, 23, 59, 59, 999999)

            except ValueError:

                try:

                    expiry_date = datetime.date(expiry_year, expiry_month, (today.day - 1), 23, 59, 59, 999999)

                except ValueError:

                    try:

                        expiry_date = datetime.date(expiry_year, expiry_month, (today.day - 2), 23, 59, 59, 999999)

                    except ValueError:

                        expiry_date = datetime.date(expiry_year, expiry_month, (today.day - 3), 23, 59, 59, 999999)

            t_line_item.warrantry_expiry_timestamp = to_java_date(expiry_date)

        return t_line_item

    def validate_cart(cartId, sourceId, couponCode):

        inventory_client = CatalogClient().get_client()

        logistics_client = LogisticsClient().get_client()

        promotion_client = PromotionClient().get_client()

        retval = ""

        emival = ""

        # No need to validate duplicate items since there are only two ways

        # to add items to a cart and both of them check whether the item being

        # added is a duplicate of an already existing item.

        cart = Cart.get_by(id=cartId)

        cart_lines = cart.lines

        customer_pincode = None

        current_time = datetime.datetime.now()

        if cart.pickupStoreId :

            store = logistics_client.getPickupStore(cart.pickupStoreId)

            customer_pincode = store.pin

        if cart.address_id != None and customer_pincode == None:

            address = Address.get_by(id=cart.address_id)

            customer_pincode = address.pin

        user = User.get_by(active_cart_id = cartId)

        dealItems = []

        privateDealUser = PrivateDealUser.get_by(id=user.id)    

        if privateDealUser is not None and privateDealUser.isActive:

            itemIds = [cartLine.item_id for cartLine in cart.lines]

            deals = inventory_client.getAllActivePrivateDeals(itemIds, 0)

            dealItems = deals.keys()

        if not customer_pincode:

            default_address_id = user.default_address_id

            if default_address_id:

                address = Address.get_by(id = default_address_id)

                customer_pincode = address.pin

        if not customer_pincode:

            #FIXME should not be hard coded. May be we can pick from config server.

            customer_pincode = "110001"

        cart.total_price = 0

        for line in cart_lines:

            old_estimate = line.estimate

            item_id = line.item_id

            item = inventory_client.getItemForSource(item_id, sourceId)

            item_shipping_info = inventory_client.isActive(item_id) 

            if item_shipping_info.isActive:

                if item_shipping_info.isRisky and item_shipping_info.quantity < line.quantity:

                    line.quantity = 1

                    retval = "Try adding a smaller quantity of " + item.brand + " " + item.modelNumber + " (" + item.color + ")"

                if item_id in dealItems:

                    line.actual_price = deals[item_id].dealPrice

                    if deals[item_id].dealTextOption==0:

                        line.dealText = ''

                    if deals[item_id].dealTextOption==2:

                        line.dealText =  deals[item_id].dealText

                    if deals[item_id].dealFreebieOption==0:

                        line.freebieId = 0

                    if deals[item_id].dealFreebieOption==2:

                        line.freebieId =  deals[item_id].dealFreebieItemId

                else:

                    line.actual_price = item.sellingPrice 

                    line.dealText = None

                    line.freebieId = None

                cart.total_price = cart.total_price + (line.actual_price * line.quantity)

                try:

                    item_delivery_estimate = logistics_client.getLogisticsEstimation(item_id, customer_pincode, DeliveryType.PREPAID).deliveryTime

                except LogisticsServiceException:

                    item_delivery_estimate = -1

                    #TODO Use the exception clause to set the retval appropriately

                except :

                    item_delivery_estimate = -1

                if item_delivery_estimate !=-1:

                    inv_client = InventoryClient().get_client()

                    itemAvailability = None

                    try:

                        itemAvailability = inv_client.getItemAvailabilityAtLocation(item_id, 1)

                    except:

                        pass

                    print 'itemAvailability billling Warehouse ', itemAvailability[2]

                    if itemAvailability is not None:

                        billingWarehouse = None

                        try:

                            billingWarehouse = inv_client.getWarehouse(itemAvailability[2])

                        except:

                            pass

                        print 'billingWarehouse Id Location ', billingWarehouse.stateId

                        if billingWarehouse is not None:

                            estimateVal = None

                            if not logistics_client.isAlive() :

                                logistics_client = LogisticsClient().get_client()

                            try:

                                estimateVal = logistics_client.getFirstDeliveryEstimateForWhLocation(customer_pincode, billingWarehouse.stateId)

                                if estimateVal ==-1:

                                    item_delivery_estimate =-1

                            except:

                                pass

                            print 'estimateVal Value ', estimateVal

                if old_estimate != item_delivery_estimate:

                    line.estimate = item_delivery_estimate

                    cart.updated_on = current_time

            else:

                Discount.query.filter(Discount.line==line).delete()

                line.delete()

        if cart.checked_out_on is not None:

            if cart.updated_on > cart.checked_out_on:

                cart.checked_out_on = None

        session.commit()

        if cart.coupon_code is not None:

            try:

                updated_cart = promotion_client.applyCoupon(cart.coupon_code, cart.id)

                if updated_cart.message is not None:

                    emival = updated_cart.message

            except PromotionException as ex:

                remove_coupon(cart.id)

                #retval = ex.message

        session.commit()

        cart = Cart.get_by(id=cartId)

        cart_lines = cart.lines

        map_lines = {}

        insurerFlag = False

        for line in cart_lines:

            if line.insurer > 0 or line.dataProtectionInsurer > 0:

                line_map = {}

                line_map['insurer'] = line.insurer

                line_map['dpinsurer'] = line.dataProtectionInsurer

                line_map['amount'] = line.discounted_price if line.discounted_price else line.actual_price

                line_map['quantity'] = line.quantity

                insurerFlag = True

                map_lines[line.item_id] = line_map

        if insurerFlag:

            map_lines = inventory_client.checkServices(map_lines)

            for line in cart_lines :

                if map_lines.has_key(line.item_id):

                    line_map = map_lines[line.item_id]

                    if line_map['insurer'] > 0:

                        if cart.discounted_price:

                            cart.discounted_price = cart.discounted_price + line_map['insureramount']

                        line.insurer = line_map['insurer']

                        line.insuranceAmount = line_map['insureramount']

                        cart.total_price = cart.total_price + line_map['insureramount']

                    if line_map['dpinsurer'] > 0:

                        if cart.discounted_price:

                            cart.discounted_price = cart.discounted_price + line_map['dpinsureramount']

                        line.dataProtectionInsurer = line_map['dpinsurer']

                        line.dataProtectionAmount = line_map['dpinsureramount']

                        cart.total_price = cart.total_price + line_map['dpinsureramount']

                    line.updated_on = datetime.datetime.now()

            cart.updated_on = datetime.datetime.now()

            session.commit()

        session.close()

        return [retval, emival]

    def merge_cart(fromCartId, toCartId):

        fromCart = Cart.get_by(id=fromCartId)

        toCart = Cart.get_by(id=toCartId)

        old_lines = fromCart.lines

        new_lines = toCart.lines

        for line in old_lines:

            for discount in line.discounts:

                discount.delete()

        session.commit()

        for line in old_lines:

            flag = True

            for new_line in new_lines:

                if line.item_id == new_line.item_id:

                    flag = False

            if flag:

                line.cart_id = toCartId

            else:

                line.delete()

        if toCart.coupon_code is None:

            toCart.coupon_code = fromCart.coupon_code

        toCart.updated_on = datetime.datetime.now()

        fromCart.expired_on = datetime.datetime.now()

        fromCart.cart_status = CartStatus.INACTIVE

        session.commit()

    def check_out(cartId):

        if cartId is None:

            raise ShoppingCartException(101, "Cart id not specified")

        cart = Cart.get_by(id = cartId)

        if cart is None:

            raise ShoppingCartException(102, "The specified cart couldn't be found")

        cart.checked_out_on = datetime.datetime.now()

        session.commit()

        return True

    def reset_cart(cartId, items):

        if cartId is None:

            raise ShoppingCartException(101, "Cart id not specified")

        for item_id, quantity in items.iteritems():

            line = Line.query.filter_by(cart_id=cartId, item_id=item_id).one()

            if line is not None:

                delete_discounts_for_line(line)

                line.discounted_price = None

                line.quantity = line.quantity - quantity

                if line.quantity == 0:

                    line.delete()

        cart = Cart.get_by(id=cartId)

        cart.updated_on = datetime.datetime.now()

        cart.checked_out_on = None

        # Removing Coupon

        cart.total_price = None

        cart.discounted_price = None

        cart.coupon_code = None

        session.commit()

        return True

    def get_carts_with_coupon_count(coupon_code):

        return Cart.query.filter_by(coupon_code = coupon_code).count()

    def show_cod_option(cartId, sourceId, pincode):

        cart = Cart.get_by(id = cartId)

        cod_option = True

        logistics_client = LogisticsClient().get_client()

        if cart:

            if cart.coupon_code:

                promotion_client = PromotionClient().get_client()

                cod_option = promotion_client.isCodApplicable(to_t_cart(cart))

            if cod_option and cart.lines:

                for line in cart.lines:

                    logistics_info = logistics_client.getLogisticsEstimation(line.item_id, pincode, DeliveryType.PREPAID)

                    if not logistics_info.codAllowed:

                        cod_option = False

                        break

                if cart.total_price > 60000:# or cart.total_price <= 250:

                    cod_option = False

        return cod_option

    def get_products_added_to_cart(startDate, endDate):

        lines = session.query(Line.item_id).filter(Line.created_on > to_py_date(startDate)).filter(Line.created_on < to_py_date(endDate)).all()

        datas = []

        for line in lines:

            datas.append(line[0])

        return datas

    def insure_item(itemId, cartId, toInsure, insurerType):

        cart = Cart.get_by(id = cartId)

        line = None

        for cartLine in cart.lines:

            if(cartLine.item_id == itemId):

                line = cartLine

                break

        if not line:

            print("Error : No line found for cartId : " + cartId + " and itemId : " + itemId)

            return False

        try:

            if toInsure:

                csc = CatalogClient().get_client()

                item = csc.getItem(itemId)

                insurerId = csc.getPrefferedInsurerForItem(itemId,insurerType)

                insuranceAmount = csc.getInsuranceAmount(itemId, line.discounted_price if line.discounted_price else line.actual_price, insurerId, line.quantity)

                if InsurerType._VALUES_TO_NAMES.get(insurerType)=='DEVICE':

                    if cart.discounted_price:

                        cart.discounted_price = cart.discounted_price - line.insuranceAmount + insuranceAmount

                    line.insurer = insurerId

                    line.insuranceAmount = insuranceAmount

                if InsurerType._VALUES_TO_NAMES.get(insurerType)=='DATA':

                    if cart.discounted_price:

                        cart.discounted_price = cart.discounted_price - line.dataProtectionAmount + insuranceAmount

                    line.dataProtectionInsurer = insurerId

                    line.dataProtectionAmount = insuranceAmount

                cart.total_price = cart.total_price + insuranceAmount

            else:

                if InsurerType._VALUES_TO_NAMES.get(insurerType)=='DEVICE':

                    cart.total_price = cart.total_price - line.insuranceAmount

                    if cart.discounted_price:

                        cart.discounted_price = cart.discounted_price - line.insuranceAmount

                    line.insurer = 0

                    line.insuranceAmount = 0

                if InsurerType._VALUES_TO_NAMES.get(insurerType)=='DATA':

                    cart.total_price = cart.total_price - line.dataProtectionAmount

                    if cart.discounted_price:

                        cart.discounted_price = cart.discounted_price - line.dataProtectionAmount

                    line.dataProtectionInsurer = 0

                    line.dataProtectionAmount = 0

            line.updated_on = datetime.datetime.now()

            cart.updated_on = datetime.datetime.now()

            session.commit()

        except:

            print("Error : Unable to insure")

            print("insurerId : " + str(insurerId) + " ItemId : " + str(itemId) + " CartId : " + str(cartId))

            return False

        return True

    def cancel_insurance(cartId):

        try:

            cart = Cart.get_by(id = cartId)

            for cartLine in cart.lines:

                cart.total_price = cart.total_price - cartLine.insuranceAmount

                if cart.discounted_price:

                    cart.discounted_price = cart.discounted_price - cartLine.insuranceAmount

                cartLine.insurer = 0

                cartLine.insuranceAmount = 0

                cartLine.updated_on = datetime.datetime.now()

            cart.updated_on = datetime.datetime.now()

            session.commit()

        except:

            print("Error : Unable to cancel insurance for cartId :" + str(cartId))

            return False

        return True

    def store_insurance_specific_details(addressId, dob, guardianName):

        try:

            insuranceDetails = InsuranceDetails.get_by(addressId = addressId);

            if insuranceDetails is None :

                insuranceDetails = InsuranceDetails()

            insuranceDetails.addressId = addressId

            insuranceDetails.dob = dob

            insuranceDetails.guardianName = guardianName

            session.commit()

        except:

            print("Error : Unable to store insurance details for addressId : " + str(addressId))

            return False

        return True

    def is_insurance_detail_present(addressId):

        try:

            insuranceDetails = InsuranceDetails.get_by(addressId = addressId);

            if insuranceDetails is None :

                return False

        except:

            print("Error : Unable to get insurance details for addressId : " + str(addressId))

            return False

        return True

    def add_items_to_cart(cartId, itemQty, couponCode=None):

        try: 

            found_cart = Cart.get_by(id=cartId)

            itemQtyMap = {}

            current_time = datetime.datetime.now()

            for itemqty in itemQty:

                itemQtyMap[itemqty.itemId] = itemqty.qty 

            if found_cart.lines:    

                for line in found_cart.lines:

                    if itemQtyMap.has_key(line.item_id):

                        line.delete()

            for itemId,qty in itemQtyMap.iteritems():

                #This condition will ensure that cart is only persisted with non-zero quantities.

                if qty==0:

                    continue

                line = Line()

                line.cart = found_cart

                line.item_id = itemId

                line.quantity = qty

                line.created_on = current_time

                line.updated_on = current_time

                line.line_status = LineStatus.LINE_ACTIVE

                line.insurer = 0

                line.insuranceAmount = 0

            if couponCode:

                found_cart.coupon_code = couponCode

            else:

                found_cart.coupon_code = None

            session.commit()

            return True

        except:

            traceback.print_exc()

            return False

    def valiate_cart_new(cartId, customer_pincode, sourceId):

        inventory_client = CatalogClient().get_client()

        logistics_client = LogisticsClient().get_client()

        promotion_client = PromotionClient().get_client()

        # No need to validate duplicate items since there are only two ways

        # to add items to a cart and both of them check whether the item being

        # added is a duplicate of an already existing item.

        cart = Cart.get_by(id=cartId)

        cart_lines = cart.lines

        current_time = datetime.datetime.now()

        user = User.get_by(active_cart_id = cartId)

        responseMap = {}

        totalQty = 0

        totalAmount = 0 

        shippingCharges=0

        cartMessages=[]

        cartItems = []

        dealItems = []

        responseMap['shippingCharges']= shippingCharges

        responseMap['cartMessages']= cartMessages

        responseMap['cartItems']= cartItems

        responseMap['pincode']= customer_pincode

        privateDealUser = PrivateDealUser.get_by(id=user.id)    

        itemIds = [cartLine.item_id for cartLine in cart.lines]

        if privateDealUser is not None and privateDealUser.isActive:

            deals = inventory_client.getAllActivePrivateDeals(itemIds, 0)

            dealItems = deals.keys()

        cart.total_price = 0

        itemsMap = inventory_client.getItems(itemIds)

        cartMessageChanged = 0

        cartMessageOOS = 0

        cartMessageUndeliverable = 0

        for line in cart_lines:

            cartItem={}

            old_estimate = line.estimate

            item_id = line.item_id

            item = itemsMap.get(item_id)

            cartItem['itemId']=line.item_id

            cartItem['quantity']=0

            cartItem['color'] = item.color

            cartItem['catalogItemId'] = item.catalogItemId

            item_shipping_info = inventory_client.isActive(item_id) 

            if item_shipping_info.isActive:

                if item_shipping_info.isRisky and item_shipping_info.quantity < line.quantity:

                    line.quantity = item_shipping_info.quantity

                    cartMessageChanged += 1

                    cartItemMessages.append({"type":"danger", "messageText":"Only " + str(item_shipping_info.quantity) + " available"})

                cartItem['maxQuantity'] = min(item_shipping_info.quantity, 20)

                if item_id in dealItems:

                    line.actual_price = deals[item_id].dealPrice

                    if deals[item_id].dealTextOption==0:

                        line.dealText = ''

                    if deals[item_id].dealTextOption==2:

                        line.dealText = deals[item_id].dealText

                    if deals[item_id].dealFreebieOption==0:

                        line.freebieId = 0

                    if deals[item_id].dealFreebieOption==2:

                        line.freebieId =  deals[item_id].dealFreebieItemId

                    cartItem['dealText'] = line.dealText

                else:

                    line.actual_price = item.sellingPrice

                    if item.bestDealText:

                        cartItem['dealText'] = item.bestDealText

                    line.dealText = None

                    line.freebieId = None

                cartItem['sellingPrice'] = line.actual_price

                cartItem['quantity'] = line.quantity

                cart.total_price = cart.total_price + (line.actual_price * line.quantity)

                try:

                    item_delivery_estimate = logistics_client.getLogisticsEstimation(item_id, customer_pincode, DeliveryType.PREPAID).deliveryTime

                except LogisticsServiceException:

                    item_delivery_estimate = -1

                    #TODO Use the exception clause to set the retval appropriately

                except :

                    item_delivery_estimate = -1

                if item_delivery_estimate !=-1:

                    inv_client = InventoryClient().get_client()

                    itemAvailability = None

                    try:

                        itemAvailability = inv_client.getItemAvailabilityAtLocation(item_id, 1)

                    except:

                        pass

                    print 'itemAvailability billling Warehouse ', itemAvailability[2]

                    if itemAvailability is not None:

                        billingWarehouse = None

                        try:

                            billingWarehouse = inv_client.getWarehouse(itemAvailability[2])

                        except:

                            pass

                        print 'billingWarehouse Id Location ', billingWarehouse.stateId

                        if billingWarehouse is not None:

                            estimateVal = None

                            if not logistics_client.isAlive() :

                                logistics_client = LogisticsClient().get_client()

                            try:

                                estimateVal = logistics_client.getFirstDeliveryEstimateForWhLocation(customer_pincode, billingWarehouse.stateId)

                                if estimateVal ==-1:

                                    item_delivery_estimate =-1

                            except:

                                pass

                            print 'estimateVal Value ', estimateVal

                cartItem['estimate'] = item_delivery_estimate

                if item_delivery_estimate == -1:

                    cartItem['quantity'] = 0

                    cartMessageUndeliverable += 1

                    cartItemMessages.append({"type":"danget", "messageText":"Undeliverable"})

                if old_estimate != item_delivery_estimate:

                    line.estimate = item_delivery_estimate

                    cart.updated_on = current_time

            else:

                cartItem['quantity'] = 0

                cartMessageOOS += 1

                cartItemMessages.append({"type":"danger", "messageText":"Out of Stock"})

                Discount.query.filter(Discount.line==line).delete()

                line.delete()

            totalQty += cartItem['quantity']

            totalAmount += line.actual_price * cartItem['quantity']

            if cartItemMessages:

                cartItems.insert(0, cartItem)

            else:

                cartItems.append(cartItem)

        if cart.checked_out_on is not None:

            if cart.updated_on > cart.checked_out_on:

                cart.checked_out_on = None

        session.commit()

        if cart.coupon_code is not None:

            try:

                updated_cart = promotion_client.applyCoupon(cart.coupon_code, cart.id)

                if updated_cart.message is not None:

                    emival = updated_cart.message

            except PromotionException as ex:

                remove_coupon(cart.id)

                #retval = ex.message

        session.commit()

        cart = Cart.get_by(id=cartId)

        cart_lines = cart.lines

        insurerFlag = False

        for line in cart_lines:

            if line.insurer > 0 or line.dataProtectionInsurer > 0:

                line.insurer = 0

                line.insuranceAmount = 0 

                line.dataProtectionInsurer = 0

                line.dataProtectionAmount = 0

                insurerFlag = True

        if insurerFlag:

            cart.updated_on = datetime.datetime.now()

            session.commit()

        session.close()

        responseMap['totalQty']= totalQty

        responseMap['totalAmount']= totalAmount

        if totalAmount < 500:

            shippingCharges = 100

        elif totalAmount < 1000:

            shippingCharges = 50

        responseMap['shippingCharge']=shippingCharges

        responseMap['cartMessageChanged'] = cartMessageChanged

        responseMap['cartMessageOOS'] = cartMessageOOS

        responseMap['cartMessageUndeliverable'] = cartMessageUndeliverable

        return json.dumps(responseMap)