Subversion Repositories SmartDukaan

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
23784 ashik.ali 1 
package com.spice.profitmandi.web.controller;
2 
 
3 
import java.util.HashMap;
4 
import java.util.HashSet;
5 
import java.util.List;
6 
import java.util.Map;
7 
import java.util.Set;
8 
 
9 
import javax.servlet.http.HttpServletRequest;
10 
 
11 
import org.apache.logging.log4j.LogManager;
12 
import org.apache.logging.log4j.Logger;
13 
import org.springframework.beans.factory.annotation.Autowired;
14 
import org.springframework.beans.factory.annotation.Qualifier;
15 
import org.springframework.http.ResponseEntity;
16 
import org.springframework.stereotype.Controller;
17 
import org.springframework.transaction.annotation.Transactional;
18 
import org.springframework.ui.Model;
19 
import org.springframework.web.bind.annotation.RequestBody;
20 
import org.springframework.web.bind.annotation.RequestMapping;
21 
import org.springframework.web.bind.annotation.RequestMethod;
22 
import org.springframework.web.bind.annotation.RequestParam;
23 
 
24 
import com.spice.profitmandi.common.enumuration.ItemType;
25 
import com.spice.profitmandi.common.enumuration.ScanType;
26 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
27 
import com.spice.profitmandi.common.model.CreateItemRequest;
28 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
29 
import com.spice.profitmandi.common.model.ScanInItemRequest;
30 
import com.spice.profitmandi.common.model.ScanOutItemRequest;
31 
import com.spice.profitmandi.common.web.util.ResponseSender;
32 
import com.spice.profitmandi.dao.entity.nonbillable.AdminCurrentInventorySnapshot;
33 
import com.spice.profitmandi.dao.entity.nonbillable.AdminDeliveryNote;
34 
import com.spice.profitmandi.dao.entity.nonbillable.Item;
35 
import com.spice.profitmandi.dao.entity.nonbillable.PartnerCurrentInventorySnapshot;
36 
import com.spice.profitmandi.dao.entity.nonbillable.Vendor;
37 
import com.spice.profitmandi.dao.entity.nonbillable.Warehouse;
38 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
39 
import com.spice.profitmandi.dao.repository.nonbillable.AdminCurrentInventorySnapshotRepository;
40 
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteRepository;
41 
import com.spice.profitmandi.dao.repository.nonbillable.AdminInventoryItemRepository;
42 
import com.spice.profitmandi.dao.repository.nonbillable.ItemRepository;
43 
import com.spice.profitmandi.dao.repository.nonbillable.PartnerCurrentInventorySnapshotRepository;
44 
import com.spice.profitmandi.dao.repository.nonbillable.UserWarehouseRepository;
45 
import com.spice.profitmandi.dao.repository.nonbillable.VendorRepository;
46 
import com.spice.profitmandi.dao.repository.nonbillable.WarehouseRepository;
47 
import com.spice.profitmandi.service.nonbillable.InventoryService;
48 
import com.spice.profitmandi.service.user.RetailerService;
49 
import com.spice.profitmandi.web.model.LoginDetails;
50 
import com.spice.profitmandi.web.util.CookiesProcessor;
51 
 
52 
@Controller
53 
@Transactional
54 
public class ItemController {
55 
 
56 
	private static final Logger LOGGER = LogManager.getLogger(ItemController.class);
57 
 
58 
	@Autowired
59 
	@Qualifier("nonbillableItemRepository")
60 
	private ItemRepository itemRepository;
61 
 
62 
	@Autowired
63 
	@Qualifier("nonbillableInventoryService")
64 
	private InventoryService inventoryService;
65 
 
66 
	@Autowired
67 
	private AdminCurrentInventorySnapshotRepository adminCurrentInventorySnapshotRepository;
68 
 
69 
	@Autowired
70 
	private AdminInventoryItemRepository adminInventoryItemRepository;
71 
 
72 
	@Autowired
73 
	private PartnerCurrentInventorySnapshotRepository partnerCurrentInventorySnapshotRepository;
74 
 
75 
	@Autowired
76 
	private VendorRepository vendorRepository;
77 
 
78 
	@Autowired
79 
	private WarehouseRepository warehouseRepository;
80 
 
81 
	@Autowired
82 
	private RetailerService retailerService;
83 
 
84 
	@Autowired
85 
	@Qualifier(value = "userRepository")
86 
	private UserRepository userRepository;
87 
 
88 
	@Autowired
89 
	private UserWarehouseRepository userWarehouseRepository;
90 
 
91 
	@Autowired
92 
	private AdminDeliveryNoteRepository adminDeliveryNoteRepository;
93 
 
94 
	@Autowired
95 
	private ResponseSender<?> responseSender;
96 
 
97 
	@Autowired
98 
	private CookiesProcessor cookiesProcessor;
99 
 
100 
	private Map<Integer, String> itemsToVendorIdNameMap(List<Item> items){
101 
		Map<Integer, String> vendorIdNameMap = new HashMap<>();
102 
		if(items.isEmpty()) {
103 
			return vendorIdNameMap;
104 
		}
105 
		Set<Integer> vendorIds = new HashSet<>();
106 
		for(Item item : items) {
107 
			vendorIds.add(item.getVendorId());
108 
		}
109 
 
110 
		List<Vendor> vendors = vendorRepository.selectByIds(vendorIds);
111 
		for(Vendor vendor : vendors) {
112 
			vendorIdNameMap.put(vendor.getId(), vendor.getName());
113 
		}
114 
		return vendorIdNameMap;
115 
	}
116 
 
117 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdDescriptionMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
118 
		if(currentInventorySnapshots.isEmpty()) {
119 
			return new HashMap<>();
120 
		}
121 
		Set<Integer> itemIds = new HashSet<>();
122 
		for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
123 
			itemIds.add(currentInventorySnapshot.getItemId());
124 
		}
125 
		return itemIdDescriptionMap(itemIds);
126 
	}
127 
 
128 
	private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdTypeMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
129 
		if(currentInventorySnapshots.isEmpty()) {
130 
			return new HashMap<>();
131 
		}
132 
		Set<Integer> itemIds = new HashSet<>();
133 
		for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
134 
			itemIds.add(currentInventorySnapshot.getItemId());
135 
		}
136 
		return itemIdTypeMap(itemIds);
137 
	}
138 
 
139 
	private Map<Integer, String> partnerCurrentInventorySnapshotsToItemIdDescriptionMap(List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots){
140 
		if(partnerCurrentInventorySnapshots.isEmpty()) {
141 
			return new HashMap<>();
142 
		}
143 
		Set<Integer> itemIds = new HashSet<>();
144 
		for(PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
145 
			itemIds.add(partnerCurrentInventorySnapshot.getItemId());
146 
		}
147 
		return itemIdDescriptionMap(itemIds);
148 
	}
149 
 
150 
	private Map<Integer, String> adminDeliveryNotesToItemIdDescriptionMap(List<AdminDeliveryNote> adminDeliveryNotes){
151 
		if(adminDeliveryNotes.isEmpty()) {
152 
			return new HashMap<>();
153 
		}
154 
		Set<Integer> itemIds = new HashSet<>();
155 
		for(AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
156 
			itemIds.add(adminDeliveryNote.getItemId());
157 
		}
158 
		return itemIdDescriptionMap(itemIds);
159 
	}
160 
 
161 
	private Map<Integer, String> itemIdDescriptionMap(Set<Integer> itemIds){
162 
		Map<Integer, String> itemIdDescriptionMap = new HashMap<>();
163 
		List<Item> items = itemRepository.selectByIds(itemIds);
164 
		for(Item item : items) {
165 
			itemIdDescriptionMap.put(item.getId(), item.getBrand() + " " + item.getDescription());
166 
		}
167 
		return itemIdDescriptionMap;
168 
	}
169 
 
170 
	private Map<Integer, String> itemIdTypeMap(Set<Integer> itemIds){
171 
		Map<Integer, String> itemIdTypeMap = new HashMap<>();
172 
		List<Item> items = itemRepository.selectByIds(itemIds);
173 
		for(Item item : items) {
174 
			itemIdTypeMap.put(item.getId(), item.getType().toString());
175 
		}
176 
		return itemIdTypeMap;
177 
	}
178 
 
179 
	private Map<Integer, String> warehouseIdNameMap(List<Warehouse> warehouses){
180 
		Map<Integer, String> warehouseIdNameMap = new HashMap<>();
181 
		for(Warehouse warehouse : warehouses) {
182 
			warehouseIdNameMap.put(warehouse.getId(), warehouse.getName());
183 
		}
184 
		return warehouseIdNameMap;
185 
	}
186 
 
187 
	@RequestMapping(value = "/createItem", method = RequestMethod.GET)
188 
	public String createItem(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
189 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
190 
		List<Item> items = itemRepository.selectAll(offset, limit);
191 
		long size = itemRepository.selectAllCount();
192 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
193 
		List<Vendor> vendors = vendorRepository.selectAll();
194 
		model.addAttribute("vendors", vendors);
195 
		model.addAttribute("items", items);
196 
		model.addAttribute("types", ItemType.values());
197 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
198 
		model.addAttribute("start", offset + 1);
199 
		model.addAttribute("size", size);
200 
		if (items.size() < limit){
201 
			model.addAttribute("end", offset + items.size());
202 
		}else{
203 
			model.addAttribute("end", offset + limit);
204 
		}
205 
		return "items";
206 
	}
207 
 
208 
	@RequestMapping(value = "/createItem", method = RequestMethod.POST)
209 
	public String createItem(HttpServletRequest request, @RequestBody CreateItemRequest createItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
210 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), createItemRequest);
211 
		inventoryService.createItem(createItemRequest);
212 
		List<Item> items = itemRepository.selectAll(offset, limit);
213 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
214 
		long size = itemRepository.selectAllCount();
215 
		List<Vendor> vendors = vendorRepository.selectAll();
216 
		model.addAttribute("vendors", vendors);
217 
		model.addAttribute("items", items);
218 
		model.addAttribute("types", ItemType.values());
219 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
220 
		model.addAttribute("start", offset + 1);
221 
		model.addAttribute("size", size);
222 
		if (items.size() < limit){
223 
			model.addAttribute("end", offset + items.size());
224 
		}else{
225 
			model.addAttribute("end", offset + limit);
226 
		}
227 
		return "items";
228 
	}
229 
 
230 
	@RequestMapping(value = "/getPaginatedItems", method = RequestMethod.GET)
231 
	public String getPaginatedItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
232 
		List<Item> items  = itemRepository.selectAll(offset, limit);
233 
		Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
234 
		List<Vendor> vendors = vendorRepository.selectAll();
235 
		model.addAttribute("vendors", vendors);
236 
		model.addAttribute("items", items);
237 
		model.addAttribute("vendorIdNameMap", vendorIdNameMap);
238 
		return "items-paginated";
239 
	}
240 
 
241 
	@RequestMapping(value = "/scanInItems", method = RequestMethod.POST)
242 
	public String scanInItems(HttpServletRequest request, @RequestBody ScanInItemRequest scanInItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
243 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanInItemRequest);
244 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
245 
		List<Item> items = itemRepository.selectAll();
246 
		inventoryService.scanInItem(scanInItemRequest, loginDetails.getFofoId());
247 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
248 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
249 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
250 
		model.addAttribute("items", items);
251 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
252 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
253 
		model.addAttribute("start", offset + 1);
254 
		model.addAttribute("size", size);
255 
		if (adminCurrentInventorySnapshots.size() < limit){
256 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
257 
		}else{
258 
			model.addAttribute("end", offset + limit);
259 
		}
260 
		return "scan-in-items";
261 
	}
262 
 
263 
	@RequestMapping(value = "/getScanInItems", method = RequestMethod.GET)
264 
	public String getScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
265 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
266 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
267 
		List<Item> items = itemRepository.selectAll();
268 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
269 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
270 
		long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
271 
		model.addAttribute("items", items);
272 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
273 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
274 
		model.addAttribute("start", offset + 1);
275 
		model.addAttribute("size", size);
276 
		if (adminCurrentInventorySnapshots.size() < limit){
277 
			model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
278 
		}else{
279 
			model.addAttribute("end", offset + limit);
280 
		}
281 
		return "scan-in-items";
282 
	}
283 
 
284 
	@RequestMapping(value = "/getPaginatedScanInItems", method = RequestMethod.GET)
285 
	public String getPaginatedScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
286 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
287 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
288 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
289 
		model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
290 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
291 
		return "scan-in-items-paginated";
292 
	}
293 
 
294 
	@RequestMapping(value = "/getScanInPartnerItems", method = RequestMethod.GET)
295 
	public String getScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
296 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
297 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
298 
 
299 
		//List<Item> items = itemRepository.selectAll();
300 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
301 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
302 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
303 
		//model.addAttribute("items", items);
304 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
305 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
306 
		model.addAttribute("start", offset + 1);
307 
		model.addAttribute("size", size);
308 
		if (partnerCurrentInventorySnapshots.size() < limit){
309 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
310 
		}else{
311 
			model.addAttribute("end", offset + limit);
312 
		}
313 
		return "scan-in-partner-items";
314 
	}
315 
 
316 
	@RequestMapping(value = "/scanInPartnerItems", method = RequestMethod.GET)
317 
	public String getScanInPartnerItems(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
318 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
319 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
320 
		inventoryService.scanInPartnerItem(deliveryNoteId, loginDetails.getFofoId());
321 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
322 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
323 
		long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
324 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
325 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
326 
		model.addAttribute("start", offset + 1);
327 
		model.addAttribute("size", size);
328 
		if (partnerCurrentInventorySnapshots.size() < limit){
329 
			model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
330 
		}else{
331 
			model.addAttribute("end", offset + limit);
332 
		}
333 
		return "scan-in-partner-items";
334 
	}
335 
 
336 
	@RequestMapping(value = "/getPaginatedScanInPartnerItems", method = RequestMethod.GET)
337 
	public String getPaginatedScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
338 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
339 
		List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
340 
		Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
341 
		model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
342 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
343 
		return "scan-in-partner-items-paginated";
344 
	}
345 
 
346 
	@RequestMapping(value = "/deliveryNoteDetails", method = RequestMethod.GET)
347 
	public ResponseEntity<?> deliveryNoteDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId) throws ProfitMandiBusinessException{
348 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
349 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
350 
		return responseSender.ok(inventoryService.getDeliveryNoteDetailsMap(deliveryNoteId, loginDetails.getFofoId()));
351 
	}
352 
 
353 
	@RequestMapping(value = "/getItemsByWarehouseId", method = RequestMethod.GET)
354 
	public String getItemsByWarehouseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
355 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
356 
		List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllAvailableByWarehouseId(warehouseId);
357 
		Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
358 
		Map<Integer, String> itemIdTypeMap = this.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
359 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
360 
		model.addAttribute("itemIdTypeMap", itemIdTypeMap);
361 
		return "warehouse-items";
362 
	}
363 
 
364 
 
365 
	@RequestMapping(value = "/getScanOutItems", method = RequestMethod.GET)
366 
	public String getScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
367 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
368 
		List<Warehouse> warehouses = warehouseRepository.selectAll();
369 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
370 
		Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
371 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
372 
		Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
373 
		long size = adminDeliveryNoteRepository.selectAllCount();
374 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
375 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
376 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
377 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
378 
		model.addAttribute("start", offset + 1);
379 
		model.addAttribute("size", size);
380 
		if (adminDeliveryNotes.size() < limit){
381 
			model.addAttribute("end", offset + adminDeliveryNotes.size());
382 
		}else{
383 
			model.addAttribute("end", offset + limit);
384 
		}
385 
		return "scan-out-items";
386 
	}
387 
 
388 
	@RequestMapping(value = "/scanOutItems", method = RequestMethod.POST)
389 
	public String scanOutItems(HttpServletRequest request, @RequestBody ScanOutItemRequest scanOutItemRequest, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
390 
		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanOutItemRequest);
391 
		inventoryService.scanOutItem(scanOutItemRequest);
392 
		List<Warehouse> warehouses = warehouseRepository.selectAll();
393 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
394 
		Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
395 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
396 
		Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
397 
		long size = adminDeliveryNoteRepository.selectAllCount();
398 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
399 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
400 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
401 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
402 
		model.addAttribute("start", offset + 1);
403 
		model.addAttribute("size", size);
404 
		if (adminDeliveryNotes.size() < limit){
405 
			model.addAttribute("end", offset + adminDeliveryNotes.size());
406 
		}else{
407 
			model.addAttribute("end", offset + limit);
408 
		}
409 
		return "scan-out-items";
410 
	}
411 
 
412 
	@RequestMapping(value = "/getPaginatedScanOutItems", method = RequestMethod.GET)
413 
	public String getPaginatedScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
414 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
415 
		List<Warehouse> warehouses = warehouseRepository.selectAll();
416 
		List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
417 
		Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
418 
		Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
419 
		Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
420 
		model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
421 
		model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
422 
		model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
423 
		model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
424 
		return "scan-out-items-paginated";
425 
	}
426 
 
427 
	@RequestMapping(value = "/getSerialNumbersByItemId", method = RequestMethod.GET)
428 
	public String getSerialNumbersByItemId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId,
429 
			@RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
430 
		int adminId = userWarehouseRepository.selectUserIdByWarehouseId(warehouseId);
431 
		List<String> itemSerialNumbers = adminInventoryItemRepository.selectSerialNumbersByAdminIdWarehouseIdItemIdScanType(adminId, warehouseId, itemId, ScanType.IN);
432 
		model.addAttribute("itemSerialNumbers", itemSerialNumbers);
433 
		return "item-serial-numbers";
434 
	}
435 
 
436 
}