Subversion Repositories SmartDukaan

package in.shop2020.crm.util;

import in.shop2020.crm.ActivityType;

import in.shop2020.crm.TicketCategory;

import in.shop2020.crm.TicketPriority;

import in.shop2020.crm.TicketStatus;

import in.shop2020.crm.domain.Activity;

import in.shop2020.crm.domain.SearchFilter;

import in.shop2020.crm.domain.Ticket;

import in.shop2020.crm.handler.ActivityHandler;

import in.shop2020.crm.handler.TicketHandler;

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

import in.shop2020.model.v1.order.TransactionService.Client;

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

import in.shop2020.thrift.clients.TransactionClient;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.transaction.annotation.Transactional;

public class FlaggedPaymentProcessorTask {

    private static Log log = LogFactory.getLog(DelayedOrderProcessorTask.class);

    private static final long   ADMIN_AGENT_ID   = 1;

    private static final long   FLAGGED_PAYMENTS_DEFAULT_ASSIGNEE_ID   = 34;

    private TicketHandler      ticketHandler;

    private ActivityHandler    activityHandler;

    public FlaggedPaymentProcessorTask()

    {

        ApplicationContext context = new ClassPathXmlApplicationContext("context.xml");

        ticketHandler              = context.getBean(TicketHandler.class);

        activityHandler            = context.getBean(ActivityHandler.class);

    }

    /* (non-Javadoc)

     * @see java.lang.Runnable#run()

     */

    /**

     * @param args

     */

    public static void main(String[] args) {

        try {

            FlaggedPaymentProcessorTask newTask = new FlaggedPaymentProcessorTask();

            Client client = new TransactionClient().getClient();

            List<Long> transactionIds = client.getTransactionsRequiringExtraProcessing(ExtraTransactionProcessingType.PAYMENT_FLAGGED);

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

                log.info("Fetched " + transactionIds.size() + " transactions");

                for (Long transactionId : transactionIds) {

                    client = new TransactionClient().getClient();

                    newTask.processFlaggedPayment(client.getTransaction(transactionId).getCustomer_id());

                    client = new TransactionClient().getClient();

                    client.markTransactionAsProcessed(transactionId, ExtraTransactionProcessingType.PAYMENT_FLAGGED);

                }

            }

            else {

                log.info("No transactions to process");

            }

        } catch (TTransportException e) {

            log.error("Could not create TransactionService client", e);

        } catch (TException e) {

            log.error("Could not fetch transactions for processing", e);

        } catch (TransactionServiceException e) {

            log.error("Could not lookup transaction", e);

        }

    }

    private void processFlaggedPayment(Long customerId) {

        log.info("Processing flagged payment for customerId: " + customerId);

        SearchFilter searchFilter = new SearchFilter();

        searchFilter.setTicketStatuses(new ArrayList<TicketStatus>());

        searchFilter.getTicketStatuses().add(TicketStatus.OPEN);

        searchFilter.getTicketStatuses().add(TicketStatus.REOPEN);

        searchFilter.setTicketCategory(TicketCategory.PAYMENT_FLAGGED);

        searchFilter.setCustomerId(customerId);

        // No need to create a ticket if there exists one for the customer!

        if (ticketHandler.getTickets(searchFilter).isEmpty()) {

            Ticket ticket = new Ticket();

            ticket.setCategory(TicketCategory.PAYMENT_FLAGGED);

            ticket.setCreatorId(ADMIN_AGENT_ID);

            ticket.setCustomerId(customerId);

            ticket.setDescription("Payment is Flagged");

            ticket.setPriority(TicketPriority.HIGH);

            ticket.setStatus(TicketStatus.OPEN);

            ticket.setAssigneeId(FLAGGED_PAYMENTS_DEFAULT_ASSIGNEE_ID);

            Activity activity = new Activity();

            activity.setCreatorId(ticket.getCreatorId());

            activity.setCustomerId(ticket.getCustomerId());

            activity.setDescription("Creating ticket");

            activity.setTicketCategory(ticket.getCategory());

            activity.setTicketDescription(ticket.getDescription());

            activity.setTicketPriority(ticket.getPriority());

            activity.setTicketStatus(ticket.getStatus());

            activity.setType(ActivityType.OTHER);

            activity.setTicketAssigneeId(ticket.getAssigneeId());

            createTicket(ticket, activity);

        }

    }

    @Transactional

    private void createTicket(Ticket ticket, Activity activity) {

        ticketHandler.insertTicket(ticket);

        activity.setTicketId(ticket.getId());

        activityHandler.insertActivity(activity);

    }

}