Subversion Repositories SmartDukaan

'''
Created on 10-May-2010

@author: ashish
'''
from elixir import *
from shop2020.model.v1.user.impl.Dataservice import Cart, Line
from shop2020.thriftpy.model.v1.user.ttypes import CartStatus, LineStatus, ShoppingCartException
import datetime
from shop2020.utils.Utils import to_py_date
from shop2020.thriftpy.model.v1.order.ttypes import Transaction,\
    TransactionStatus


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()
        cart.accessed_on = datetime.datetime.now()
        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)
    if cart:
        cart.accessed_on = datetime.datetime.now()
        session.commit()
    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_item(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(Line.cart.has(id = cart_id))
    query = query.filter_by(item_id = item_id)
    
#    query = LineItem.query.filter_by(item_id = item_id)
#    query = query.filter(LineItem.cart.id == cart_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 get_item_by_id(line_id):
    return Line.get_by(id=line_id)

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")    
    
    item = get_item(item_id, cart_id, None,True)
    if item:
        #change the quantity only
        item.quantity = quantity
        session.commit()
        return item.id
    
    cart = get_cart_by_id(cart_id)
    if not cart:
        raise ShoppingCartException(101, "no cart attached to this id")
    
    line = Line()
    line.item_id = item_id
    line.quantity = quantity
    line.created_on = datetime.datetime.now()
    line.updated_on = datetime.datetime.now()
    line.line_status = LineStatus.LINE_ACTIVE
    
    cart.lines.append(line)
    session.commit()
    return line.id

def delete_item_from_cart(cart_id, item_id):
    if not item_id:
        raise ShoppingCartException(101, "item_id cannot be null")
    item = get_item(item_id, cart_id, None, True)
    item.delete()
    session.commit()
    return

def change_item_quantity(cart_id, item_id, quantity):
    return add_item_to_cart(cart_id, item_id, quantity)

def change_item_status(cart_id, item_id, status):
    if not status:
        raise ShoppingCartException(101, "Status cannot be made null")
    item = get_item(item_id, cart_id, None, True)
    if item:
        item.line_status = status
        session.commit()
    else:
        raise ShoppingCartException(101, "Unable to probe the item 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")
    cart.address_id = address_id
    session.commit()
    
def commit_cart(cart_id, transaction_client):
    
    cart = get_cart_by_id(cart_id)
    cart.cart_status = CartStatus.COMMITTED
    cart.committed_on = datetime.datetime.now()
    session.commit()
    #now we have a cart. Need to create a transaction with it
    #transaction = transaction_client.create_transaction(cart)
    return True
"""
    transaction.shoppingCartid = cart_id
    transaction.customer_id = cart.user_id
    transaction.transactionStatus = TransactionStatus.INIT
    transaction.statusDescription = "Transaction submitted to warehouse"
    transaction.created_on = datetime.datetime.now()
    transaction.warehouse_id = 1;
    
    cart_lines = cart.lines
    for line in cart_lines:
        if line.status == LineStatus.LINE_ACTIVE:
            #line is active
            line_item = get_line_item(cartLine.getItemId());
// create orders equivalent to quantity. Create one order per item.
for(int i= 0; i<cartLine.getQuantity(); i++){
    //  set order
    Order order = getOrder(c.getAddressId(), lineItem);
    order.addToLineitems(lineItem);
    orders.add(order);
"""
    
def validate_cart(cartId):
    # 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.
    return True
    
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() 
"""    
    t_line.id = line.id
    t_line.itemId = line.item_id
    t_line.quantity = line.quantity
    t_line.createdOn = to_java_date(line.created_on)
    t_line.updatedOn = to_java_date(line.updated_on)
    t_line.lineStatus = line.line_status
"""