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
from shop2020.thriftpy.model.v1.user.ttypes import CartStatus, LineStatus, ShoppingCartException
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.model.v1.catalog.ttypes import Item as TItem
from shop2020.thriftpy.logistics.ttypes import LogisticsInfo as TLogisticsInfo

from shop2020.clients.TransactionClient import TransactionClient
from shop2020.clients.InventoryClient import InventoryClient
from shop2020.clients.LogisticsClient import LogisticsClient
from shop2020.model.v1 import user

def get_cart(user_id):
    query = Cart.query.filter_by(user_id=user_id)      
    query = query.filter_by(cart_status = CartStatus.ACTIVE)
    try:
        cart = query.one()
        session.commit()
    except:
        return None
#        raise ShoppingCartException(101, "Cart does not exist")
    return cart

def get_cart_by_id(id):
    cart = Cart.get_by(id=id)
    return cart

def create_cart(user_id):
    cart = get_cart(user_id)
    if not cart: 
        cart = Cart()
        cart.user_id = user_id
        cart.created_on = datetime.datetime.now()
        cart.updated_on = datetime.datetime.now()
        cart.cart_status = CartStatus.ACTIVE
        session.commit()
    
    return cart

def get_cart_by_user_id_and_status(user_id, status):
    query = Cart.query.filter_by(user_id=user_id)
    if status:
        query = query.filter_by(cart_status=status)
    carts = query.all()
    return carts

def get_carts_by_status(status):
    return Cart.query.filter_by(cart_status=status).all()

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 change_cart_status(cart_id, status):
    cart = get_cart_by_id(id)
    if not cart:
        raise ShoppingCartException(101, "no cart attached to this id")
    if not status:
        raise ShoppingCartException(101, "invalid status")
    cart.cart_status = status
    session.commit()
    
def add_item_to_cart(cart_id, item_id, quantity):
    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")
    
    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.line_status = LineStatus.LINE_ACTIVE
    session.commit()

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)
    item.delete()
    current_time = datetime.datetime.now()
    cart.updated_on = current_time
    session.commit()

def change_item_status(cart_id, item_id, status):
    if not status:
        raise ShoppingCartException(101, "Status cannot be made null")
    line = get_line(item_id, cart_id, None, True)
    if line:
        line.line_status = status
        current_time = datetime.datetime.now()
        line.updated_on = current_time
        line.cart.updated_on = current_time
        session.commit()
    else:
        raise ShoppingCartException(101, "Unable to probe the line you desired")
    
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 commit_cart(cart_id):   
    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 = cart.user_id
    txn.createdOn = to_java_date(datetime.datetime.now())
    txn.transactionStatus = TTransactionStatus.INIT
    txn.statusDescription = "New Order"
    
    txn.orders = create_orders(cart)
    
    transaction_client = TransactionClient().get_client()
    txn_id = transaction_client.createTransaction(txn)
    session.commit()
    
    #new_cart = create_cart(cart.user_id)
    #user = User.get_by(id=cart.user_id)
    #user.active_cart_id = new_cart.id
    #session.commit()
    return txn_id

def create_orders(cart):
    cart_lines = cart.lines
    orders = []
    
    for line in cart_lines:
        if line.line_status == LineStatus.LINE_ACTIVE:
            i = 0
            while i< line.quantity:
                t_line_item = create_line_item(line.item_id)
                t_order = create_order(cart.user_id, cart.address_id, t_line_item)
                orders.append(t_order)
                i += 1
    return orders

def create_order(user_id, address_id, t_line_item):
    user = User.get_by(id=user_id)
    address = Address.get_by(id=address_id)
    t_order = TOrder()
    
    t_order.customer_id = user.id
    t_order.customer_name = user.name
    t_order.customer_email = user.email
    
    t_order.customer_pincode = address.pin
    t_order.customer_address = get_address_string(address)
    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.total_weight = t_line_item.total_weight
    t_order.lineitems = [t_line_item]
    
    t_order.status = OrderStatus.PAYMENT_PENDING
    t_order.statusDescription = "Submitted to warehouse"
    t_order.created_timestamp = to_java_date(datetime.datetime.now())
    
    logistics_client = LogisticsClient().get_client()
    logistics_info = logistics_client.getLogisticsInfo(t_order.customer_pincode, t_line_item.item_id)
    
    t_order.logistics_provider_id = logistics_info.providerId
    t_order.airwaybill_no = logistics_info.airway_billno
    t_order.tracking_id = t_order.airwaybill_no
    t_order.expected_delivery_time = to_java_date(datetime.datetime.now()) + 60*60*1000*logistics_info.deliveryTime
    t_order.warehouse_id = logistics_info.warehouseId

    return t_order
        
def create_line_item(item_id):
    inventory_client = InventoryClient().get_client()
    item = inventory_client.getItem(item_id)
    t_line_item = TLineItem()
    t_line_item.model_name = item.modelName
    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.extra_info = item.featureDescription
    t_line_item.brand = item.manufacturerName
    t_line_item.item_id = item.id
    t_line_item.quantity = 1
    t_line_item.unit_price = item.sellingPrice
    t_line_item.unit_weight = item.weight
    t_line_item.total_price = item.sellingPrice
    t_line_item.total_weight = item.weight
    return t_line_item

def get_address_string(address):
    return address.line_1 + "\n" + address.line_2 + "\n Landmark: " + "\n"
    
def validate_cart(cartId):
    inventory_client = InventoryClient().get_client()
    logistics_client = LogisticsClient().get_client()
    retval = True
    # 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 = ""
    current_time = datetime.datetime.now()
    if cart.address_id:
        address = Address.get_by(id=cart.address_id)
        customer_pincode = address.pin
    for line in cart_lines:
        old_estimate = line.estimate
        item_id = line.item_id
        if inventory_client.isActive(item_id):
            if customer_pincode:
                try:
                    item_delivery_estimate = logistics_client.getLogisticsEstimation(item_id, customer_pincode).deliveryTime
                except:
                    item_delivery_estimate = 3
                if old_estimate != item_delivery_estimate:
                    line.estimate = item_delivery_estimate
                    cart.updated_on = current_time
                    retval = False
        else:
            line.delete()
            retval = False
    if cart.checked_out_on is not None:
        if cart.updated_on > cart.checked_out_on:
            retval = False
    session.commit()
    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:
        flag = True
        for new_line in new_lines:
            if line.item_id == new_line.item_id:
                flag = False
        if flag:
            toCart.lines.append(line)

    toCart.updatedOn = 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:
            line.quantity = line.quantity - quantity
            if line.quantity == 0:
                line.delete()
    cart = Cart.get_by(cartId)
    cart.updated_on = datetime.datetime.now()
    session.commit()
    return True