Subversion Repositories SmartDukaan

/******************************************************************************* 

 *  Copyright 2009 Amazon Services.

 *  Licensed under the Apache License, Version 2.0 (the "License"); 

 *  

 *  You may not use this file except in compliance with the License. 

 *  You may obtain a copy of the License at: http://aws.amazon.com/apache2.0

 *  This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 

 *  CONDITIONS OF ANY KIND, either express or implied. See the License for the 

 *  specific language governing permissions and limitations under the License.

 * ***************************************************************************** 

 *

 *  Marketplace Web Service Java Library

 *  API Version: 2009-01-01

 *  Generated: Wed Feb 18 13:28:48 PST 2009 

 * 

 */

package com.amazonaws.mws.mock;

import com.amazonaws.mws.model.*;

import com.amazonaws.mws.*;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Unmarshaller;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.xml.sax.InputSource;

import java.util.concurrent.Future;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.atomic.AtomicInteger;

/**

 *

 * MarketplaceWebServiceMock is the implementation of MarketplaceWebService based

 * on the pre-populated set of XML files that serve local data. It simulates 

 * responses from Marketplace Web Service service.

 *

 * Use this to test your application without making a call to Marketplace Web Service 

 *

 * Note, current Mock Service implementation does not valiadate requests

 *

 */

public  class MarketplaceWebServiceMock implements MarketplaceWebService {

    private final Log log = LogFactory.getLog(MarketplaceWebServiceMock.class);

    private static JAXBContext  jaxbContext;

    private static ThreadLocal<Unmarshaller> unmarshaller;

    private ExecutorService asyncExecutor = Executors.newCachedThreadPool(

            new ThreadFactory() {

                private final AtomicInteger threadNumber = new AtomicInteger(1);

                public Thread newThread(Runnable task) {

                    Thread thread = new Thread(task, "MarketplaceWebServiceMock-Thread-" + threadNumber.getAndIncrement());

                    thread.setDaemon(Boolean.TRUE);

                    if (thread.getPriority() != Thread.NORM_PRIORITY) {

                        thread.setPriority(Thread.NORM_PRIORITY);

                    }

                    return thread;

                }

                });

    /** Initialize JAXBContext and  Unmarshaller **/

    static {

        try {

            jaxbContext = JAXBContext.newInstance("com.amazonaws.mws.model", MarketplaceWebService.class.getClassLoader());

        } catch (JAXBException ex) {

            throw new ExceptionInInitializerError(ex);

        }

        unmarshaller = new ThreadLocal<Unmarshaller>() {

            protected synchronized Unmarshaller initialValue() {

                try {

                    return jaxbContext.createUnmarshaller();

                } catch(JAXBException e) {

                    throw new ExceptionInInitializerError(e);

                }

            }

        };

    }

    // Public API ------------------------------------------------------------//

    /**

     * Get Report 

     *

     * The GetReport operation returns the contents of a report. Reports can potentially be

     * very large (>100MB) which is why we only return one report at a time, and in a

     * streaming fashion.

     *   

     * @param request

     *          GetReport Action

     * @return

     *          GetReport Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportResponse getReport(GetReportRequest request)

        throws MarketplaceWebServiceException {

        GetReportResponse response;

        try {

            response = (GetReportResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportResponse> getReportAsync(final

GetReportRequest request) {

        Future<GetReportResponse> response = asyncExecutor.submit(new Callable<GetReportResponse>() {

            public GetReportResponse call() throws MarketplaceWebServiceException {

                return getReport(request);

            }

            });

        return response;

    }

    /**

     * Get Report Schedule Count 

     *

     * returns the number of report schedules

     *   

     * @param request

     *          GetReportScheduleCount Action

     * @return

     *          GetReportScheduleCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportScheduleCountResponse getReportScheduleCount(GetReportScheduleCountRequest request)

        throws MarketplaceWebServiceException {

        GetReportScheduleCountResponse response;

        try {

            response = (GetReportScheduleCountResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportScheduleCountResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportScheduleCountResponse> getReportScheduleCountAsync(final

GetReportScheduleCountRequest request) {

        Future<GetReportScheduleCountResponse> response = asyncExecutor.submit(new Callable<GetReportScheduleCountResponse>() {

            public GetReportScheduleCountResponse call() throws MarketplaceWebServiceException {

                return getReportScheduleCount(request);

            }

            });

        return response;

    }

    /**

     * Get Report Request List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     *   

     * @param request

     *          GetReportRequestListByNextToken Action

     * @return

     *          GetReportRequestListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportRequestListByNextTokenResponse getReportRequestListByNextToken(GetReportRequestListByNextTokenRequest request)

        throws MarketplaceWebServiceException {

        GetReportRequestListByNextTokenResponse response;

        try {

            response = (GetReportRequestListByNextTokenResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportRequestListByNextTokenResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportRequestListByNextTokenResponse> getReportRequestListByNextTokenAsync(final

GetReportRequestListByNextTokenRequest request) {

        Future<GetReportRequestListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetReportRequestListByNextTokenResponse>() {

            public GetReportRequestListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getReportRequestListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Update Report Acknowledgements 

     *

     * The UpdateReportAcknowledgements operation updates the acknowledged status of one or more reports.

     *   

     * @param request

     *          UpdateReportAcknowledgements Action

     * @return

     *          UpdateReportAcknowledgements Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public UpdateReportAcknowledgementsResponse updateReportAcknowledgements(UpdateReportAcknowledgementsRequest request)

        throws MarketplaceWebServiceException {

        UpdateReportAcknowledgementsResponse response;

        try {

            response = (UpdateReportAcknowledgementsResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("UpdateReportAcknowledgementsResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<UpdateReportAcknowledgementsResponse> updateReportAcknowledgementsAsync(final

UpdateReportAcknowledgementsRequest request) {

        Future<UpdateReportAcknowledgementsResponse> response = asyncExecutor.submit(new Callable<UpdateReportAcknowledgementsResponse>() {

            public UpdateReportAcknowledgementsResponse call() throws MarketplaceWebServiceException {

                return updateReportAcknowledgements(request);

            }

            });

        return response;

    }

    /**

     * Submit Feed 

     *

     * Uploads a file for processing together with the necessary

     * metadata to process the file, such as which type of feed it is.

     * PurgeAndReplace if true means that your existing e.g. inventory is

     * wiped out and replace with the contents of this feed - use with

     * caution (the default is false).

     *   

     * @param request

     *          SubmitFeed Action

     * @return

     *          SubmitFeed Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public SubmitFeedResponse submitFeed(SubmitFeedRequest request)

        throws MarketplaceWebServiceException {

        SubmitFeedResponse response;

        try {

            response = (SubmitFeedResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("SubmitFeedResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<SubmitFeedResponse> submitFeedAsync(final

SubmitFeedRequest request) {

        Future<SubmitFeedResponse> response = asyncExecutor.submit(new Callable<SubmitFeedResponse>() {

            public SubmitFeedResponse call() throws MarketplaceWebServiceException {

                return submitFeed(request);

            }

            });

        return response;

    }

    /**

     * Submit Feed From File

     *

     * Uploads a file from disk for processing together with the necessary

     * metadata to process the file, such as which type of feed it is.

     * PurgeAndReplace if true means that your existing e.g. inventory is

     * wiped out and replace with the contents of this feed - use with

     * caution (the default is false).

     * 

     * This function assumes the Content MD5 value is unset in the request, and will

     * set it before making the Submit Feed request. The Feed Content must be stored

     * on disk, as the assumption is that the content is accessed through

     * a FileInputStream.

     * 

     * @param request

     *          SubmitFeedRequest request without the contentMd5 field set.

     * @return

     *          SubmitFeed Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public SubmitFeedResponse submitFeedFromFile(SubmitFeedRequest request)

        throws MarketplaceWebServiceException {

        SubmitFeedResponse response;

        try {

            response = (SubmitFeedResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("SubmitFeedResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<SubmitFeedResponse> submitFeedFromFileAsync(final

SubmitFeedRequest request) {

        Future<SubmitFeedResponse> response = asyncExecutor.submit(new Callable<SubmitFeedResponse>() {

            public SubmitFeedResponse call() throws MarketplaceWebServiceException {

                return submitFeed(request);

            }

            });

        return response;

    }

    /**

     * Get Report Count 

     *

     * returns a count of reports matching your criteria;

     * by default, the number of reports generated in the last 90 days,

     * regardless of acknowledgement status

     *   

     * @param request

     *          GetReportCount Action

     * @return

     *          GetReportCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportCountResponse getReportCount(GetReportCountRequest request)

        throws MarketplaceWebServiceException {

        GetReportCountResponse response;

        try {

            response = (GetReportCountResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportCountResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportCountResponse> getReportCountAsync(final

GetReportCountRequest request) {

        Future<GetReportCountResponse> response = asyncExecutor.submit(new Callable<GetReportCountResponse>() {

            public GetReportCountResponse call() throws MarketplaceWebServiceException {

                return getReportCount(request);

            }

            });

        return response;

    }

    /**

     * Get Feed Submission List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     *   

     * @param request

     *          GetFeedSubmissionListByNextToken Action

     * @return

     *          GetFeedSubmissionListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetFeedSubmissionListByNextTokenResponse getFeedSubmissionListByNextToken(GetFeedSubmissionListByNextTokenRequest request)

        throws MarketplaceWebServiceException {

        GetFeedSubmissionListByNextTokenResponse response;

        try {

            response = (GetFeedSubmissionListByNextTokenResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetFeedSubmissionListByNextTokenResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetFeedSubmissionListByNextTokenResponse> getFeedSubmissionListByNextTokenAsync(final

GetFeedSubmissionListByNextTokenRequest request) {

        Future<GetFeedSubmissionListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetFeedSubmissionListByNextTokenResponse>() {

            public GetFeedSubmissionListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getFeedSubmissionListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Cancel Feed Submissions 

     *

     * cancels feed submissions - by default all of the submissions of the

     * last 30 days that have not started processing

     *   

     * @param request

     *          CancelFeedSubmissions Action

     * @return

     *          CancelFeedSubmissions Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public CancelFeedSubmissionsResponse cancelFeedSubmissions(CancelFeedSubmissionsRequest request)

        throws MarketplaceWebServiceException {

        CancelFeedSubmissionsResponse response;

        try {

            response = (CancelFeedSubmissionsResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("CancelFeedSubmissionsResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<CancelFeedSubmissionsResponse> cancelFeedSubmissionsAsync(final

CancelFeedSubmissionsRequest request) {

        Future<CancelFeedSubmissionsResponse> response = asyncExecutor.submit(new Callable<CancelFeedSubmissionsResponse>() {

            public CancelFeedSubmissionsResponse call() throws MarketplaceWebServiceException {

                return cancelFeedSubmissions(request);

            }

            });

        return response;

    }

    /**

     * Request Report 

     *

     * requests the generation of a report

     *   

     * @param request

     *          RequestReport Action

     * @return

     *          RequestReport Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public RequestReportResponse requestReport(RequestReportRequest request)

        throws MarketplaceWebServiceException {

        RequestReportResponse response;

        try {

            response = (RequestReportResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("RequestReportResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<RequestReportResponse> requestReportAsync(final

RequestReportRequest request) {

        Future<RequestReportResponse> response = asyncExecutor.submit(new Callable<RequestReportResponse>() {

            public RequestReportResponse call() throws MarketplaceWebServiceException {

                return requestReport(request);

            }

            });

        return response;

    }

    /**

     * Get Feed Submission Count 

     *

     * returns the number of feeds matching all of the specified criteria

     *   

     * @param request

     *          GetFeedSubmissionCount Action

     * @return

     *          GetFeedSubmissionCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetFeedSubmissionCountResponse getFeedSubmissionCount(GetFeedSubmissionCountRequest request)

        throws MarketplaceWebServiceException {

        GetFeedSubmissionCountResponse response;

        try {

            response = (GetFeedSubmissionCountResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetFeedSubmissionCountResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetFeedSubmissionCountResponse> getFeedSubmissionCountAsync(final

GetFeedSubmissionCountRequest request) {

        Future<GetFeedSubmissionCountResponse> response = asyncExecutor.submit(new Callable<GetFeedSubmissionCountResponse>() {

            public GetFeedSubmissionCountResponse call() throws MarketplaceWebServiceException {

                return getFeedSubmissionCount(request);

            }

            });

        return response;

    }

    /**

     * Cancel Report Requests 

     *

     * cancels report requests that have not yet started processing,

     * by default all those within the last 90 days

     *   

     * @param request

     *          CancelReportRequests Action

     * @return

     *          CancelReportRequests Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public CancelReportRequestsResponse cancelReportRequests(CancelReportRequestsRequest request)

        throws MarketplaceWebServiceException {

        CancelReportRequestsResponse response;

        try {

            response = (CancelReportRequestsResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("CancelReportRequestsResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<CancelReportRequestsResponse> cancelReportRequestsAsync(final

CancelReportRequestsRequest request) {

        Future<CancelReportRequestsResponse> response = asyncExecutor.submit(new Callable<CancelReportRequestsResponse>() {

            public CancelReportRequestsResponse call() throws MarketplaceWebServiceException {

                return cancelReportRequests(request);

            }

            });

        return response;

    }

    /**

     * Get Report List 

     *

     * returns a list of reports; by default the most recent ten reports,

     * regardless of their acknowledgement status

     *   

     * @param request

     *          GetReportList Action

     * @return

     *          GetReportList Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportListResponse getReportList(GetReportListRequest request)

        throws MarketplaceWebServiceException {

        GetReportListResponse response;

        try {

            response = (GetReportListResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportListResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportListResponse> getReportListAsync(final

GetReportListRequest request) {

        Future<GetReportListResponse> response = asyncExecutor.submit(new Callable<GetReportListResponse>() {

            public GetReportListResponse call() throws MarketplaceWebServiceException {

                return getReportList(request);

            }

            });

        return response;

    }

    /**

     * Get Feed Submission Result 

     *

     * retrieves the feed processing report

     *   

     * @param request

     *          GetFeedSubmissionResult Action

     * @return

     *          GetFeedSubmissionResult Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetFeedSubmissionResultResponse getFeedSubmissionResult(GetFeedSubmissionResultRequest request)

        throws MarketplaceWebServiceException {

        GetFeedSubmissionResultResponse response;

        try {

            response = (GetFeedSubmissionResultResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetFeedSubmissionResultResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetFeedSubmissionResultResponse> getFeedSubmissionResultAsync(final

GetFeedSubmissionResultRequest request) {

        Future<GetFeedSubmissionResultResponse> response = asyncExecutor.submit(new Callable<GetFeedSubmissionResultResponse>() {

            public GetFeedSubmissionResultResponse call() throws MarketplaceWebServiceException {

                return getFeedSubmissionResult(request);

            }

            });

        return response;

    }

    /**

     * Get Feed Submission List 

     *

     * returns a list of feed submission identifiers and their associated metadata

     *   

     * @param request

     *          GetFeedSubmissionList Action

     * @return

     *          GetFeedSubmissionList Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetFeedSubmissionListResponse getFeedSubmissionList(GetFeedSubmissionListRequest request)

        throws MarketplaceWebServiceException {

        GetFeedSubmissionListResponse response;

        try {

            response = (GetFeedSubmissionListResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetFeedSubmissionListResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetFeedSubmissionListResponse> getFeedSubmissionListAsync(final

GetFeedSubmissionListRequest request) {

        Future<GetFeedSubmissionListResponse> response = asyncExecutor.submit(new Callable<GetFeedSubmissionListResponse>() {

            public GetFeedSubmissionListResponse call() throws MarketplaceWebServiceException {

                return getFeedSubmissionList(request);

            }

            });

        return response;

    }

    /**

     * Get Report Request List 

     *

     * returns a list of report requests ids and their associated metadata

     *   

     * @param request

     *          GetReportRequestList Action

     * @return

     *          GetReportRequestList Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportRequestListResponse getReportRequestList(GetReportRequestListRequest request)

        throws MarketplaceWebServiceException {

        GetReportRequestListResponse response;

        try {

            response = (GetReportRequestListResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportRequestListResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportRequestListResponse> getReportRequestListAsync(final

GetReportRequestListRequest request) {

        Future<GetReportRequestListResponse> response = asyncExecutor.submit(new Callable<GetReportRequestListResponse>() {

            public GetReportRequestListResponse call() throws MarketplaceWebServiceException {

                return getReportRequestList(request);

            }

            });

        return response;

    }

    /**

     * Get Report Schedule List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     *   

     * @param request

     *          GetReportScheduleListByNextToken Action

     * @return

     *          GetReportScheduleListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportScheduleListByNextTokenResponse getReportScheduleListByNextToken(GetReportScheduleListByNextTokenRequest request)

        throws MarketplaceWebServiceException {

        GetReportScheduleListByNextTokenResponse response;

        try {

            response = (GetReportScheduleListByNextTokenResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportScheduleListByNextTokenResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportScheduleListByNextTokenResponse> getReportScheduleListByNextTokenAsync(final

GetReportScheduleListByNextTokenRequest request) {

        Future<GetReportScheduleListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetReportScheduleListByNextTokenResponse>() {

            public GetReportScheduleListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getReportScheduleListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Get Report List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     *   

     * @param request

     *          GetReportListByNextToken Action

     * @return

     *          GetReportListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportListByNextTokenResponse getReportListByNextToken(GetReportListByNextTokenRequest request)

        throws MarketplaceWebServiceException {

        GetReportListByNextTokenResponse response;

        try {

            response = (GetReportListByNextTokenResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportListByNextTokenResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportListByNextTokenResponse> getReportListByNextTokenAsync(final

GetReportListByNextTokenRequest request) {

        Future<GetReportListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetReportListByNextTokenResponse>() {

            public GetReportListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getReportListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Manage Report Schedule 

     *

     * Creates, updates, or deletes a report schedule

     * for a given report type, such as order reports in particular.

     *   

     * @param request

     *          ManageReportSchedule Action

     * @return

     *          ManageReportSchedule Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public ManageReportScheduleResponse manageReportSchedule(ManageReportScheduleRequest request)

        throws MarketplaceWebServiceException {

        ManageReportScheduleResponse response;

        try {

            response = (ManageReportScheduleResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("ManageReportScheduleResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<ManageReportScheduleResponse> manageReportScheduleAsync(final

ManageReportScheduleRequest request) {

        Future<ManageReportScheduleResponse> response = asyncExecutor.submit(new Callable<ManageReportScheduleResponse>() {

            public ManageReportScheduleResponse call() throws MarketplaceWebServiceException {

                return manageReportSchedule(request);

            }

            });

        return response;

    }

    /**

     * Get Report Request Count 

     *

     * returns a count of report requests; by default all the report

     * requests in the last 90 days

     *   

     * @param request

     *          GetReportRequestCount Action

     * @return

     *          GetReportRequestCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportRequestCountResponse getReportRequestCount(GetReportRequestCountRequest request)

        throws MarketplaceWebServiceException {

        GetReportRequestCountResponse response;

        try {

            response = (GetReportRequestCountResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportRequestCountResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportRequestCountResponse> getReportRequestCountAsync(final

GetReportRequestCountRequest request) {

        Future<GetReportRequestCountResponse> response = asyncExecutor.submit(new Callable<GetReportRequestCountResponse>() {

            public GetReportRequestCountResponse call() throws MarketplaceWebServiceException {

                return getReportRequestCount(request);

            }

            });

        return response;

    }

    /**

     * Get Report Schedule List 

     *

     * returns the list of report schedules

     *   

     * @param request

     *          GetReportScheduleList Action

     * @return

     *          GetReportScheduleList Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportScheduleListResponse getReportScheduleList(GetReportScheduleListRequest request)

        throws MarketplaceWebServiceException {

        GetReportScheduleListResponse response;

        try {

            response = (GetReportScheduleListResponse)getUnmarshaller().unmarshal

                    (new InputSource(this.getClass().getResourceAsStream("GetReportScheduleListResponse.xml")));

            log.debug("Response from Mock Service: " + response.toXML());

        } catch (JAXBException jbe) {

            throw new MarketplaceWebServiceException("Unable to process mock response", jbe);

        }

        return response;

    }

    public Future<GetReportScheduleListResponse> getReportScheduleListAsync(final

GetReportScheduleListRequest request) {

        Future<GetReportScheduleListResponse> response = asyncExecutor.submit(new Callable<GetReportScheduleListResponse>() {

            public GetReportScheduleListResponse call() throws MarketplaceWebServiceException {

                return getReportScheduleList(request);

            }

            });

        return response;

    }

    /**

     * Get unmarshaller for current thread

     */

    private Unmarshaller getUnmarshaller() {

        return unmarshaller.get();

    }

}