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);
    }
}