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

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

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)

    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)

    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.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