Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.crm.util;

import in.shop2020.crm.domain.Activity;

import in.shop2020.crm.domain.SearchFilter;

import in.shop2020.crm.domain.Ticket;

import in.shop2020.crm.ActivityType;

import in.shop2020.crm.TicketCategory;

import in.shop2020.crm.TicketPriority;

import in.shop2020.crm.TicketStatus;

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.RechargeOrder;

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

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

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

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;

/**

 * @author rajveer

 * Processor all the recharge orders whose recharge status is unkown. 

 */

public class UncertainRechargeProcessorTask {

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

    private static final long   ADMIN_AGENT_ID   = 1;

    private static final long   OUTBOUND_DEFAULT_ASSIGNEE_ID   = 29;

    private TicketHandler      ticketHandler;

    private ActivityHandler    activityHandler;

    public UncertainRechargeProcessorTask()

    {

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

        ticketHandler              = context.getBean(TicketHandler.class);

        activityHandler            = context.getBean(ActivityHandler.class);

    }

    public static void main(String[] args) {

        try {

            UncertainRechargeProcessorTask newTask = new UncertainRechargeProcessorTask();

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

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

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

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

                for (Long transactionId : transactionIds) {

                    newTask.processRechargeTxn(transactionId);

                    client = new TransactionClient().getClient();

                    client.markTransactionAsProcessed(transactionId, ExtraTransactionProcessingType.RECHARGE_UNKNOWN);

                }

            }

            else {

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

            }

        } catch (TTransportException e) {

            log.error("Error creating client", e);

        } catch (TException e) {

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

        } catch (TransactionServiceException e) {

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

        } catch (UserContextException e) {

            log.error("Could not find user", e);

        }

    }

    /**

     * Method that creates a ticket if necessary for COD verification

     * @throws TException 

     * @throws TransactionServiceException 

     * @throws UserContextException 

     */

    private void processRechargeTxn(long transactionId)

            throws TransactionServiceException, TException,

            UserContextException {

        log.info("Processing txn id: " + transactionId);

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

        RechargeOrder rechargeOrder = client.getRechargeOrdersForTransaction(transactionId);

        log.info("Processing order: " + rechargeOrder.getId());

        in.shop2020.crm.domain.SearchFilter searchFilter = new SearchFilter();

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

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

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

        searchFilter.setTicketCategory(TicketCategory.RECHARGE_RELATED);

        searchFilter.setCustomerId(rechargeOrder.getUserId());

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

        // customer!

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

            log.info("Logging ticket");

            Ticket ticket = new Ticket();

            ticket.setCategory(TicketCategory.RECHARGE_RELATED);

            ticket.setCreatorId(ADMIN_AGENT_ID);

            ticket.setCustomerId(rechargeOrder.getUserId());

            ticket.setDescription("Unknown Recharge Status");

            ticket.setPriority(TicketPriority.HIGH);

            ticket.setStatus(TicketStatus.OPEN);

            ticket.setAssigneeId(OUTBOUND_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.setTicketAssigneeId(ticket.getAssigneeId());

            activity.setType(ActivityType.OTHER);

            createTicket(ticket, activity);

        }

    }

    @Transactional

    private void createTicket(Ticket ticket, Activity activity) {

        ticketHandler.insertTicket(ticket);

        activity.setTicketId(ticket.getId());

        activityHandler.insertActivity(activity);

    }

}