Subversion Repositories SmartDukaan

'''
Created on 10-May-2010

@author: ashish
'''
from elixir import *
from shop2020.model.v1.user.impl.Dataservice import Cart, Line, Address, User, Discount
from shop2020.thriftpy.model.v1.user.ttypes import CartStatus, LineStatus, ShoppingCartException,\
    PromotionException
import datetime
from shop2020.utils.Utils import to_py_date, to_java_date

from shop2020.thriftpy.model.v1.order.ttypes import Transaction as TTransaction,\
    TransactionStatus as TTransactionStatus, Order as TOrder, LineItem as TLineItem, OrderStatus 

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

from shop2020.clients.TransactionClient import TransactionClient
from shop2020.clients.CatalogClient import CatalogClient
from shop2020.clients.LogisticsClient import LogisticsClient
from shop2020.model.v1 import user
from shop2020.clients.PromotionClient import PromotionClient

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")
    retval = ""
    inventory_client = CatalogClient().get_client()
    item = inventory_client.getItemForSource(item_id, sourceId)
    item_shipping_info = inventory_client.isActive(item_id)
    if not item_shipping_info.isActive:
        return inventory_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.quantity = quantity
        line.updated_on = current_time
    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
    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(cart_id, coupon_code, total_price, discounted_price):
    cart = get_cart_by_id(cart_id)
    if not cart:
        raise ShoppingCartException(101, "no cart attached to this id")
    cart.total_price = total_price
    cart.discounted_price = discounted_price
    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
    
    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):   
    cart = get_cart_by_id(cart_id)   
    #now we have a cart. Need to create a transaction with it
    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
    txn.orders = create_orders(cart, userId)
    
    transaction_client = TransactionClient().get_client()
    txn_id = transaction_client.createTransaction(txn)
    session.commit()
    
    return txn_id

def create_orders(cart, userId):
    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
        
    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.item_id, line.actual_price if isGv else (line.actual_price - discount.discount))
                    t_order = create_order(userId, cart.address_id, t_line_item, cart.pickupStoreId, discount.discount if isGv else 0)
                    orders.append(t_order)
                    i += 1
                quantity_remaining_for_order -= discount.quantity
            
            i = 0
            while i < quantity_remaining_for_order:
                t_line_item = create_line_item(line.item_id, line.actual_price)
                t_order = create_order(userId, cart.address_id, t_line_item, cart.pickupStoreId, 0)
                orders.append(t_order)
                i += 1
    return orders

def create_order(userId, address_id, t_line_item, pickupStoreId, gvAmount):
    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
    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 
    return t_order
        
def create_line_item(item_id, final_price, quantity=1):
    inventory_client = CatalogClient().get_client()
    item = inventory_client.getItem(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
    t_line_item.dealText = item.bestDealText
    
    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):
    inventory_client = CatalogClient().get_client()
    logistics_client = LogisticsClient().get_client()
    promotion_client = PromotionClient().get_client()
    retval = ""
    # 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
    if not customer_pincode:
        user = User.get_by(active_cart_id = cartId)
        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 + ")"
            
            line.actual_price = item.sellingPrice 
            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 old_estimate != item_delivery_estimate:
                line.estimate = item_delivery_estimate
                cart.updated_on = current_time
                if old_estimate != None:
                    retval = "Delivery Estimates updated."
        else:
            line.delete()
            retval = "Some items have been removed from the cart."
    if cart.checked_out_on is not None:
        if cart.updated_on > cart.checked_out_on:
            cart.checked_out_on = None
            if retval == "":
                retval = "Your cart has been updated after the last checkout."
    session.commit()
    
    if cart.coupon_code is not None:
        try:
            updated_cart = promotion_client.applyCoupon(cart.coupon_code, cart.id)
            for t_line in updated_cart.lines:
            #Find the line in the database which corresponds to this line
                line = Line.query.filter_by(cart = cart).filter_by(item_id = t_line.itemId).one()
            #Update its discounted price.
                line.discounted_price = t_line.discountedPrice
            cart.discounted_price = updated_cart.discountedPrice
            session.commit()
        except PromotionException as ex:
            remove_coupon(cart.id)
            retval = ex.message
    return retval

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(cart.coupon_code)
        
        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 > 20000 or cart.total_price <= 250:
                cod_option = False
    return cod_option
    
def close_session():
    if session.is_active:
        print "session is active. closing it."
        session.close()