Subversion Repositories SmartDukaan

Rev

Rev 8021 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
7473 vikram.rag 1 
package com.amazonservices.mws.orders.samples;
2 
 
3 
import in.shop2020.feeds.products.AmazonEnvelope;
4 
import in.shop2020.feeds.products.AmazonEnvelope.Message;
5 
import in.shop2020.feeds.products.OrderAcknowledgement;
6 
import in.shop2020.feeds.products.Header;
7 
import in.shop2020.logistics.LogisticsServiceException;
8 
import in.shop2020.logistics.PickUpType;
9 
import in.shop2020.model.v1.inventory.AmazonInventorySnapshot;
10 
import in.shop2020.model.v1.order.AmazonOrdersToAcknowledge;
11 
import in.shop2020.model.v1.order.OrderSource;
12 
import in.shop2020.model.v1.order.OrderType;
13 
import in.shop2020.model.v1.order.SourceDetail;
14 
import in.shop2020.model.v1.order.TransactionServiceException;
15 
import in.shop2020.model.v1.order.TransactionStatus;
16 
import in.shop2020.model.v1.user.User;
17 
import in.shop2020.model.v1.user.UserContextException;
18 
import in.shop2020.payments.PaymentException;
19 
import in.shop2020.payments.PaymentStatus;
20 
import in.shop2020.thrift.clients.InventoryClient;
21 
import in.shop2020.thrift.clients.PaymentClient;
22 
import in.shop2020.thrift.clients.TransactionClient;
23 
import in.shop2020.thrift.clients.UserClient;
24 
import in.shop2020.utils.GmailUtils;
25 
 
26 
import java.io.File;
27 
import java.io.FileInputStream;
28 
import java.io.FileNotFoundException;
29 
import java.io.IOException;
30 
import java.math.BigInteger;
31 
import java.security.DigestInputStream;
32 
import java.security.MessageDigest;
33 
import java.security.NoSuchAlgorithmException;
34 
import java.util.ArrayList;
35 
import java.util.Arrays;
36 
import java.util.GregorianCalendar;
37 
import java.util.HashMap;
38 
import java.util.List;
39 
import java.util.Map;
40 
import java.util.Random;
41 
 
42 
import com.amazonaws.mws.model.SubmitFeedRequest;
43 
import javax.xml.bind.JAXBContext;
44 
import javax.xml.bind.JAXBException;
45 
import javax.xml.bind.Marshaller;
46 
import javax.xml.datatype.DatatypeConfigurationException;
47 
import javax.xml.datatype.DatatypeFactory;
48 
import javax.xml.datatype.XMLGregorianCalendar;
49 
import javax.xml.transform.Result;
50 
 
51 
import org.apache.http.HttpStatus;
52 
import org.apache.thrift.TException;
53 
import org.apache.thrift.transport.TTransportException;
54 
import org.apache.commons.codec.binary.Base64;
55 
import org.apache.commons.logging.Log;
56 
import org.apache.commons.logging.LogFactory;
57 
import com.amazonaws.mws.MarketplaceWebService;
58 
import com.amazonaws.mws.MarketplaceWebServiceClient;
59 
import com.amazonaws.mws.MarketplaceWebServiceConfig;
60 
import com.amazonaws.mws.MarketplaceWebServiceException;
61 
import com.amazonaws.mws.model.FeedSubmissionInfo;
62 
import com.amazonaws.mws.model.IdList;
63 
import com.amazonaws.mws.model.ResponseMetadata;
64 
import com.amazonaws.mws.model.SubmitFeedRequest;
65 
import com.amazonaws.mws.model.SubmitFeedResponse;
66 
import com.amazonaws.mws.model.SubmitFeedResult;
67 
import com.amazonservices.mws.orders.MarketplaceWebServiceOrders;
68 
import com.amazonservices.mws.orders.MarketplaceWebServiceOrdersClient;
69 
import com.amazonservices.mws.orders.MarketplaceWebServiceOrdersException;
70 
import com.amazonservices.mws.orders.model.FulfillmentChannelEnum;
71 
import com.amazonservices.mws.orders.model.ListOrderItemsByNextTokenRequest;
72 
import com.amazonservices.mws.orders.model.ListOrderItemsByNextTokenResponse;
73 
import com.amazonservices.mws.orders.model.ListOrderItemsByNextTokenResult;
74 
import com.amazonservices.mws.orders.model.ListOrderItemsRequest;
75 
import com.amazonservices.mws.orders.model.ListOrderItemsResponse;
76 
import com.amazonservices.mws.orders.model.ListOrderItemsResult;
77 
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenRequest;
78 
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenResponse;
79 
import com.amazonservices.mws.orders.model.ListOrdersByNextTokenResult;
80 
import com.amazonservices.mws.orders.model.ListOrdersRequest;
81 
import com.amazonservices.mws.orders.model.ListOrdersResponse;
82 
import com.amazonservices.mws.orders.model.ListOrdersResult;
83 
import com.amazonservices.mws.orders.model.MarketplaceIdList;
84 
import com.amazonservices.mws.orders.model.Order;
85 
import com.amazonservices.mws.orders.model.OrderItem;
86 
import com.amazonservices.mws.orders.model.OrderStatusEnum;
87 
import com.amazonservices.mws.orders.model.OrderStatusList;
88 
 
89 
/**
90 
 * This sample illustrates continuous order updates retrieval. It contains a
91 
 * order updates fetcher job that fetches updates every 15 minutes.
92 
 */
93 
 
94 
public class FetchOrderUpdatesJob {
95 
 
96 
	/*
97 
	 * Add required parameters in OrdersConfig.java before trying out this
98 
	 * sample.
99 
	 */
100 
 
101 
	public static final Log log = LogFactory.getLog(OrderFetcherSample.class);
7531 vikram.rag 102 
	//private volatile boolean keepRunning = true;
103 
	private boolean keepRunning = true;
7473 vikram.rag 104 
	/*************************************
105 
	 * Throttling Limits in Milliseconds *
106 
	 *************************************/
107 
	// 1 call per 10 mins
108 
	static final long LIST_ORDERS_THROTTLE_LIMIT = 600000L;
109 
	// 1 call per 12 secs
110 
	static final long LIST_ORDER_ITEMS_THROTTLE_LIMIT = 12000L;
111 
 
112 
	final public static String AMAZON_ORDER_ACKNOWLEDGEMENT_XML = "/home/vikram/OrderAcknowledgeMent.xml";
113 
 
7531 vikram.rag 114 
	static final int INTERVAL_IN_MINS = 30; // 1-minute update interval
7473 vikram.rag 115 
 
116 
	//static final int INTERVAL_IN_MINS = 15; // 15-minute update interval
117 
 
118 
	protected MarketplaceWebServiceOrders service;
119 
	protected String sellerId = null;
120 
	protected MarketplaceIdList marketplaceIdList = null;
121 
	private File file;
122 
 
123 
	public FetchOrderUpdatesJob(
124 
			MarketplaceWebServiceOrders marketplaceWebServiceOrdersClient,
125 
			String sellerId, MarketplaceIdList marketplaceIdList) {
126 
		if (marketplaceWebServiceOrdersClient == null) {
127 
			throw new IllegalArgumentException(
128 
			"MarketplaceWebServiceOrders object cannot be null.");
129 
		}
130 
		this.service = marketplaceWebServiceOrdersClient;
131 
		this.sellerId = sellerId;
132 
		this.marketplaceIdList = marketplaceIdList;
133 
	}
134 
 
135 
	public static void main(String... args) {
136 
		MarketplaceWebServiceOrders client = new MarketplaceWebServiceOrdersClient(
137 
				OrdersConfig.accessKeyId,
138 
				OrdersConfig.secretAccessKey,
139 
				OrdersConfig.applicationName,
140 
				OrdersConfig.applicationVersion,
141 
				OrdersConfig.config);
142 
		final FetchOrderUpdatesJob orderFetcher = new FetchOrderUpdatesJob(
143 
				client, OrdersConfig.sellerId,
144 
				OrdersConfig.marketplaceIdList);
145 
 
7531 vikram.rag 146 
		/*	Thread fetchOrderUpdatesJobThread = new Thread(new Runnable() {
7473 vikram.rag 147 
			public void run() {
148 
				orderFetcher.startPeriodicSynch();
149 
			}
150 
		});
151 
 
7512 vikram.rag 152 
		// Start the FetchOrderUpdatesJobandAcknowledge in the second thread.
7473 vikram.rag 153 
		fetchOrderUpdatesJobThread.start();
154 
 
155 
		/*
156 
		 * The following code puts this thread to sleep for an hour and then the
157 
		 * stopSynch() method is called which stops the job in the second
158 
		 * thread.
159 
		 */
160 
 
161 
		/*
7531 vikram.rag 162 
		 *
7473 vikram.rag 163 
		 * for some other length of time .
164 
		 */
165 
		try {
7531 vikram.rag 166 
			orderFetcher.startPeriodicSynch();
167 
			//log.info("Main thread sleeping.");
168 
			//Thread.sleep(3600000L); // = 1 hour
169 
			//log.info("Main thread awake.");
7535 kshitij.so 170 
		} catch (Exception e) {
7473 vikram.rag 171 
			log.error(e.getMessage(), e);
7535 kshitij.so 172 
			return;
7473 vikram.rag 173 
		}
174 
 
7531 vikram.rag 175 
		//log.info("Main thread setting keepRunning to false.");
176 
		//orderFetcher.stopSynch(); // Stops the FetchOrderUpdatesJobandAcknowledge thread.
7473 vikram.rag 177 
 
178 
		// Join the two threads and wait for the fetchOrderUpdatesJobThread to
179 
		// finish.
7531 vikram.rag 180 
 
181 
		/*	try {
7473 vikram.rag 182 
			fetchOrderUpdatesJobThread.join();
183 
		} catch (InterruptedException e) {
184 
			log.error(e.getMessage(), e);
185 
			return;
7531 vikram.rag 186 
		}*/
7473 vikram.rag 187 
	}
188 
 
189 
	/**
190 
	 * Call this method to start this job. Note that the job will run until the
191 
	 * keepRunning flag is set to false.
192 
	 */
193 
	public void startPeriodicSynch() {
194 
 
195 
		DatatypeFactory df = null;
196 
		try {
197 
			df = DatatypeFactory.newInstance();
198 
		} catch (DatatypeConfigurationException e) {
199 
			log.error(e.getMessage(), e);
200 
		}
7535 kshitij.so 201 
		TransactionClient tcl=null;
202 
		long time=0;
7538 vikram.rag 203 
		try {
204 
			tcl = new TransactionClient();
205 
			time = tcl.getClient().getSourceDetail(3).getLastUpdatedOn();
206 
		} catch (TException e) {
207 
			// TODO Auto-generated catch block
208 
			e.printStackTrace();
209 
		}
7535 kshitij.so 210 
 
7538 vikram.rag 211 
 
7535 kshitij.so 212 
		GregorianCalendar Time = new GregorianCalendar();
213 
		Time.setTimeInMillis(time);
214 
		XMLGregorianCalendar startTime = df.newXMLGregorianCalendar(Time);
7473 vikram.rag 215 
		// endTime = now -2. So, startTime = now - 2 - INTERVAL_IN_MINS.
216 
		System.out.println("Sync job start time." + startTime.getDay() +"-"+ startTime.getMonth()+"-" + startTime.getHour()+":"+startTime.getMinute());
217 
 
7535 kshitij.so 218 
 
7531 vikram.rag 219 
		//startTime.add(df.newDurationDayTime(false, 0, 0, INTERVAL_IN_MINS ,	0));
220 
		//System.out.println("Sync job start time after add .." + startTime.getDay() +"-"+ startTime.getMonth()+"-" + startTime.getHour()+":"+startTime.getMinute());
7473 vikram.rag 221 
		/*
222 
		 * This loop keeps running until the stopSynch() method is called.
223 
		 * stopSynch() sets keepRunning to false.
224 
		 */
225 
		System.out.println("Sync job starting.");
226 
		log.info("Sync job starting.");
227 
		while (keepRunning) {
228 
			// Subtract 2 minutes because endTime returned from server = now - 2
229 
			// mins.
230 
			long timeWaited = System.currentTimeMillis()
231 
			- startTime.toGregorianCalendar().getTimeInMillis()
232 
			- 120000;
233 
 
234 
			System.out.println("Time waited : " + timeWaited/60000 + "Minutes");
235 
			/*
236 
			 * If the timeWaited is greater than 30 times the interval, we exit
237 
			 * from the loop as the job is lagging far behind in getting new
238 
			 * orders.
239 
			 */
240 
			//if (timeWaited > 24 * 4 * INTERVAL_IN_MINS * 60L * 1000L) {
241 
			if (timeWaited > 100000 * 60L * 1000L) {
242 
				keepRunning = false;
243 
				System.out.println("Setting keep running to false");
7531 vikram.rag 244 
				log.info("timeWaited is greater than 30 times the interval. This a too large a time interval for which to fetch orders.");
7473 vikram.rag 245 
			}
246 
			/*
247 
			 * If the time lapsed is greater than or equal to 15 mins, we will
248 
			 * try to fetchOrderUpdates giving it a startTime.
249 
			 */
250 
			else if (timeWaited >= INTERVAL_IN_MINS * 60L * 1000L) {
251 
				log.info("Time to fetch new order updates.");
7538 vikram.rag 252 
 
7473 vikram.rag 253 
				XMLGregorianCalendar endTime = fetchOrderUpdatesSince(startTime);
254 
				//System.out.println("End Time is : " + endTime.getDay() +"-"+ endTime.getMonth()+"-" + endTime.getHour()+":"+endTime.getMinute());
7512 vikram.rag 255 
				//createandsubmitOrderAcknowlegementFeed();
7473 vikram.rag 256 
				if (endTime != null) {
257 
					startTime = endTime;
7538 vikram.rag 258 
 
7535 kshitij.so 259 
					try {
7538 vikram.rag 260 
						tcl.getClient().updateSourceDetailTimestamp(3,endTime.toGregorianCalendar().getTimeInMillis());
7535 kshitij.so 261 
					} catch (TException e) {
262 
						// TODO Auto-generated catch block
263 
						e.printStackTrace();
264 
					}
7538 vikram.rag 265 
				} else {
7473 vikram.rag 266 
					log.info("endTime returned is null. Sleeping for "
267 
							+ INTERVAL_IN_MINS + " minutes.");
268 
					try {
269 
						Thread.sleep(INTERVAL_IN_MINS * 60L * 1000L);
270 
					} catch (InterruptedException e) {
271 
						log.error(e.getMessage(), e);
272 
						stopSynch();
273 
						break;
274 
					}
275 
				}
276 
			} else {
277 
				try {
278 
					long timeToSleepInMilliseconds = INTERVAL_IN_MINS * 60000L
279 
					- timeWaited;
280 
					log.info("Thread sleeping for "
281 
							+ Math.round(timeToSleepInMilliseconds / 60000)
282 
							+ " minutes.");
283 
					// Sleep in 1 minute intervals for timeToSleepInMilliseconds
284 
					// or until keepRunning is set to false.
285 
					for (long i = timeToSleepInMilliseconds; i > 0
286 
					&& keepRunning; i = i - 60000L) {
287 
						if (i < 60000L) {
288 
							Thread.sleep(i);
289 
						} else {
290 
							Thread.sleep(60000L);
291 
						}
292 
					}
293 
 
294 
				} catch (InterruptedException e) {
295 
					log.error(e.getMessage(), e);
296 
					stopSynch();
297 
					break;
298 
				}
299 
			}
300 
		}
301 
		log.info("Sync job ending.");
302 
	}
303 
 
304 
	/**
305 
	 * Call this method to stop execution of this job. The job will stop after
306 
	 * it has finished processing the current call (if it is in the middle of
307 
	 * processing any). For example if a listOrders call has been invoked, then
308 
	 * it will terminate the job only after the call returns with valid results.
309 
	 * If this method is called while the thread is sleeping, because a request
310 
	 * was throttled, the job will terminate after it wakes up.
311 
	 */
312 
	public void stopSynch() {
7531 vikram.rag 313 
		//keepRunning = false;
7473 vikram.rag 314 
	}
315 
 
316 
	/**
317 
	 * Gets all orders updated between the given startTime and the calculated
318 
	 * endTime. The endTime is calculated by the service as server's system
319 
	 * clock time minus 2 mins. The method returns this endTime.
320 
	 *
321 
	 */
322 
	protected XMLGregorianCalendar fetchOrderUpdatesSince(
323 
			XMLGregorianCalendar startTime) {
324 
		System.out.println("Fetching order updates since " + startTime.toString());
325 
		log.info("Fetching order updates since " + startTime.toString());
326 
		ListOrdersRequest listOrdersRequest = new ListOrdersRequest();
327 
 
328 
		listOrdersRequest.setSellerId(sellerId);
329 
		if (OrdersConfig.marketplaceIdList != null) {
330 
			listOrdersRequest
331 
			.setMarketplaceId(OrdersConfig.marketplaceIdList);
332 
		}
333 
		listOrdersRequest.setLastUpdatedAfter(startTime);
334 
		OrderStatusList statusList = new OrderStatusList();
335 
		List<OrderStatusEnum> orderstatusList = new ArrayList<OrderStatusEnum>();
336 
		orderstatusList.add(OrderStatusEnum.UNSHIPPED);
337 
		orderstatusList.add(OrderStatusEnum.PARTIALLY_SHIPPED);
338 
		//orderstatusList.add(OrderStatusEnum.CANCELED);
339 
 
340 
		statusList.setStatus(orderstatusList);
341 
		listOrdersRequest.setOrderStatus(statusList);
342 
		XMLGregorianCalendar lastUpdatedDate = null;
343 
 
344 
		try {
345 
			ListOrdersResult listOrdersResult = listOrders(listOrdersRequest);
346 
			if (listOrdersResult.isSetLastUpdatedBefore()) {
347 
				lastUpdatedDate = listOrdersResult.getLastUpdatedBefore();
348 
			}
349 
 
350 
			if (listOrdersResult != null && listOrdersResult.isSetNextToken()) {
351 
				ListOrdersByNextTokenRequest listOrdersByNextTokenRequest = new ListOrdersByNextTokenRequest();
352 
				listOrdersByNextTokenRequest.setSellerId(sellerId);
353 
				String nextToken = listOrdersResult.getNextToken();
354 
				ListOrdersByNextTokenResult listOrdersByNextTokenResult = null;
355 
				while (nextToken != null && keepRunning) {
356 
					listOrdersByNextTokenRequest.setNextToken(nextToken);
357 
					listOrdersByNextTokenResult = listOrdersByNextToken(listOrdersByNextTokenRequest);
358 
					nextToken = listOrdersByNextTokenResult.getNextToken();
359 
				}
360 
				if (listOrdersByNextTokenResult.isSetLastUpdatedBefore()) {
361 
					lastUpdatedDate = listOrdersByNextTokenResult
362 
					.getLastUpdatedBefore();
363 
				}
364 
			}
365 
			return lastUpdatedDate;
366 
		} catch (MarketplaceWebServiceOrdersException ex) {
367 
			log.error(ex.getMessage(), ex);
368 
			System.out.println("Caught Exception: " + ex.getMessage());
369 
			System.out.println("Response Status Code: " + ex.getStatusCode());
370 
			System.out.println("Error Code: " + ex.getErrorCode());
371 
			System.out.println("Error Type: " + ex.getErrorType());
372 
			System.out.println("Request ID: " + ex.getRequestId());
373 
			System.out.print("XML: " + ex.getXML());
374 
			return null;
375 
		}
376 
	}
377 
	//This method will create Order Acknowledgement FEED
378 
	public void createandsubmitOrderAcknowlegementFeed() {
379 
		TransactionClient tcl=null;
380 
		List<AmazonOrdersToAcknowledge> amazonOrdersToAcknowledge=null;
381 
		try {
382 
			tcl = new TransactionClient();
383 
			amazonOrdersToAcknowledge = tcl.getClient().getAmazonOrdersToAcknowledge();
384 
		} catch (TTransportException e2) {
385 
			// TODO Auto-generated catch block
386 
			e2.printStackTrace();
387 
		} catch (TException e) {
388 
			// TODO Auto-generated catch block
389 
			e.printStackTrace();
390 
		}
391 
		if(amazonOrdersToAcknowledge!=null && amazonOrdersToAcknowledge.size() > 0){
392 
			file = new File(AMAZON_ORDER_ACKNOWLEDGEMENT_XML);
393 
			AmazonEnvelope amazonenvelope = new AmazonEnvelope();
394 
			Header header = new Header();
395 
			header.setDocumentVersion("1.0");
396 
			header.setMerchantIdentifier("AF6E3O0VE0X4D");
397 
			header.setOverrideReleaseId(null);
398 
			amazonenvelope.setHeader(header);
399 
			amazonenvelope.setMessageType("OrderAcknowledgement");
400 
			amazonenvelope.setMarketplaceName(null);
401 
			List<Message> messages = amazonenvelope.getMessage();
402 
			Map<String,Long> amazonOrdertxnMap = new HashMap<String,Long>();
403 
			Map<String,List<String>> amazonOrderIdOrderItemMap = new HashMap<String,List<String>>();
404 
			Map<String,Integer> amazonOrderItemSuccessMap = new HashMap<String,Integer>();
405 
			Map<String,Integer> amazonOrderItemFailureMap = new HashMap<String,Integer>();
406 
			for(AmazonOrdersToAcknowledge amazonOrderToAcknowledge:amazonOrdersToAcknowledge ){
407 
				if(!amazonOrdertxnMap.containsKey(amazonOrderToAcknowledge.getAmazonOrderId())){
408 
					amazonOrdertxnMap.put(amazonOrderToAcknowledge.getAmazonOrderId(),amazonOrderToAcknowledge.getTransaction_id());
409 
				}
410 
				if(!amazonOrderIdOrderItemMap.containsKey(amazonOrderToAcknowledge.getAmazonOrderId())){
411 
					List<String> orderItemsList = new ArrayList<String>();
412 
					orderItemsList.add(amazonOrderToAcknowledge.getAmazonOrderItemId());
413 
					amazonOrderIdOrderItemMap.put(amazonOrderToAcknowledge.getAmazonOrderId(),orderItemsList);
414 
				}
415 
				else{
416 
					if(!amazonOrderIdOrderItemMap.get(amazonOrderToAcknowledge.getAmazonOrderId()).contains(amazonOrderToAcknowledge.getAmazonOrderItemId()))
417 
						amazonOrderIdOrderItemMap.get(amazonOrderToAcknowledge.getAmazonOrderId()).add(amazonOrderToAcknowledge.getAmazonOrderItemId());
418 
				}
419 
				if(amazonOrderToAcknowledge.getStatus().equals("Order-Payment-Success")){
420 
					amazonOrderItemSuccessMap.put(amazonOrderToAcknowledge.getAmazonOrderId()+amazonOrderToAcknowledge.getAmazonOrderItemId(),amazonOrderToAcknowledge.getCount());
421 
				}
422 
				if(amazonOrderToAcknowledge.getStatus().equals("Order-Payment-Failure")){
423 
					amazonOrderItemFailureMap.put(amazonOrderToAcknowledge.getAmazonOrderId()+amazonOrderToAcknowledge.getAmazonOrderItemId(),amazonOrderToAcknowledge.getCount());
424 
				}
425 
			}
426 
			JAXBContext context;
427 
			Marshaller m=null;
428 
			try {
429 
				context = JAXBContext.newInstance(AmazonEnvelope.class);
430 
				m = context.createMarshaller();
431 
			} catch (JAXBException e1) {
432 
				// TODO Auto-generated catch block
433 
				e1.printStackTrace();
434 
			}
435 
 
436 
			for (Map.Entry<String,List<String>> entry : amazonOrderIdOrderItemMap.entrySet()){
437 
				OrderAcknowledgement orderAcknowLedgement = new OrderAcknowledgement();
438 
				List<OrderAcknowledgement.Item> acknowledgementItems = orderAcknowLedgement.getItem();
439 
				String orderid = entry.getKey();
440 
				orderAcknowLedgement.setAmazonOrderID(orderid);
441 
				orderAcknowLedgement.setMerchantOrderID(amazonOrdertxnMap.get(orderid).toString());
442 
				orderAcknowLedgement.setStatusCode("Failure");
443 
				for(String orderItemId :entry.getValue()){
444 
					OrderAcknowledgement.Item orderAcknowledgementItem = new OrderAcknowledgement.Item();
445 
					if(amazonOrderItemSuccessMap.get(orderid+orderItemId)!=null && amazonOrderItemSuccessMap.get(orderid+orderItemId) > 0){
446 
						orderAcknowledgementItem.setAmazonOrderItemCode(orderItemId);
447 
						orderAcknowLedgement.setStatusCode("Success");
448 
					}
449 
					else{
450 
						orderAcknowledgementItem.setAmazonOrderItemCode(orderItemId);
451 
						orderAcknowledgementItem.setCancelReason("ShippingAddressUndeliverable");
452 
					}
453 
					acknowledgementItems.add(orderAcknowledgementItem);
454 
 
455 
				}
456 
				AmazonEnvelope.Message message = new AmazonEnvelope.Message();
457 
				Random rand = new Random();
458 
				message.setMessageID(BigInteger.valueOf(Math.abs(rand.nextInt())));
459 
				message.setOrderAcknowledgement(orderAcknowLedgement);
460 
				messages.add(message);
461 
			}
462 
 
463 
			System.out.println("Messages is " + messages);
464 
			try {
465 
				m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
466 
				m.marshal(amazonenvelope, file);
467 
				m.marshal(amazonenvelope, System.out);
468 
 
469 
			} catch (Exception e) {
470 
				// TODO Auto-generated catch block
471 
				e.printStackTrace();
472 
 
473 
			}
474 
			if(submitAcknowledgementFeed()==0);
475 
			//if(true)
476 
			{
477 
				for (Map.Entry<String,Long> entry : amazonOrdertxnMap.entrySet()){
478 
					try {
479 
						tcl.getClient().changeAmazonOrderStatus(entry.getKey(),"Acknowledgement-Sent");
480 
					} catch (TException e) {
481 
						// TODO Auto-generated catch block
482 
						e.printStackTrace();
483 
					}
484 
 
485 
				}
486 
			}
487 
//			GmailUtils  gm = GmailUtils();
488 
//			gm.sendSSLMessage(arg0, arg1, arg2, arg3, arg4, arg5)
489 
		}
490 
 
491 
 
492 
	}
493 
 
494 
	/*
495 
	 * listOrders call. If a request is throttled, this method calls the
496 
	 * throttling handler and sets the retry flag to true.
497 
	 */
498 
	protected ListOrdersResult listOrders(ListOrdersRequest request)
499 
	throws MarketplaceWebServiceOrdersException {
500 
		boolean retry;
501 
		ListOrdersResponse listOrdersResponse = null;
502 
		ListOrdersResult listOrdersResult = null;
503 
		do {
504 
			retry = false;
505 
			try {
506 
				System.out.println("Calling ListOrders.");
507 
				log.info("Calling ListOrders.");
508 
				listOrdersResponse = service.listOrders(request);
509 
			} catch (MarketplaceWebServiceOrdersException ex) {
510 
				if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
511 
						&& "RequestThrottled".equals(ex.getErrorCode())) {
512 
					retry = true;
513 
					requestThrottledExceptionHandler(LIST_ORDERS_THROTTLE_LIMIT);
514 
				} else {
515 
					throw ex;
516 
				}
517 
			}
518 
			if (listOrdersResponse != null
519 
					&& listOrdersResponse.isSetListOrdersResult()) {
520 
				listOrdersResult = listOrdersResponse.getListOrdersResult();
521 
				if (listOrdersResult.isSetOrders()
522 
						&& listOrdersResult.getOrders().isSetOrder()) {
523 
					processOrderUpdates(listOrdersResult.getOrders().getOrder());
524 
				}
525 
			}
526 
		} while (retry && keepRunning);
527 
		return listOrdersResult;
528 
	}
529 
 
530 
	/*
531 
	 * listOrdersByNextToken call. If a request is throttled, this method calls
532 
	 * the throttling handler and sets the retry flag to true.
533 
	 */
534 
	protected ListOrdersByNextTokenResult listOrdersByNextToken(
535 
			ListOrdersByNextTokenRequest listOrdersByNextTokenRequest)
536 
	throws MarketplaceWebServiceOrdersException {
537 
		boolean retry;
538 
		ListOrdersByNextTokenResponse listOrdersByNextTokenResponse = null;
539 
		ListOrdersByNextTokenResult listOrdersByNextTokenResult = null;
540 
		do {
541 
			retry = false;
542 
			try {
543 
				log.info("Calling ListOrdersByNextToken.");
544 
				listOrdersByNextTokenResponse = service
545 
				.listOrdersByNextToken(listOrdersByNextTokenRequest);
546 
			} catch (MarketplaceWebServiceOrdersException ex) {
547 
				if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
548 
						&& "RequestThrottled".equals(ex.getErrorCode())) {
549 
					retry = true;
550 
					requestThrottledExceptionHandler(LIST_ORDERS_THROTTLE_LIMIT);
551 
				} else {
552 
					throw ex;
553 
				}
554 
			}
555 
			if (listOrdersByNextTokenResponse != null
556 
					&& listOrdersByNextTokenResponse
557 
					.isSetListOrdersByNextTokenResult()) {
558 
				listOrdersByNextTokenResult = listOrdersByNextTokenResponse
559 
				.getListOrdersByNextTokenResult();
560 
				if (listOrdersByNextTokenResult.isSetOrders()
561 
						&& listOrdersByNextTokenResult.getOrders().isSetOrder()) {
562 
					processOrderUpdates(listOrdersByNextTokenResult.getOrders()
563 
							.getOrder());
564 
				}
565 
			}
566 
		} while (retry && keepRunning);
567 
		return listOrdersByNextTokenResult;
568 
	}
569 
 
570 
	/**
571 
	 * This method is called to process updates on each of the orders that are
572 
	 * returned by the ListOrders and ListOrdersByNextToken calls.
573 
	 */
574 
	protected void processOrderUpdates(List<Order> orders)
575 
	throws MarketplaceWebServiceOrdersException {
576 
		ListOrderItemsResult listOrderItemsResult;
577 
		log.info("Processing order updates.");
578 
		for (Order order : orders) {
579 
			if (shouldFetchOrderItems(order)) {
580 
				log.info("Order being processed: " + order.getAmazonOrderId());
581 
				listOrderItemsResult = listOrderItems(order);
582 
				if (listOrderItemsResult != null
583 
						&& listOrderItemsResult.isSetNextToken()) {
584 
					ListOrderItemsByNextTokenRequest listOrderItemsByNextTokenRequest = new ListOrderItemsByNextTokenRequest();
585 
					listOrderItemsByNextTokenRequest
586 
					.setSellerId(OrdersConfig.sellerId);
587 
					String nextToken = listOrderItemsResult.getNextToken();
588 
 
589 
					ListOrderItemsByNextTokenResult listOrderItemsByNextTokenResult = null;
590 
 
591 
					while (nextToken != null && keepRunning) {
592 
						listOrderItemsByNextTokenRequest
593 
						.setNextToken(nextToken);
594 
						listOrderItemsByNextTokenResult = listOrderItemsByNextToken(
595 
								listOrderItemsByNextTokenRequest, order);
596 
						nextToken = listOrderItemsByNextTokenResult
597 
						.getNextToken();
598 
					}
599 
				}
600 
			}
601 
		}
602 
	}
603 
 
604 
	/*
605 
	 * listOrderItems call. If a request is throttled, this method calls the
606 
	 * throttling handler and sets the retry flag to true.
607 
	 */
608 
	protected ListOrderItemsResult listOrderItems(Order order)
609 
	throws MarketplaceWebServiceOrdersException {
610 
		System.out.println("Calling ListOrderItems.");
611 
		log.info("Calling ListOrderItems.");
612 
		boolean retry;
613 
		List<OrderItem> items;
614 
		ListOrderItemsRequest listOrderItemsRequest = new ListOrderItemsRequest();
615 
		listOrderItemsRequest.setSellerId(sellerId);
616 
		listOrderItemsRequest.setAmazonOrderId(order.getAmazonOrderId());
617 
		ListOrderItemsResponse listOrderItemsResponse = null;
618 
		ListOrderItemsResult listOrderItemsResult = null;
619 
 
620 
		do {
621 
			retry = false;
622 
			try {
623 
				listOrderItemsResponse = service
624 
				.listOrderItems(listOrderItemsRequest);
625 
			} catch (MarketplaceWebServiceOrdersException ex) {
626 
				if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
627 
						&& "RequestThrottled".equals(ex.getErrorCode())) {
628 
					retry = true;
629 
					requestThrottledExceptionHandler(LIST_ORDER_ITEMS_THROTTLE_LIMIT);
630 
				} else {
631 
					throw ex;
632 
				}
633 
			}
634 
			if (listOrderItemsResponse != null
635 
					&& listOrderItemsResponse.isSetListOrderItemsResult()) {
636 
				listOrderItemsResult = listOrderItemsResponse
637 
				.getListOrderItemsResult();
638 
				if (listOrderItemsResult.isSetOrderItems()
639 
						&& listOrderItemsResult.getOrderItems()
640 
						.isSetOrderItem()) {
641 
					items = listOrderItemsResponse.getListOrderItemsResult()
642 
					.getOrderItems().getOrderItem();
643 
					processOrderItems(order, items);
644 
				}
645 
			}
646 
 
647 
		} while (retry && keepRunning);
648 
 
649 
		return listOrderItemsResult;
650 
	}
651 
 
652 
	/*
653 
	 * listOrderItemsByNextToken call. If a request is throttled, this method
654 
	 * calls the throttling handler and sets the retry flag to true.
655 
	 */
656 
	protected ListOrderItemsByNextTokenResult listOrderItemsByNextToken(
657 
			ListOrderItemsByNextTokenRequest listOrderItemsByNextTokenRequest,
658 
			Order order) throws MarketplaceWebServiceOrdersException {
659 
		log.info("Calling ListOrderItemsByNextToken.");
660 
		boolean retry;
661 
		List<OrderItem> items;
662 
		ListOrderItemsByNextTokenResponse listOrderItemsByNextTokenResponse = null;
663 
		ListOrderItemsByNextTokenResult listOrderItemsByNextTokenResult = null;
664 
 
665 
		do {
666 
			retry = false;
667 
			try {
668 
				listOrderItemsByNextTokenResponse = service
669 
				.listOrderItemsByNextToken(listOrderItemsByNextTokenRequest);
670 
			} catch (MarketplaceWebServiceOrdersException ex) {
671 
				if (ex.getStatusCode() == HttpStatus.SC_SERVICE_UNAVAILABLE
672 
						&& "RequestThrottled".equals(ex.getErrorCode())) {
673 
					retry = true;
674 
					requestThrottledExceptionHandler(LIST_ORDER_ITEMS_THROTTLE_LIMIT);
675 
				} else {
676 
					throw ex;
677 
				}
678 
			}
679 
			if (listOrderItemsByNextTokenResponse != null
680 
					&& listOrderItemsByNextTokenResponse
681 
					.isSetListOrderItemsByNextTokenResult()) {
682 
				listOrderItemsByNextTokenResult = listOrderItemsByNextTokenResponse
683 
				.getListOrderItemsByNextTokenResult();
684 
				if (listOrderItemsByNextTokenResult.isSetOrderItems()
685 
						&& listOrderItemsByNextTokenResult.getOrderItems()
686 
						.isSetOrderItem()) {
687 
					items = listOrderItemsByNextTokenResponse
688 
					.getListOrderItemsByNextTokenResult()
689 
					.getOrderItems().getOrderItem();
690 
					processOrderItems(order, items);
691 
				}
692 
			}
693 
		} while (retry && keepRunning);
694 
 
695 
		return listOrderItemsByNextTokenResult;
696 
	}
697 
 
698 
	/**
7540 vikram.rag 699 
	 * Checks if order exists in the system
700 
	 * If not then only processes the order
7473 vikram.rag 701 
	 */
702 
	protected boolean shouldFetchOrderItems(Order order) {
7540 vikram.rag 703 
		TransactionClient tcl=null;
704 
		try {
705 
			tcl = new TransactionClient();
7545 vikram.rag 706 
			List<in.shop2020.model.v1.order.AmazonOrder> amazonOrderItems = tcl.getClient().getAmazonOrderByAmazonOrderId(order.getAmazonOrderId());
7540 vikram.rag 707 
			if(amazonOrderItems.size()==0){
708 
				return true;
709 
			}
710 
			else{
711 
				return false;
712 
			}
713 
 
714 
		} catch (TException e) {
715 
			e.printStackTrace();
716 
		}
717 
		return false;
7473 vikram.rag 718 
	}
719 
 
720 
	/**
7540 vikram.rag 721 
	 *
722 
	 * Processes Order Items
7473 vikram.rag 723 
	 */
724 
	public void processOrderItems(Order order, List<OrderItem> orderItems) {
725 
		log.info("****************** Order info********************");
726 
		log.info(order.toString());
727 
		System.out.println("------------------------------------------");
728 
		System.out.println("--------Amazon Order Details START--------");
729 
		System.out.println("------------------------------------------");
730 
		System.out.println("Amazon Order ID                  :  " + order.getAmazonOrderId());
731 
		System.out.println("Buyer Email                      :  " + order.getBuyerEmail());
732 
		System.out.println("Buyer Name                       :  " + order.getBuyerName());
733 
		System.out.println("MarketPlace ID                   :  " + order.getMarketplaceId());
734 
		System.out.println("Order Channel                    :  " + order.getOrderChannel());
735 
		System.out.println("Sales Channel                    :  " + order.getSalesChannel());
736 
		System.out.println("Seller Order ID                  :  " + order.getSellerOrderId());
737 
		System.out.println("Shipment Service Level Category  :  " + order.getShipmentServiceLevelCategory());
738 
		System.out.println("Shipment Service Level           :  " + order.getShipServiceLevel());
739 
		System.out.println("TFM Shipment Status              :  " + order.getTFMShipmentStatus());
740 
		System.out.println("Number of Items Shipped          :  " + order.getNumberOfItemsShipped());
741 
		System.out.println("Number of Items UnShipped        :  " + order.getNumberOfItemsUnshipped());
742 
		System.out.println("Fulfillment Channel              :  " + order.getFulfillmentChannel());
743 
		System.out.println("Last Updated Date                :  " + order.getLastUpdateDate());
744 
		System.out.println("Order Status                     :  " + order.getOrderStatus());
745 
		//System.out.println("Order Currency code              :  " + order.getOrderTotal().getCurrencyCode());
746 
		//System.out.println("Order Amount                     :  " + order.getOrderTotal().getAmount());
747 
		System.out.println("Payment Method                   :  " + order.getPaymentMethod());
748 
		System.out.println("Payment Execution Detail         :  " + order.getPaymentExecutionDetail());
749 
		System.out.println("Purchase Date                    :  " + order.getPurchaseDate());
750 
		System.out.println("Shipping Address                 :  " + order.getShippingAddress());
751 
		System.out.println("------------------------------------------");
752 
		System.out.println("-----------Amazon Order Details END-------");
753 
		System.out.println("------------------------------------");
754 
		Map<String,String> orderItemSkuMap = new HashMap<String,String>();
755 
		if (orderItems != null && orderItems.size() > 0) {
756 
			log.info("================== Order Items info ====================");
757 
			System.out.println("================== Order Items info ====================");
758 
			int i = 0;
759 
			for (OrderItem item : orderItems) {
760 
				log.info(item.toString());
761 
				System.out.println("===================================");
762 
				System.out.println("Order Item : " + (i+1));
763 
				System.out.println("Item ASIN :  " + item.getASIN());
764 
				System.out.println("Item Gift Message Text :  " + item.getGiftMessageText());
765 
				System.out.println("Item Gift Wrap Level   :  " + item.getGiftWrapLevel());
766 
				System.out.println("Order Item ID          :  " + item.getOrderItemId());
767 
				System.out.println("Quantity Ordered       :  " + item.getQuantityOrdered());
768 
				System.out.println("Saholic Item ID        :  " + item.getSellerSKU());
769 
				System.out.println("Item Description       :  " + item.getTitle());
770 
				System.out.println("Item Quantity Shipped  :  " + item.getQuantityShipped());
771 
				System.out.println("Item Quantity Ordered  :  " + item.getQuantityOrdered());
772 
				System.out.println("COD Fees               :  " + item.getCODFee());
773 
				System.out.println("COD Fees Discount      :  " + item.getCODFeeDiscount());
774 
				System.out.println("Gift Wrap Price        :  " + item.getGiftWrapPrice());
775 
				System.out.println("Gift Wrap Text         :  " + item.getGiftWrapTax());
776 
				System.out.println("Invoice Data           :  " + item.getInvoiceData());
777 
				System.out.println("Item Price             :  " + item.getItemPrice());
778 
				System.out.println("Item Tax               :  " + item.getItemTax());
779 
				System.out.println("Promotion Discount     :  " + item.getPromotionDiscount());
780 
				System.out.println("Promotion IDs          :  " + item.getPromotionIds());
781 
				System.out.println("Shipping Discounts     :  " + item.getShippingDiscount());
782 
				System.out.println("Shipping Price         :  " + item.getShippingPrice());
783 
				System.out.println("Shipping Tax           :  " + item.getShippingTax());
784 
				System.out.println("===================================");
785 
				orderItemSkuMap.put(item.getSellerSKU(),item.getOrderItemId());
786 
				System.out.println("SKU and Order Item Code are  : " + item.getSellerSKU() + " " +item.getOrderItemId() );
787 
				i++;
788 
			}
789 
			//if(order.getFulfillmentChannel().equals(FulfillmentChannelEnum.MFN) && (order.getOrderStatus().equals(OrderStatusEnum.UNSHIPPED) || order.getOrderStatus().equals(OrderStatusEnum.CANCELED))){
790 
			//if(order.getFulfillmentChannel().equals(FulfillmentChannelEnum.MFN) && (order.getOrderStatus().equals(OrderStatusEnum.UNSHIPPED) || order.getOrderStatus().equals(OrderStatusEnum.PARTIALLY_SHIPPED))){
791 
			if(order.getFulfillmentChannel().equals(FulfillmentChannelEnum.MFN) && order.getOrderStatus().equals(OrderStatusEnum.UNSHIPPED) && order.getSellerOrderId()==null ){
8021 rajveer 792 
				String userEmail = order.getBuyerEmail();
793 
		    	User user = new User();
794 
		    	user.setCommunicationEmail(userEmail);
795 
		    	user.setEmail(userEmail);
796 
		    	user.setName(order.getBuyerName());
797 
		    	user.setMobileNumber(order.getShippingAddress().getPhone());
798 
		    	user.setPassword("amazon");
799 
		    	try {
800 
		    		UserClient ucl = new UserClient();
801 
		    		user = ucl.getClient().createUser(user);
802 
		    	} catch(Exception e) {
803 
		    		//////////////log.error("Unable to get default source", e);
804 
		    	}
805 
 
806 
		    	long userId = user.getUserId();
7473 vikram.rag 807 
				AmazonOrder amazonOrder = new AmazonOrder();
8021 rajveer 808 
				long txnId = amazonOrder.persistTransaction(userId, user.getActiveCartId(), user.getEmail(), order, orderItems);
809 
 
7473 vikram.rag 810 
				TransactionClient tcl=null;
811 
				InventoryClient icl = null;
812 
				PaymentClient pcl = null;
813 
				Map<Long,Double> saholicItemMap = new HashMap<Long,Double>();
814 
				if (txnId != -1){
815 
					List<in.shop2020.model.v1.order.AmazonOrder> amazonOrders = new ArrayList<in.shop2020.model.v1.order.AmazonOrder>();
816 
					try {
817 
 
818 
						tcl = new TransactionClient();
819 
						icl = new InventoryClient();
820 
						pcl = new PaymentClient();;
8021 rajveer 821 
						System.out.println("temp id is" +userId);
822 
						List<in.shop2020.model.v1.order.Order>  saholicOrders =tcl.getClient().getOrdersForTransaction(txnId,userId);
7473 vikram.rag 823 
						for(in.shop2020.model.v1.order.Order saholicOrder:saholicOrders)
824 
						{
825 
							List<in.shop2020.model.v1.order.LineItem> lineitems= saholicOrder.getLineitems();
826 
							long itemId=0;
827 
							for(in.shop2020.model.v1.order.LineItem lineitem:lineitems){
828 
								itemId = lineitem.getItem_id();
829 
								if(saholicItemMap.get(lineitem.getItem_id())!=null)
830 
									saholicItemMap.put(lineitem.getItem_id(),saholicItemMap.get(lineitem.getItem_id())+1);
831 
								else
832 
									saholicItemMap.put(lineitem.getItem_id(),lineitem.getQuantity());
833 
							}
834 
							in.shop2020.model.v1.order.AmazonOrder aOrder = new in.shop2020.model.v1.order.AmazonOrder();
835 
							aOrder.setAmazonOrderCode(order.getAmazonOrderId());
836 
							aOrder.setAmazonOrderItemCode(orderItemSkuMap.get(Long.toString(itemId)));
837 
							aOrder.setItem_id(itemId);
838 
							aOrder.setOrderId(saholicOrder.getId());
839 
							aOrder.setTransactionId(txnId);
840 
							aOrder.setStatus("Order-Creation-Success");
841 
							tcl.getClient().addAmazonOrder(aOrder);
842 
							amazonOrders.add(aOrder);
843 
						}
8021 rajveer 844 
						long merchantPaymentId = pcl.getClient().createPayment(userId, Double.parseDouble(order.getOrderTotal().getAmount()), 15, txnId, false);
7473 vikram.rag 845 
						pcl.getClient().updatePaymentDetails(merchantPaymentId, "", "", "15", "", "", "", "", "", PaymentStatus.SUCCESS, "", null);
846 
						boolean success=tcl.getClient().changeTransactionStatus(txnId, TransactionStatus.AUTHORIZED, "Payment authorized", PickUpType.COURIER.getValue(), OrderType.B2C, OrderSource.AMAZON);
847 
						if(success){
848 
							for(in.shop2020.model.v1.order.AmazonOrder aorder:amazonOrders){
849 
								AmazonInventorySnapshot amazonInventorySnapshot=icl.getClient().getAmazonInventoryForItem(aorder.getItem_id());
850 
								long reserved = (amazonInventorySnapshot.getReserved()+1);
851 
								amazonInventorySnapshot.setReserved(reserved);
10457 vikram.rag 852 
								icl.getClient().addOrUpdateAmazonInventoryForItem((amazonInventorySnapshot),0);
7473 vikram.rag 853 
								tcl.getClient().updateAmazonOrderStatus(aorder.getOrderId(),"Order-Payment-Success");
854 
							}
855 
						}
856 
					}
857 
					catch (TTransportException e) {
7578 vikram.rag 858 
						try{
859 
							tcl = new TransactionClient();
860 
						}
7579 vikram.rag 861 
						catch (TTransportException ex) {
7578 vikram.rag 862 
 
863 
						}
864 
 
7473 vikram.rag 865 
						for(in.shop2020.model.v1.order.AmazonOrder aorder:amazonOrders){
866 
							try {
867 
								tcl.getClient().updateAmazonOrderStatus(aorder.getOrderId(),"Order-Payment-Failure");
868 
							} catch (TException e1) {
869 
								// TODO Auto-generated catch block
870 
								e1.printStackTrace();
871 
							}
872 
						}
873 
 
874 
						//e.printStackTrace();
875 
					} catch (TException e) {
876 
						// TODO Auto-generated catch block
877 
						e.printStackTrace();
878 
					} catch (PaymentException e) {
879 
						// TODO Auto-generated catch block
880 
						e.printStackTrace();
881 
					} catch (TransactionServiceException e) {
882 
						// TODO Auto-generated catch block
883 
						e.printStackTrace();
884 
					}
885 
				}
886 
			}
887 
 
888 
		}
889 
	}
890 
 
891 
 
892 
	/*
893 
	 * When a request is throttled, this method is called to make the thread
894 
	 * sleep for a period of time specified by the throttling limit.
895 
	 */
896 
	private void requestThrottledExceptionHandler(
897 
			long throttlingLimitInMilliseconds) {
898 
		try {
899 
			log.info("Request throttled. Sleeping for "
900 
					+ throttlingLimitInMilliseconds / 1000 + " seconds.");
901 
 
902 
			// Sleep in 1 minute intervals for throttlingLimitInMillis or until
903 
			// keepRunning is set to false.
904 
			for (long i = throttlingLimitInMilliseconds; i > 0 && keepRunning; i = i - 60000L) {
905 
				if (i < 60000L) {
906 
					Thread.sleep(i);
907 
				} else {
908 
					Thread.sleep(60000L);
909 
				}
910 
			}
911 
		} catch (InterruptedException e) {
912 
			log.error(e.getMessage(), e);
913 
			return;
914 
		}
915 
	}
916 
 
917 
	public static String computeContentMD5HeaderValue( FileInputStream fis) {
918 
		try {
919 
			DigestInputStream dis = new DigestInputStream( fis,
920 
					MessageDigest.getInstance( "MD5" ));
921 
			byte[] buffer = new byte[8192];
922 
			while( dis.read( buffer ) > 0 );
923 
			String md5Content = new String(Base64.encodeBase64(dis.getMessageDigest().digest())
924 
			);
925 
			// Effectively resets the stream to be beginning of the file via a
926 
			fis.getChannel().position( 0 );
927 
			return md5Content;
928 
		} catch (NoSuchAlgorithmException e) {
929 
			// TODO Auto-generated catch block
930 
			e.printStackTrace();
931 
		} catch (IOException e) {
932 
			// TODO Auto-generated catch block
933 
			e.printStackTrace();
934 
		}
935 
		return null;
936 
 
937 
	}
938 
 
939 
	public int submitAcknowledgementFeed(){
940 
 
7512 vikram.rag 941 
		SubmitFeedRequest request= new SubmitFeedRequest();
7473 vikram.rag 942 
		final String merchantId = "AF6E3O0VE0X4D";
943 
		// marketplaces to which this feed will be submitted; look at the
944 
		// API reference document on the MWS website to see which marketplaces are
945 
		// included if you do not specify the list yourself
946 
		final IdList marketplaces = new IdList(Arrays.asList(
947 
		"A21TJRUUN4KGV"));
948 
		request.setMerchant(merchantId);
949 
		FileInputStream fis=null;
950 
		try {
951 
			fis = new FileInputStream(AMAZON_ORDER_ACKNOWLEDGEMENT_XML);
952 
		} catch (FileNotFoundException e1) {
953 
			// TODO Auto-generated catch block
954 
			e1.printStackTrace();
955 
			return -1;
956 
		}
957 
		final String accessKeyId = "AKIAII3SGRXBJDPCHSGQ";
958 
		final String secretAccessKey = "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";
959 
 
960 
		final String appName = "Test";
961 
		final String appVersion = "1.0";
962 
 
963 
		MarketplaceWebServiceConfig config = new MarketplaceWebServiceConfig();
964 
 
965 
		// India
966 
		config.setServiceURL("https://mws.amazonservices.in");
967 
 
968 
		request.setContentMD5(computeContentMD5HeaderValue(fis));
969 
		request.setFeedContent(fis);
970 
		request.setMarketplaceIdList(marketplaces);
971 
		request.setFeedType("_POST_ORDER_ACKNOWLEDGEMENT_DATA_");
972 
		MarketplaceWebService s_service = new MarketplaceWebServiceClient(
973 
				accessKeyId, secretAccessKey, appName, appVersion, config);
974 
 
975 
		try {
976 
 
977 
			SubmitFeedResponse response = s_service.submitFeed(request);
978 
 
979 
			System.out.println("SubmitFeed Action Response");
980 
			System.out
981 
			.println("=============================================================================");
982 
			System.out.println();
983 
 
984 
			System.out.print("    SubmitFeedResponse");
985 
			System.out.println();
986 
			if (response.isSetSubmitFeedResult()) {
987 
				System.out.print("        SubmitFeedResult");
988 
				//	System.out.println();
989 
				SubmitFeedResult submitFeedResult = response
990 
				.getSubmitFeedResult();
991 
				if (submitFeedResult.isSetFeedSubmissionInfo()) {
992 
					//	System.out.print("            FeedSubmissionInfo");
993 
					//	System.out.println();
994 
					FeedSubmissionInfo feedSubmissionInfo = submitFeedResult
995 
					.getFeedSubmissionInfo();
996 
					if (feedSubmissionInfo.isSetFeedSubmissionId()) {
997 
						System.out.print("                FeedSubmissionId");
998 
						System.out.println();
999 
						System.out.print("                    "
1000 
								+ feedSubmissionInfo.getFeedSubmissionId());
1001 
 
1002 
						System.out.println();
1003 
					}
1004 
					if (feedSubmissionInfo.isSetFeedType()) {
1005 
						System.out.print("                FeedType");
1006 
						System.out.println();
1007 
						System.out.print("                    "
1008 
								+ feedSubmissionInfo.getFeedType());
1009 
						System.out.println();
1010 
					}
1011 
					if (feedSubmissionInfo.isSetSubmittedDate()) {
1012 
						System.out.print("                SubmittedDate");
1013 
						System.out.println();
1014 
						System.out.print("                    "
1015 
								+ feedSubmissionInfo.getSubmittedDate());
1016 
						System.out.println();
1017 
					}
1018 
					if (feedSubmissionInfo.isSetFeedProcessingStatus()) {
1019 
						System.out
1020 
						.print("                FeedProcessingStatus");
1021 
						System.out.println();
1022 
						System.out.print("                    "
1023 
								+ feedSubmissionInfo.getFeedProcessingStatus());
1024 
						System.out.println();
1025 
					}
1026 
					if (feedSubmissionInfo.isSetStartedProcessingDate()) {
1027 
						System.out
1028 
						.print("                StartedProcessingDate");
1029 
						System.out.println();
1030 
						System.out
1031 
						.print("                    "
1032 
								+ feedSubmissionInfo
1033 
								.getStartedProcessingDate());
1034 
						System.out.println();
1035 
					}
1036 
					if (feedSubmissionInfo.isSetCompletedProcessingDate()) {
1037 
						System.out
1038 
						.print("                CompletedProcessingDate");
1039 
						System.out.println();
1040 
						System.out.print("                    "
1041 
								+ feedSubmissionInfo
1042 
								.getCompletedProcessingDate());
1043 
						System.out.println();
1044 
					}
1045 
				}
1046 
			}
1047 
			if (response.isSetResponseMetadata()) {
1048 
				System.out.print("        ResponseMetadata");
1049 
				System.out.println();
1050 
				ResponseMetadata responseMetadata = response
1051 
				.getResponseMetadata();
1052 
				if (responseMetadata.isSetRequestId()) {
1053 
					System.out.print("            RequestId");
1054 
					System.out.println();
1055 
					System.out.print("                "
1056 
							+ responseMetadata.getRequestId());
1057 
					System.out.println();
1058 
				}
1059 
			}
1060 
			System.out.println(response.getResponseHeaderMetadata());
1061 
			System.out.println();
1062 
			System.out.println();
1063 
			return 0;
1064 
 
1065 
		} catch (MarketplaceWebServiceException ex) {
1066 
 
1067 
			System.out.println("Caught Exception: " + ex.getMessage());
1068 
			System.out.println("Response Status Code: " + ex.getStatusCode());
1069 
			System.out.println("Error Code: " + ex.getErrorCode());
1070 
			System.out.println("Error Type: " + ex.getErrorType());
1071 
			System.out.println("Request ID: " + ex.getRequestId());
1072 
			System.out.print("XML: " + ex.getXML());
1073 
			System.out.println("ResponseHeaderMetadata: " + ex.getResponseHeaderMetadata());
1074 
			return -1;
1075 
		}
7512 vikram.rag 1076 
 
7473 vikram.rag 1077 
	}
1078 
 
1079 
}