Subversion Repositories SmartDukaan

'''
Created on 29-Mar-2010

@author: ashish
'''
from shop2020.model.v1.order.impl.DataService import Transaction, LineItem,\
    AdditionalInfo, Payment, Shipment, TransactionTrail, Billing, ItemInfo,\
    Alerts, ExtraItemInfo
from shop2020.thriftpy.model.v1.order.ttypes import Transaction as T_Transaction,\
    TransactionServiceException
import datetime
from shop2020.utils.OrderStatus import status_transaction_init,\
    status_shipment_shipped, status_shipment_delivered, get_c_status
from elixir import *
from shop2020.utils.Utils import to_py_date
from sqlalchemy.sql.expression import and_


def get_new_transaction():
    transaction = Transaction()
    transaction.createdOn = datetime.datetime.now()
    transaction.status = status_transaction_init
    transaction.status_message = "New transaction"
    transaction.trails = []
    session.commit()
    return transaction

def create_transaction(t_transaction):
    orderinfo = t_transaction.orderInfo
    if not orderinfo:
        raise TransactionServiceException(101, "Orderinfo missing from the transaction")
    transaction = get_new_transaction()
    for line_item in orderinfo.lineitems:
        litem = LineItem()
        if line_item.item.id:
            litem.item_id = line_item.item.id
            item_info = ItemInfo()
            item_info.price = line_item.item.price
            item_info.weight = line_item.item.weight
            litem.item_info = item_info
        litem.added_on = to_py_date(line_item.addedOn)
        transaction.lineitems.append(litem)
        if line_item.additionalInfo:
            for k,v in line_item.additionalInfo.iteritems():
                additional_info = AdditionalInfo()
                additional_info.key = k
                additional_info.value = v
                litem.additional_info.append(additional_info)
    if t_transaction.shoppingCartid:
        transaction.shopping_cart_id = t_transaction.shoppingCartid
    transaction.customer_id = t_transaction.customer_id
    transaction.expected_delivery_time = to_py_date(t_transaction.expectedDeliveryTime)
    #no need to set status. It is already set.
    #transaction.status = t_transaction.transactionStatus
    transaction.status_message = t_transaction.statusDescription
    transaction.createdOn = to_py_date(t_transaction.createdOn)
    
    #add payment info
    #transaction.payments=[]
    if t_transaction.paymentInfo:
        if not t_transaction.paymentInfo.payments:
            raise TransactionServiceException(108, "no payments found")
        
        for k,v in t_transaction.paymentInfo.payments.iteritems():
            payment = Payment()
            payment.merchant_tx_id = v.merchant_tx_id
            payment.bank_tx_id = v.bank_tx_id
            payment.mode = v.mode
            payment.amount = v.amount
            payment.payment_id = v.id
            payment.status = v.status
            payment.status_message = v.description
            payment.start_time = to_py_date(v.submissionTimestamp)
            payment.finish_time = to_py_date(v.completionTimestamp)
            transaction.payments.append(payment)
    if not t_transaction.shipmentInfo:
        raise TransactionServiceException(109, "no shipping info attached with this")
    transaction.shipments = []
    for v in t_transaction.shipmentInfo.shipments:
        shipment = Shipment()
        shipment.weight = v.weight
        shipment.insurance_value = v.insurance
        shipment.status = get_c_status(v.status);
        shipment.address = v.address
        transaction.shipments.append(shipment)
    session.commit()
    return transaction.id
            
    
def get_transaction(transaction_id):
    transaction = Transaction.get_by(id=transaction_id)
    if not transaction:
        raise TransactionServiceException(108, "no such transaction")
    
    return transaction

def get_all_transactions(status, from_date, to_date):
    if not status:
        if not from_date and not to_date:
            #get all between from_date and to_date
            return Transaction.query.all()
        
        if not from_date:
            return Transaction.query.filter(Transaction.createdOn < to_date).all()
        
        if not to_date:
            return Transaction.query.filter(Transaction.createdOn > to_date).all()
        return Transaction.query.filter(and_(Transaction.createdOn < to_date , Transaction.createdOn > from_date)).all()
        
    
    if not from_date and not to_date:
        return Transaction.query.filter(Transaction.status == status).all()
    if not from_date:
        return Transaction.query.filter(and_(Transaction.status == status, Transaction.createdOn <to_date)).all()
    if not from_date:
        return Transaction.query.filter(and_(Transaction.status == status, Transaction.createdOn >from_date)).all()
    if not from_date:
        return Transaction.query.filter(and_(Transaction.status == status, and_(Transaction.createdOn <to_date, Transaction.createdOn > from_date))).all()
    
    
def get_transactions_for_shipment_status(status, from_date, to_date):
    
    if not status:
        raise TransactionServiceException(101, "unknown status")
    
    query = Shipment.query.filter(Shipment.status == status)
    
    if from_date:
        query = query.filter(Shipment.shipment_time >from_date)
    if to_date:
        query = query.filter(Shipment.shipment_time <to_date)
    
    shipments =  query.all()
    
    transactions = {}
    for shipment in shipments:
        if not transactions[shipment.transaction.id]:
            transactions.append(shipment.transaction)
    return transactions.values()


def get_transactions_for_customer(customer_id, from_date, to_date, status):
    if not customer_id:
        raise TransactionServiceException(101, "bas customer id")
    query = Transaction.query.filter(Transaction.customer_id == customer_id)
    if status:
        query = query.filter(Transaction.status == status)
    if from_date:
        query = query.filter(Transaction.createdOn >from_date)
    if to_date:
        query = query.filter(Transaction.createdOn < to_date)
    return query.all()

def get_transactions_for_customer_shipment(customer_id, from_date, to_date, status):
    
    if not customer_id:
        raise TransactionServiceException(101, "unknown customer id")
    
    query = Shipment.query.filter(Shipment.transaction.customerId == customer_id)
    
    if status:
        query = query.filter(Shipment.status == status)
    
    if from_date:
        query = query.filter(Shipment.shipment_time >from_date)
    
    if to_date:
        query = query.filter(Shipment.shipment_time <to_date)
    
    shipments =  query.all()
    
    transactions = {}
    for shipment in shipments:
        if not transactions[shipment.transaction.id]:
            transactions.append(shipment.transaction)
    return transactions.values()

def get_transaction_status(transaction_id):
    
    if not transaction_id:
        raise TransactionServiceException(101, "bad transaction id")
    
    transaction = get_transaction(transaction_id)
    
    return transaction.status

def change_transaction_status(transaction_id, new_status, description):
    transaction = get_transaction(transaction_id)
    trail = TransactionTrail()
    trail.old_value = str(transaction.status)
    trail.new_value = str(new_status)
    transaction.status = new_status
    trail.transaction = transaction
    trail.timestamp = datetime.datetime.now()
    trail.description = description
    transaction.status_message = description
    session.commit()
    return True

def set_shipping_tracker_info(transaction_id, shipping_id, tracking_id, airwayBillNo, provider):
    shipment = Shipment.get_by(id=shipping_id)
    if not shipment:
        raise TransactionServiceException(101, "not such shipment found")
    
    transaction = shipment.transaction
    if transaction.id != transaction_id:
        raise TransactionServiceException(108, "Looks like this is invalid transaction")
    shipment.tracking_id = tracking_id
    shipment.airway_bill_no = airwayBillNo
    shipment.provider = provider
    trail = TransactionTrail()
    trail.timestamp = datetime.datetime.now()
    trail.description = "shipping_id %d:tracking_id %s:airwayBill %s: provider %s" %(shipping_id, tracking_id, airwayBillNo, provider)
    trail.transaction = transaction
    session.commit()
    return True

def change_shipping_status(transaction_id, shipping_id, status, description):
    shipment = Shipment.get_by(id=shipping_id)
    if not shipment:
        raise TransactionServiceException(101, "not such shipment found")
    
    transaction = shipment.transaction
    if transaction.id != transaction_id:
        raise TransactionServiceException(108, "Looks like this is invalid transaction")
    
    trail = TransactionTrail()
    trail.old_value = str(shipment.status)
    trail.new_value = str(status)
    shipment.status = status
    trail.transaction = transaction
    trail.timestamp = datetime.datetime.now()
    trail.description = "Shipping status change : %s"%(description)
    shipment.status_message = description
    session.commit()
    return True

def set_shipping_date(transaction_id, shipping_id, timestamp):
    shipment = Shipment.get_by(id=shipping_id)
    if not shipment:
        raise TransactionServiceException(101, "not such shipment found")
    
    transaction = shipment.transaction
    if transaction.id != transaction_id:
        raise TransactionServiceException(108, "Looks like this is invalid transaction")
    
    trail = TransactionTrail()
    trail.old_value = str(shipment.status)
    trail.new_value = str(status_shipment_shipped)
    shipment.status = status_shipment_shipped
    trail.transaction = transaction
    trail.timestamp = datetime.datetime.now()
    trail.description = "Shipping status change : %s"%(shipment.id)
    shipment.status_message = "Shipment dispatched"
    shipment.shipment_time = timestamp
    session.commit()
    return True


def set_delivery_date(transaction_id, shipping_id, timestamp):
    shipment = Shipment.get_by(id=shipping_id)
    if not shipment:
        raise TransactionServiceException(101, "not such shipment found")
    
    transaction = shipment.transaction
    if transaction.id != transaction_id:
        raise TransactionServiceException(108, "Looks like this is invalid transaction")
    
    trail = TransactionTrail()
    trail.old_value = str(shipment.status)
    trail.new_value = str(status_shipment_delivered)
    shipment.status = status_shipment_delivered
    trail.transaction = transaction
    trail.timestamp = datetime.datetime.now()
    trail.description = "Shipping status change : %s"%(shipment.id)
    shipment.status_message = "Shipment delivered"
    shipment.delivery_time = timestamp
    session.commit()
    return True

def set_billing(transaction_id, t_billing):
    transaction = get_transaction(transaction_id)
    line_item = LineItem.query.filter_by(transaction_id=transaction_id).all()
    #line_item = LineItem.get_by(id = t_billing.lineItem.id)
    if not line_item:
        raise TransactionServiceException(101, "unable to get this line item for id %d" % (t_billing.lineItem.id))
    billing = Billing()
    billing.line_item = line_item
    billing.bill_number = t_billing.billNumber
    try:
        billing.created_on = to_py_date(t_billing.generatedTimestamp)
    except:
        raise TransactionServiceException(108, "bad time stamp found while adding billing for transaction id %d" %(transaction.id))
    billing.generated_by = t_billing.generatedBy
    session.commit()
    return True

def get_line_items(transaction_id):
    transaction = get_transaction(transaction_id)
    if not transaction.lineitems:
        raise TransactionServiceException(108, "no lineitems with transaction %d"%(transaction_id))
    return transaction.lineitems

def get_shipments(transaction_id):
    transaction = get_transaction(transaction_id)
    if not transaction.shipments:
        raise TransactionServiceException(108, "no shipments with transaction %d"%(transaction_id))
    return transaction.shipments
    
def get_billings(transaction_id):
    transaction = get_transaction(transaction_id)
    if not transaction.lineitems:
        raise TransactionServiceException(108, "no lineitems, hence no billing with transaction %d"%(transaction_id))
    billings = []
    for lineitem in transaction.lineitems:
        billings.append(lineitem.billing)
    return billings
    return transaction.shipments

def get_transactions_for_shopping_cart_id(shopping_cart_id):
    transactions = Transaction.query.filter_by(shopping_cart_id=shopping_cart_id).all()
    if not transactions:
        raise TransactionServiceException(108, "transactions for this shopping cart")
    return transactions

def get_alerts(transaction_id, all):
    query = Alerts.query.filter_by(transaction_id=transaction_id)
    if not all:
        query = query.filter_by(valid=True)
    return query.all()

def set_alert(transaction_id, unset, type, comment):
    #get existing alert
    if unset:
        query = Alerts.query.filter_by(transaction_id=transaction_id)
        query = query.filter_by(type=type)
        alerts = query.all()
        for alert in alerts:
            if alert.valid:
                alert.valid = False
                alert.comment = comment
                alert.time_unset = datetime.datetime.now()
    else:
        alert = Alerts()
        alert.transaction_id = transaction_id
        alert.valid = True
        alert.type = type
        alert.comment = comment
        alert.time_set = datetime.datetime.now()
    session.commit()
    
def get_extra_info(transaction_id):
    return ExtraItemInfo.get_by(transaction_id=transaction_id)

def set_extra_info(transaction_id, sku_id, model, vendor, colour):
    extra_item_info = ExtraItemInfo()
    extra_item_info.transaction_id = transaction_id
    extra_item_info.sku_id = sku_id
    extra_item_info.model = model
    extra_item_info.vendor = vendor
    extra_item_info.colour = colour
    session.commit()