Subversion Repositories SmartDukaan

'''

Created on 29-Mar-2010

@author: ashish

'''

from shop2020.model.v1.order.impl.DataService import Transaction, LineItem,\

    Payment, Alerts, Order

from shop2020.thriftpy.model.v1.order.ttypes import Transaction as T_Transaction,\

    TransactionServiceException

import datetime

from shop2020.utils.OrderStatus import status_transaction_init, get_c_status

from elixir import *

from shop2020.utils.Utils import to_py_date

from sqlalchemy.sql.expression import and_

from shop2020.model.v1 import order

def get_new_transaction():

    transaction = Transaction()

    transaction.createdOn = datetime.datetime.now()

    transaction.status = status_transaction_init 

    transaction.status_message = "New transaction"

    return transaction

'''

    customer_id = Field(Integer)

    shopping_cart_id = Field(Integer)

    payments = OneToMany("Payment")

    orders = OneToMany("Order")

'''

def create_order(t_order):

    order = Order()

    if t_order.warehouse_id:

        order.warehouse_id = t_order.warehouse_id

    if t_order.logistics_provider_id:    

        order.logistics_provider_id = t_order.logistics_provider_id

        order.airwaybill_no = t_order.airwaybill_no

        order.tracking_id = t_order.tracking_id

    if t_order.expected_delivery_time:    

        order.expected_delivery_time = to_py_date(t_order.expected_delivery_time)

    if t_order.customer_id:    

        order.customer_id = t_order.customer_id

        order.customer_name = t_order.customer_name

        order.customer_mobilenumber = t_order.customer_mobilenumber

        order.customer_pincode = t_order.customer_pincode

        order.customer_address = t_order.customer_address

        order.customer_email = t_order.customer_email

    #new status and status description to be added    

    order.status = get_c_status(t_order.status)  

    order.statusDescription = t_order.statusDescription

    order.total_amount = t_order.total_amount

    order.total_weight = t_order.total_weight

    if t_order.created_timestamp:

        order.created_timestamp = to_py_date(t_order.created_timestamp)

    else:

        order.created_timestamp = datetime.datetime.now()    

    #these fields will not be populated in initial

    """

    order.invoice_number = order.invoice_number

    order.billed_by = order.billed_by

    order.accepted_timestamp = order.accepted_timestamp

    order.billing_timestamp = order.billing_timestamp

    order.shipping_timestamp = order.shipping_timestamp

    order.delivery_timestamp = order.delivery_timestamp

    """

    return order

def create_transaction(t_transaction):

    t_orders = t_transaction.orders

    if not t_orders:

        raise TransactionServiceException(101, "Orders missing from the transaction")

    transaction = get_new_transaction()

    transaction.customer_id = t_transaction.customer_id 

    transaction.shopping_cart_id = t_transaction.shoppingCartid

    for t_order in t_orders:

        order = create_order(t_order)

        order.transaction = transaction 

        for line_item in t_order.lineitems:

            litem = LineItem()

            litem.sku_id = line_item.sku_id

            litem.brand = line_item.brand

            if line_item.model_number:

                litem.model_number = line_item.model_number

            if line_item.model_name:    

                litem.model_name = line_item.model_name

            if line_item.extra_info:

                litem.extra_info = line_item.extra_info

            litem.quantity = line_item.quantity

            litem.unit_price = line_item.unit_price

            litem.unit_weight = line_item.unit_weight

            litem.total_price = line_item.total_price

            litem.total_weight = line_item.total_weight

            """

            if line_item.addedOn:

                litem.added_on = to_py_date(line_item.addedOn)

            else:

                litem.added_on = datetime.datetime.now()

            """

            litem.order = order

    #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_transactions_for_customer(customer_id, from_date, to_date, status):

    if not customer_id:

        raise TransactionServiceException(101, "bad 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_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_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)

    transaction.status = new_status

    transaction.status_message = description

    session.commit()

    return True

def get_order(order_id):

    order = Order.get_by(id=order_id)

    if not order:

        raise TransactionServiceException(108, "no such order")

    return order

def get_orders_for_customer(customer_id, from_date, to_date, status):

    if not customer_id:

        raise TransactionServiceException(101, "bad customer id")

    query = Order.query.filter(Order.customer_id == customer_id)

    if status:

        query = query.filter(Order.status == status)

    if from_date:

        query = query.filter(Order.created_timestamp >from_date)

    if to_date:

        query = query.filter(Order.created_timestamp < to_date)

    return query.all()

def get_all_orders(status, from_date, to_date, warehouse_id):

    if not warehouse_id:

        raise TransactionServiceException(101, "bad warehouse id")

    query = Order.query.filter(Order.warehouse_id == warehouse_id)

    if status:

        query = query.filter(Order.status == status)

    if from_date:

        query = query.filter(Order.created_timestamp >from_date)

    if to_date:

        query = query.filter(Order.created_timestamp < to_date)

    return query.all()

def change_order_status(self, orderId, status, description):

    order = get_order(orderId)

    order.status = status

    order.statusDescription = description

    session.commit()

    return True

def get_orders_for_transaction(transaction_id):

    orders = Order.query.filter_by(transaction_id=transaction_id).all()

    if not orders:

        raise TransactionServiceException(101, "No order for the transaction")

    return orders

def get_line_items_for_order(order_id):

    query = LineItem.query.filter(LineItem.order_id == order_id)

    return query.all()

def add_billing_details(orderId, invoice_number, billed_by):

    order = Order.get_by(id=orderId)

    if not order:

        raise TransactionServiceException(101, "No order found for the givem orderid")

    order.invoice_number = invoice_number

    order.billed_by = billed_by

    session.commit()

    return True

def get_alerts(order_id, all):

    query = Alerts.query.filter_by(order_id=order_id)

    if not all:

        query = query.filter_by(valid=True)

    return query.all()

def set_alert(order_id, unset, type, comment):

    #get existing alert

    if unset:

        query = Alerts.query.filter_by(order_id=order_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.order_id = order_id

        alert.valid = True

        alert.type = type

        alert.comment = comment

        alert.time_set = datetime.datetime.now()

    session.commit()

"""

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

        transaction.warehouse_id = t_transaction.warehouse_id

    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, warehouse_id):

    query = Transaction.query

    if warehouse_id:

        query = query.filter_by(warehouse_id=warehouse_id)

    if not status:

        if not from_date and not to_date:

            #get all between from_date and to_date

            return query.all()

        if not from_date:

            return query.filter(Transaction.createdOn < to_date).all()

        if not to_date:

            return query.filter(Transaction.createdOn > to_date).all()

        return query.filter(and_(Transaction.createdOn < to_date , Transaction.createdOn > from_date)).all()

    if not from_date and not to_date:

        return query.filter(Transaction.status == status).all()

    if not from_date:

        return query.filter(and_(Transaction.status == status, Transaction.createdOn <to_date)).all()

    if not from_date:

        return query.filter(and_(Transaction.status == status, Transaction.createdOn >from_date)).all()

    if not from_date:

        return 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()

"""