Subversion Repositories SmartDukaan

package in.shop2020.support.controllers;

import in.shop2020.model.v1.inventory.InventoryService.Client;

import in.shop2020.model.v1.inventory.InventoryServiceException;

import in.shop2020.model.v1.catalog.Item;

import in.shop2020.model.v1.inventory.ItemInventory;

import in.shop2020.model.v1.inventory.VendorItemMapping;

import in.shop2020.model.v1.inventory.Warehouse;

import in.shop2020.support.models.BillingUpdate;

import in.shop2020.support.models.InventoryUpdate;

import in.shop2020.support.models.PLBDetails;

import in.shop2020.support.models.Update;

import in.shop2020.thrift.clients.CatalogClient;

import in.shop2020.thrift.clients.InventoryClient;

import in.shop2020.thrift.clients.TransactionClient;

import in.shop2020.utils.ConfigClientKeys;

import in.shop2020.utils.GmailUtils;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.mail.MessagingException;

import org.apache.commons.lang.StringUtils;

import org.apache.struts2.rest.DefaultHttpHeaders;

import org.apache.struts2.rest.HttpHeaders;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.opensymphony.xwork2.ModelDriven;

public class UpdatesController implements ModelDriven<InventoryUpdate>{

    /**

     * 

     */

    private static final int HOTSPOT_VENDOR_ID = 1;

    /**

     * 

     */

    private static final String FIELD_DELIMITER = "~#~#~#";

    private static Logger logger = LoggerFactory.getLogger(UpdatesController.class);

	private InventoryUpdate inventoryUpdate = new InventoryUpdate();

	private String timestampAndItemIds;

	private Map<Long, List<String>> hotspotMappings = new HashMap<Long, List<String>>();

	private int errorCode = 0;

	private String errorMessage;

	private boolean fullPlbSync = false;

	private String id;

    private Client snapshotClient;

	public UpdatesController(){

	}

	@Override

	public InventoryUpdate getModel() {

		return this.inventoryUpdate;

	}

	public HttpHeaders show(){

		logger.info("Status requested for warehouse id: " + getId());

		Client client;

		try {

			client = new InventoryClient().getClient();

			long warehouseId = Long.parseLong(getId());

			Warehouse warehouse = client.getWarehouse(warehouseId);

			timestampAndItemIds = warehouse.getVendorString();

			List<String> itemKeys = new ArrayList<String>();

			if (!fullPlbSync) {

			    client = new InventoryClient().getClient();

			    itemKeys = client.getItemKeysToBeProcessed(warehouseId);

			}

			for (String itemKey : itemKeys) {

			    timestampAndItemIds += FIELD_DELIMITER + itemKey;

			}

		} catch (Exception e) {

			logger.error("Error getting the warehouse or setting the timestamp", e);

		}

		return new DefaultHttpHeaders("lsuccess");

	}

	/**

     * @return

     */

    private List<Item> fetchItems() {

        try {

            in.shop2020.model.v1.catalog.CatalogService.Client snapshotClient = new CatalogClient().getClient();

            return snapshotClient.getAllItems(true);

        } catch (Exception e) {

            logger.error("Could not fetch all items. Retrying.", e);

            try {

                Thread.sleep(30000 * Long.parseLong(inventoryUpdate.getwarehouseId()));

            } catch (Exception e1) {

                logger.error("Could not sleep.", e1);

            }

            return fetchItems();

        }

    }

	/**

     * @return

     */

    private ItemInventory fetchInventory(long itemId) {

        try {

            return snapshotClient.getItemInventoryByItemId(itemId);

        } catch (Exception e) {

            logger.error("Could not fetch all items. Retrying.", e);

            try {

                snapshotClient = new InventoryClient().getClient();

                return fetchInventory(itemId);

            } catch (TTransportException e1) {

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

                return null;

            }

        }

    }

    /**

     * 

     */

    private void loadHotspotMappings() {

        try {

            for (VendorItemMapping mapping : snapshotClient.getAllVendorItemMappings()) {

                if (mapping.getVendorId() == HOTSPOT_VENDOR_ID) {

                    long itemId = mapping.getItemId();

                    if (!hotspotMappings.containsKey(itemId)) {

                        hotspotMappings.put(itemId, new ArrayList<String>());

                    }

                    hotspotMappings.get(itemId).add(mapping.getItemKey().trim().toLowerCase());

                }

            }

        } catch (Exception e) {

            logger.error("Could not load vendor item mappings. Trying to reload.", e);

            try {

                Thread.sleep(30000 * Long.parseLong(inventoryUpdate.getwarehouseId()));

            } catch (Exception e1) {

                logger.error("Could not sleep.", e1);

            }

            try {

                snapshotClient = new InventoryClient().getClient();

                loadHotspotMappings();

            } catch (TTransportException e1) {

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

            }

        }

    }

    /**

	 * Stores the inventory updates on the history and the production server.

	 * @return

	 */

	public HttpHeaders create(){

		logger.info(inventoryUpdate.toString());

		try {

		    //The snapshot client is used to update the inventory snapshot for production systems.

		    InventoryClient snapshotCatalogServiceClient = new InventoryClient();

			Client snapshotClient = snapshotCatalogServiceClient.getClient();

	         //The history client is used to update the inventory history on the processing system.

            InventoryClient historyInventoryServiceClient = new InventoryClient(

                    ConfigClientKeys.inventory_history_service_server_host.toString(),

                    ConfigClientKeys.inventory_history_service_server_port.toString());

			Client historyClient = historyInventoryServiceClient.getClient();

			Client stagingCatalogClient = new InventoryClient(ConfigClientKeys.catalog_service_server_host_prod.toString(),

                    ConfigClientKeys.catalog_service_server_port.toString()).getClient();

		    //The snapshot client is used to update the inventory snapshot for production systems.

		    TransactionClient transactionClient = new TransactionClient();

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

			Long warehouseId = Long.parseLong(inventoryUpdate.getwarehouseId());

			String timestamp = inventoryUpdate.getCurrentTimestamp();

			Map<String, Long> availability = new HashMap<String, Long>();

			List<Update> updates = inventoryUpdate.getUpdates();

			if (updates != null) {

	            for(Update update: updates){

	                String key = update.getKey();

	                long quantity = (long) Double.parseDouble(update.getQuantity());

	                if(availability.containsKey(key)){

	                    quantity = quantity + availability.get(key);

	                }

	                availability.put(key, quantity);

	            }			    

			}

			//Update the snapshot before the history since that is more important.

			snapshotClient.updateInventory(warehouseId, timestamp, availability);

			stagingCatalogClient.updateVendorString(warehouseId, timestamp);

			historyClient.updateInventoryHistory(warehouseId, timestamp, availability);

			List<BillingUpdate> billingUpdates = inventoryUpdate.getBillingUpdates();

			if(billingUpdates!=null){

				for(BillingUpdate billingUpdate: billingUpdates){

					tClient.addInvoiceNumber(Long.parseLong(billingUpdate.getOrderId()), billingUpdate.getInvoiceNumber(), billingUpdate.getColor());

				}

			}

			List<PLBDetails> plbDetails = inventoryUpdate.getPlbDetails();

			if (plbDetails != null) {

			    Map<String, PLBDetails> currentInventory = new HashMap<String, PLBDetails>();

			    for (PLBDetails plbDetail : plbDetails) {

			        try {

			            if (fullPlbSync) {

			                currentInventory.put(plbDetail.getItemKey().toLowerCase(), plbDetail);

			            }

			            else {

	                        snapshotClient.resetAvailability(

	                                plbDetail.getItemKey(), 1,

	                                plbDetail.getQuantity().longValue(), warehouseId);

	                        snapshotClient.markMissedInventoryUpdatesAsProcessed(

	                                plbDetail.getItemKey(), warehouseId);

			            }

                    } catch (Exception e) {

                        logger.error("Could not reset availability of: " + plbDetail.getItemKey(), e);

                        GmailUtils g = new GmailUtils();

                        g.sendSSLMessage(new String[]{ "mandeep.dhir@shop2020.in" }, "Error resetting availability for " + plbDetail.getItemKey() + " in warehouseId: " + warehouseId + " to " + plbDetail.getQuantity(), "", "cnc.center@shop2020.in", "5hop2o2o", new ArrayList<File>());

                    }

			    }

			    sendMailForPLBMismatches(warehouseId, currentInventory);

			}

		} catch (Exception e) {

			logger.error("Unable to update inventory", e);

		}

		return new DefaultHttpHeaders("psuccess");

	}

    private void sendMailForPLBMismatches(Long warehouseId, Map<String, PLBDetails> currentInventory)

            throws InventoryServiceException, TException, MessagingException {

        if (fullPlbSync) {

            snapshotClient = new InventoryClient().getClient();

            loadHotspotMappings();

            Map<Item, PLBDetails> mismatches = new HashMap<Item, PLBDetails>();

            List<Item> items = fetchItems();

            for (Item item : items) {

                if (hotspotMappings.containsKey(item.getId())) {

                    PLBDetails plbDetails = null;

                    for (String s : hotspotMappings.get(item.getId())) {

                        if (currentInventory.containsKey(s.trim().toLowerCase())) {

                            plbDetails = currentInventory.get(s.trim().toLowerCase());

                        }

                    }

                    Long currentSnapshotAvailability = fetchInventory(item.getId()).getAvailability().get(warehouseId);

                    if ((currentSnapshotAvailability == null || currentSnapshotAvailability.equals(0l)) && 

                        (plbDetails == null || plbDetails.getQuantity().longValue() == 0))

                    {

                        continue;

                    }

                    if (currentSnapshotAvailability == null || plbDetails == null ||

                        !currentSnapshotAvailability.equals(plbDetails.getQuantity().longValue()))

                    {

                        mismatches.put(item, plbDetails);

                    }

                }

            }

            String subject = mismatches.size() + " mismatches with PLB sync for warehouse id: " + warehouseId;

            File file = new File("mismatches.xls");

            try {

                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));

                bufferedWriter.write(StringUtils.join(new String[] { "Item Id",

                        "Brand", "Model Name", "Model Number",

                        "Color", "SpiceOnlineRetailStock", "HotspotStock" }, '\t'));

                for (Item item : mismatches.keySet()) {

                    Long currentSnapshotAvailability = fetchInventory(item.getId()).getAvailability().get(warehouseId);

                    String plbQuantity = mismatches.get(item) == null ? "0" : mismatches.get(item).getQuantity().toString();

                    String currentSnapshotQuantity = currentSnapshotAvailability == null ? "0" : currentSnapshotAvailability.toString();

                    bufferedWriter.newLine();

                    bufferedWriter.write(StringUtils.join(new String[] { String.valueOf(item.getId()), item.getBrand(), item.getModelName(),

                            item.getModelNumber(), item.getColor(),currentSnapshotQuantity, plbQuantity }, "\t"));

                }

                bufferedWriter.close();

            } catch (IOException e) {

                logger.error("Could not write mismatches to file", e);

            }

            GmailUtils g = new GmailUtils();

            g.sendSSLMessage(new String[]{ "mandeep.dhir@shop2020.in", "sandeep.sachdeva@shop2020.in", "ashutosh.saxena@shop2020.in", "rajneesh.arora@shop2020.in", "pankaj.kankar@shop2020.in" }, subject, 

                    "", "cnc.center@shop2020.in", "5h0p2o2o", file.getAbsolutePath());

        }

    }

	public int getErrorCode() {

		return errorCode;

	}

	public String getErrorMessage() {

		return errorMessage;

	}

	public String getId(){

		return id;

	}

	public void setId(String id){

		this.id = id;

	}

	public InventoryUpdate getInventoryUpdate() {

		return inventoryUpdate;

	}

	public void setInventoryUpdate(InventoryUpdate inventoryUpdate) {

		this.inventoryUpdate = inventoryUpdate;

	}

	public void setTimestampAndItemIds(String timestampAndItemIds) {

		this.timestampAndItemIds = timestampAndItemIds;

	}

	public String getTimestampAndItemIds() {

		return timestampAndItemIds;

	}

    public boolean isFullPlbSync() {

        return fullPlbSync;

    }

    public void setFullPlbSync(boolean fullPlbSync) {

        this.fullPlbSync = fullPlbSync;

    }

}