Subversion Repositories SmartDukaan

package com.amazonservices.mws.orders.samples;

import java.util.GregorianCalendar;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.Duration;
import javax.xml.datatype.XMLGregorianCalendar;

import org.apache.http.HttpStatus;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.amazonservices.mws.orders.MarketplaceWebServiceOrders;
import com.amazonservices.mws.orders.MarketplaceWebServiceOrdersClient;
import com.amazonservices.mws.orders.MarketplaceWebServiceOrdersException;
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenRequest;
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenResponse;
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenResult;
import com.amazonservices.mws.orders.model.ListOrdersRequest;
import com.amazonservices.mws.orders.model.ListOrdersResponse;
import com.amazonservices.mws.orders.model.ListOrdersResult;
import com.amazonservices.mws.orders.model.Order;
import com.amazonservices.mws.orders.model.OrderList;

/**
 * Sample file that fetches orders created during a given time period.
 */

public class OrderFetcherSample {

    /*
     * Add required parameters in OrdersConfig.java before trying out this
     * sample.
     */
    public static final Log log = LogFactory.getLog(OrderFetcherSample.class);

    /*****************************************
     * Throttling Limits in Milliseconds
     *****************************************/
    static final long LIST_ORDERS_THROTTLE_LIMIT = 600000L; // 1 call/10 mins

    protected MarketplaceWebServiceOrders service;

    public OrderFetcherSample() {
        /*********************************************************************
         * Instantiate Http Client Implementation of Marketplace Web Service *
         * Orders
         *********************************************************************/
        this.service = new MarketplaceWebServiceOrdersClient(
                OrdersConfig.accessKeyId,
                OrdersConfig.secretAccessKey,
                OrdersConfig.applicationName,
                OrdersConfig.applicationVersion,
                OrdersConfig.config);
    }

    /**
     * Fetches all orders created in the given time period and processes them
     * locally. If end is null, it will be ignored (the MWS service will pick an
     * appropriate time, which is now - 2 minutes).
     */
    public void fetchOrders(XMLGregorianCalendar start, XMLGregorianCalendar end) throws MarketplaceWebServiceOrdersException {
        ListOrdersRequest listOrdersRequest = new ListOrdersRequest();
        listOrdersRequest.setSellerId(OrdersConfig.sellerId);
        if (OrdersConfig.marketplaceIdList != null) {
            listOrdersRequest
                    .setMarketplaceId(OrdersConfig.marketplaceIdList);
        }
        listOrdersRequest.setCreatedAfter(start);
        if (start == null) {
            throw new IllegalArgumentException("Start date cannot be null.");
        }
        if (end != null) {
            listOrdersRequest.setCreatedBefore(end);
        }

        try {
            ListOrdersResult listOrdersResult = listOrders(listOrdersRequest);

            if (listOrdersResult != null && listOrdersResult.isSetNextToken()) {
                ListOrdersByNextTokenRequest listOrdersByNextTokenRequest = new ListOrdersByNextTokenRequest();
                listOrdersByNextTokenRequest
                        .setSellerId(OrdersConfig.sellerId);
                String nextToken = listOrdersResult.getNextToken();
                ListOrdersByNextTokenResult listOrdersByNextTokenResult = null;
                while (nextToken != null) {
                    listOrdersByNextTokenRequest.setNextToken(nextToken);
                    listOrdersByNextTokenResult = listOrdersByNextToken(listOrdersByNextTokenRequest);
                    nextToken = listOrdersByNextTokenResult.getNextToken();
                }
            }
        } catch (MarketplaceWebServiceOrdersException ex) {
            System.out.println("Caught Exception: " + ex.getMessage());
            System.out.println("Response Status Code: " + ex.getStatusCode());
            System.out.println("Error Code: " + ex.getErrorCode());
            System.out.println("Error Type: " + ex.getErrorType());
            System.out.println("Request ID: " + ex.getRequestId());
            System.out.print("XML: " + ex.getXML());
            throw ex;
        }
    }

    private ListOrdersResult listOrders(ListOrdersRequest request)
            throws MarketplaceWebServiceOrdersException {
        boolean retry;
        ListOrdersResponse listOrdersResponse = null;
        ListOrdersResult listOrdersResult = null;
        do {
            retry = false;
            try {
                listOrdersResponse = service.listOrders(request);

            } catch (MarketplaceWebServiceOrdersException ex) {
                if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
                        && "RequestThrottled".equals(ex.getErrorCode())) {
                    retry = true;
                    requestThrottledExceptionHandler(LIST_ORDERS_THROTTLE_LIMIT);
                } else {
                    throw ex;
                }
            }
            if (listOrdersResponse != null
                    && listOrdersResponse.isSetListOrdersResult()) {
                listOrdersResult = listOrdersResponse.getListOrdersResult();
                if (listOrdersResult.isSetOrders()) {
                    processOrders(listOrdersResult.getOrders());
                }
            }

        } while (retry);
        return listOrdersResult;
    }

    private ListOrdersByNextTokenResult listOrdersByNextToken(
            ListOrdersByNextTokenRequest listOrdersByNextTokenRequest)
            throws MarketplaceWebServiceOrdersException {
        boolean retry;
        ListOrdersByNextTokenResponse listOrdersByNextTokenResponse = null;
        ListOrdersByNextTokenResult listOrdersByNextTokenResult = null;
        do {
            retry = false;
            try {

                listOrdersByNextTokenResponse = service
                        .listOrdersByNextToken(listOrdersByNextTokenRequest);
            } catch (MarketplaceWebServiceOrdersException ex) {
                if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
                        && "RequestThrottled".equals(ex.getErrorCode())) {
                    retry = true;
                    requestThrottledExceptionHandler(LIST_ORDERS_THROTTLE_LIMIT);
                } else {
                    throw ex;
                }
            }
            if (listOrdersByNextTokenResponse != null
                    && listOrdersByNextTokenResponse
                            .isSetListOrdersByNextTokenResult()) {
                listOrdersByNextTokenResult = listOrdersByNextTokenResponse
                        .getListOrdersByNextTokenResult();
                if (listOrdersByNextTokenResult.isSetOrders()) {
                    processOrders(listOrdersByNextTokenResult.getOrders());
                }
            }

        } while (retry);
        return listOrdersByNextTokenResult;
    }

    private void requestThrottledExceptionHandler(long throttlingLimit) {
        try {
            log.info("Request throttled. Sleeping for " + throttlingLimit
                    + " milliseconds.");
            Thread.sleep(throttlingLimit);
        } catch (InterruptedException e) {
            log.error(e.getMessage(), e);
            return;
        }
    }

    /*
     * TODO: Insert your order processing logic here.
     */
    protected void processOrders(OrderList orders) {
        System.out.println(orders.toString());
    }

    public static void main(String... args) {

        OrderFetcherSample orderFetcher = new OrderFetcherSample();
        DatatypeFactory df = null;
        try {
            df = DatatypeFactory.newInstance();
        } catch (DatatypeConfigurationException e) {
            log.error(e.getMessage(), e);
        }

        /******************************************
         * Uncomment the desired fetchOrders call *
         ******************************************/

        /* Fetch orders for the last 24 hours GMT */
        XMLGregorianCalendar start1 = df
                .newXMLGregorianCalendar(new GregorianCalendar());
        Duration negativeOneDay = df.newDurationDayTime(false, 0, 24, 0, 0);
        start1.add(negativeOneDay);
//        try {
//             orderFetcher.fetchOrders(start1, null);
//        } catch (MarketplaceWebServiceOrdersException e) {
//            log.error(e.getMessage(), e);
//        }

        /*
         * Fetch orders for the last quarter (Oct 1st, 2010 to Dec 31st, 2010
         * PST)
         */
        XMLGregorianCalendar start2 = df.newXMLGregorianCalendarDate(2010, 10,
                1, -480);
        XMLGregorianCalendar end2 = df.newXMLGregorianCalendarDate(2011, 01,
                01, -480);
//        try {
//            orderFetcher.fetchOrders(start2, end2);
//        } catch (MarketplaceWebServiceOrdersException e) {            
//            e.printStackTrace();
//        }
    }

}