Subversion Repositories SmartDukaan

Rev

Rev 14753 | Rev 14755 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
6484 amar.kumar 1 
package in.shop2020.warehouse.util;
2 
 
14754 manish.sha 3 
import in.shop2020.model.v1.catalog.CatalogService;
4 
import in.shop2020.model.v1.catalog.Item;
14751 manish.sha 5 
import in.shop2020.model.v1.inventory.BillingType;
6 
import in.shop2020.model.v1.inventory.InventoryService;
7 
import in.shop2020.model.v1.inventory.InventoryServiceException;
8 
import in.shop2020.model.v1.inventory.InventoryType;
9 
import in.shop2020.model.v1.inventory.ItemInventory;
10 
import in.shop2020.model.v1.inventory.Warehouse;
11 
import in.shop2020.model.v1.inventory.WarehouseType;
14754 manish.sha 12 
import in.shop2020.thrift.clients.CatalogClient;
14751 manish.sha 13 
import in.shop2020.thrift.clients.InventoryClient;
14 
import in.shop2020.utils.GmailUtils;
15 
import in.shop2020.warehouse.InventoryAvailability;
16 
import in.shop2020.warehouse.handler.ScanHandler;
17 
 
6484 amar.kumar 18 
import java.io.BufferedWriter;
19 
import java.io.File;
20 
import java.io.FileWriter;
21 
import java.io.IOException;
22 
import java.util.ArrayList;
14751 manish.sha 23 
import java.util.Arrays;
6484 amar.kumar 24 
import java.util.HashMap;
25 
import java.util.List;
26 
import java.util.Map;
27 
 
28 
import javax.mail.MessagingException;
29 
 
30 
import org.apache.commons.lang.StringUtils;
31 
import org.apache.thrift.TException;
32 
import org.springframework.context.ApplicationContext;
33 
import org.springframework.context.support.ClassPathXmlApplicationContext;
34 
 
35 
public class InventoryMismatchGenerator {
36 
 
14751 manish.sha 37 
	private ScanHandler scanHandler;
38 
 
6484 amar.kumar 39 
	/**
40 
	 * @param args
41 
	 */
42 
 
43 
	public InventoryMismatchGenerator() {
44 
		ApplicationContext context = new ClassPathXmlApplicationContext("context.xml");
14751 manish.sha 45 
		scanHandler = context.getBean(ScanHandler.class);
6484 amar.kumar 46 
	}
47 
 
48 
	public static void main(String[] args) {
49 
		InventoryMismatchGenerator mismatchGenerator = new InventoryMismatchGenerator();
50 
		try {
51 
			mismatchGenerator.sendMailForMismatches();
14751 manish.sha 52 
		} catch (Exception e) {
6484 amar.kumar 53 
			// TODO Auto-generated catch block
54 
			e.printStackTrace();
55 
		}
56 
	}
57 
 
14751 manish.sha 58 
	public void sendMailForMismatches() throws MessagingException, TException, InventoryServiceException {
59 
 
60 
		List<InventoryMismatchUnit> inventoryMismatches = new ArrayList<InventoryMismatchUnit>();
6484 amar.kumar 61 
 
14751 manish.sha 62 
		InventoryClient inventoryClient = new InventoryClient();
63 
 
14754 manish.sha 64 
		CatalogClient catalogClient = new CatalogClient();
65 
 
66 
		CatalogService.Client catalogServiceClient = catalogClient.getClient();
67 
 
14751 manish.sha 68 
		InventoryService.Client invClient = inventoryClient.getClient();
69 
 
14754 manish.sha 70 
		List<Item> allAliveItems = catalogServiceClient.getAllAliveItems();
71 
 
72 
		Map<Long, Item> allAliveItemsMap = new HashMap<Long, Item>();
73 
 
14751 manish.sha 74 
		Map<Long, ItemInventory> itemInventoryMap = invClient.getInventorySnapshot(0);
75 
		List<Warehouse> allWarehouses = invClient.getAllWarehouses(false);
76 
 
77 
		List<Long> PHYSICAL_WAREHOUSE_IDS = Arrays.asList(7L,13L,1765L,3298L,3931L);
78 
		Map<Long, Warehouse> allWarehousesMap = new HashMap<Long, Warehouse>();
79 
 
80 
		List<InventoryAvailability> totalInventoryList;
81 
 
82 
		for(Warehouse wh : allWarehouses){
83 
			allWarehousesMap.put(wh.getId(), wh);
84 
		}
85 
 
14754 manish.sha 86 
		for(Item item: allAliveItems){
87 
			allAliveItemsMap.put(item.getId(), item);
88 
		}
89 
 
14751 manish.sha 90 
		for(Long physicalWarehouseId : PHYSICAL_WAREHOUSE_IDS){
91 
			totalInventoryList = new ArrayList<InventoryAvailability>();
92 
 
93 
			List<InventoryAvailability> serializedInventoryList = scanHandler.getCurrentSerializedInventoryByScans(physicalWarehouseId);
94 
			List<InventoryAvailability> nonSerializedInventoryList = scanHandler.getCurrentNonSerializedInventoryByScans(physicalWarehouseId);
95 
 
96 
			totalInventoryList.addAll(serializedInventoryList);
97 
			totalInventoryList.addAll(nonSerializedInventoryList);
98 
 
14753 manish.sha 99 
			Map<Long, InventoryAvailability> totalInventoryMap = new HashMap<Long, InventoryAvailability>();
100 
 
14751 manish.sha 101 
			for(InventoryAvailability availability : totalInventoryList){
14754 manish.sha 102 
				totalInventoryMap.put(availability.getItemId(), availability);
103 
			}
104 
 
105 
			for(InventoryAvailability availability : totalInventoryList){
14751 manish.sha 106 
				long totalInventoryAsCatalog = 0;
14754 manish.sha 107 
				if(itemInventoryMap.containsKey(availability.getItemId())){
108 
					ItemInventory itemInvObj = itemInventoryMap.get(availability.getItemId());
14753 manish.sha 109 
					Map<Long, Long> itemAvailibility = itemInvObj.getAvailability();
110 
					for(Long whId : itemAvailibility.keySet()){
111 
						Warehouse warehouse = allWarehousesMap.get(whId);
112 
						if(warehouse.getBillingType() == BillingType.OURS && warehouse.getBillingWarehouseId()==physicalWarehouseId &&
113 
						   warehouse.getInventoryType()==InventoryType.GOOD && warehouse.getWarehouseType() == WarehouseType.OURS){
114 
							totalInventoryAsCatalog = totalInventoryAsCatalog + itemAvailibility.get(whId);
115 
						}
14751 manish.sha 116 
					}
14753 manish.sha 117 
					InventoryMismatchUnit invMismatchUnit = new InventoryMismatchUnit();
118 
					invMismatchUnit.setItemId(availability.getItemId());
119 
					invMismatchUnit.setBrand(availability.getBrand());
120 
					invMismatchUnit.setModelName(availability.getModelName());
121 
					invMismatchUnit.setModelNumber(availability.getModelNumber());
122 
					invMismatchUnit.setColor(availability.getColor());
123 
					invMismatchUnit.setQuantityAsPerScans(availability.getQuantity());
124 
					invMismatchUnit.setQuantityAsPerCatalog(totalInventoryAsCatalog);
125 
					inventoryMismatches.add(invMismatchUnit);
126 
				}else{
127 
					InventoryMismatchUnit invMismatchUnit = new InventoryMismatchUnit();
128 
					invMismatchUnit.setItemId(availability.getItemId());
129 
					invMismatchUnit.setBrand(availability.getBrand());
130 
					invMismatchUnit.setModelName(availability.getModelName());
131 
					invMismatchUnit.setModelNumber(availability.getModelNumber());
132 
					invMismatchUnit.setColor(availability.getColor());
133 
					invMismatchUnit.setQuantityAsPerScans(availability.getQuantity());
134 
					invMismatchUnit.setQuantityAsPerCatalog(totalInventoryAsCatalog);
135 
					inventoryMismatches.add(invMismatchUnit);
14751 manish.sha 136 
				}
137 
			}
138 
 
14754 manish.sha 139 
			for(Long itemId : itemInventoryMap.keySet()){
140 
				Item it = null;
141 
				if(!totalInventoryMap.containsKey(itemId)){
142 
					if(allAliveItemsMap.containsKey(itemId)){
143 
						it = allAliveItemsMap.get(itemId);
144 
					}else{
145 
						continue;
146 
					}
147 
				}else{
148 
					continue;
149 
				}
150 
				long totalInventoryAsCatalog = 0;
151 
				ItemInventory itemInvObj = itemInventoryMap.get(itemId);
152 
				Map<Long, Long> itemAvailibility = itemInvObj.getAvailability();
153 
				for(Long whId : itemAvailibility.keySet()){
154 
					Warehouse warehouse = allWarehousesMap.get(whId);
155 
					if(warehouse.getBillingType() == BillingType.OURS && warehouse.getBillingWarehouseId()==physicalWarehouseId &&
156 
					   warehouse.getInventoryType()==InventoryType.GOOD && warehouse.getWarehouseType() == WarehouseType.OURS){
157 
						totalInventoryAsCatalog = totalInventoryAsCatalog + itemAvailibility.get(whId);
158 
					}
159 
				}
160 
				InventoryMismatchUnit invMismatchUnit = new InventoryMismatchUnit();
161 
				invMismatchUnit.setItemId(it.getId());
162 
				invMismatchUnit.setBrand(it.getBrand());
163 
				invMismatchUnit.setModelName(it.getModelName());
164 
				invMismatchUnit.setModelNumber(it.getModelNumber());
165 
				invMismatchUnit.setColor(it.getColor());
166 
				invMismatchUnit.setQuantityAsPerScans(0);
167 
				invMismatchUnit.setQuantityAsPerCatalog(totalInventoryAsCatalog);
168 
				inventoryMismatches.add(invMismatchUnit);
169 
			}
170 
 
14751 manish.sha 171 
		}
172 
 
173 
		/*
174 
 
175 
 
176 
 
6484 amar.kumar 177 
		List<Map<String, Integer>> serializedInventorybyScansinList = inventoryItemhandler.getCurrentSerializedInventory();
178 
		List<Map<String, Integer>> unSerializedInventorybyScansinList = inventoryItemhandler.getCurrentNonSerializedInventory();
14751 manish.sha 179 
 
180 
 
6484 amar.kumar 181 
 
182 
		Map<Long, Long> itemAvailabilityByScans = new HashMap<Long, Long>();
183 
 
184 
		for (Map<String,Integer> inventoryForItem : serializedInventorybyScansinList) {
185 
			Object sumObj = inventoryForItem.get("sum");
186 
			String sumString = sumObj.toString();
187 
			Long availability = Long.parseLong(sumString);
188 
			itemAvailabilityByScans.put(Long.parseLong(inventoryForItem.get("itemId").toString()), availability);
189 
		}
190 
 
191 
		for (Map<String,Integer> inventoryForItem : unSerializedInventorybyScansinList) {
192 
			Object sumObj = inventoryForItem.get("sum");
193 
			String sumString = sumObj.toString();
194 
			Long availability = Long.parseLong(sumString);
195 
			itemAvailabilityByScans.put(Long.parseLong(inventoryForItem.get("itemId").toString()), availability);
196 
		}
197 
 
198 
 
199 
 
200 
		Map<Long, Long> itemAvailabilitiesOnSite = null;
201 
 
202 
		try {
203 
			in.shop2020.model.v1.catalog.CatalogService.Client catalogClient = new CatalogClient().getClient();
6493 amar.kumar 204 
			List<Item> activeItems = 	catalogClient.getAllItems(false);
6484 amar.kumar 205 
			List<Long> itemIds = new ArrayList<Long>();
206 
			for(Item item : activeItems) {
207 
				itemIds.add(item.getId());
208 
			}
14751 manish.sha 209 
			 Client inventoryClient = new InventoryClient().getClient();
210 
			itemAvailabilitiesOnSite = inventoryClient.getItemAvailabilitiesAtOurWarehouses(itemIds);
6484 amar.kumar 211 
		} catch (TException e) {
212 
			e.printStackTrace();
213 
			return;
214 
		} catch (CatalogServiceException e) {
215 
			// TODO Auto-generated catch block
216 
			e.printStackTrace();
217 
		}
218 
 
219 
 
220 
		for( Long itemId : itemAvailabilitiesOnSite.keySet()) {
221 
			if(itemAvailabilityByScans.containsKey(itemId)) {
222 
				if(itemAvailabilitiesOnSite.get(itemId)!=itemAvailabilityByScans.get(itemId)) {
223 
					Long[] mismatch = new Long[2];
224 
					mismatch[0] = itemAvailabilityByScans.get(itemId);
225 
					mismatch[1] = itemAvailabilitiesOnSite.get(itemId);
226 
					availabilityMismatchMap.put(itemId, mismatch);
227 
				}
228 
			} else  {
229 
				if(itemAvailabilitiesOnSite.get(itemId)!=0) {
230 
					Long[] mismatch = new Long[2];
231 
					mismatch[0] = 0L;
232 
					mismatch[1] = itemAvailabilitiesOnSite.get(itemId);
233 
					availabilityMismatchMap.put(itemId, mismatch);
234 
				}
235 
			}
236 
		}
237 
 
238 
		for( Long itemId : itemAvailabilityByScans.keySet()) {
239 
			if(!availabilityMismatchMap.containsKey(itemId)) {
240 
				if(itemAvailabilitiesOnSite.containsKey(itemId)) {
241 
					if(itemAvailabilitiesOnSite.get(itemId)!=0 && (itemAvailabilitiesOnSite.get(itemId)!=itemAvailabilityByScans.get(itemId))) {
242 
						Long[] mismatch = new Long[2];
243 
						mismatch[0] = itemAvailabilityByScans.get(itemId);
244 
						mismatch[1] = itemAvailabilitiesOnSite.get(itemId);
245 
						availabilityMismatchMap.put(itemId, mismatch);
246 
					}
9849 amar.kumar 247 
				} else {
6484 amar.kumar 248 
					if(itemAvailabilityByScans.get(itemId)!=0) {
249 
						Long[] mismatch = new Long[2];
250 
						mismatch[0] = itemAvailabilityByScans.get(itemId);
251 
						mismatch[1] = 0L;
252 
						availabilityMismatchMap.put(itemId, mismatch);
253 
					}
254 
				}
255 
			}
14751 manish.sha 256 
		}*/
257 
		int mismatchRecordsNumber = 0;
9851 amar.kumar 258 
        //String subject = availabilityMismatchMap.size() + " mismatches in inventory compared to scan Records: ";
6484 amar.kumar 259 
        File file = new File("inv_mismatches.xls");
260 
 
261 
        try {
262 
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
263 
            bufferedWriter.write(StringUtils.join(new String[] { "Item Id",
264 
                    "Brand", "Model Name", "Model Number",
265 
                    "Color", "Inventory shown", "Inventory through Scans" }, '\t'));
14751 manish.sha 266 
            for (InventoryMismatchUnit invUnit : inventoryMismatches) {
267 
            	if(invUnit.getQuantityAsPerScans()==invUnit.getQuantityAsPerCatalog()){
9217 amar.kumar 268 
            		continue;
269 
            	}
6484 amar.kumar 270 
                bufferedWriter.newLine();
14751 manish.sha 271 
                bufferedWriter.write(StringUtils.join(new String[] { String.valueOf(invUnit.getItemId()), invUnit.getBrand(), invUnit.getModelName(),
272 
                		invUnit.getModelNumber(), invUnit.getColor(),invUnit.getQuantityAsPerCatalog()+"", invUnit.getQuantityAsPerScans()+"" }, "\t"));
273 
                mismatchRecordsNumber++;
6484 amar.kumar 274 
            }
275 
            bufferedWriter.close();
276 
        } catch (IOException e) {
14751 manish.sha 277 
 
6484 amar.kumar 278 
        }
9851 amar.kumar 279 
        String subject = mismatchRecordsNumber + " mismatches in inventory compared to scan Records: ";
6484 amar.kumar 280 
        GmailUtils g = new GmailUtils();
14751 manish.sha 281 
        g.sendSSLMessage(new String[]{ "manish.sharma@shop2020.in"/*,"sandeep.sachdeva@shop2020.in","rajveer.singh@shop2020.in"*/ }, subject,
282 
                "", "adwords@shop2020.in", "adwords_shop2020", file.getAbsolutePath());
6484 amar.kumar 283 
	}
284 
}