Subversion Repositories SmartDukaan

def accept_order(orderId):

    logging.info("Accepting order no: " + str(orderId))

    order = get_order(orderId)

    ordersList = []

    ordersList.append(order)

    updatedOrders = logisticsProviderFinalCheck(ordersList)

    order = updatedOrders[0]

    logistics_client = LogisticsClient().get_client()

    provider = logistics_client.getProvider(order.logistics_provider_id)

    providerLimits = logistics_client.getProviderLimitDetailsForPincode(provider.id, order.customer_pincode)

    if order.total_weight is None or order.total_weight == 0:

        raise TransactionServiceException(210, "Weight not defined for this order:- "+str(order.id)+". Contact Category Team")

    if order.total_weight > provider.bundleWeightLimit:

        raise TransactionServiceException(210, "Logistics Partner "+provider.name+ " Group Shipment Weight Limit Violated i.e. "+str(provider.bundleWeightLimit)+" Suggestion: Split Order!!!")

    if order.cod:

        if order.total_amount > provider.maxCodLimit:

            raise TransactionServiceException(210, "Logistics Partner "+provider.name+ " Max Cod Amount Collection Limit Violated i.e. "+ str(provider.maxCodLimit)+" Suggestion: Split Order!!!")

    #SelfPickUp and Runner 

    if order.logistics_provider_id not in [4,5]:

        providerCodLimit = float(providerLimits.get("providerCodLimit"))

        providerPrepaidLimit = float(providerLimits.get("providerPrepaidLimit"))

        if order.cod:

            if order.total_amount > providerCodLimit:

                raise TransactionServiceException(212, "Provider Maximum COD Limit Violated for Customer Pincode i.e. "+str(providerCodLimit)+" Suggestion: Split Order!!!")

        if not order.cod:

            if order.total_amount > providerPrepaidLimit:

                raise TransactionServiceException(212, "Logistics Partner "+provider.name+ " Max Prepaid Amount Limit Violated Rs." +str(providerPrepaidLimit)+" Suggestion: Split Order!!!")

    if order.status in [OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS, OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT, OrderStatus.CAPTURE_IN_PROCESS]:

        if not order.cod:

            if order.transaction.status == TransactionStatus.AUTHORIZED and order.transaction.payment_option!=capitalFloatPayMethod:

                __capture_txn(order.transaction_id)

                change_transaction_status(order.transaction_id, TransactionStatus.IN_PROCESS, "Payment received", PickUpType.COURIER, order.orderType, order.source)

        order.status = OrderStatus.ACCEPTED

        order.statusDescription = "Order Accepted"

        order.accepted_timestamp = datetime.datetime.now()

        txnSeqRequired = 0

        txnShipSeq = TransactionShipmentSequence.query.filter(TransactionShipmentSequence.transactionId==order.transaction_id).order_by(desc(TransactionShipmentSequence.id)).first()

        if txnShipSeq is None:

            txnShipSeq = TransactionShipmentSequence()

            txnShipSeq.transactionId = order.transaction_id

            txnShipSeq.createdTimestamp = datetime.datetime.now()

            txnShipSeq.sequence = 1

            txnSeqRequired = 1

        else:

            txnShipSeqNew = TransactionShipmentSequence()

            txnShipSeqNew.transactionId = txnShipSeq.transactionId

            txnShipSeqNew.createdTimestamp = datetime.datetime.now()

            txnShipSeqNew.sequence = txnShipSeq.sequence + 1

            txnSeqRequired = txnShipSeq.sequence + 1

        order.logisticsTransactionId = str(order.transaction_id)+"-"+str(txnSeqRequired)

        if order.source == 6 or order.source == 7 or order.source == 8:

            if order.source == 8 and order.cod:

                order.cod = False                

            session.commit()

            return "True"

        __amend_fulfilment_warehouse(order)

        __update_transfer_price(order, order.fulfilmentWarehouseId)

        if order.orderType == OrderType.B2B:

            user_client = UserClient().get_client()

            if user_client.isPrivateDealUser(order.customer_id):

                billing_address = user_client.getBillingAddressForUser(order.customer_id)

                if billing_address is not None:

                    if billing_address.state.strip()!=order.customer_state.strip():

                        order.orderType=OrderType.B2C

        session.commit()

        '''

        if order.logistics_provider_id != 7 and order.airwaybill_no is None or order.airwaybill_no == "null":

            logistics_client = LogisticsClient().get_client()

            if order.cod and order.total_amount > 1:

                airwaybillNo= logistics_client.getEmptyAWB(order.logistics_provider_id, DeliveryType.COD)

            else:

                airwaybillNo= logistics_client.getEmptyAWB(order.logistics_provider_id, DeliveryType.PREPAID)

            order.airwaybill_no = airwaybillNo

            order.tracking_id = airwaybillNo           

            session.commit()

        '''

        logging.info("Successfully accepted the order no.:" + str(orderId))

        return True

    else:

        logging.warning("Accept called for the unacceptable order: " + str(orderId))

        return False

def accept_orders_for_item_id(itemId, inventory):

    """

    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the

    given order is not a COD order, it also captures the payment if the same has not been captured.

    Parameters:

     - itemId

     - inventory

    """

    orders = Order.query.filter(Order.warehouse_id == 9).filter(Order.status.in_(tuple([OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS]))).order_by(Order.expected_shipping_time).all()

    for order in orders:

        if order.source ==6:

            continue

        if inventory > 0:

            lineitem = order.lineitems[0]

            if itemId == lineitem.item_id:

                try:

                    accept_order(order.id)

                    inventory = inventory - lineitem.quantity

                except:

                    logging.info("Unable to accept the order")

        else:

            order_outofstock(order.id)

    return True

    print 'Process completed', updatedOrders[0].logistics_provider_id

    awbNumber = None

    if updatedOrders[0].logistics_provider_id not in [1,2,7]:

        deltype = DeliveryType.PREPAID

        if updatedOrders[0].cod:

            deltype = DeliveryType.COD

        if not logistics_client.isAlive():

            logistics_client = LogisticsClient().get_client()

        awbNumber = logistics_client.getNewEmptyAwb(provider.id, deltype, totalOrderQuantity)

    if awbNumber is not None:

        update_master_order_awb(str(updatedOrders[0].transaction_id)+"-"+str(txnSeqRequired), awbNumber)

    singleOrder = updatedOrders[0]

    if singleOrder.orderType == OrderType.B2B:

        user_client = UserClient().get_client()

        if user_client.isPrivateDealUser(singleOrder.customer_id):

            billing_address = user_client.getBillingAddressForUser(singleOrder.customer_id)

            if billing_address is not None:

                if billing_address.state.strip()!=singleOrder.customer_state.strip():

                    totalOrders = get_orders_for_transaction(singleOrder.transaction.id, singleOrder.customer_id)

                    for order in totalOrders:

                        order.orderType=OrderType.B2C

    session.commit()