Subversion Repositories SmartDukaan

package in.shop2020;

import in.shop2020.logistics.DeliveryType;
import in.shop2020.logistics.LogisticsInfo;
import in.shop2020.logistics.LogisticsServiceException;
import in.shop2020.model.v1.catalog.CatalogService.Client;
import in.shop2020.model.v1.catalog.FlipkartItem;
import in.shop2020.model.v1.catalog.Item;
import in.shop2020.model.v1.catalog.status;
import in.shop2020.model.v1.inventory.FlipkartInventorySnapshot;
import in.shop2020.model.v1.inventory.InventoryType;
import in.shop2020.model.v1.inventory.ItemInventory;
import in.shop2020.model.v1.inventory.Warehouse;
import in.shop2020.model.v1.inventory.WarehouseLocation;
import in.shop2020.model.v1.inventory.WarehouseType;
import in.shop2020.model.v1.order.OrderSource;
import in.shop2020.serving.model.Order;
import in.shop2020.serving.model.OrderItems;
import in.shop2020.thrift.clients.CatalogClient;
import in.shop2020.thrift.clients.InventoryClient;
import in.shop2020.thrift.clients.LogisticsClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.utils.GmailUtils;
import inventory.FlipkartInventoryItem;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.mail.MessagingException;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;

import com.google.gson.Gson;



public class CreateSubmitFlipkartInventoryFeed {
        private static Map<Long, FlipkartInventoryItem> flipkartItemsInventoryMap = new HashMap<Long, FlipkartInventoryItem>();
        private static List<FlipkartItem> flipkartItems;
        private static List<FlipkartItem> flipkartInventoryItems = new ArrayList<FlipkartItem>();
        private static Map<Long,Long> itemIdOrdersMap = new HashMap<Long,Long>();
        private static Map<Long,Item> aliveItemsMap = new HashMap<Long,Item>();
        private static Map<String,Long> heldOrdersMap = new HashMap<String,Long>();
        static java.text.SimpleDateFormat sdf;
        static String emailFromAddress;
        static String password;
        static GmailUtils mailer;
        static String sendTo[];
        static
        {
                sdf = new java.text.SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
                emailFromAddress = "build@shop2020.in";
                password = "cafe@nes";
                mailer = new GmailUtils();
                sendTo = new String[]{"vikram.raghav@shop2020.in"};
                /*sendTo = new String[]{ "sandeep.sachdeva@shop2020.in", "vikram.raghav@shop2020.in", "rajneesh.arora@shop2020.in",
                                "khushal.bhatia@shop2020.in","manoj.kumar@saholic.com","chaitnaya.vats@saholic.com",
                                "yukti.jain@shop2020.in","manoj.pal@shop2020.in","chandan.kumar@shop2020.in","ankush.dhingra@shop2020.in","amar.kumar@shop2020.in"};
                */List<String> flipkartorderids = null;
                Client catalogServiceClient = null;
                try {
                        catalogServiceClient = new CatalogClient().getClient();
                } catch (TTransportException e) {
                        e.printStackTrace();
                }
                try {
                        flipkartItems = catalogServiceClient.getAllFlipkartItems();
                } catch (TException e) {
                        e.printStackTrace();
                }
                for(FlipkartItem flipkartItem:flipkartItems){
                        if(flipkartItem.isIsListedOnFlipkart() && !flipkartItem.isSuppressInventoryFeed())
                                flipkartInventoryItems.add(flipkartItem);
                }
                if(flipkartInventoryItems.size()==0){
                        String text = "";
                        try {
                                mailer.sendSSLMessage(sendTo,"No items to send inventory ", emailFromAddress, password, text);
                                System.exit(0);
                        } catch (MessagingException e) {
                                e.printStackTrace();
                        }
                }
                in.shop2020.model.v1.order.TransactionService.Client transactionClient = null;
                try {
                        flipkartorderids = FetchOrders();
                } catch (ClientProtocolException e1) {
                        e1.printStackTrace();
                } catch (IOException e1) {
                        e1.printStackTrace();
                }
                try {
                        transactionClient = new TransactionClient("support_transaction_service_server_host","transaction_service_server_port").getClient();
                        if(flipkartorderids!=null && flipkartorderids.size()>0){
                                itemIdOrdersMap = transactionClient.getCreatedOrdersForFlipkart(flipkartorderids);
                        }
                } catch (TTransportException e) {
                        try {
                                itemIdOrdersMap = transactionClient.getCreatedOrdersForFlipkart(flipkartorderids);
                        } catch (TException e1) {
                                e1.printStackTrace();
                        }
                        //e.printStackTrace();
                }catch (TException e) {
                        e.printStackTrace();
                }

        }

        public static void main(String[] args) throws ClientProtocolException, TException{
                calculateinventory();
                DefaultHttpClient httpclient = new DefaultHttpClient();
                httpclient = (DefaultHttpClient) WebClientWrapper.wrapClient(httpclient);
                //httpclient.getCredentialsProvider().setCredentials(
                //              new AuthScope("sandbox-api.flipkart.net", 443),
                //              new UsernamePasswordCredentials("og3yg5994bxbxxc1", "8a137068-417c-4e4f-ae95-9295ab938d88"));/// Test Server Access Keys
                httpclient.getCredentialsProvider().setCredentials(
                                new AuthScope("api.flipkart.net", 443),
                                new UsernamePasswordCredentials("m2z93iskuj81qiid","0c7ab6a5-98c0-4cdc-8be3-72c591e0add4")); //Prod Server Access Keys
                HttpPost httppost = new HttpPost("https://api.flipkart.net/sellers/skus/listings/bulk"); // PROD
                //HttpPost httppost = new HttpPost("https://sandbox-api.flipkart.net/sellers/skus/listings/bulk"); // TEST
                StringBuffer jsonRequest = new StringBuffer();
                StringBuffer jsonStart = new StringBuffer();
                jsonStart = jsonStart.append("{\"listings\":[");
                StringBuffer jsonEnd = new StringBuffer();
                jsonEnd.append("]}");
                //System.out.println("JSON request  " + jsonRequest);
                LogisticsClient logisticsServiceClient;
                in.shop2020.logistics.LogisticsService.Client logisticsClient=null;
                LogisticsInfo logisticinfo = null;
                try {
                        logisticsServiceClient = new LogisticsClient("logistics_service_prod_server_host","logistics_service_prod_server_port");
                        logisticsClient = logisticsServiceClient.getClient();

                } catch (TTransportException e) {
                        e.printStackTrace();
                }
                long stock=0;
                int i=0;
                long available,reserve,heldforsource,totalheld,allocable,holdinventory,defaultinventory,actualstock,orders,heldorders;
                StringBuffer inventoryItems =new StringBuffer();
                String tableHeader = "<html><table border=\"1\" align=\"center\"><tr>" 
                        + "<td><b>" + "Product Name" +"</b></td>"
                        +"<td><b>" + "Item ID" + "</b></td>"
                        +"<td><b>" + "Inventory" + "</b></td>"
                        +"<td><b>" + "Orders Added to Inventory" + "</b></td>"
                        +"<td><b>" + "Sent Inventory" + "</b></td>"
                        +"<td><b>" + "Procurement SLA" + "</b></td>"
                        +"<td><b>" + "Orders on Hold" + "</b></td>"
                        +"</tr>";
                String tableFooter = "</table></html>";
                Item item;
                StringBuffer feedResponse=  new StringBuffer();
                List<FlipkartInventorySnapshot> inventorysnapshotlist = new ArrayList<FlipkartInventorySnapshot>();
                for(Entry<Long, FlipkartInventoryItem> entry:flipkartItemsInventoryMap.entrySet()){
                        actualstock=0;
                        orders=0;
                        stock=0;
                        heldorders=0;
                        available = entry.getValue().getAvailability();
                        reserve = entry.getValue().getReserve();
                        heldforsource = entry.getValue().getHeldForSource();
                        totalheld = entry.getValue().getTotalHeldInventory();
                        holdinventory = entry.getValue().getHoldInventory();
                        defaultinventory = entry.getValue().getDefaultInventory();
                        System.out.println("Item ID  " + entry.getKey());
                        System.out.println("Available " + available);
                        System.out.println("Reserve " + reserve);
                        System.out.println("Held For Source " + heldforsource);
                        System.out.println("Total Held " + totalheld);
                        System.out.println("General Hold " + holdinventory );
                        System.out.println("Default Inventory " + defaultinventory);
                        if(!entry.getValue().getStatus().equals(status.PAUSED)){
                                if(entry.getValue().getRisky()){
                                        if((available - reserve) < totalheld && totalheld!=0){
                                                stock = (long) Math.floor(((available - reserve)*heldforsource/totalheld));
                                        }
                                        else{
                                                allocable = available - reserve - totalheld - holdinventory;
                                                if(allocable < 0){
                                                        allocable = 0;
                                                }
                                                stock = Math.round(allocable*1/3) + heldforsource;
                                        }

                                }
                                else{
                                        allocable = available - reserve - totalheld;
                                        if(allocable < 0){
                                                allocable = 0;
                                        }
                                        if((allocable + heldforsource ) > defaultinventory){
                                                stock = Math.round(allocable*1/3) +  heldforsource;
                                        }
                                        else{
                                                stock = defaultinventory;
                                        }
                                }
                                System.out.println("Item ID " + entry.getKey()+" Stock "+stock +" Orders " + itemIdOrdersMap.get(entry.getKey()));
                                actualstock = stock;
                                if(itemIdOrdersMap!=null && itemIdOrdersMap.containsKey(entry.getKey())){
                                        stock = stock + itemIdOrdersMap.get(entry.getKey());  
                                        orders = itemIdOrdersMap.get(entry.getKey());
                                }
                                if(stock<0){
                                        stock =0;
                                }
                                else{
                                        if(stock > 25){
                                                stock=25;
                                        }
                                }
                        }
                        else{
                                stock =0;
                        }
                        try {
                                logisticinfo = logisticsClient.getLogisticsEstimation(entry.getValue().getId(),"110001",DeliveryType.COD);
                        } catch (LogisticsServiceException e) {
                                e.printStackTrace();
                                continue;
                        }
                        catch (TTransportException e) {
                                logisticsServiceClient = new LogisticsClient("logistics_service_prod_server_host","logistics_service_prod_server_port");
                                logisticsClient = logisticsServiceClient.getClient();
                        } 
                        jsonRequest.append("{\"skuId\":"+"\""+entry.getValue().getSkuAtflipkart()+
                                        "\","+"\"attributeValues\""+":"+
                                        "{\"procurement_sla\""+":"+"\""+logisticinfo.getShippingTime()+
                                        "\","+"\"stock_count\""+":"+"\""+stock+"\""+"}}");
                        FlipkartInventorySnapshot inventorySnapshot = new FlipkartInventorySnapshot();
                        inventorySnapshot.setItem_id(entry.getKey());
                        inventorySnapshot.setAvailability(stock);
                        if(heldOrdersMap.containsKey(entry.getValue().getSkuAtflipkart())){
                                inventorySnapshot.setHeldOrders(heldOrdersMap.get(entry.getValue().getSkuAtflipkart()));
                                heldorders = heldOrdersMap.get(entry.getValue().getSkuAtflipkart());
                        }
                        else{
                                inventorySnapshot.setHeldOrders(0);
                        }
                        inventorySnapshot.setCreatedOrders(orders);
                        inventorysnapshotlist.add(inventorySnapshot);
                        item = aliveItemsMap.get(entry.getValue().getId());
                        inventoryItems.append("<tr>" 
                                        + "<td>" +getProductName(item)+"</td>"
                                        +"<td>" + item.getId() + "</td>"
                                        +"<td>" + actualstock + "</td>"
                                        +"<td>" + orders + "</td>"
                                        +"<td>" + stock + "</td>"
                                        +"<td>" + logisticinfo.getShippingTime() + "</td>"
                                        +"<td>" + heldorders + "</td>"
                                        +"</tr>");
                        i++;
                        if(flipkartItemsInventoryMap.entrySet().size()!=1 && (i!=flipkartItemsInventoryMap.entrySet().size()) ){
                                if(i%10!=0){
                                        jsonRequest.append(",");
                                }
                        }
                        if(i%10==0 || i==flipkartItemsInventoryMap.entrySet().size()){
                                StringEntity input = null;
                                try {
                                        input = new StringEntity(jsonStart+jsonRequest.toString()+jsonEnd);
                                        System.out.println("Json input " + jsonStart+jsonRequest.toString()+jsonEnd);
                                        jsonRequest = new StringBuffer();
                                } catch (UnsupportedEncodingException e) {
                                        e.printStackTrace();
                                }
                                input.setContentType("application/json");

                                httppost.setEntity(input);
                                HttpResponse response = null;
                                try {
                                        System.out.println("Before send " );
                                        response = httpclient.execute(httppost);
                                        System.out.println("After send " );
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                                BufferedReader rd = null;
                                try {
                                        rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                                } catch (IllegalStateException e) {
                                        e.printStackTrace();
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                                String line;
                                in.shop2020.model.v1.inventory.InventoryService.Client inventoryServiceClient;
                                try {
                                        while ((line = rd.readLine()) != null) {
                                                System.out.println("Response " + line);
                                                if(line.equalsIgnoreCase("{\"status\":\"success\"}")){
                                                        inventoryServiceClient = new InventoryClient("inventory_service_server_host","inventory_service_server_port").getClient();
                                                        inventoryServiceClient.addOrUpdateFlipkartInventorySnapshot(inventorysnapshotlist);
                                                        inventorysnapshotlist = new ArrayList<FlipkartInventorySnapshot>();
                                                }
                                                else{
                                                        feedResponse.append(line);
                                                }

                                        }
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                }
                System.out.println("Before sending email");
                String text = tableHeader+inventoryItems.toString()+tableFooter;
                try {
                        mailer.sendSSLMessage(sendTo,"Flipkart Inventory Sent Details ", emailFromAddress, password, text);
                } catch (MessagingException e) {
                        e.printStackTrace();
                }
                if(feedResponse.toString().length()>0){
                        try {
                                mailer.sendSSLMessage(sendTo, "Flipkart Inventory could not be updated ", feedResponse.toString(), emailFromAddress, password,new ArrayList<File>());
                        } catch (MessagingException e) {
                                e.printStackTrace();
                        }
                }
                else{
                        try {
                                mailer.sendSSLMessage(sendTo, "Flipkart Inventory updated successfully ", feedResponse.toString(), emailFromAddress, password,new ArrayList<File>());
                        } catch (MessagingException e) {
                                e.printStackTrace();
                        }
                }
        }

        private static void calculateinventory(){
                CatalogClient catalogServiceClient = null;
                Map<Long,ItemInventory> availability= new HashMap<Long,ItemInventory>();
                try {
                        catalogServiceClient = new CatalogClient();
                } catch (TTransportException e) {
                        e.printStackTrace();
                }
                in.shop2020.model.v1.catalog.CatalogService.Client catalogClient = catalogServiceClient.getClient();
                try {
                        List<Item> aliveItems = catalogClient.getAllAliveItems();
                        for(in.shop2020.model.v1.catalog.Item thriftItem:aliveItems){
                                aliveItemsMap.put(thriftItem.getId(), thriftItem);

                        }
                        InventoryClient inventoryServiceClient = new InventoryClient();
                        try {
                                inventoryServiceClient = new InventoryClient();
                        } catch (TTransportException e) {
                                e.printStackTrace();
                        }
                        in.shop2020.model.v1.inventory.InventoryService.Client inventoryClient = inventoryServiceClient.getClient();
                        List<in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems> ignoreItems = inventoryClient.getIgnoredWarehouseidsAndItemids();
                        availability = inventoryClient.getInventorySnapshot(0);
                        List<Warehouse> allwarehouses = inventoryClient.getWarehouses(null,null,0,0,0);
                        Map<Long,Warehouse> allWarehousesMap = new HashMap<Long,Warehouse>();
                        for(Warehouse warehouse:allwarehouses){
                                allWarehousesMap.put(warehouse.getId(),warehouse);
                        }
                        List<Warehouse> warehouses = inventoryClient.getWarehouses(WarehouseType.OURS_THIRDPARTY,null,0,0,0);
                        List<Warehouse> ours_warehouses = inventoryClient.getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 0, 0, 0);
                        List<Long> thirdpartywarehouseids = new ArrayList<Long>();
                        List<Long> oursGoodWarehouse = new ArrayList<Long>();
                        for(Warehouse warehouse:warehouses){
                                thirdpartywarehouseids.add(warehouse.getId());
                        }
                        for (Warehouse warehouse:ours_warehouses){
                                oursGoodWarehouse.add(warehouse.getId());
                        }
                        long available=0;
                        long reserve=0;
                        long total_warehouse_held=0;
                        long heldForSource=0;
                        long total_held=0;
                        double nlc=0;
                        double maxnlc=0;
                        Item thriftItem;
                        for(FlipkartItem flipkartItem:flipkartInventoryItems){
                                if(aliveItemsMap.get(flipkartItem.getItem_id()) != null){
                                        thriftItem = aliveItemsMap.get(flipkartItem.getItem_id());      
                                }
                                else{
                                        continue;
                                }
                                available=0;
                                reserve=0;
                                total_warehouse_held=0;
                                heldForSource=0;
                                total_held=0;
                                nlc=0;
                                List<Warehouse> vendor_warehouses=null;
                                FlipkartInventoryItem item;
                                if(availability.get(thriftItem.getId())!=null){ 
                                        ItemInventory iteminventory = availability.get(thriftItem.getId());
                                        Map<Long,Long> itemavailability = new HashMap<Long,Long>();
                                        itemavailability = iteminventory.getAvailability();
                                        if (thriftItem.isIsWarehousePreferenceSticky() && thriftItem.getPreferredVendor()!=0){
                                                //System.out.println("Item id "+thriftItem.getId()+".Found prefered vendor and warehouse is marked sticky (Calculating availability)"+thriftItem.getPreferredVendor());                                         
                                                vendor_warehouses = inventoryClient.getWarehouses(WarehouseType.THIRD_PARTY,InventoryType.GOOD , thriftItem.getPreferredVendor(), 0, 0);
                                                vendor_warehouses.addAll(ours_warehouses);
                                                for (Warehouse warehouse:vendor_warehouses){
                                                        if(warehouse.getBillingWarehouseId()!=7){
                                                                if(warehouse.getLogisticsLocation().equals(WarehouseLocation.Delhi) && warehouse.getWarehouseType().equals(WarehouseType.THIRD_PARTY) && warehouse.getVendor().getId()!=1){

                                                                }
                                                                else{
                                                                        continue;
                                                                }
                                                        }
                                                        in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems ignoredItem = new in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems();
                                                        ignoredItem.setItemId(thriftItem.getId());
                                                        ignoredItem.setWarehouseId(warehouse.getId());
                                                        if (itemavailability.get(warehouse.getId())!=null && !thirdpartywarehouseids.contains(warehouse.getId()) && !ignoreItems.contains(ignoredItem)){
                                                                try{
                                                                        nlc = inventoryClient.getNlcForWarehouse(warehouse.getId(),thriftItem.getId());
                                                                }
                                                                catch(TTransportException e){
                                                                        inventoryClient = inventoryServiceClient.getClient(); 
                                                                        nlc = inventoryClient.getNlcForWarehouse(warehouse.getId(),thriftItem.getId());
                                                                }
                                                                maxnlc = flipkartItem.getMaxNlc();

                                                                //System.out.println("itemId:" + thriftItem.getId() + "\tmaxnlc: " + maxnlc + "\tnlc:" + nlc + "\twid:" + warehouse.getId() );
                                                                if(nlc !=0 && (maxnlc >= nlc)){
                                                                        total_warehouse_held = inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), warehouse.getId(), 0);
                                                                        heldForSource = heldForSource + total_warehouse_held - inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), warehouse.getId(), 8);
                                                                        available = available + itemavailability.get(warehouse.getId());
                                                                        total_held = total_held + total_warehouse_held; 
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\tavailable:" + available);
                                                                }
                                                                else if(maxnlc==0){
                                                                        total_warehouse_held = inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), warehouse.getId(), 0);
                                                                        heldForSource = heldForSource + total_warehouse_held - inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), warehouse.getId(), 8);
                                                                        available = available + itemavailability.get(warehouse.getId());
                                                                        total_held = total_held + total_warehouse_held;
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\tavailable:" + available);
                                                                }
                                                        }
                                                }
                                        }
                                        else{
                                                for (Map.Entry<Long,Long> entry :  itemavailability.entrySet()) {
                                                        if(allWarehousesMap.get(entry.getKey()).getBillingWarehouseId()!=7){
                                                                if(allWarehousesMap.get(entry.getKey()).getLogisticsLocation().equals(WarehouseLocation.Delhi) && allWarehousesMap.get(entry.getKey()).getWarehouseType().equals(WarehouseType.THIRD_PARTY) && allWarehousesMap.get(entry.getKey()).getVendor().getId()!=1){

                                                                }
                                                                else{
                                                                        continue;
                                                                }
                                                        }
                                                        in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems ignoredItem = new in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems();
                                                        ignoredItem.setItemId(thriftItem.getId());
                                                        ignoredItem.setWarehouseId(entry.getKey());
                                                        if(!thirdpartywarehouseids.contains(entry.getKey()) && !ignoreItems.contains(ignoredItem)){

                                                                nlc = inventoryClient.getNlcForWarehouse(entry.getKey(),thriftItem.getId());
                                                                maxnlc = flipkartItem.getMaxNlc();
                                                                //System.out.println("itemId:" + thriftItem.getId() + "\tmaxnlc: " + maxnlc + "\tnlc:" + nlc + "\twid:" + entry.getKey() );
                                                                if(nlc !=0 && (maxnlc >= nlc)){
                                                                        total_warehouse_held = inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), entry.getKey(), 0);
                                                                        heldForSource = heldForSource + total_warehouse_held - inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), entry.getKey(), 8);
                                                                        available =  available + entry.getValue();
                                                                        total_held = total_held + total_warehouse_held;
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\tavailable:" + available);
                                                                }
                                                                else if(maxnlc==0){
                                                                        total_warehouse_held = inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), entry.getKey(), 0);
                                                                        heldForSource = heldForSource + total_warehouse_held - inventoryClient.getHoldInventoryDetailForItemForWarehouseIdExceptSource(thriftItem.getId(), entry.getKey(), 8);
                                                                        available = available + itemavailability.get(entry.getKey());
                                                                        total_held = total_held + total_warehouse_held;
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\tavailable:" + available);
                                                                }

                                                        }
                                                }
                                        }
                                        Map<Long,Long> itemreserve = new HashMap<Long,Long>();
                                        itemreserve = iteminventory.getReserved();
                                        if (thriftItem.isIsWarehousePreferenceSticky() && thriftItem.getPreferredVendor()!=0){
                                                //System.out.println("Item id "+thriftItem.getId()+".Found prefered vendor and warehouse is marked sticky (Calculating Reserve)"+thriftItem.getPreferredVendor());
                                                for (Warehouse warehouse:vendor_warehouses){
                                                        if(warehouse.getBillingWarehouseId()!=7){
                                                                if(warehouse.getLogisticsLocation().equals(WarehouseLocation.Delhi) && warehouse.getWarehouseType().equals(WarehouseType.THIRD_PARTY) && warehouse.getVendor().getId()!=1){

                                                                }
                                                                else{
                                                                        continue;
                                                                }
                                                        }
                                                        in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems ignoredItem = new in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems();
                                                        ignoredItem.setItemId(thriftItem.getId());
                                                        ignoredItem.setWarehouseId(warehouse.getId());
                                                        if (itemreserve.get(warehouse.getId())!=null && !thirdpartywarehouseids.contains(warehouse.getId()) && !ignoreItems.contains(warehouse.getId())){
                                                                nlc = inventoryClient.getNlcForWarehouse(warehouse.getId(),thriftItem.getId());
                                                                maxnlc = flipkartItem.getMaxNlc();
                                                                //System.out.println("itemId:" + thriftItem.getId() + "\tmaxnlc: " + maxnlc + "\tnlc:" + nlc + "\twid:" + warehouse.getId() );
                                                                if(nlc !=0 && (maxnlc >= nlc)){
                                                                        reserve = reserve + itemreserve.get(warehouse.getId());
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\treserve:" + reserve);
                                                                }
                                                                else if(maxnlc==0){
                                                                        reserve = reserve + itemreserve.get(warehouse.getId());
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\treserve:" + reserve);
                                                                }

                                                        }
                                                }
                                        }else{
                                                for (Map.Entry<Long,Long> entry : itemreserve.entrySet()) {
                                                        if(allWarehousesMap.get(entry.getKey()).getBillingWarehouseId()!=7){
                                                                if(allWarehousesMap.get(entry.getKey()).getLogisticsLocation().equals(WarehouseLocation.Delhi) && allWarehousesMap.get(entry.getKey()).getWarehouseType().equals(WarehouseType.THIRD_PARTY) && allWarehousesMap.get(entry.getKey()).getVendor().getId()!=1){

                                                                }
                                                                else{
                                                                        continue;
                                                                }
                                                        }
                                                        in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems ignoredItem = new in.shop2020.model.v1.inventory.IgnoredInventoryUpdateItems();
                                                        ignoredItem.setItemId(thriftItem.getId());
                                                        ignoredItem.setWarehouseId(entry.getKey());
                                                        if(!thirdpartywarehouseids.contains(entry.getKey()) && !ignoreItems.contains(ignoredItem)){
                                                                nlc = inventoryClient.getNlcForWarehouse(entry.getKey(),thriftItem.getId());
                                                                maxnlc = flipkartItem.getMaxNlc();
                                                                //System.out.println("itemId:" + thriftItem.getId() + "\tmaxnlc: " + maxnlc + "\tnlc:" + nlc + "\twid:" + entry.getKey() );
                                                                if(nlc !=0 && (maxnlc >= nlc)){
                                                                        reserve =  reserve + entry.getValue();
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\treserve:" + reserve);
                                                                }
                                                                else if(maxnlc==0){
                                                                        reserve =  reserve + entry.getValue();
                                                                        //System.out.println("itemId:" + thriftItem.getId() + "\ttotal_held: " + total_held + "\theldForSource:" + heldForSource + "\treserve:" + reserve);
                                                                }

                                                        }

                                                        else{
                                                                //System.out.println("skipping inventory for warehouse id " + entry.getKey());
                                                        }
                                                }
                                        }
                                        item= new FlipkartInventoryItem(thriftItem.getId(),available,reserve,heldForSource,thriftItem.getHoldInventory(),thriftItem.getDefaultInventory(),total_held,thriftItem.isRisky(),thriftItem.getItemStatus(),flipkartItem.getSkuAtFlipkart());
                                        //System.out.println("itemId:" + thriftItem.getId() + "\tavailable: " + available + "\treserve" + reserve + "\theldForSource:" + heldForSource + "\twebsite_hold:" + thriftItem.getHoldInventory() + "\tdefault_inv:" +thriftItem.getDefaultInventory());
                                }
                                else{
                                        item = new FlipkartInventoryItem(thriftItem.getId(),0,0,0,thriftItem.getHoldInventory(),thriftItem.getDefaultInventory(),0,thriftItem.isRisky(),thriftItem.getItemStatus(),flipkartItem.getSkuAtFlipkart());
                                        //System.out.println("itemId:" + thriftItem.getId() + "\tavailable: " + available + "\treserve" + reserve + "\theldForSource:" + heldForSource + "\twebsite_hold:" + thriftItem.getHoldInventory() + "\tdefault_inv:" +thriftItem.getDefaultInventory());
                                }

                                //System.out.println(" Item details are " + thriftItem.getId() +" " + available + " " + reserve + " " + thriftItem.getHoldInventory() + " "+ thriftItem.getDefaultInventory() + " " + thriftItem.isRisky());
                                //System.out.println("+++++++++++++++++++++++");
                                flipkartItemsInventoryMap.put(thriftItem.getId(),item);

                        }

                } catch (TException e) {
                        e.printStackTrace();
                }
        }

        static List<String> FetchOrders() throws ClientProtocolException, IOException{
                HttpClient client = new DefaultHttpClient();
                HttpPost post = new HttpPost("https://seller.flipkart.com/login");
                BufferedReader rd= null;
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
                nameValuePairs.add(new BasicNameValuePair("authName",
                "flipkart"));
                nameValuePairs.add(new BasicNameValuePair("username",
                "flipkart-support@saholic.com"));
                nameValuePairs.add(new BasicNameValuePair("password",
                "076c27ee24d7596b06608a8ed2559f87"));
                post.setEntity(new UrlEncodedFormEntity(nameValuePairs,"utf-8"));
                HttpResponse response = client.execute(post);
                rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                String line = "";
                Gson gson;
                List<Order> orders = new ArrayList<Order>(); 
                OrderItems new_orders;
                OrderItems conf_orders;
                HttpGet get_new;
                HttpGet get_conf; 
                long time;
                int i=1;
                while ((line = rd.readLine()) != null) {
                        System.out.println(line);
                }
                time = System.currentTimeMillis();
                while(true){
                        get_new = new HttpGet("https://seller.flipkart.com/dashboard/som/new_order_items?status=on_hold%2Capproved.payment_approved&sort=confirm_by_date&page="+i+"&page_size=100&_="+time);
                        response = client.execute(get_new);
                        rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                        line = "";
                        gson = new Gson();
                        new_orders = (OrderItems) gson.fromJson(rd, OrderItems.class);
                        if(new_orders.getOrder_items().size()>0){
                                orders.addAll(new_orders.getOrder_items());
                        }
                        else{
                                break;
                        }
                        i++;
                }
                i=1;
                time = System.currentTimeMillis();
                while(true){
                        get_conf = new HttpGet("https://seller.flipkart.com/dashboard/som/confirmed_order_items?status=approved.seller_approved&sort=confirm_by_date&page="+i+"&page_size=100&_="+time);
                        response = client.execute(get_conf);
                        rd = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                        line = "";
                        gson = new Gson();
                        conf_orders = (OrderItems) gson.fromJson(rd, OrderItems.class);
                        if(conf_orders.getOrder_items().size()>0){
                                orders.addAll(conf_orders.getOrder_items());
                        }
                        else{
                                break;
                        }
                        i++;
                }
                List<String> orderIdList = new ArrayList<String>();
                Long heldOrders = 0L;
                for(Order order:orders){
                        //System.out.println("Order  " + order.getExternalId() +" "+order.getOrderItemId() + " : "+ order.getStatus() + " "+order.getStatusDateMessage() + " "
                        //              + order.getStatusLabel() + " " + order.getPickup_by_date() + " "+ order.getTrackingId());
                        orderIdList.add(order.getExternalId());
                        if(order.getStatus().equalsIgnoreCase("on_hold")){
                                if(heldOrdersMap.containsKey(String.valueOf(order.getSku()))){
                                        heldOrders = heldOrdersMap.get(String.valueOf(order.getSku()))+order.getQuantity();
                                        heldOrdersMap.put(String.valueOf(order.getSku()),heldOrders);
                                        System.out.println("Item ID " + order.getSku() + " Held Orders " + heldOrdersMap.get(String.valueOf(order.getSku())));
                                }
                                else{
                                        heldOrders = (long) order.getQuantity();
                                        heldOrdersMap.put(String.valueOf(order.getSku()),heldOrders);
                                        System.out.println("Item ID " + order.getSku() + " Held Orders " + heldOrdersMap.get(String.valueOf(order.getSku())));
                                }
                        }
                }
                return orderIdList; 
        }
        static String getProductName(Item item){
                return getName(item.getBrand())+" " + getName(item.getModelName())+" " + getName(item.getModelNumber())+" " + getName(item.getColor()); 

        }
        static String getName(String name){
                if(name==null || name.length()==0){
                        return "";
                }
                else{
                        return name;
                }
        }
}