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, jacket_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.jacket_number = jacket_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()
"""