Subversion Repositories SmartDukaan

Rev

Blame | Last modification | View Log | RSS feed 

package com.spice.profitmandi.web.controller;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.enumuration.ItemType;
import com.spice.profitmandi.common.enumuration.ScanType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CreateItemRequest;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.model.ScanInItemRequest;
import com.spice.profitmandi.common.model.ScanOutItemRequest;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.nonbillable.AdminCurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.nonbillable.AdminDeliveryNote;
import com.spice.profitmandi.dao.entity.nonbillable.Item;
import com.spice.profitmandi.dao.entity.nonbillable.PartnerCurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.nonbillable.Vendor;
import com.spice.profitmandi.dao.entity.nonbillable.Warehouse;
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminCurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminInventoryItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.ItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.PartnerCurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.nonbillable.UserWarehouseRepository;
import com.spice.profitmandi.dao.repository.nonbillable.VendorRepository;
import com.spice.profitmandi.dao.repository.nonbillable.WarehouseRepository;
import com.spice.profitmandi.service.nonbillable.InventoryService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;

@Controller
@Transactional
public class ItemController {
        
        private static final Logger LOGGER = LogManager.getLogger(ItemController.class);
        
        @Autowired
        @Qualifier("nonbillableItemRepository")
        private ItemRepository itemRepository;
        
        @Autowired
        @Qualifier("nonbillableInventoryService")
        private InventoryService inventoryService;
        
        @Autowired
        private AdminCurrentInventorySnapshotRepository adminCurrentInventorySnapshotRepository;
        
        @Autowired
        private AdminInventoryItemRepository adminInventoryItemRepository;
        
        @Autowired
        private PartnerCurrentInventorySnapshotRepository partnerCurrentInventorySnapshotRepository;
        
        @Autowired
        private VendorRepository vendorRepository;
        
        @Autowired
        private WarehouseRepository warehouseRepository;
        
        @Autowired
        private RetailerService retailerService;
        
        @Autowired
        @Qualifier(value = "userRepository")
        private UserRepository userRepository;
        
        @Autowired
        private UserWarehouseRepository userWarehouseRepository;
        
        @Autowired
        private AdminDeliveryNoteRepository adminDeliveryNoteRepository;
        
        @Autowired
        private ResponseSender<?> responseSender;
        
        @Autowired
        private CookiesProcessor cookiesProcessor;
        
        private Map<Integer, String> itemsToVendorIdNameMap(List<Item> items){
                Map<Integer, String> vendorIdNameMap = new HashMap<>();
                if(items.isEmpty()) {
                        return vendorIdNameMap;
                }
                Set<Integer> vendorIds = new HashSet<>();
                for(Item item : items) {
                        vendorIds.add(item.getVendorId());
                }
                
                List<Vendor> vendors = vendorRepository.selectByIds(vendorIds);
                for(Vendor vendor : vendors) {
                        vendorIdNameMap.put(vendor.getId(), vendor.getName());
                }
                return vendorIdNameMap;
        }
        
        private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdDescriptionMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
                if(currentInventorySnapshots.isEmpty()) {
                        return new HashMap<>();
                }
                Set<Integer> itemIds = new HashSet<>();
                for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
                        itemIds.add(currentInventorySnapshot.getItemId());
                }
                return itemIdDescriptionMap(itemIds);
        }
        
        private Map<Integer, String> adminCurrentInventorySnapshotsToItemIdTypeMap(List<AdminCurrentInventorySnapshot> currentInventorySnapshots){
                if(currentInventorySnapshots.isEmpty()) {
                        return new HashMap<>();
                }
                Set<Integer> itemIds = new HashSet<>();
                for(AdminCurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
                        itemIds.add(currentInventorySnapshot.getItemId());
                }
                return itemIdTypeMap(itemIds);
        }
        
        private Map<Integer, String> partnerCurrentInventorySnapshotsToItemIdDescriptionMap(List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots){
                if(partnerCurrentInventorySnapshots.isEmpty()) {
                        return new HashMap<>();
                }
                Set<Integer> itemIds = new HashSet<>();
                for(PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
                        itemIds.add(partnerCurrentInventorySnapshot.getItemId());
                }
                return itemIdDescriptionMap(itemIds);
        }
        
        private Map<Integer, String> adminDeliveryNotesToItemIdDescriptionMap(List<AdminDeliveryNote> adminDeliveryNotes){
                if(adminDeliveryNotes.isEmpty()) {
                        return new HashMap<>();
                }
                Set<Integer> itemIds = new HashSet<>();
                for(AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
                        itemIds.add(adminDeliveryNote.getItemId());
                }
                return itemIdDescriptionMap(itemIds);
        }
        
        private Map<Integer, String> itemIdDescriptionMap(Set<Integer> itemIds){
                Map<Integer, String> itemIdDescriptionMap = new HashMap<>();
                List<Item> items = itemRepository.selectByIds(itemIds);
                for(Item item : items) {
                        itemIdDescriptionMap.put(item.getId(), item.getBrand() + " " + item.getDescription());
                }
                return itemIdDescriptionMap;
        }
        
        private Map<Integer, String> itemIdTypeMap(Set<Integer> itemIds){
                Map<Integer, String> itemIdTypeMap = new HashMap<>();
                List<Item> items = itemRepository.selectByIds(itemIds);
                for(Item item : items) {
                        itemIdTypeMap.put(item.getId(), item.getType().toString());
                }
                return itemIdTypeMap;
        }
        
        private Map<Integer, String> warehouseIdNameMap(List<Warehouse> warehouses){
                Map<Integer, String> warehouseIdNameMap = new HashMap<>();
                for(Warehouse warehouse : warehouses) {
                        warehouseIdNameMap.put(warehouse.getId(), warehouse.getName());
                }
                return warehouseIdNameMap;
        }
        
        @RequestMapping(value = "/createItem", method = RequestMethod.GET)
        public String createItem(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                List<Item> items = itemRepository.selectAll(offset, limit);
                long size = itemRepository.selectAllCount();
                Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
                List<Vendor> vendors = vendorRepository.selectAll();
                model.addAttribute("vendors", vendors);
                model.addAttribute("items", items);
                model.addAttribute("types", ItemType.values());
                model.addAttribute("vendorIdNameMap", vendorIdNameMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (items.size() < limit){
                        model.addAttribute("end", offset + items.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "items";
        }
        
        @RequestMapping(value = "/createItem", method = RequestMethod.POST)
        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{
                LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), createItemRequest);
                inventoryService.createItem(createItemRequest);
                List<Item> items = itemRepository.selectAll(offset, limit);
                Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
                long size = itemRepository.selectAllCount();
                List<Vendor> vendors = vendorRepository.selectAll();
                model.addAttribute("vendors", vendors);
                model.addAttribute("items", items);
                model.addAttribute("types", ItemType.values());
                model.addAttribute("vendorIdNameMap", vendorIdNameMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (items.size() < limit){
                        model.addAttribute("end", offset + items.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "items";
        }
        
        @RequestMapping(value = "/getPaginatedItems", method = RequestMethod.GET)
        public String getPaginatedItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                List<Item> items  = itemRepository.selectAll(offset, limit);
                Map<Integer, String> vendorIdNameMap = this.itemsToVendorIdNameMap(items);
                List<Vendor> vendors = vendorRepository.selectAll();
                model.addAttribute("vendors", vendors);
                model.addAttribute("items", items);
                model.addAttribute("vendorIdNameMap", vendorIdNameMap);
                return "items-paginated";
        }
        
        @RequestMapping(value = "/scanInItems", method = RequestMethod.POST)
        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{
                LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanInItemRequest);
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Item> items = itemRepository.selectAll();
                inventoryService.scanInItem(scanInItemRequest, loginDetails.getFofoId());
                List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
                long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
                model.addAttribute("items", items);
                model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (adminCurrentInventorySnapshots.size() < limit){
                        model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-in-items";
        }
        
        @RequestMapping(value = "/getScanInItems", method = RequestMethod.GET)
        public String getScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<Item> items = itemRepository.selectAll();
                List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
                long size = adminCurrentInventorySnapshotRepository.selectAllCountByAdminId(loginDetails.getFofoId());
                model.addAttribute("items", items);
                model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (adminCurrentInventorySnapshots.size() < limit){
                        model.addAttribute("end", offset + adminCurrentInventorySnapshots.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-in-items";
        }
        
        @RequestMapping(value = "/getPaginatedScanInItems", method = RequestMethod.GET)
        public String getPaginatedScanInItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllByAdminId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
                model.addAttribute("adminCurrentInventorySnapshots", adminCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                return "scan-in-items-paginated";
        }
        
        @RequestMapping(value = "/getScanInPartnerItems", method = RequestMethod.GET)
        public String getScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                
                //List<Item> items = itemRepository.selectAll();
                List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
                long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
                //model.addAttribute("items", items);
                model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (partnerCurrentInventorySnapshots.size() < limit){
                        model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-in-partner-items";
        }
        
        @RequestMapping(value = "/scanInPartnerItems", method = RequestMethod.GET)
        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{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                inventoryService.scanInPartnerItem(deliveryNoteId, loginDetails.getFofoId());
                List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
                long size = partnerCurrentInventorySnapshotRepository.selectAllCountByFofoId(loginDetails.getFofoId());
                model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (partnerCurrentInventorySnapshots.size() < limit){
                        model.addAttribute("end", offset + partnerCurrentInventorySnapshots.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-in-partner-items";
        }
        
        @RequestMapping(value = "/getPaginatedScanInPartnerItems", method = RequestMethod.GET)
        public String getPaginatedScanInPartnerItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository.selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.partnerCurrentInventorySnapshotsToItemIdDescriptionMap(partnerCurrentInventorySnapshots);
                model.addAttribute("partnerCurrentInventorySnapshots", partnerCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                return "scan-in-partner-items-paginated";
        }
        
        @RequestMapping(value = "/deliveryNoteDetails", method = RequestMethod.GET)
        public ResponseEntity<?> deliveryNoteDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                return responseSender.ok(inventoryService.getDeliveryNoteDetailsMap(deliveryNoteId, loginDetails.getFofoId()));
        }
        
        @RequestMapping(value = "/getItemsByWarehouseId", method = RequestMethod.GET)
        public String getItemsByWarehouseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                List<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots = adminCurrentInventorySnapshotRepository.selectAllAvailableByWarehouseId(warehouseId);
                Map<Integer, String> itemIdDescriptionMap = this.adminCurrentInventorySnapshotsToItemIdDescriptionMap(adminCurrentInventorySnapshots);
                Map<Integer, String> itemIdTypeMap = this.adminCurrentInventorySnapshotsToItemIdTypeMap(adminCurrentInventorySnapshots);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("itemIdTypeMap", itemIdTypeMap);
                return "warehouse-items";
        }
        
        
        @RequestMapping(value = "/getScanOutItems", method = RequestMethod.GET)
        public String getScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                List<Warehouse> warehouses = warehouseRepository.selectAll();
                List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
                Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
                Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
                long size = adminDeliveryNoteRepository.selectAllCount();
                model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (adminDeliveryNotes.size() < limit){
                        model.addAttribute("end", offset + adminDeliveryNotes.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-out-items";
        }
        
        @RequestMapping(value = "/scanOutItems", method = RequestMethod.POST)
        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{
                LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), scanOutItemRequest);
                inventoryService.scanOutItem(scanOutItemRequest);
                List<Warehouse> warehouses = warehouseRepository.selectAll();
                List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
                Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
                Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
                long size = adminDeliveryNoteRepository.selectAllCount();
                model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (adminDeliveryNotes.size() < limit){
                        model.addAttribute("end", offset + adminDeliveryNotes.size());
                }else{
                        model.addAttribute("end", offset + limit);
                }
                return "scan-out-items";
        }
        
        @RequestMapping(value = "/getPaginatedScanOutItems", method = RequestMethod.GET)
        public String getPaginatedScanOutItems(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException{
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                List<Warehouse> warehouses = warehouseRepository.selectAll();
                List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.adminDeliveryNotesToItemIdDescriptionMap(adminDeliveryNotes);
                Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);
                Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();
                model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                return "scan-out-items-paginated";
        }
        
        @RequestMapping(value = "/getSerialNumbersByItemId", method = RequestMethod.GET)
        public String getSerialNumbersByItemId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId,
                        @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model) throws ProfitMandiBusinessException{
                int adminId = userWarehouseRepository.selectUserIdByWarehouseId(warehouseId);
                List<String> itemSerialNumbers = adminInventoryItemRepository.selectSerialNumbersByAdminIdWarehouseIdItemIdScanType(adminId, warehouseId, itemId, ScanType.IN);
                model.addAttribute("itemSerialNumbers", itemSerialNumbers);
                return "item-serial-numbers";
        }
        
}