Subversion Repositories SmartDukaan

package in.shop2020.hotspot.dashbaord.server;

import in.shop2020.hotspot.dashbaord.shared.actions.AddJacketNumberResponse;
import in.shop2020.model.v1.inventory.BillingType;
import in.shop2020.model.v1.order.Order;
import in.shop2020.model.v1.order.OrderStatus;
import in.shop2020.model.v1.order.ShipmentLogisticsCostDetail;
import in.shop2020.model.v1.order.TransactionServiceException;
import in.shop2020.model.v1.order.TransactionService.Client;
import in.shop2020.thrift.clients.LogisticsClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.WarehouseClient;
import in.shop2020.thrift.clients.config.ConfigClient;
import in.shop2020.warehouse.InventoryItem;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.thrift.TException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.providers.logistics.Provider;
import com.providers.logistics.ProviderFactory;


public class ProcessBulkBilling{
        private static  Logger logger = LoggerFactory.getLogger(ProcessBulkBilling.class);

        private String fileName;
        private String logisticsTransactionId;
        private String packageDimensions;
        private List<InventoryItem> inventoryItems;
        private Map<Long, Long> itemQuantityMap= new HashMap<Long, Long>();
        private Map<Long, List<InventoryItem>> inventoryItemMap= new HashMap<Long, List<InventoryItem>>();
        private ArrayList<String> imei_list = new ArrayList<String>();
        private BillingType billingType;
        private String user;
        private List<Order> orders_list;
        private Map<Long, List<String>> itemNumbersMap = new HashMap<Long, List<String>>();
        private Map<Long, List<String>> serialNumbersMap = new HashMap<Long, List<String>>();
        private Map<Long, List<Long>> freebieWarehouseIdMap = new HashMap<Long, List<Long>>();
        private static final long jacket_number = 1;
        private static final String invoice_type = "Individual";
        
        private static String live = "";
        
        static {
                try {
                        ConfigClient cc = ConfigClient.getClient();
                        live = cc.get("live");
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }


        ProcessBulkBilling(String fileName, String logisticsTransactionId, String packageDimensions, BillingType billingType, String user) {
                logger.info("FileName "+fileName+" logisticsTransactionId "+logisticsTransactionId+" packageDimension "+packageDimensions+" billingType "+billingType+" user "+user);
                this.fileName = fileName;
                this.logisticsTransactionId = logisticsTransactionId;
                this.packageDimensions = packageDimensions;
                this.billingType = billingType;
                this.user = user;
        }

        public boolean processReport() {
                try{

                        FileInputStream iFile = new FileInputStream(new File(fileName));
                        HSSFWorkbook workbook = new HSSFWorkbook(iFile);
                        HSSFSheet sheet = workbook.getSheetAt(0);
                        DataFormatter formatter = new DataFormatter();
                        for (int iterator=sheet.getFirstRowNum()+1;iterator<=sheet.getLastRowNum();iterator++){
                                logger.info("Iterator -----" + iterator);
                                HSSFCell imei_cell = sheet.getRow(iterator).getCell(0);
                                String imei = formatter.formatCellValue(imei_cell).trim();
                                if (imei == null || imei.isEmpty()){
                                        break;
                                }
                                if (imei_list.contains(imei)){
                                        return false;
                                }
                                logger.info(imei);
                                imei_list.add(imei);
                        }
                        return true;
                }
                catch(Exception e){
                        e.printStackTrace();
                        return false;
                }
        }

        private String addBillingInformation(){

                Order t_order = orders_list.get(0);
                try{
                        TransactionClient txnClient = new TransactionClient();
                        Client client = txnClient.getClient();


                        if (packageDimensions==null){
                                return "Illegal package dimensions";
                        }

                        try{
                                ShipmentLogisticsCostDetail slcd = new ShipmentLogisticsCostDetail();
                                slcd.setLogisticsTransactionId(t_order.getLogisticsTransactionId());
                                slcd.setPackageDimensions(packageDimensions);
                                client.addShipmentLogisticDetail(slcd);
                        }
                        catch(Exception slcd_ex){
                                slcd_ex.printStackTrace();
                                return "Unable to add ShipmentLogisticsCostDetail";
                        }


                        if (t_order.getAirwaybill_no()==null){
                                String airway_billno = null;
                                if(live.equals("true")) {
                                        try{
                                                //If aramaex then
                                                if (t_order.getLogistics_provider_id()==2){
                                                        Provider logisticsProvider = ProviderFactory.getProvider((int)orders_list.get(0).getLogistics_provider_id());
                                                        airway_billno = logisticsProvider.getAirwayBillNo(orders_list);
                                                }
                                                else{
                                                        LogisticsClient lc = new LogisticsClient();
                                                        airway_billno = lc.getClient().getEmptyAWB(t_order.getLogistics_provider_id(), t_order.getLogisticsTransactionId());
                                                }
                                                if (airway_billno==null || airway_billno.isEmpty()){
                                                        throw new Exception("Empty airway bill number");
                                                }
                                        }
                                        catch(Exception airwayBillException){
                                                airwayBillException.printStackTrace();
                                                return "Unable to assign airway bill number";
                                        }
                                } else if (live.equals("false")){
                                        airway_billno = String.valueOf(new Date().getTime());
                                } else {
                                        return "Config error";
                                }
                                client.updateMasterOrderAWB(t_order.getLogisticsTransactionId(), airway_billno);
                        }


                        if((billingType == BillingType.OURS || billingType == BillingType.OURS_EXTERNAL) && t_order.getStatus().getValue() >= OrderStatus.BILLED.getValue()){
                                return "Already Billed";
                        }

                        long billing_type = billingType.getValue();

                        Set<Long> orderIdSet = itemNumbersMap.keySet();
                        List<Long> order_ids = new ArrayList<Long>();
                        order_ids.addAll(orderIdSet);

                        boolean status = client.addBillingDetailsForGrouppedOrders(order_ids, "", itemNumbersMap, serialNumbersMap, freebieWarehouseIdMap , user, jacket_number, billing_type, false, invoice_type);
                        // If provider is ECom Express then forward shipping request after billing
                        if(t_order.getLogistics_provider_id()==49) {
                                return "Order billed but could not forward request to provider";
                                try {
                                        LogisticsClient lc = new LogisticsClient();
                                        lc.getClient().pushCourierDetailsForEcomExpress(Arrays.asList(t_order.getLogisticsTransactionId()));
                                } catch (Exception e) {
                                        logger.error("Error pushing courier details", e);
                                }
                        }

                        if(!status)
                                return "Couldn't add billing info on server";

                        return "Billing Info added successfully";
                }  catch(TransactionServiceException tse){
                        logger.error("Exception while adding InventoryServiceHandlerjacket number", tse);
                        return "Error While Billing Order:" + tse.getMessage();
                } catch (TException e) {
                        return "Unknown exception from server:" + e.getMessage();
                }
        }

        public String checkBillingDetails(){
                try{
                        Client tc = new TransactionClient().getClient();
                        orders_list = tc.getGroupOrdersByLogisticsTxnId(logisticsTransactionId);
                }
                catch(Exception e){
                        e.printStackTrace();
                        return "Service Error!!!";
                }
                long total_quantity = 0;
                for (Order o : orders_list){
                        if (itemQuantityMap.containsKey(o.getLineitems().get(0).getItem_id())){
                                itemQuantityMap.put(o.getLineitems().get(0).getItem_id(), itemQuantityMap.get(o.getLineitems().get(0).getItem_id())+(long)o.getLineitems().get(0).getQuantity());
                        }
                        else{
                                itemQuantityMap.put(o.getLineitems().get(0).getItem_id(), (long)o.getLineitems().get(0).getQuantity());
                        }
                        total_quantity = (long) (total_quantity + o.getLineitems().get(0).getQuantity());
                }
                if (total_quantity != imei_list.size()){
                        return "Quantity and imei mismatch.Supplied imei's not equal to quantity to bill";
                }
                try{
                        in.shop2020.warehouse.WarehouseService.Client wc = new WarehouseClient().getClient();
                        inventoryItems = wc.getInventoryItems(imei_list);
                        logger.info(imei_list.toString());
                        logger.info(inventoryItems.toString());
                        for (InventoryItem it : inventoryItems){
                                if (inventoryItemMap.containsKey(it.getItemId())){
                                        inventoryItemMap.get(it.getItemId()).add(it);
                                }
                                else{
                                        List<InventoryItem> it_list = new ArrayList<InventoryItem>();
                                        it_list.add(it);
                                        inventoryItemMap.put(it.getItemId(), it_list);
                                }
                        }
                }
                catch(Exception e){
                        return "Exception while getting inventory items from warehouse";
                }
                logger.info("itemQuantityMap "+itemQuantityMap);
                logger.info("inventoryItemMap "+inventoryItemMap);
                for(Map.Entry<Long, Long> entry : itemQuantityMap.entrySet()){
                        List<InventoryItem> inventory_items = inventoryItemMap.get(entry.getKey());
                        if (inventory_items == null){
                                return "Mismatch in inventory items.Quantity to bill "+entry.getValue()+".InventoryItem available 0 for item_id "+entry.getKey();
                        }
                        if (inventory_items.size()!= entry.getValue()){
                                return "Mismatch in inventory items.Quantity to bill "+entry.getValue()+".InventoryItem available "+inventory_items.size()+" for item_id "+entry.getKey();
                        }
                }
                for (Order o : orders_list){

                        freebieWarehouseIdMap.put(o.getId(), new ArrayList<Long>());

                        for(int i=0;i< o.getLineitems().get(0).getQuantity();i++){

                                if (itemNumbersMap.containsKey(o.getId())){
                                        itemNumbersMap.get(o.getId()).add("1");
                                }
                                else{
                                        List<String> itemNumbers = new ArrayList<String>();
                                        itemNumbers.add("1");
                                        itemNumbersMap.put(o.getId(), itemNumbers);
                                }

                                if (serialNumbersMap.containsKey(o.getId())){
                                        InventoryItem inventory_item = inventoryItemMap.get(o.getLineitems().get(0).getItem_id()).remove(0);
                                        serialNumbersMap.get(o.getId()).add(inventory_item.getSerialNumber());
                                }
                                else{
                                        List<String> serialNumbers = new ArrayList<String>();
                                        InventoryItem inventory_item = inventoryItemMap.get(o.getLineitems().get(0).getItem_id()).remove(0);
                                        serialNumbers.add(inventory_item.getSerialNumber());
                                        serialNumbersMap.put(o.getId(), serialNumbers);
                                }
                        }
                }

                return addBillingInformation();
        }

}