Subversion Repositories SmartDukaan

namespace java in.shop2020.model.v1.order
namespace py shop2020.thriftpy.model.v1.order

include "GenericService.thrift"

/***
        Order objects.
*/

enum AmazonFCWarehouseLocation {
        Mumbai = 0,
        Bangalore = 1,
        Gurgaon = 2
}

enum FlipkartFCWarehouseLocation {
        Delhi = 0
}

enum OrderStatus{
        PAYMENT_PENDING,
        PAYMENT_FAILED,
        COD_VERIFICATION_PENDING,
        SUBMITTED_FOR_PROCESSING,
        ACCEPTED,
        INVENTORY_LOW,
        REJECTED,
        BILLED,
        PAYMENT_FLAGGED, 
        SHIPPED_FROM_WH,
        SHIPPED_TO_LOGST,
        PAYMENT_FLAGGED_DENIED,      
        DELIVERY_SUCCESS,
        CANCEL_REQUEST_RECEIVED,
        CANCEL_REQUEST_CONFIRMED,
        CANCELLED_ON_CUSTOMER_REQUEST,
        SHIPPED_TO_DESTINATION_CITY,
        REACHED_DESTINATION_CITY,
        COD_VERIFICATION_FAILED,
        FAILED,
        RTO_IN_TRANSIT,
        RTO_RECEIVED_PRESTINE,
        DOA_PICKUP_REQUEST_RAISED,
        DOA_PICKUP_CONFIRMED,
        DOA_RETURN_IN_TRANSIT,
        DOA_RECEIVED_PRESTINE,
        DOA_CERT_INVALID,
        DOA_CERT_VALID,
        RTO_RESHIPPED,
        DOA_INVALID_RESHIPPED,
        DOA_VALID_RESHIPPED,
        RTO_REFUNDED,
        DOA_VALID_REFUNDED,
        DOA_INVALID_REFUNDED,
        CANCELLED_DUE_TO_LOW_INVENTORY,
        LOW_INV_PO_RAISED,
        LOW_INV_REVERSAL_IN_PROCESS,
        LOW_INV_NOT_AVAILABLE_AT_HOTSPOT,
        LOW_INV_PO_RAISED_TIMEOUT,
        LOW_INV_REVERSAL_TIMEOUT,
        FIRST_DELIVERY_ATTEMPT_MADE,
        CAPTURE_IN_PROCESS,
        DOA_REQUEST_RECEIVED,
        DOA_REQUEST_AUTHORIZED,
        DOA_PICKUP_DENIED,
        DOA_RECEIVED_DAMAGED,
        DOA_LOST_IN_TRANSIT,
        DOA_RESHIPPED_RCVD_DAMAGED,
        DOA_REFUNDED_RCVD_DAMAGED,
        DOA_RESHIPPED_LOST_IN_TRANSIT,
        DOA_REFUNDED_LOST_IN_TRANSIT,
        RTO_RECEIVED_DAMAGED,
        RTO_LOST_IN_TRANSIT,
        RTO_DAMAGED_RESHIPPED,
        RTO_DAMAGED_REFUNDED,
        RTO_LOST_IN_TRANSIT_RESHIPPED,
        RTO_LOST_IN_TRANSIT_REFUNDED,
        RTO_INVENTORY_REVERSED,
        RET_REQUEST_RECEIVED,
        RET_REQUEST_AUTHORIZED,
        RET_PICKUP_REQUEST_RAISED,
        RET_PICKUP_DENIED,
        RET_PICKUP_CONFIRMED,
        RET_RETURN_IN_TRANSIT,
        RET_RECEIVED_PRESTINE,
        RET_RECEIVED_DAMAGED,
        RET_LOST_IN_TRANSIT,
        RET_PRODUCT_USABLE,
        RET_PRODUCT_UNUSABLE,
        RET_PRODUCT_USABLE_RESHIPPED,
        RET_PRODUCT_USABLE_REFUNDED,
        RET_PRODUCT_UNUSABLE_RESHIPPED,
        RET_PRODUCT_UNUSABLE_REFUNDED,
        RET_RESHIPPED_RCVD_DAMAGED,
        RET_REFUNDED_RCVD_DAMAGED,
        RET_RESHIPPED_LOST_IN_TRANSIT,
        RET_REFUNDED_LOST_IN_TRANSIT,
        LOST_IN_TRANSIT,
        LOST_IN_TRANSIT_RESHIPPED,
        LOST_IN_TRANSIT_REFUNDED,
        DELIVERED_AT_STORE,
        RECEIVED_AT_STORE,
        APPROVAL_PENDING,
        PARTIAL_RETURN_IN_PROCESS,
        PARTIAL_RETURN,
        COMPLETE_RETURN_IN_PROCESS,
        COMPLETE_RETURN,
        REFUNDED_WITHOUT_PICKUP,
        REPLACED_WITHOUT_PICKUP
}

enum TransactionStatus{
        INIT,
        IN_PROCESS,
        COMPLETED,
        FAILED,
        AUTHORIZED,
        COD_IN_PROCESS,
        FLAGGED
}

enum OrderType{
        B2C,
        B2Cbulk,
        B2B,
        RECHARGE,
        RCH4HOTSPOT,
        WALLETCREDIT
}

enum ExtraTransactionProcessingType {
    COD_VERIFICATION,
    DELAYED_DELIVERY,
    PAYMENT_FLAGGED,
    RECHARGE_UNKNOWN
}

enum DenominationType {
        TOPUP = 1,
    SPECIAL = 2,
    DATA = 3
}

enum TaxType {
        VAT = 0,
        CST = 1,
        CFORM = 2,
        IGST = 3,
        SGST = 4
}

struct LineItem{
        1:i64 id,
        2:i64 item_id,
        3:string productGroup,
        4:string brand,
        5:string model_number,
        6:string color,
        7:string model_name,
        8:string extra_info,
        9:double quantity,
        10:double mrp,
        11:double unit_price,
        12:double unit_weight,
        13:double total_price,
        14:double transfer_price,
        15:double total_weight,
        16:optional string serial_number,
        17:optional string item_number,
        18:optional string dealText,
        19:i64 warrantry_expiry_timestamp,
        20:double vatRate,
        21:double nlc,
        22:double logisticsCost,
        23:double codCollectionCharges,
        24:double returnQty,
        25:i64 damaged_expiry_timestamp,
        26:double igstRate,
        27:double cgstRate,
        28:double sgstRate,
        29:string hsnCode
}

enum WalletReferenceType{
        RECHARGE,
        PURCHASE,
        CASHBACK,
        REVERSAL,
        REFUND,
        FAILURE,
        ADVANCE_AMOUNT,
        SHIPPING_REFUND,
        ADVANCE_REVERSAL,
        OPENING_BALANCE,
        SCHEME_IN,
        SCHEME_OUT,
        DAMAGE_PROTECTION,
        PRICE_DROP,
        RECHARGE_COMMISSIONS,
        PREBOOKING_ORDER
}

enum DelayReason {
        INVENTORY_LOW_PHASED_OUT,
        INVENTORY_LOW_COLOR_NOT_AVAILABLE,
        INVENTORY_LOW_REVERSAL_NOT_ON_TIME,
        INVENTORY_LOW_PRODUCT_NOT_SEALED,
        COURIER_DELAY_NOT_DELIVERED_TO_COURIER_ON_TIME,
        COURIER_DELAY_DID_NOT_CONNECT,
        COURIER_DELAY_CUSTOMER_NOT_AVAILABLE,
        COURIER_DELAY_INCORRECT_ADDRESS,
        COURIER_DELAY_OCTROI_DELAY,
        COURIER_DELAY_FORCES_OF_NATURE,
        COD_VERIFICATION_DELAY,
        PAYMENT_FLAGGED,
        OTHERS
}

enum ProductCondition{
        GOOD,
        BAD
}

struct Order{
        1:i64 id,
        2:i64 warehouse_id,
        /**
                item info
        **/
        3:list<LineItem> lineitems,
        /**
          logistics info
        **/
        4:i64 logistics_provider_id,
        5:string airwaybill_no,
        6:string tracking_id,
        7:i64 expected_delivery_time,
        /**
          customer info
        **/
        8:i64 customer_id,
        9:string customer_name,
        10:string customer_mobilenumber,
        11:string customer_pincode,
        12:string customer_address1,
        13:string customer_address2,
        14:string customer_email,
        15:string customer_city,
        16:string customer_state,

        /**
                status and misc info
        **/
        17:OrderStatus status,
        18:string statusDescription,
        19:double total_amount,
        20:double total_weight,
        /**
                billing info
        **/
        21:string invoice_number,
        22:string billed_by,
        /**
                timestamps
        **/
        23:i64 created_timestamp,
        24:i64 accepted_timestamp,
        25:i64 billing_timestamp,
        26:i64 shipping_timestamp,
        27:i64 pickup_timestamp,
        28:i64 delivery_timestamp,
        29:i64 outofstock_timestamp,
        30:i64 jacket_number,
        31:string receiver,
        32:i64 batchNo,
        33:i64 serialNo,
        34:bool doaFlag,
        35:string pickupRequestNo,
        36:i64 transactionId,
        37:string purchaseOrderNo,
        38:bool cod,
        39:DelayReason delayReason,
        40:i64 promised_delivery_time,
        41:i64 expected_shipping_time,
        42:i64 verification_timestamp,
        43:i64 promised_shipping_time,
        44:optional i64 reship_timestamp,
        45:optional i64 refund_timestamp,
        46:optional i64 new_order_id,
        47:OrderStatus previousStatus,
        48:i64 vendorId,
        49:optional i64 doa_auth_timestamp,
        50:string delayReasonText,
        51:string refundReason,
        52:i64 purchaseOrderId,
        53:optional i64 doa_logistics_provider_id,
        54:i64 originalOrderId,
        55:i64 fulfilmentWarehouseId,
        56:bool vendorPaid,
        57:optional i64 received_return_timestamp,
        58:optional i64 first_attempt_timestamp,
        59:OrderType orderType,
        60:i64 pickupStoreId,
        61:bool logisticsCod,
        62:i64 gvAmount,
        63:bool otg,
        64:i64 courier_delivery_time
        65:i64 insurer,
        66:double insuranceAmount,
        67:string dob,
        68:string guardianName,
        69:i64 freebieItemId,
        70:i64 source,
        71:double advanceAmount,
        72:i64 storeId,
        73:ProductCondition productCondition,
        74:i64 dataProtectionInsurer,
        75:double dataProtectionAmount,
        76:TaxType taxType,
        77:string logisticsTransactionId,
        78:double shippingCost,
        79:double codCharges,
        80:i64 seller_id,
        81:i64 warehouse_address_id,
        82:double wallet_amount,
        83:double net_payable_amount,
        84:double shippingRefund
}

struct Attribute{
        1:string name,
        2:string value
}

struct PendingStoreOrder{
        1:i64 id,
        2:i64 storeId,
        3:i64 productId,
        4:string pincode,
        5:string name,
        6:string email,
        7:string phone,
        8:string line1,
        9:string line2,
        10:string city,
        11:string state,
        12:i64 createdOn
}

struct OrderStatusAuditTrail{
        1:i64 id,
        2:i64 orderId,
        3:i64 status,
        4:i64 timestamp,
        5:i64 description
}

struct AmazonOrdersToAcknowledge{
        1:string amazonOrderId,
        2:string amazonOrderItemId,
        3:string status,
        4:i64 transaction_id,
        5:i32 count
}


struct SellerInfo {
        1:i64 sellerId,
        2:string organisationName,
        3:string registeredAddress,
        4:string regId,
        5:string cinNumber,
        6:string tin,
        7:i64 stateId,
        8:string gstin
}

struct WarehouseAddress{
        1:i64 id,
        2:string address,
        3:string pin,
        4:i64 state_id,
        5:i64 created,
        6:string contact_number,
        7:string contact_person
}

struct BuyerInfo {
        1:i64 buyerId,
        2:string organisationName,
        3:string registeredAddress,
        4:string regId,
        5:string cinNumber,
        6:string tin,
        7:i64 addressId,
        8:WarehouseAddress buyerAddress,
        9:i64 stateId,
        10:string gstin
}

struct Transaction{
        1:i64 id,
        2:list<Order> orders,
        3:i64 createdOn,
        4:TransactionStatus transactionStatus,
        5:string statusDescription,
        6:i64 shoppingCartid,
        7:i64 customer_id,
        8:string coupon_code,
        9:string sessionSource,
        10:i64 sessionStartTime,
        11:string firstSource,
    12:i64 firstSourceTime,
    13:i64 payment_option,
    14:double totalShippingCost,
    15:double totalCodCharges
}

struct WarehouseAddressMapping{
        1:i64 warehouse_id,
        2:i64 address_id,
        3:i64 created,
        4:i64 updated
}




enum AlertType{
        NEW_INVENTORY_ALERT,
        ORDER_READY_TO_ACCEPT
}

struct Alert{
        1:i64 id,
        2:AlertType type,
        3:i64 status,
        4:i64 timestamp,
        5:string description
        6:i64 warehouseId
}

struct ReturnOrder{
        1:i64 orderId,
        2:i64 warehouseId,
    3:i64 jacketNumber,
    4:string invoiceNumber,
    5:i64 itemId,
    6:string productGroup,
    7:string brand,
    8:string modelNumber,
    9:string modelName,
    10:string color,
    11:double totalPrice,
    12:double transferPrice,
    13:bool processedStatus,
    14:i64 createdAt,
    15:i64 processedAt
}

struct PaymentSettlement        {
    2:i64 paymentGatewayId,
    3:i64 referenceId,
    4:i64 settlementDate,
    5:double serviceTax,
    6:double otherCharges,
    7:double netCollection
}

struct CODPaymentSettlement     {
    1:i64 orderId,
    2:i64 settlementDate,
    3:double collection
}

enum HotspotAction{
        PO_RAISED,
        REVERSAL_INITIATED,
        NOT_AVAILABLE
}

struct TimeoutSummary{
        1:i32 poRaised,
        2:i32 poEstimate
        3:i32 reversalInitiated,
        4:i32 reversalEstimate
}

struct CODVerificationAgent{
        1:i64 orderId,
        2:string agentEmailId
}

enum RechargeType {
    MOBILE = 1,
    DTH = 2
}

enum RechargeOrderStatus {
    PAYMENT_PENDING = 1,
    PAYMENT_FAILED = 2,
    PAYMENT_SUCCESSFUL = 3,
    RECHARGE_FAILED = 4,
    RECHARGE_SUCCESSFUL = 5,
    RECHARGE_FAILED_REFUNDED = 6,
    REFUNDED = 7,
    PARTIALLY_REFUNDED = 8,
    INIT = 9,
    RECHARGE_UNKNOWN = 10,
    RECHARGE_IN_PROCESS = 11
}

enum OrderSource {
        WEBSITE = 1,
        STORE = 2,
        AMAZON =3,
        HOMESHOP18  = 4,
        NAAPTOL = 5,
        EBAY = 6,
        SNAPDEAL = 7,
        FLIPKART = 8,
        MOBILESITE = 9,
        JUNGLEE = 10    
}

enum RechargeMode {
        SYNC = 1,
        ASYNC = 2
}


enum WalletSource {
        RECHARGE = 1,
        PHYSICAL = 2,
        DTR = 3
}

struct RechargeOrder {
    1:i64 id,
    2:string displayId,
    3:i64 totalAmount,
    4:i64 walletAmount,
    5:i64 transactionId,
    6:i64 invoiceNumber,
    7:OrderType orderType,
    8:i64 operatorId,
    9:RechargeType rechargeType,
   10:RechargeOrderStatus status,
   11:string deviceNumber,
   12:i64 userId,
   13:string userEmailId,
   14:i64 creationTimestamp,
   15:string spiceTID,
   16:i64 responseTimestamp,
   17:string description,
   18:string plan,
   19:string couponCode,
   20:i64 couponAmount,
   21:i64 refundTimestamp,
   22:string ipAddress
}

struct RechargeStatistics{
        1:map<i64, i64> statusCounts,
        2:map<i64, i64> operatorCounts,
    3:map<string, list<RechargeOrder>> currentOrders,
    4:map<string, i64> amounts
}

struct RechargePlan {
        1:i64 operatorId,
    2:string name,
    3:string displayName,
    4:string description
}

struct RechargeDenomination {
        1:i64 operatorId,
        2:i64 circleId,
        3:DenominationType denominationType,
        4:i64 amount,
        5:string validity,
        6:string description
}

struct DeviceNumberInfo {
        1:i64 operatorId,
        2:string circleCode
        3:string operatorName
}

struct UserWallet {
    1:i64 id,
    2:i64 amount,
    3:i64 userId,
    4:i64 refundable_amount  
}

struct UserWalletHistory {
        1:i64 id,
    2:i64 walletId,
    3:i64 refundableAmount,
    4:i64 amount,
    5:i64 timestamp,
    6:string description,
    7:i64 referenceNumber,
    8:WalletReferenceType referenceType    
}

enum EmiChargeType {
    FIXED = 1,
    PERCENTAGE = 2
}

struct EmiScheme{
    1:i64 id,
    2:i64 gatewayId,
        3:i64 bankId,
    4:i64 tenure,
    5:string bankName,
    6:i64 minAmount,
    7:string tenureDescription,
    8:EmiChargeType     chargeType,
    9:double chargeValue,
    10:double interestRate    
}

exception TransactionServiceException{
        1:i32 errorCode,
        2:string message
}

struct Company{
    1:i64 id,
    2:string name,
    3:string Address
}
    
struct WalletForCompany{
    1:i64 id,
    2:i64 companyId,
    3:double amount
}
    
struct WalletHistoryForCompany{
    1:i64 id,
    2:i64 walletId,
    3:double amount,
    4:i64 transactionTime,
    5:double openingBal,
    6:double closingBal,
    7:i64 referenceNumber,
    8:string description
}
    
enum PayMethod{
        CASH = 1,
        CARD = 2,
        CHEQUE = 3
}

struct FRC {
    1:i64 id,
    2:i64 operatorId,
    3:i64 circleId,
    4:i64 denomination,
    5:i64 maxDiscount
}

struct HotspotStore {
        1:i64 id,
    2:string hotspotId, 
    3:i64 companyId,
    4:string name,
    5:string city,
    6:i64 collectedAmount,
    7:i64 availableLimit,
    8:i64 creditLimit,
    9:string salt,
    10:string password,
    11:bool isActive,
    12:i64 circleId,
    13:string email,
    14:string line1,
    15:string line2,
    16:string state,
    17:string pin,
    18:string phone,
    19:string approvalEmail
}

struct HotspotServiceMatrix {
        1:i64 storeId,
        2:string hotspotId,
        3:bool pickupFromStoreService,
        4:bool storeWebsiteService,
        5:bool rechargeService
}

struct RechargeTransaction{
    1:i64 id,
    2:i64 storeId,
    3:double amount,
    4:i64 transactionTime,
    5:string deviceNum,
    6:RechargeType deviceType,
    7:bool isFrc,
    8:string email,
    9:double discount,
    10:double paymentAmount,
    11:PayMethod payMethod,
    12:RechargeOrderStatus status,
    13:string invoiceNumber,
    14:i64 circleId,
    15:i64 operatorId,
    16:string plan,
    17:string ipAddress,
    18:string name,
    19:string cafNum,
    20:string simNum,
    21:string alternateNumber,
    22:string description,
    23:i64 responseTime,
        24:string spiceTID,
    25:string aggTID,
    26:string providerTID
}

struct TelecomCircle {
        1:i64 id,
    2:string name,
    3:string code
}

struct SourceDetail {
        1:i64 id,
    2:string name,
    3:string email,
    4:string tinNumber,
    5:i64 lastUpdatedOn
}

struct AmazonOrder {
    1:i64 orderId,
    2:string amazonOrderCode,
    3:string amazonOrderItemCode,
    4:i64 transactionId,
    5:i64 item_id,
    6:string status,
    7:i64 purchaseDateOnAmazon
}

enum StorePaymentStatus{
        ADV_RECEIVED = 1,
        ADV_REFUNDED = 2,
        FULL_PAY_RECEIVED = 3,
        REFUNDED = 4,
        REFUND_REQUESTED = 5,
        REFUND_INITIATED = 6
}

struct StoreOrderDetail {
        1:i64 orderId,
        2:i64 storeId,
        3:double advanceAmount,
        4:double cashAmount,
        5:double cardAmount,
        6:StorePaymentStatus payStatus,
        7:string edcBank,
        8:double cashRefundAmount,
        9:double cardRefundAmount,
        10:string approvalCode,
        11:string cardType
}

struct StoreOrderCollection {
    1:string hotspotId,
    2:i64 orderId,
    3:string collectionType,
    4:string productName,
    5:i64 advanceAmount,
    6:i64 cash,
    7:i64 card,
    8:i64 addedAt,
    9:i64 pushedAt,
    10:bool pushedToOcr
}

struct EbayOrder {
        1:i64 orderId,
        2:i64 salesRecordNumber,
        3:string paisaPayId,
        4:string ebayListingId,
        5:double subsidyAmount,
        6:i64 ebayTxnDate,
        7:string transactionId,
        8:string listingName,
        9:double listingPrice,
        10:string bluedartPaisaPayRef   
}

struct FbaItemPrices{
         1:i64 item_id  
     2:double minFbaPrice,
     3:double minMfnPrice,
     4:double ourPrice,
     5:double salePrice,
     6:i64 minFbaPriceSnapshotDate
     7:i64 minMfnPriceSnapshotDate
     8:i64 ourPriceSnapshotDate
     9:i64 salePriceSnapshotDate

} 

struct SnapdealOrder {
        1:i64 orderId,
        2:string referenceCode,
        3:string subOrderId,
        4:double listingPrice,
        5:string productName,
        6:i64 snapdealTxnDate
        7:double maxNlc
}

struct FlipkartOrder {
        1:string flipkartOrderId,
        2:string flipkartSubOrderId,
        3:i64 flipkartTxnDate,
        4:i64 orderId,
        5:double shippingPrice,
        6:double octroiFee,  
        7:double emiFee
        8:double maxNlc 
}

struct OrderStatusGroups{
        1:list<OrderStatus> codCancellable = [OrderStatus.COD_VERIFICATION_PENDING,
                                                                                OrderStatus.SUBMITTED_FOR_PROCESSING,
                                                                                OrderStatus.ACCEPTED,
                                                                                OrderStatus.INVENTORY_LOW,
                                                                                OrderStatus.LOW_INV_PO_RAISED,
                                                                                OrderStatus.LOW_INV_REVERSAL_IN_PROCESS,
                                                                                OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT,
                                                                                OrderStatus.BILLED,
                                                                                OrderStatus.PAYMENT_FLAGGED],
                                                                                
        2:list<OrderStatus> prepaidCancellableBeforeBilled = [OrderStatus.COD_VERIFICATION_PENDING,
                                                                                OrderStatus.SUBMITTED_FOR_PROCESSING,
                                                                                OrderStatus.ACCEPTED,
                                                                                OrderStatus.INVENTORY_LOW,
                                                                                OrderStatus.LOW_INV_PO_RAISED,
                                                                                OrderStatus.LOW_INV_REVERSAL_IN_PROCESS,
                                                                                OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT],
                                                                                
        3:list<OrderStatus> prepaidCancellableAfterBilled = [OrderStatus.BILLED, OrderStatus.PAYMENT_FLAGGED],
        
        4:list<OrderStatus> openOrders = [
                                                                                OrderStatus.PAYMENT_PENDING,                    OrderStatus.COD_VERIFICATION_PENDING,
                                                                                OrderStatus.SUBMITTED_FOR_PROCESSING,   OrderStatus.ACCEPTED,
                                                                                OrderStatus.INVENTORY_LOW,                              OrderStatus.BILLED,
                                                                                OrderStatus.PAYMENT_FLAGGED,                    OrderStatus.SHIPPED_FROM_WH,
                                                                                OrderStatus.SHIPPED_TO_LOGST,                   OrderStatus.PAYMENT_FLAGGED_DENIED,
                                                                                OrderStatus.SHIPPED_TO_DESTINATION_CITY,        OrderStatus.REACHED_DESTINATION_CITY,
                                                                                OrderStatus.CANCEL_REQUEST_RECEIVED,    OrderStatus.CANCEL_REQUEST_CONFIRMED,
                                                                                OrderStatus.RTO_IN_TRANSIT,                             OrderStatus.RTO_RECEIVED_PRESTINE,
                                                                                OrderStatus.DOA_PICKUP_REQUEST_RAISED,  OrderStatus.DOA_PICKUP_CONFIRMED,
                                                                                OrderStatus.DOA_RETURN_IN_TRANSIT,              OrderStatus.DOA_RECEIVED_PRESTINE,
                                                                                OrderStatus.DOA_CERT_INVALID,                   OrderStatus.DOA_CERT_VALID,
                                                                                OrderStatus.LOW_INV_PO_RAISED,                  OrderStatus.LOW_INV_REVERSAL_IN_PROCESS,
                                                                                OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT,   OrderStatus.LOW_INV_PO_RAISED_TIMEOUT,
                                                                                OrderStatus.LOW_INV_REVERSAL_TIMEOUT,   OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE,
                                                                                OrderStatus.CAPTURE_IN_PROCESS,                 OrderStatus.DOA_REQUEST_RECEIVED,
                                                                                OrderStatus.DOA_REQUEST_AUTHORIZED,             OrderStatus.DOA_RECEIVED_DAMAGED,
                                                                                OrderStatus.DOA_LOST_IN_TRANSIT,                OrderStatus.RTO_RECEIVED_DAMAGED,
                                                                                OrderStatus.RTO_LOST_IN_TRANSIT,                OrderStatus.RTO_INVENTORY_REVERSED,
                                                                                OrderStatus.RET_REQUEST_RECEIVED,               OrderStatus.RET_REQUEST_AUTHORIZED,
                                                                                OrderStatus.RET_PICKUP_REQUEST_RAISED,  OrderStatus.RET_PICKUP_DENIED,
                                                                                OrderStatus.RET_PICKUP_CONFIRMED,               OrderStatus.RET_RETURN_IN_TRANSIT,
                                                                                OrderStatus.RET_RECEIVED_PRESTINE,              OrderStatus.RET_RECEIVED_DAMAGED,
                                                                                OrderStatus.RET_LOST_IN_TRANSIT,                OrderStatus.RET_PRODUCT_USABLE,
                                                                                OrderStatus.DELIVERED_AT_STORE,                 OrderStatus.RECEIVED_AT_STORE
                                                                        ],
        5:list<OrderStatus> refundedOrders = [
                                                                                OrderStatus.CANCELLED_ON_CUSTOMER_REQUEST,      OrderStatus.RTO_REFUNDED,
                                                                                OrderStatus.DOA_VALID_REFUNDED,                         OrderStatus.DOA_INVALID_REFUNDED,
                                                                                OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY,     OrderStatus.DOA_REFUNDED_RCVD_DAMAGED,
                                                                                OrderStatus.DOA_REFUNDED_LOST_IN_TRANSIT,       OrderStatus.RTO_DAMAGED_REFUNDED,
                                                                                OrderStatus.RTO_LOST_IN_TRANSIT_REFUNDED,       OrderStatus.RET_PRODUCT_USABLE_REFUNDED,
                                                                                OrderStatus.RET_PRODUCT_UNUSABLE_REFUNDED,      OrderStatus.RET_REFUNDED_LOST_IN_TRANSIT,
                                                                                OrderStatus.RET_REFUNDED_RCVD_DAMAGED,          OrderStatus.LOST_IN_TRANSIT_REFUNDED
                                                                        ],
        6:list<OrderStatus> shippedOrders = [
                                                                                OrderStatus.SHIPPED_FROM_WH,                    OrderStatus.SHIPPED_TO_LOGST,
                                                                                OrderStatus.SHIPPED_TO_DESTINATION_CITY,        OrderStatus.REACHED_DESTINATION_CITY,
                                                                                OrderStatus.RTO_IN_TRANSIT,                             OrderStatus.RTO_RECEIVED_PRESTINE,
                                                                                OrderStatus.DOA_PICKUP_REQUEST_RAISED,  OrderStatus.DOA_PICKUP_CONFIRMED,
                                                                                OrderStatus.DOA_RETURN_IN_TRANSIT,              OrderStatus.DOA_RECEIVED_PRESTINE,
                                                                                OrderStatus.DOA_CERT_INVALID,                   OrderStatus.DOA_CERT_VALID,
                                                                                OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE,OrderStatus.DOA_REQUEST_RECEIVED,
                                                                                OrderStatus.DOA_REQUEST_AUTHORIZED,             OrderStatus.DOA_RECEIVED_DAMAGED,
                                                                                OrderStatus.DOA_LOST_IN_TRANSIT,                OrderStatus.RTO_RECEIVED_DAMAGED,
                                                                                OrderStatus.RTO_LOST_IN_TRANSIT,                OrderStatus.RTO_INVENTORY_REVERSED,
                                                                                OrderStatus.RET_REQUEST_RECEIVED,               OrderStatus.RET_REQUEST_AUTHORIZED,
                                                                                OrderStatus.RET_PICKUP_REQUEST_RAISED,  OrderStatus.RET_PICKUP_DENIED,
                                                                                OrderStatus.RET_PICKUP_CONFIRMED,               OrderStatus.RET_RETURN_IN_TRANSIT,
                                                                                OrderStatus.RET_RECEIVED_PRESTINE,              OrderStatus.RET_RECEIVED_DAMAGED,
                                                                                OrderStatus.RET_LOST_IN_TRANSIT,                OrderStatus.RET_PRODUCT_USABLE,
                                                                                OrderStatus.RET_PRODUCT_UNUSABLE,               OrderStatus.LOST_IN_TRANSIT,
                                                                                OrderStatus.DELIVERED_AT_STORE,                 OrderStatus.RECEIVED_AT_STORE
                                                                        ],
        7:list<OrderStatus> failedOrders = [
                                                                                OrderStatus.PAYMENT_FAILED,                             OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY,
                                                                                OrderStatus.REJECTED,                                   OrderStatus.DOA_INVALID_REFUNDED,
                                                                                OrderStatus.DOA_INVALID_RESHIPPED,              OrderStatus.DOA_VALID_REFUNDED,
                                                                                OrderStatus.DOA_VALID_RESHIPPED,                OrderStatus.RTO_REFUNDED,
                                                                                OrderStatus.RTO_RESHIPPED, OrderStatus.COD_VERIFICATION_FAILED
                                                                        ]
}

struct AmazonFbaSalesSnapshot {
        1:i64 dateOfSale
        2:i64 item_id
        3:i32 totalOrderCount
        4:i64 amazonFbaInventory
        5:bool isOutOfStock
    6:double salePrice
    7:double minFbaPrice
    8:double minMfnPrice
    9:double totalSale
    10:double promotionSale
    11:i32 promotionOrderCount
    12:double ourPrice
    13:i64 minFbaPriceSnapshotDate
    14:i64 minMfnPriceSnapshotDate
    15:i64 ourPriceSnapshotDate
    16:i64 salePriceSnapshotDate
    17:AmazonFCWarehouseLocation fcLocation
}

struct AmazonFbaOrderReturns {
        1:string amazonOrderId,
        2:i64 insertionTimestamp,
        3:i64 sku,
        4:i64 creationTimestamp,
        5:i64 shippedQuantity,
        6:i64 sellableReturnQuantity,
        7:i64 nonSellableReturnQuantity
}

struct FlipkartAdvantageOrder {
        1:string fkOrderId,
        2:string fkOrderItemId,
        3:i64 sku,
        4:i64 creationTimestamp
        5:string customerName,
        6:string customerAddress,
        7:string pincode,
        8:string customerCity,
        9:string customerState
        10:string customerPhone
        11:string status,
        12:i64 quantity,
        13:double totalPrice,
        14:double listPrice,
        15:i64 modifiedDate,
        16:string listingId,
        17:string cancelReason,
        18:string returnReason,
        19:string freebieItemId,
        20:string productTitle
}

struct FlipkartFaSalesSnapshot {
        1:i64 dateOfSale
        2:i64 item_id
        3:i32 totalOrderCount
        4:bool isOutOfStock
    5:double totalSale
    6:double ourPrice
    7:FlipkartFCWarehouseLocation fcLocation
    8:i32 returnQuantity
    9:double returnValue
}

struct AmazonHourlySaleSnapshot {
        1:i64 snapshotTime
        2:i64 item_id
        3:i32 totalOrderCount
        4:i64 amazonFbaInventory
        5:bool isOutOfStock
    6:double totalSale
    7:double promotionSale
    8:i32 promotionOrderCount
    9:AmazonFCWarehouseLocation fcLocation
}

struct AmazonFbaOrderItem {
        1:string amazonOrderId,
        2:i64 purchaseDate,
        3:string orderStatus,
        4:i64 item_id,
        5:AmazonFCWarehouseLocation fcLocation,
        6:double totalAmount,
        7:double promotionDiscount,
        8:i64 quantity
}

struct HsOrder {
        1:i64 orderId,
        2:string hsOrderNo,
        3:string hsSubOrderNo,
        4:string catalogueName,
        5:i64 hsOrderDate,
        6:string hsProductId,
        7:string hsItemId,
        8:string sellerSku,
        9:string paymentMode,
        10:string courierName,
        11:i64 slaDays,
        12:string shippingName
}

/*
struct PaytmOrder {
        1:i64 orderId,
        2:string paytmOrderId,
        3:string paytmSubOrderId,
        4:
}*/

struct Creditor{
        1:i64 id,
        2:string name,
        3:bool active,
        4:double ticket_size,
        5:i64 credit_due_days, 
        6:i64 created,
        7:i64 updated
}

struct UserSanction{
        1:i64 id,
        2:i64 user_id, 
        3:i64 creditor_id, 
        4:string user_ref_id,
        5:double credit_limit, 
        6:double credit_blocked, 
        7:double loan, 
        8:bool active, 
        9:i64 created, 
        10:i64 updated,
        11:double ticket_size,
        12:i64 credit_due_days 
}

struct PaginatedUserSanction{
        1:bool hasMore,
        2:i64 totalCount,
        3:list<UserSanction> userSanctions
}

enum CreditTxnType{
        BLOCKED,
        BLOCKED_REVERSED,
        LOAN,
        LOAN_CANCELLED,
        PAID,
        DEFAULTED,
        CORRECTION
}

struct CreditHistory{
        1:i64 id,
        2:i64 user_id,
        3:i64 creditor_id,
        4:i64 payment_id, 
        5:double  amount,
        6:CreditTxnType credit_type, 
        7:i64 created, 
        8:string shipping_id
}

struct PaginatedCreditHistory{
        1:bool hasMore,
        2:i64 totalCount,
        3:list<CreditHistory> creditHistoryList
}

struct LoanHistory{
        1:i64 id,
        2:i64 user_id,
        3:i64 creditor_id,
        4:i64 payment_id, 
        5:double  amount,
        6:CreditTxnType credit_type, 
        7:i64 created, 
        8:i64 updated,
        9:string loan_id, 
        10:i64 due_date,
        11:i64 value_date,
        12:string invoiceNumber
}

struct PaginatedLoanHistory{
        1:bool hasMore,
        2:i64 totalCount,
        3:list<LoanHistory> loanHistoryList
}


struct OutstandingPayments{
        1:i64 user_id,
        2:string counter_name
        3:i64 creditor_id,
        4:i64 payment_id,
        5:double totalAmount,
        6:i64 created
}

enum ReturnAction{
        REPLACEMENT,
        REFUND
}

enum ReturnPickupType{
        NOW,
        LATER,
        NOT_REQUIRED
}

enum RefundType{
        INIT,
        CHEQUE,
        WALLET,
        COUPON,
        GATEWAY,
        REPLACEMENT
}

enum ReplacementShippingType{
        IMMEDIATE,
        LATER
}

enum ReturnTxnPickupStatus{
        PENDING,
        PICKUP_REQUESTED,
        PICKUP_CONFIRMED,
        PICKUP_SCHEDULED,
        PICKUP_IN_TRANSIT,
        PICKUP_RECEIVED
}

struct ReturnPickupRequest{
        1:i64 id,
        2:i64 logisticsProviderId,
        3:string pickupRequestNo,
        4:i64 confirmedAt,
        5:i64 promised_pickup_timestamp,
        6:i64 pickedUpAt,
        7:ReturnTxnPickupStatus pickupStatus
}

enum ReceivedReturnType{
        PRESTINE,
        DAMAGED,
        LOST_IN_TRANSIT
}

enum ReturnTxnResolutionStatus{
        PENDING,
        AWAITING_PICKUP,
        QUALITY_CHECK,
        REPLACEMENT_ORDER_CREATED,
        REPLACEMENT_DONE,
        REFUND_IN_PROCESS,
        REFUND_DONE,
        CLOSED
}

struct ReturnOrderInfo{
        1:i64 id,
        2:i64 returnTransactionId,
        3:string masterOrderId,
        4:i64 orderId,
        5:i64 lineItemId,
        6:i64 logisticsRequestId,       
        7:i64 returnQuantity,
        8:i64 receivedQuantity,
        9:i64 createdAt,
        10:i64 processedAt,
        11:string returnStatus,
        12:i64 reshippedAt,
        13:i64 receivedAt,
        14:string refundReason,
        15:string refundedBy,
        16:i64 refundedAt,
        17:i64 warehouse_id,
        18:double refundAmount,
        19:RefundType refundType,
        20:string refundDescription,
        21:ReturnPickupType returnPickupType,
        22:ReplacementShippingType shippingType,
        23:i64 replacementOrderId,
        24:ReceivedReturnType receivedReturnType,
        25:i64 freebieItemId,
        26:ReturnAction returnAction,
        27:ReturnTxnResolutionStatus returnTxnResolutionStatus,
        28:LineItem lineitem,
        29:ReturnPickupRequest returnPickUpRequest
}

enum ReturnTransactionStatus{
        INITIATED,
        AUTHORIZED,
        INPROCESS,
        REJECTED,
        PROCESSED,
        COMPLETED,
        CLOSED
}

struct ReturnTransaction{
        1:i64 id,
        2:ReturnTransactionStatus status,
        3:string customer_email,
        4:string customer_name,
        5:i64 customer_id,
        6:i64 address_id,
        7:i64 ticketId
        8:i64 createdAt,
        9:i64 processedAt,
        10:i64 authorizedAt,
        11:i64 closedAt,
        12:string customerAddress,
        13:string pincode,
        14:string customerCity,
        15:string customerState,
        16:string customerPhone,
        17:list<ReturnOrderInfo> returnOrders
}

struct ShipmentLogisticsCostDetail{
        1:string logisticsTransactionId,
        2:string airwayBillNo,
        3:double shipmentAmount,
        4:double shipmentWeight,
        5:double shipmentLogsiticsCost,
        6:double shipmentCodCollectionCharges,
        7:i64 createdAt,
        8:i64 updatedAt,
        9:string packageDimensions
}

struct ShipmentDelayDetail{
        1:i64 orderId,
        2:DelayReason delayReason,
        3:string delayReasonText,
        4:i64 delay
}


struct Pmsa{
        1:i64 id,
        2:string name,
        3:string phone,
        4:string emailId,
        5:string address,
        6:string state,
        7:string level,
        8:string l1_email,
        9:string l2_email,
        10:bool activated,
        11:string pin,
        12:string code,
        13:i64 createdAt
}

struct PmsaSearchFilter{
        1:string name,
        2:string phone,
        3:string emailId,
        4:string code,
        5:bool activated,
        6:string l1_email,
        7:string l2_email
}

service TransactionService extends GenericService.GenericService{
        
        i64 createTransaction(1:Transaction transaction) throws (1:TransactionServiceException ex),
        
        //      Get transaction methods.
        Transaction getTransaction(1:i64 id) throws (1:TransactionServiceException ex),
        list<Transaction> getTransactionsForCustomer(1:i64 customerId, 2:i64 from_date, 3:i64 to_date, 4:TransactionStatus status) throws (1:TransactionServiceException ex),
        list<Transaction> getTransactionsForShoppingCartId(1:i64 shoppingCartId) throws (1:TransactionServiceException ex),
        TransactionStatus getTransactionStatus(1:i64 transactionId) throws (1:TransactionServiceException ex),
        bool changeTransactionStatus(1:i64 transactionId, 2:TransactionStatus status, 3:string description, 4:i64 pickUp, 5:OrderType orderType, 6:OrderSource source) throws (1:TransactionServiceException ex),
        
        bool enqueueTransactionInfoEmail(1:i64 transactionId) throws (1:TransactionServiceException ex),
        
        list<Order> getAllOrders(1:list<OrderStatus> statuses, 2:i64 from_date, 3:i64 to_date, 4:i64 warehouse_id) throws (1:TransactionServiceException ex),
        
        /**
        Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
        Pass the status as null and the limit as 0 to ignore them.
        */
        list<Order> getOrdersInBatch(1:list<OrderStatus> statuses, 2:i64 offset, 3:i64 limit, 4:i64 warehouse_id, 5:i64 source) throws (1:TransactionServiceException ex),
        
        /**
        Returns the count of orders with the given statuses assigned to the given warehouse.
        */
        i32 getOrderCount(1:list<OrderStatus> statuses, 2:i64 warehouseId, 3:i64 source) throws (1:TransactionServiceException ex),
        
        /**
        Returns orders within a range of their billing dates
        */
        list<Order> getOrdersByBillingDate(1:OrderStatus status, 2:i64 start_billing_date, 3:i64 end_billing_date, 4:i64 warehouse_id) throws (1:TransactionServiceException ex),
        
        /**
        Returns orders for a particular provider and warehouse which were shipped between the given dates.
        Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise. 
        Pass providerId and warehouseId as -1 to ignore both these parameters.
        */
        list<Order> getOrdersByShippingDate(1:i64 fromShippingDate, 2:i64 toShippingDate, 3:i64 providerId, 4:i64 warehouseId, 5:bool cod) throws (1:TransactionServiceException ex),
        
        /**
        Returns order ids for orders which can be returned
        */
        list<i64> getReturnableOrdersForCustomer(1:i64 customer_id, 2:i64 limit) throws (1:TransactionServiceException ex),

        /**
        Returns order ids for orders which can be cancelled
        */
        list<i64> getCancellableOrdersForCustomer(1:i64 customer_id, 2:i64 limit) throws (1:TransactionServiceException ex),
        
        bool changeOrderStatus(1:i64 orderId, 2:OrderStatus status, 3:string description) throws (1:TransactionServiceException ex),
        
        /**
        Returns list of orders for given transaction Id. Also filters based on customer Id so that
        only user who owns the transaction can view its order details.
        */
        list<Order> getOrdersForTransaction(1:i64 transactionId 2:i64 customerId)  throws (1:TransactionServiceException ex),

        /**
        Returns list of orders for the given customer created between the given dates and having the given statuses.
        Pass and empty list to ignore filtering on statuses.
        */      
        list<Order> getOrdersForCustomer(1:i64 customerId, 2:i64 from_date, 3:i64 to_date, 4:list<OrderStatus> statuses) throws (1:TransactionServiceException ex),
        
        i64 createOrder(1:Order order) throws (1:TransactionServiceException ex),
        Order getOrder(1:i64 id) throws (1:TransactionServiceException ex),
        list<LineItem> getLineItemsForOrder(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        list<Order> getOrderList(1:list<i64> order_ids),
        
        list<Order> getOrderListForVendor(1:list<i64> order_ids, 2:i64 vendorId),
        
        /**
        Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
        Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
        */
        Order getOrderForCustomer(1:i64 orderId, 2:i64 customerId) throws (1:TransactionServiceException ex),
        
        //Alerts apis 
        list<Alert> getAlerts(1:i64 type, 2:i64 warehouseId, 3:i64 status, 4:i64 timestamp),
        void addAlert(1:i64 type, 2:i64 warehouseId, 3:string description),
        void markAlertsAsSeen(1:i64 warehouseId),
        
        /**
        Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
        */
        i64 getValidOrderCount(),

        /**
        Returns the number of distinct customers who have done successful transactions
        */
        i64 getNoOfCustomersWithSuccessfulTransaction(),
        
        /**
        Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
        List contains two values, first minimum amount and second maximum amount.       
        */
        list<double> getValidOrdersAmountRange(),
        
        /**
        Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
        If limit is passed as 0, then all valid Orders are returned. 
        */
        list<Order> getValidOrders(1:i64 limit, 2:bool onlyStore),
        
        /**
        Create a batch of all the pending orders for the given warehouse.
        The returned list is orderd by created_timestamp.
        If there are no pending orders, an empty list is returned.
        */
        list<Order> batchOrders(1:i64 warehouseId) throws (1:TransactionServiceException ex),
        
        /**
        Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found. 
        */
        bool markOrderAsOutOfStock(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
        Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
        timestamp. It is intended to be used for COD orders but can be harmlessly 
        used for all other orders as well.
        Throws an exception if no such order exists.
        */
        bool verifyOrder(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
        Marks the given order as ACCEPTED and 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.
        Throws an exception if no such order exists.
        */
        bool acceptOrder(1:i64 orderId) throws (1:TransactionServiceException ex),

        bool unacceptOrder(1:i64 orderId),
        
        /**
        Add billing details such as the bill number and the biller to the Order.
        Adds jacket number, item number and Serial no. to the order. Doesn't update
        the IMEI no. if a -1 is supplied.
        Also, it generates an invoice number for the order, marks the order as
        BILLED and sets the billing timestamp.
        Returns false if it doesn't find the order with the given ID.
        */
        bool addBillingDetails(1:i64 orderId, 2:string invoice_number, 3:list<string> serialNumber, 4:list<string> itemNumber, 5:i64 freebieWarehouseId, 6:string billed_by, 7:i64 jacketNumber, 8:i64 billingType, 9:i64 fulfilmentWarehouseId, 10:bool authorize) throws (1:TransactionServiceException ex),

        /**
        Add the invoice number to the order.
        */      
        void addInvoiceNumber(1:i64 orderId, 2:string invoiceNumber, 3:string color, 4:string serialNumber, 5:string itemNumber) throws (1:TransactionServiceException ex),
        
        /**
        Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
        given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
        */
        bool markOrdersAsShippedFromWarehouse(1:i64 warehouseId, 2:i64 providerId, 3:bool cod, 4:list<i64> orderIds) throws (1:TransactionServiceException ex),
        
        bool markOrdersAsReturnedFromStore(1:i64 providerId, 2:list<i64> orderIds, 3:list<string> awbs) throws (1:TransactionServiceException ex),
                
        /**
        Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
        Raises an exception if we encounter report for an AWB number that we did not ship.      
        */
        void markOrdersAsPickedUp(1:i64 providerId, 2:map<string, string> pickupDetails) throws (1:TransactionServiceException ex),
        
        /**
        Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
        */
        list<Order> getOrdersNotPickedUp(1:i64 providerId),
        
        /**
        Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
        the name of the receiver.
        Raises an exception if we encounter report for an AWB number that we did not ship.
        */
        void markOrdersAsDelivered(1:i64 providerId, 2:map<string, string> deliveredOrders) throws (1:TransactionServiceException ex),
        
        /**
        Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
        Raises an exception if we encounter report for an AWB number that we did not ship.
        */
        void markAsRTOrders(1:i64 providerId, 2:map<string, string> returnedOrders) throws (1:TransactionServiceException ex),
        
        /**
        Returns a list of orders that were returned by courier.
        */
        list<Order> getRTOrders(1:i64 providerId),
        
        /**
        Update the status description of orders whose AWB numbers are keys of the Map.
        */
        void updateNonDeliveryReason(1:i64 providerId, 2:map<string, string> undeliveredOrders) throws (1:TransactionServiceException ex),
        
        /**
        Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
        */
        list<Order> getNonDeliveredOrdersbyCourier(1:i64 providerId),
        
        /**
        Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
        */
        void markOrdersAsLocalConnected(1:i64 providerId, 2:map<string, string> local_connected_orders) throws (1:TransactionServiceException ex),
        
        /**
        Returns a list of orders that were picked up or shipped but pending local connection.
        */
        list<Order> getOrdersNotLocalConnected(1:i64 providerId),
        
        /**
        Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
        */
        void markOrdersAsDestinationCityReached(1:i64 providerId, 2:map<string, string> destination_city_reached_orders) throws (1:TransactionServiceException ex),
        
        /**
        Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
        */
        void markOrdersAsFirstDeliveryAttempted(1:i64 providerId, 2:map<string, string> first_atdl_orders) throws (1:TransactionServiceException ex),
        
        /**
        Returns the list of orders whose delivery time has passed but have not been
        delivered yet for the given provider and warehouse. To get a complete list of
        undelivered orders, pass them as -1. 
        Returns an empty list if no such orders exist.
        */
        list<Order> getUndeliveredOrders(1:i64 providerId, 2:i64 warehouseId),
        
        /**
        Returns the list of orders whose expected delivery date has passed but have not been
        delivered yet.
        Returns an empty list if no such orders exist.
        */
        list<Order> getUndeliveredOrdersExpectedDeliveryDateNotMet(),
        
        /**
        Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
        Returns the final flag status.
        Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS. 
        */
        bool toggleDOAFlag(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        void markOrderAsDelivered(1:i64 orderId, 2:i64 deliveryTimestamp, string receiver) throws (1:TransactionServiceException ex),
        
        void markOrderAsReceivedAtStore(1:i64 orderId, 2:i64 deliveryTimestamp) throws (1:TransactionServiceException ex),
        
        /**
         Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED 
        */
        bool markOrderDoaRequestReceived(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
         CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED 
         to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS. 
        */
        bool markOrderDoaRequestAuthorized(1:i64 orderId, 2:bool isAuthorized, 3:bool fromStore, 4:bool isReship) throws (1:TransactionServiceException ex),
        
        /**
         Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED 
        */
        bool markOrderReturnRequestReceived(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
         CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED 
         to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS. 
        */
        bool markOrderReturnRequestAuthorized(1:i64 orderId, 2:bool isAuthorized, 3:bool fromStore, 4:bool isReship) throws (1:TransactionServiceException ex),

        /**
        Sends out an email to the account manager of the original courier provider used to ship the order.
        If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
        If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
        For any other status, it returns false.
        Throws an exception if the order with the given id couldn't be found.
        */
        bool requestPickupNumber(1:i64 orderId, 2:i64 providerId) throws (1:TransactionServiceException ex),
        
        /**
        If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
                1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
                2. Changes order status to be DOA_PICKUP_AUTHORIZED.
                3. Returns true
        If the order is in any other status, it returns false.
        Throws an exception if the order with the given id couldn't be found.
        */
        bool authorizePickup(1:i64 orderId, 2:string pickupNumber, 3:i64 providerId) throws (1:TransactionServiceException ex),
        
        /**
        Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
        */
        void markDoasAsPickedUp(1:i64 providerId, 2:map<string, string> pickupDetails),
        
        /**
        Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
        */
        list<Order> getDoasNotPickedUp(1:i64 providerId),
        
        /**
        Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
        */
        void markReturnOrdersAsPickedUp(1:i64 providerId, 2:map<string, string> pickupDetails),
        
        /**
        Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
        */
        list<Order> getReturnOrdersNotPickedUp(1:i64 providerId),
        
        /**
        If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
        If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
        If the order is in any other state, it returns false.
        Throws an exception if the order with the given id couldn't be found.
        */
        bool receiveReturn(1:i64 orderId, 2:i64 receiveCondition, 3:bool receiveFreebie, 4:string serialNumbers) throws (1:TransactionServiceException ex),
        
        /**
        Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
        the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
        If the order is in any other state, it returns false.
        Throws an exception if the order with the given id couldn't be found.
        */
        bool validateDoa(1:i64 orderId, 2:bool isValid) throws (1:TransactionServiceException ex),
        
        bool validateReturnProduct(1:i64 orderId, 2:bool isUsable) throws (1:TransactionServiceException ex),
        
        /**
        If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
                1. Creates a new order for processing in the BILLED state. All billing information is saved.
                2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
                
        If the order is in DOA_CERT_VALID state, it does the following:
                1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
                2. Creates a return order for the warehouse executive to return the DOA material.
                3. Marks the current order as the final DOA_VALID_RESHIPPED state.
        
        Returns the id of the newly created order.
        
        Throws an exception if the order with the given id couldn't be found.
        */
        i64 reshipOrder(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
        If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
                1. Creates a refund request for batch processing.
                2. Creates a return order for the warehouse executive to return the shipped material.
                3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
        
        If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
                1. Creates a refund request for batch processing.
                2. Cancels the reservation of the item in the warehouse.
                3. Marks the current order as the REFUNDED final state.

        For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
                1. Cancels the reservation of the item in the warehouse.
                2. Marks the current order as CANCELED. 
                
        In all cases, it updates the reason for cancellation or refund and the person who performed the action.
         
        Returns True if it is successful, False otherwise.

        Throws an exception if the order with the given id couldn't be found.
        */
        bool refundOrder(1:i64 orderId, 2:string refundedBy, 3:string reason) throws (1:TransactionServiceException ex),
        
        /**
        Get all return orders created between the from and to dates for the given warehouse.
        Ignores the warehouse if it is passed as -1.
        */
        list<ReturnOrder> getReturnOrders(1:i64 warehouseId, 2:i64 fromDate, 3:i64 toDate),
        
        /**
        Get all return orders created between the from and to dates.
        */
        list<ReturnOrder> getAllReturnOrders(1:bool onlyNotProcessed, 2:i64 fromDate, 3:i64 toDate),
        
        /**
        Returns the ReturnOrder corresponding to the given id.
        Throws an exception if the return order with the given id couldn't be found.
        */
        ReturnOrder getReturnOrder(1:i64 id) throws (1:TransactionServiceException ex),
        
        /**
        Marks the return order with the given id as processed. Raises an exception if no such return order exists. 
        */
        void processReturn(1:i64 returnOrderId) throws (1:TransactionServiceException ex),

        /**
        Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
        */
        Order updateWeight(1:i64 orderId, 2:double weight) throws (1:TransactionServiceException ex),
        
        /**
        Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
        Currently, it also ensures that only a different color of the given item is shipped.
        */
        Order changeItem(1:i64 orderId, 2:i64 itemId) throws (1:TransactionServiceException ex),
        
        Order changeCourierProvider(1:i64 orderId, 2:i64 providerId) throws (1:TransactionServiceException ex),
        
        /**
        Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
        */
        Order shiftToWarehouse(1:i64 orderId, 2:i64 warehouseId) throws (1:TransactionServiceException ex),
        
        /**
        Adds the given delay reason to the given order.
        Increases the expected delivery time of the given order by the given no. of days.
        Raises an exception if no order with the given id can be found.
        */
        bool addDelayReason(1:i64 orderId, 2:DelayReason delayReason, 3:i64 furtherDelay, 4:string delayReasonText) throws (1:TransactionServiceException ex),
        
        /**
        Marks the COD orders with given AWB nos. as having been processed.
        Updates the captured amount for the corresponding payment.
        
        Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
        1. There is no order corresponding to an AWB number.
        2. The captured amount for a payment exceeds the total payment.
        3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
        */
        map<string, string> reconcileCodCollection(1:map<string, double> collectedAmountMap, 2:string xferBy, 3:string xferTxnId, 4:i64 xferDate) throws (1:TransactionServiceException ex),

    /**
     * Returns the list of transaction ids that require some extra processing and
     * which belong to a particular category. This is currently used by CRM
     * application. If no such transaction ids are present, it returns an empty list.
     */
    list<i64> getTransactionsRequiringExtraProcessing(1:ExtraTransactionProcessingType category),

        /**
         * Marks a particular transaction as processed for a particular cateogory.
         * It essentially deletes the transaction id record for a particular
         * processing type category (if present) from DB.
         * This is currently used by CRM application.
         */
        void markTransactionAsProcessed(1:i64 transactionId, 2:ExtraTransactionProcessingType category),
        
        /**
        Returns a map containing the number of risky orders keyed by item id. A risky order
        is defined as one whose shipping date is about to expire.
        */
        map<i64, i64> getItemWiseRiskyOrdersCount(),
        
        /**
        Returns a list of all orders which have items with given id
        */
        list<Order> getOrdersForItemIds(1:list<i64> itemIds),
        
        /**
         * Mark order as cancellation request received. If customer sends request of cancellation of 
         * a particular order, this method will be called. It will just change status of the order 
         * depending on its current status. It also records the previous status, so that we can move 
         * back to that status if cancellation request is denied.
         */
        void markOrderCancellationRequestReceived(1:i64 orderId) throws (1:TransactionServiceException ex),

        /**
         * If we decide to to cancel order, CRM will call this method to move the status of order to 
         * cancellation request confirmed. After this OM will be able to cancel the order.      
         */
        void markOrderCancellationRequestConfirmed(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
         * If we decide to not to cancel order, we will move the order ro previous status.      
         */
        void markOrderCancellationRequestDenied(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        /**
         * If we and/or payment gateway has decided to accept the payment, this method needs to be called.
         * Changed transaction and all orders status to payment accepted.  
         */
        void markTransactionAsPaymentFlagRemoved(1:i64 transactionId) throws (1:TransactionServiceException ex),
        
        /**
        * This method is called when a flagged payment is deemed unserviceable and the corresponding orders
        * need to be cancelled
        */
        void refundTransaction(1:i64 transactionId, 2:string refundedBy, 3:string reason) throws (1:TransactionServiceException ex),

        /**
         * Updates shipment address of an order. Delivery and shipping date estimates
         * etc. are also updated here.
         *
         * Throws TransactionServiceException in case address change is not
         * possible due to certain reasons such as new pincode in address is
         * not serviceable etc.
         */
        void updateShipmentAddress(1:i64 orderId, 2:i64 addressId) throws (1:TransactionServiceException ex)
        
        /**
        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.
        */
        bool acceptOrdersForItemId(1:i64 itemId, 2:i64 inventory) throws (1:TransactionServiceException ex),
        
        void markOrdersAsPORaised(1:i64 vendorId, 2:i64 itemId, 3:i64 quantity, 4:i64 estimate, 5:bool isReminder) throws (1:TransactionServiceException ex),
        void markOrdersAsReversalInitiated(1:i64 vendorId, 2:i64 itemId, 3:i64 quantity, 4:i64 estimate, 5:bool isReminder) throws (1:TransactionServiceException ex),
        void markOrdersAsNotAvailabke(1:i64 vendorId, 2:i64 itemId, 3:i64 quantity, 4:i64 estimate, 5:bool isReminder) throws (1:TransactionServiceException ex),
        
        map<i32, TimeoutSummary> markOrdersAsTimeout(1:i64 vendorId) throws (1:TransactionServiceException ex),

        /**
        Mark order as LOST_IN_TRANSIT
        */
        bool markOrderAsLostInTransit(1:i64 orderId) throws (1:TransactionServiceException ex),
                
        /**
        Returns the order corresponding to an AWB number
        */
        list<Order> getOrderForAwb(1:string awb) throws (1:TransactionServiceException ex),
        
        /**
        Returns the order corresponding to a logistics provider id for a given list of order status
        */
        list<Order> getOrdersForProviderForStatus(1:i64 logistics_provider_id, 2:list<OrderStatus> order_status_list) throws (1:TransactionServiceException ex)
        
        /**
        Returns list of orders fullfiled from a certain vendor and billed in a given date range
        */
        list<Order> getBilledOrdersForVendor(1:i64 vendorId, 2:i64 billingDateFrom, 3:i64 billingDateTo) throws (1:TransactionServiceException ex),
        
        list<Order> getSlippedSippingDateOrders() throws (1:TransactionServiceException ex),
        
        list<Order> getCancelledOrders(1:i64 cancelDateFrom, 2:i64 cancelDateTo) throws (1:TransactionServiceException ex),
        
        void saveBluedartSettlements(1:map<i64, double> mapAWBAndAmount) throws (1:TransactionServiceException ex),
        
        void savePaymentSettlements(1:i64 settlementDate, 2:i64 paymentGatewayId, 3:i64 referenceId, 4:double serviceTax, 5:double otherCharges, 6:double netCollection) throws (1:TransactionServiceException ex),
        
        void saveEBSSettlementSummary(1:i64 settlementId, 2:i64 settlementDate, 3:i64 transactionDateFrom, 4:i64 transactionDateTo, 5:double amount) throws (1:TransactionServiceException ex),
        
        PaymentSettlement getSettlementForPrepaid(1:i64 referenceId, 2:bool isRefund) throws (1:TransactionServiceException ex),
        
        PaymentSettlement getSettlementForCod(1:i64 orderId, 2:bool isRefund) throws (1:TransactionServiceException ex),
        
        map<i64, string> getEBSSettlementSummaries() throws (1:TransactionServiceException ex),
        
        void markEBSSettlementUploaded(1:i64 settlementId) throws (1:TransactionServiceException ex),
        
        i64 getEBSSettlementDate(1:i64 settlementId) throws (1:TransactionServiceException ex),
        
        list<PaymentSettlement> getSettlementsByDate(1:i64 settlementDateFrom, 2:i64 settlementDateTo, 3:bool isRefund) throws (1:TransactionServiceException ex),
        
        /**
        Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids 
        */
        list<i64> getReshippedOrderIds(1:list<i64> orderIds) throws (1:TransactionServiceException ex),
        
        list<Order> getBilledOrders(1:i64 vendorId, 2:bool onlyVendorNotPaid, 3:i64 billingDateFrom, 4:i64 billingDateTo) throws (1:TransactionServiceException ex),
        
        map<i64, i64> getStatusDistributionOfOrders(1:i64 startDate, 2:i64 endDate) throws (1:TransactionServiceException ex),
        
        list<i64> getOrderIdsForStatus(1:i64 status, 2:i64 startDatetime, 3:i64 endDatetime) throws (1:TransactionServiceException ex),
        
        /**
         * Updates the agent who handled the COD verification call
         */
        void updateCODAgent(1:string agent, 2:i64 orderId) throws (1:TransactionServiceException ex),
        
        void updateOrderAsPaidToVendor(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        void updateOrderOnlyAsPaidToVendor(1:i64 orderId) throws (1:TransactionServiceException ex),
        
        list<Order> getRefundedOrdersMarkedPaid() throws (1:TransactionServiceException ex),
        
        /**
        * gets all COD Verification Agents for all orderIds from a minId to maxId
        *
        */
        list<CODVerificationAgent> getAllVerificationAgents(1:i64 minOrderId, 2:i64 maxOrderId),
        
        /**
        * gets all attributes for a given orderId
        */
        list<Attribute> getAllAttributesForOrderId(1:i64 orderId),
        
        /**
        * sets attributes for an order
        */
        void setOrderAttributes(1:i64 orderId, list<Attribute> attributes),
        
        /**
        * sets attributes for all orders in a transaction
        */
        void setOrderAttributeForTransaction(1:i64 transactionId, Attribute attribute),
        
        list<Order> getReceivePendingOrders(1:i64 storeId),
        
        list<Order> getReceivedAtStoreOrders(1:i64 storeId),
        
        list<Order> getOrdersCollectionAtStore(1:i64 storeId, 2:i64 fromDate, 3:i64 toDate, 4:bool onlyCod),

        string getOrderAttributeValue(1:i64 orderId, string attributeName),
        
        bool changeJacketNumber(1:i64 orderId, 2:i64 jacketNumber),
        
        bool markOrderAsRtoInTransit(1:i64 orderId),
        
        /**
         * Accepts appropriate order for an item in a given billingWarehouse. Usually
         * invoked while scanning IN of items.
         */
         void acceptOrderForItem(1:i64 itemId, 2:i64 quantity, 3:i64 fulfilmentWarehouseId, 4:i64 billingWarehouseId);

         RechargeOrder createRechargeOrder(1:RechargeOrder rechargeOrder) throws  (1:TransactionServiceException ex);
         RechargeOrder getRechargeOrder(1:i64 rechargeRrderId) throws  (1:TransactionServiceException ex);
         list<RechargeOrder> getRechargeOrders(1:i64 userId);
                 
         bool updateRechargeOrderStatus(1:i64 rechargeOrderId, 2:RechargeOrderStatus rechargeOrderStatus) throws  (1:TransactionServiceException ex);
         bool activateRechargeTxn(1:i64 rechargeOrderId) throws  (1:TransactionServiceException ex);
         UserWallet getUserWallet(1:i64 userId);
         list<UserWalletHistory> getUserWalletHistory(1:i64 userId);
         list<UserWalletHistory>  getLatestUserWalletHistory(1:i64 userId, 2:i64 offset, 3:i64 limit);
         /**
         Returns a recharge order for a given transactionId
         */
         RechargeOrder getRechargeOrdersForTransaction(1:i64 txnId) throws (1:TransactionServiceException ex);
         map<i64, string> getServiceProviders(1:RechargeType rechargeType, 2:bool onlyActive);
         DeviceNumberInfo getServiceProviderForDevice(1:RechargeType rechargeType, 2:string deviceNumber);
         string validateRecharge(1:RechargeType rechargeType, 2:string deviceNumber, 3:i64 userSelectedProviderId, 4:string clientAddress);
         list<RechargeOrder> getRechargeOrdersForDevice(1:string deviceNumber);
         //void addAmountToWallet(1:i64 userId, 2:i64 orderId, 3:i64 amount);
         void creditBatch(1:i64 batchId, 2:string userAmount);
         
         RechargeStatistics getRechargeStatistics();
         
         list<RechargeOrder> getRechargeOrdersForStatus(1:i64 status);
         list<RechargePlan> getPlansForOperator(1:i64 operatorId);
         
         /**
         Returns denominations for a given operator and circle
         */
         list<RechargeDenomination> getRechargeDenominations(1:i64 operatorId, 2:string circleCode, 3:DenominationType denominationType) throws (1:TransactionServiceException ex);
         
         void updateAvailabilityStatus(1:i64 operatorId, 2:i64 circleId, 3:bool isAvailable);
         
         list<EmiScheme> getAvailableEmiSchemes();
         
         map<i64, double> getMiscCharges(1:i64 transactionId);
         
         bool refundRechargeOrder(1:i64 rechargeOrderId) throws (1:TransactionServiceException ex);
         
         list<Order> getPhysicalOrders(1:i64 fromDate, 2:i64 toDate);
         
         binary getDocument(1:i64 docType, 2:i64  docSource);
         
         bool changeShippingAddress(1:i64 orderId, 2:string line1, 3:string line2, 4:string city, 5:string state, 6:string pin);
         
         binary retrieveInvoice(1:i64 orderId, 2:i64 userId);
         
         list<string> receiveUpdatesForRedExpress(1:string awbNumber);
         
         RechargeTransaction createRechargeTransaction(1:RechargeTransaction thriftRechargeTransaction);
         
         list<RechargeTransaction> getRechargeTransactions(1:i64 storeId);

         list<RechargeTransaction> getRechargeTrans(1:i64 storeId, 2:i64 startDate, 3:i64 endDate, 4:RechargeOrderStatus status);
         
         RechargeTransaction getRechargeTransaction(1:i64 rechargeId);
         
         list<FRC> getFRCs(1:i64 circleId, 2:i64 operatorId);
         
         HotspotStore getHotspotStore(1:i64 id, 2:string hotspotid);
         
         TelecomCircle getTelecomCircle(1:i64 id, 2:string code);
         
         binary retrieveHotspotRechargeInvoice(1:i64 rechargeId);
         
         Order splitFreebieOrder(1:i64 orderId, 2:string splitReason, 3:i64 shippingDate);
         
         list<RechargeTransaction> getRechargeTransactionsByNumber(1:string number, 2:i64 storeId);
         
         bool updateHotspotStorePassword(1:i64 storeId, 2:string password);
         
         i64 topupCompanyWallet(1:i64 companyId, 2:i64 amount);

         i64 getWalletBalanceForCompany(1:i64 companyId);
         
         i64 getSaholicRechargeBalance();
                 
         SourceDetail getSourceDetail(1:i64 source);
         
         list<TelecomCircle> getAllCircles();
         
         bool deleteFrcs(1:list<i64> frcIdsToDelete);
         
         void addAmazonOrder(1:AmazonOrder amazonOrder);
         
         bool updateAmazonOrderStatus(1:i64 orderId,2:string status);
         
         list<Order> getAmazonOrdersShipped();
         
         list<Order> getAmazonOrdersCancelled(1:i64 interval);
         
         AmazonOrder getAmazonOrder(1:i64 orderId);
         
         list<AmazonOrder> getAmazonOrderByAmazonOrderId(1:string amazonOrderId);
         
         list<Order> getOrdersForStore(1:i64 id, 2:i64 storeId, 3:i64 startDate, 4:i64 endDate, 5:list<OrderStatus> statuses);
         
         binary getStoreOrderAdvanceInvoice(1:i64 orderId, 2:i64 storeId);
         
         bool addFrc(1:i64 circleId, 2:i64 operatorId, 3:i64 denomination, 4:i64 maxDiscount);
         
         string addSeries(1:i64 circle, 2:i64 operatorId, 3:i64 series);
         
         bool saveStoreOrderDetail(1:StoreOrderDetail storeOrderDetail);
         
         StoreOrderDetail getStoreOrderDetail(1:i64 orderId, 2:i64 storeId);
         
         list<string> getAllEdcBanks();
         
         bool saveRefundAmountsForStoreOrder(1:i64 orderId, 2:i64 storeId, 3:double cashRefundAmount, 4:double cardRefundAmount);
         
         list<StoreOrderCollection> getCollectionsForStore(1:i64 storeId, 2:i64 startDate, 3:i64 endDate);
         
         list<AmazonOrdersToAcknowledge> getAmazonOrdersToAcknowledge(1:OrderSource source);
         
         void changeAmazonOrderStatus(1:string amazonOrderCode,2:string status);
         
         bool updateTimestampForAmazonOrder(1:map<i64, map<string,string>> amazonOrderDelivery);
         
         bool updateSourceDetailTimestamp(1:i64 id , 2:i64 lastUpdatedOn);
         
         list<Order> getOrdersByMobileNumber(1:string mobileNumber);
         
         list<Order> getOrdersByAmazonOrderCode(1:string amazonId);
         
         bool convertStoreToNormal(1:i64 orderId);
         
         Order updateFreebieItem(1:i64 orderId, 2:i64 newFreebieItemId);
         
         list<HotspotServiceMatrix> getHotspotServiceMatrices();
         
         Order updateOrderAWB(1:i64 orderId, 2:string airwayBillNo);
         
         list<Order> getOrdersByVendor(1:list<i64> vendors, 2:list<OrderStatus> statuses) throws (1:TransactionServiceException ex);
         
         void createEbayOrder(1:EbayOrder ebayOrder);
         
         EbayOrder getEbayOrderByOrderId(1:i64 orderId);
         
         EbayOrder getEbayOrderBySalesRecNumber(1:i64 salesRecordNumber);
         
         list<EbayOrder> getEbayOrder(1:i64 salesRecordNumber, 2:string listingId, 3:string paisapayId);
         
         void updateEbayOrder(1:EbayOrder ebayOrder);
         
         bool ebayOrderExists(1:i64 salesRecNumber, 2:string ebayListingId);
         
         void updateOrderForEbay(1:Order order);
         
         Order splitEbayOrder(1:i64 orderId, 2:i64 splitOrderQty, 3:i64 splitOrderItemId, 4:bool usePowerShip);
         
         void addOrUpdateAmazonFbaSalesSnapshot(1:AmazonFbaSalesSnapshot amazonfbasalessnapshot);
         
         list<AmazonFbaSalesSnapshot> getAmazonFbaSalesSnapshotForDays(1:i32 days);
         
     AmazonFbaSalesSnapshot getAmazonFbaSalesLatestSnapshotForItem(1:i64 item_id);
     
     void createSnapdealOrder(1:SnapdealOrder snapdealOrder);
     
     list<SnapdealOrder> getSnapdealOrder(1:i64 orderId, 2:string referenceCode, 3:string subrderId)
     
     bool snapdealOrderExists(1:string subOrderId, 2:string referenceCode);
     
     void updateLatestFbaPricesForItem(1:FbaItemPrices fbaitemprices)
     
     bool flipkartOrderExists(1:string flipkartOrderId, 2:string flipkartSubOrderId)
     
     void createFlipkartOrder(1:FlipkartOrder flipkartOrder)
     
     FlipkartOrder getFlipkartOrder(1:i64 orderId)
     
     FlipkartOrder getFlipkartOrderByOrderItemId(1:string flipkartOrderItemId)
     
     void updateFlipkartOrderDatesAndAWB(1:string flipkartOrderId,2:string flipkartSubOrderId,3:i64 date,4:string awb)
     
     map<i64,i64> getOrdersCreatedAfterTimestampForSource(1:i64 timestamp,2:i64 source)
     
     list<Order> getOrderForAirwayBillNo(1:string airwaybillNo) throws (1:TransactionServiceException ex)

         i64 getMinCreatedTimeStampUndeliveredOrdersForSource(1:i32 source)
         
         void updateSnapdealOrdersStatus(1:map<string, list<list<string>>> orders)  throws (1:TransactionServiceException ex)
         
         void updateFlipkartOrdersStatus(1:list<list<string>> delivered_orders)  throws (1:TransactionServiceException ex)

         void bulkAddOrUpdateAmazonFbaSalesSnapshot(1:list<AmazonFbaSalesSnapshot> amazonfbasalessnapshotlist)
         
         map<i64,i64> getCreatedOrdersForFlipkart(list<string> flipkartorderids)
         
         bool isPrivateDealTransaction(1:i64 transactionId)
         
         AmazonFbaSalesSnapshot getAmazonFbaSalesLatestSnapshotForItemLocationWise(1:i64 item_id,2:i64 location);
         
         bool changeEasyshipMfnOrderTxnStatus(1:i64 transactionId, 2:TransactionStatus status, 3:string description, 4:i64 pickUp, 5:OrderType orderType, 6:OrderSource source, 7:i64 shipTimestamp, 8:i64 deliveryTimeStamp) throws (1:TransactionServiceException ex)
         
         void updateAmazonFbaOrdersReturns(1:list<AmazonFbaOrderReturns> fbaOrderReturns) throws (1:TransactionServiceException ex)
         
         list<AmazonFbaOrderReturns> getAllAmazonFbaOrderReturnsByCurrentTime(1:i64 insertionTimestamp) throws (1:TransactionServiceException ex)
         
         map<i64, map<string, i64>> getTotalSaleReturnsFbaSkusCurentTime(1:i64 insertionTimestamp) throws (1:TransactionServiceException ex)
         
         list<FlipkartOrder> getVerificationPendingOrdersFK() throws (1:TransactionServiceException ex)
         
         FlipkartAdvantageOrder getFAOrderByFkOrderId(1:string fkOrderId, 2:string fkOrderItemId) throws (1:TransactionServiceException ex)
         
         list<FlipkartAdvantageOrder> getAllFAOrdersList(1:string status) throws (1:TransactionServiceException ex)
         
         void addUpdateFaOrdersBulk(1:list<FlipkartAdvantageOrder> faOrdersList) throws (1:TransactionServiceException ex)
         
         void addInvoiceDetailsToOrders(1:i64 transactionId, 2:i64 customerId) throws (1:TransactionServiceException ex)
         
         bool flipkartFaOrderExists(1:string fkOrderId, 2:string fkOrderItemId) throws (1:TransactionServiceException ex)
         
         RechargeOrder getRcgOrderStatus(1:i64 rechargeOrderId,2:bool isFinal)
         
         RechargeTransaction getRcgTransactionStatus(1:i64 rechargeTransactionId,2:bool isFinal)
         
         void bulkAddOrUpdateFlipkartFaSalesSnapshot(1:list<FlipkartFaSalesSnapshot> flipkartfasalessnapshotlist)
         
         list<FlipkartFaSalesSnapshot> getFlipkartFaSalesSnapshotForDays(1:i32 days)
         
         FlipkartFaSalesSnapshot getFlipkartFaSalesSnapshotBySkuAndSaleDate(1:i64 item_id, 2:i64 dateOfSale)
         
         bool acceptPackageOrders(list<i64> orders) throws (1:TransactionServiceException ex)
         
         list<Order> getGroupOrdersByLogisticsTxnId(1:string logisticsTxnId) throws (1:TransactionServiceException ex)
         
         bool addBillingDetailsForGrouppedOrders(1:list<i64> order_ids, 2:string invoice_number, 3:map<i64,list<string>> itemNumbersMap, 4:map<i64,list<string>> serialNumbersMap, 5:map<i64,list<i64>> freebieWarehouseIdMap, 6:string billed_by, 7:i64 jacketNumber, 8:i64 billingType, 9:bool authorize, 10:string invoiceType) throws (1:TransactionServiceException ex)
         
         string getInvoiceFormatLogisticsTxnId(1:i64 transactionId, 2:i64 shipementSeq) throws (1:TransactionServiceException ex)
         
         void createHomeShopOrder(1:HsOrder snapdealOrder);
     
     list<HsOrder> getHomeShopOrder(1:i64 orderId, 2:string hsOrderNo, 3:string hsSubOrderNo);
     
     bool homeShopOrderExists(1:string hsOrderNo, 2:string hsSubOrderNo);
     
     Order splitBulkOrder(1:i64 orderId, 2:i64 splitOrderQty);
     
     string moveOrdersToCorrectWarehouse();
     
     Creditor getCreditorInfo(1:i64 id, 2:string name)
    
    bool updateCreditorInfo(1:Creditor creditor) 
    
    list<UserSanction> getUserSanctionDetails(1:i64 userId)
    
    UserSanction getUserSanctionDetailsForCreditor(1:i64 userId, i64 creditorId)
    
    bool updateUserSanction(1:UserSanction userSanaction) throws (1:TransactionServiceException pe)
    
    list<CreditHistory> getCreditHistoryRecordsForTransaction(1:i64 paymentId, 2:CreditTxnType creditTxnType)
    
    list<CreditHistory> getCreditHistoryRecordsForUserAndCreditor(1:i64 userId, 2:i64 creditorId, 3:CreditTxnType creditTxnType)
    
    bool processCreditTransaction(1:i64 paymentId, 2:i64 userId, 3:i64 creditorId, 4:list<CreditHistory> creditTxns) throws (1:TransactionServiceException pe)
    
    double getLoanPayableForUserToCreditor(1:i64 userId, 2:i64 creditorId, 3:i64 dueDate)
    
    list<LoanHistory> getLoanHistoryRecordsForTransaction(1:i64 paymentId, 2:CreditTxnType creditTxnType)
    
    list<LoanHistory> getLoanHistoryRecordsForUserAndCreditor(1:i64 userId, 2:i64 creditorId, 3:CreditTxnType creditTxnType)
    
    bool processLoanTransaction(1:i64 paymentId, 2:i64 userId, 3:i64 creditorId, 4:list<LoanHistory> creditTxns) throws (1:TransactionServiceException pe)
    
    PaginatedCreditHistory getLimitedCreditHistoryRecords(1:i64 paymentId, 2:i64 userId, 3:i64 creditorId, 4:i64 limit, 5:i64 offset)
    
    PaginatedLoanHistory getLimitedLoanHistoryRecords(1:i64 paymentId, 2:i64 userId, 3:i64 creditorId, 4:i64 limit, 5:i64 offset)
    
    PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(1:i64 userId, 2:i64 creditorId, 3:i64 limit, 4:i64 offset,5:string sort)
    
    list<OutstandingPayments> getOutstandingPayments(1:string fetchType, 2:i64 userId, 3:i64 limit)
    
    map<bool,string> markPaymentSettled(1:i64 userId,2:i64 paymentId,3:double totalAmount,4:i64 repaymentDate)
    
    ReturnOrderInfo getReturnOrderInfo(1:i64 id) throws (1:TransactionServiceException ex);
     
     map<i64,list<ReturnOrderInfo>> getReturnOrderInfoList(1:list<i64> order_ids);
        
         map<i64,list<ReturnOrderInfo>> getReturnOrderInfoListAsByStatus(1:list<i64> order_ids, 2:list<string> statuses);
     
     bool updateReturnOrderInfo(1:ReturnOrderInfo returnInfo) throws (1:TransactionServiceException ex);
     
     map<i64, bool> bulkUpdateReturnOrderInfo(1:map<i64,list<ReturnOrderInfo>> orderReturnInfosMap) throws (1:TransactionServiceException ex);
     
     list<ReturnOrderInfo> getReturnOrdersAsPerWarehouseId(1:i64 warehouseId);
     
     ReturnTransaction createReturnTransaction(1:ReturnTransaction returnTransaction, 2:string itemCondition, 3:bool overrideWarranty) throws (1:TransactionServiceException ex);
     
     ReturnTransaction getReturnTransaction(1:i64 id) throws (1:TransactionServiceException ex);
         
         list<ReturnOrderInfo> getReturnOrdersForReturnTransaction(1:i64 returnTransactionId)  throws (1:TransactionServiceException ex);
         
         bool changeReturnTransactionStatus(1:i64 returnTransactionId, 2:ReturnTransactionStatus status, 3:list<i64> returnOrderIds) throws (1:TransactionServiceException ex);
         
         i64 createReturnPickupRequest(1:list<i64> returnOrderIds) throws (1:TransactionServiceException ex);
         
         bool updateReturnPickupRequest(1:ReturnPickupRequest returnPickupRequest) throws (1:TransactionServiceException ex);
         
         list<ReturnOrderInfo> getAllReturnOrdersForReturnPickupRequest(1:i64 logisticsRequestId) throws (1:TransactionServiceException ex);
         
         bool receiveReturnPickup(1:map<i64,map<string, string>> returnOrdersMap, 2:i64 id) throws (1:TransactionServiceException ex);
         
         bool validateReturnPickup(1:i64 returnPickupId, 2:map<i64, bool>returnOrdersMap) throws (1:TransactionServiceException ex);
         
         bool processReturnPickup(1:i64 returnPickupId, 2:map<i64, map<string, string>> returnOrdersMap) throws (1:TransactionServiceException ex);
         
         bool markReturnTransactionComplete(1:i64 returnTransactionId) throws (1:TransactionServiceException ex);
         
         bool refundReturnTransactionPayment(1:map<i64, map<string, string>> refundOrdersMap, 2:i64 returntransactionId) throws (1:TransactionServiceException ex);
         
         list<ReturnTransaction> getReturnTransactionsForCustomer(1:list<ReturnTransactionStatus> statusList, 2:string customerMobile, 3:string customerEmail, 4:i64 returnTransactionId, 5:i64 customerId) throws (1:TransactionServiceException ex);
         
         bool verifyOrderForTransaction(1:i64 transactionId) throws (1:TransactionServiceException ex);
         
         /**
         Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
         These orders should be in order of promised shipping time. 
         Pass the status as null and the limit as 0 to ignore them.
         */
         list<Order> getOrdersInBatchAsPromisedShipping(1:list<OrderStatus> statuses, 2:i64 offset, 3:i64 limit, 4:i64 warehouse_id, 5:i64 source) throws (1:TransactionServiceException ex),
                
        /**
        * sets attributes for all orders in a Master Order Id or Shipment Id
        */
        void setOrderAttributeForMasterOrderId(1:string logisticsTransactionId, 2:list<Attribute> attributes)
        
        bool updateMasterOrderAWB(1:string logisticsTransactionId, 2:string airwayBillNo);
        
        bool addOrUpdateShipmentLogisticsCostDetails(1:list<ShipmentLogisticsCostDetail>  shipmentLogisticsCostDetails)
        
        list<Order> getEligibleOrdersForReturn(1:i64 customerId, 2:string itemCondition, 3:bool overrideWarranty) 
        
        list<ReturnOrderInfo> getEligibleReturnOrdersForPickup(1:i64 customerId)
        
        bool validateReturnTransaction(1:i64 customerId, 2:map<i64,i64> returnOrdersMap, 3:string itemCondition, 4:bool overrideWarranty)
        
        list<PendingStoreOrder> getPendingStoreOrders(1:i64 storeId);
        
        SellerInfo getSellerInfo(1:i64 sellerId);
        
        WarehouseAddress getWarehouseAddress(1:i64 address_id);
        
        BuyerInfo getBuyerByWarehouse(1:i64 warehouse_id);
        
        bool markReturnNotRequiredOrdersProcessed(1:ReturnOrderInfo returnOrderInfo) throws (1:TransactionServiceException ex);
        
        ReturnPickupRequest getReturnPickupRequest(1:i64 returnPickupId);
        
        ReturnOrderInfo splitReturnOrderInfo(1:i64 returnOrderId, 2:i64 splitOrderQty);
        
        bool deleteReturnOrder(1:i64 returnOrderId);
        
        bool refundReturnOrder(1:ReturnOrderInfo returnOrderInfo, 2:list<Attribute> attributes);
        
        list<i64> addShipmentDelay(1:list<ShipmentDelayDetail> shipmentDelayDetail);
        
        ShipmentLogisticsCostDetail getCostDetailForLogisticsTxnId(1:string logisticsTxnId);
        
        void addShipmentLogisticDetail(1:ShipmentLogisticsCostDetail shipmentLogisticsCostDetail)
        
        i64 createPayment(1:i64 userId, 2:i64 txnId, 3:i32 gatewayId)
        
        double calculatePaymentAmount(1:i64 txnId)
        
        list<Order> getBilledOrdersForManifestGen(1:i64 warehouse_id, 2:i64 logistics_provider_id, 3:bool cod)
        
        bool registerRsa(1:i64 userId,2:string activation_code)
        
        string addSalesAssociate(1:Pmsa pmsa,2:string referrerEmail, 3:string l1_userEmail)
        
        list<Pmsa> searchPmsa(1:PmsaSearchFilter pmsaSearchFilter,2:string associateEmail)
        
        Pmsa getPmsaUser(1:i64 id, 2:string associateEmail);
        
        string updatePmsaUser(1:Pmsa pmsa, 2:string associateEmail);
        
        list<Pmsa> getPmsaUsers(1:string associateEmail);
        
        list<Pmsa> getPendingAssociates(1:string associateEmail)
        
        list<i64> getStatsForAssociates(1:string associateEmail)
        
        Pmsa getmypmsaprofile(1:string associateEmail)
        
        bool creditUserWallet(1:i64 userId, 2:i64 amount, 3:double cash_back, 4:string shortDesc)
        
        list<RechargeOrder> getPaginatedRechargeOrders(1:i64 userId, 2:i32 offset, 3:i32 limit)
        
        bool markOrderForRegisteredGstInvoice(list<i64> tranasction_ids)
        
        bool isShipmentCod(1:string logisticsTransactionId)
        
        list<Order> getInTransitOrdersOnDate(1:i64 closingDate);
        list<Order> getInTransitOrdersOnDateByItemId(1:i64 closingDate, 2:i64 itemId);
        
        bool addPriceDrop(1:i64 item_id, 2:list<string>imeis, 3:double amount, 4:i64 affected_on)
}