Subversion Repositories SmartDukaan

package in.shop2020.serving.services;

import in.shop2020.model.v1.order.LineItem;

import in.shop2020.model.v1.order.Order;

import in.shop2020.model.v1.order.Transaction;

import in.shop2020.model.v1.order.TransactionServiceException;

import in.shop2020.model.v1.order.TransactionStatus;

import in.shop2020.model.v1.user.Cart;

import in.shop2020.model.v1.user.Line;

import in.shop2020.model.v1.user.PromotionException;

import in.shop2020.model.v1.user.ShoppingCartException;

import in.shop2020.model.v1.user.UserContextService;

import in.shop2020.payments.PaymentException;

import in.shop2020.payments.PaymentService.Client;

import in.shop2020.serving.utils.Utils;

import in.shop2020.thrift.clients.PaymentServiceClient;

import in.shop2020.thrift.clients.PromotionServiceClient;

import in.shop2020.thrift.clients.TransactionServiceClient;

import in.shop2020.thrift.clients.UserContextServiceClient;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.thrift.TException;

/**

 * This class has methods to be used to process non-gateway-specific aspects of

 * payments and transactions.

 * 

 * @author Chandranshu

 * 

 */

public class CommonPaymentService {

	private static final boolean PAYMENT_NOT_CREATED = false;

	private static Logger log = Logger.getLogger(Class.class);

	private long paymentId;

	private double amount;

	public long getPaymentId() {

		return paymentId;

	}

	public double getAmount() {

		return amount;

	}

	/**

	 * Creates a payment for the given cart of the given user for the given

	 * transaction. Stores the id of the newly created payment and the amount

	 * for which this payment was created. They can be retrieved later on using

	 * {@link #getPaymentId()}getPaymentId() and {@link #getAmount()}getAmount()

	 * methods respectively later on.

	 * 

	 * @param currentCartId

	 *            The cart for which the payment object has to be created.

	 * @param userId

	 *            The user for whom the payment has to be created.

	 * @param txnId

	 *            The transaction against which the payment has to be created.

	 * @param gatewayId

	 * @return True if the payment object is successfully created, False

	 *         otherwise.

	 */

	public boolean createPayment(long currentCartId, long userId, long txnId, int gatewayId){

		PaymentServiceClient paymentServiceClient = null;

		try {

			paymentServiceClient = new PaymentServiceClient();

		} catch (Exception e) {

			log.error("Error while getting payment client");

			e.printStackTrace();

			return PAYMENT_NOT_CREATED;

		}

		try {

			amount = calculatePaymentAmount(currentCartId);

		} catch (ShoppingCartException e1) {

			log.error("Not able to fetch payment amount from cart id." + e1.getId() + e1.getMessage());

			e1.printStackTrace();

			return PAYMENT_NOT_CREATED;

		} catch (TException e1) {

			log.error("Not able to fetch payment amount." + e1.getMessage());

			e1.printStackTrace();

			return PAYMENT_NOT_CREATED;

		}

		Client paymentClient = paymentServiceClient.getClient();

		try {

			paymentId = paymentClient.createPayment(userId, amount, gatewayId, txnId);

		} catch (PaymentException e1) {

			log.error("Not able to create payment object." + e1.getError_code() + e1.getMessage());

			e1.printStackTrace();

			return PAYMENT_NOT_CREATED;

		} catch (TException e) {

			log.error("Not able to create payment object." + e.getMessage());

			e.printStackTrace();

			return PAYMENT_NOT_CREATED;

		}

		return true;

	}

	/**

	 * Marks the given transaction as in process. Once the transaction is marked

	 * as successful, the items in the cart for which this transaction was

	 * processed are removed from the cart.<br>

	 * Please note that it's possible that a user has added items to the cart

	 * and so it's not possible to simply wipe out their cart.<br>

	 * Again, it's important to ensure that we remove only as much quantity of

	 * items as for which the order was processed.

	 * 

	 * @param txnId The transaction which should be marked as successful.

	 * @param userServiceClient A user context service client to use.

	 * @param transactionServiceClient A transaction service client to use.

	 */

	public static void processSuccessfulTxn(long txnId, UserContextServiceClient userServiceClient, TransactionServiceClient transactionServiceClient) {

		Transaction transaction = null;

		Map<Long,Double> items = new HashMap<Long, Double>();

		try {

			in.shop2020.model.v1.order.TransactionService.Client transactionClient = transactionServiceClient.getClient();

			transactionClient.changeTransactionStatus(txnId, TransactionStatus.IN_PROCESS, "Payment received for the order");

			transaction = transactionClient.getTransaction(txnId);

			for(Order order: transaction.getOrders()){

				for(LineItem lineitem: order.getLineitems()){

					Long itemId = lineitem.getItem_id();

					Double quantity = items.get(itemId);

					if(quantity==null){

						quantity = lineitem.getQuantity();

					}

					else{

						quantity= quantity + lineitem.getQuantity();

					}

					items.put(itemId, quantity);

				}

			}

		} catch (TException e1) {

			log.error("Unable to update status of transaction. Thrift Exception" + e1.getMessage());

			e1.printStackTrace();

		} catch (TransactionServiceException e) {

			log.error("Unable to update status of transaction. Thrift Exception" + e.getErrorCode() + e.getMessage());

			e.printStackTrace();

		}

        try   {

            // Tracking Coupon Usage 

            UserContextService.Client userClient = userServiceClient.getClient();

            Cart cart = userClient.getCart(transaction.getShoppingCartid());

            PromotionServiceClient promotionServiceClient = new PromotionServiceClient();

            String couponCode = cart.getCouponCode();

            if (couponCode != null && !couponCode.isEmpty()) {

                promotionServiceClient.getClient().trackCouponUsage(couponCode, txnId, transaction.getCustomer_id());

            }

        } catch (ShoppingCartException e) {

            log.error("Error occurred in reading CardId for transaction");

            e.printStackTrace();

        } catch (PromotionException e) {

            log.error("Promotion Exception: " + e.getMessage());

            e.printStackTrace();

        } catch (TException e)  {

            log.error("Transport from Promotion Service failed");

            e.printStackTrace();

        } catch (Exception e) {

            e.printStackTrace();

        }

		try {

			//TODO Optimize the function to send less amount of data over network

			log.info("Transaction shopping cart id is: " + transaction.getShoppingCartid());

			log.info("Items to restr in cart are: " + items );

            userServiceClient.getClient().resetCart(transaction.getShoppingCartid(), items);

		}catch (TException e) {

			log.error("Error while updating information in payment database.");

			e.printStackTrace();

			//FIXME Even we get exception we should sent url back to payment gateway. And some thing back channel should be done

		} catch (ShoppingCartException e) {

			log.error("Error while reseting the cart in cart database.");

			e.printStackTrace();

		}catch (Exception e) {

            // TODO: handle exception

        }

	}

	/**

	 * Enqueues the transaction successful email, containing transaction info,

	 * to be sent later by batch job.

	 * 

	 * @param transactionClient

	 */

	public static void sendTxnEmail(long txnId, TransactionServiceClient transactionServiceClient) {

		in.shop2020.model.v1.order.TransactionService.Client transactionClient = transactionServiceClient.getClient();

		try {

			transactionClient.enqueueTransactionInfoEmail(txnId);

		} catch (Exception e) {

			log.error("Error while adding email to dispatch queue.");

			e.printStackTrace();

		}

	}

	/**

	 * Marks a transaction as well as all its orders as failed.

	 * 

	 * @param txnId

	 *            The id of the transaction which has to be marked as failed.

	 * @param transactionServiceClient

	 */

	public static void processFailedTxn(long txnId, TransactionServiceClient transactionServiceClient) {

		try {

			in.shop2020.model.v1.order.TransactionService.Client transactionClient = transactionServiceClient.getClient();

			transactionClient.changeTransactionStatus(txnId, TransactionStatus.FAILED, "Payment failed for the transaction.");

		} catch(TException e){

			log.error("Thrift exception while getting information from transaction service.");

			e.printStackTrace();

		} catch (TransactionServiceException e) {

			log.error("Error while updating status information in transaction database.");

			e.printStackTrace();

		}

	}

	/**

	 * Calculates the amount for the payment required for the given cart.

	 * 

	 * @param cartId

	 *            Id of the cart for which this payment amount has to be

	 *            calculated.

	 * @return The total amount for which a payment should be created.

	 * @throws ShoppingCartException

	 *             If no cart can be found for the given id.

	 * @throws TException

	 */

	private double calculatePaymentAmount(long cartId) throws ShoppingCartException, TException{

		double totalAmount = 0;

		Cart cart;

		UserContextServiceClient userContextServiceClient = null;

		try {

			userContextServiceClient = new UserContextServiceClient();

		} catch (Exception e) {

			e.printStackTrace();

		}

		in.shop2020.model.v1.user.UserContextService.Client userClient = userContextServiceClient.getClient();

		cart = userClient.getCart(cartId);

		if(cart.getCouponCode() == null || cart.getDiscountedPrice() == 0.0)  {

		    List<Line> lineItems = cart.getLines(); 

	        for (Line line : lineItems) {

	            long productId = line.getItemId();

	            // FIXME: It's expensive to get the price of each item from the

	            // catalog service. We maintain the pricing info in the line items

	            // themselves now.

	            totalAmount =  totalAmount + line.getQuantity() * Utils.getItemPrice(productId);

	        }

		} else    {

		    totalAmount = cart.getDiscountedPrice();

		}

		return totalAmount;

	}

	// TODO: The service client parameters are unnecessary but initializing them

	// again when the caller has the necessary references has a performance

	// overhead. Need to think more about this.

}