Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.util.ArrayList;
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.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.InstructionItemRequest;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.model.ScanInItemRequest;
import com.spice.profitmandi.common.model.ScanInPartnerItemRequest;
import com.spice.profitmandi.common.model.ScanOutItemRequest;
import com.spice.profitmandi.common.model.ScanOutPartnerItemRequest;
import com.spice.profitmandi.dao.entity.nonbillable.AdminCurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.nonbillable.AdminDeliveryNote;
import com.spice.profitmandi.dao.entity.nonbillable.InstructionItem;
import com.spice.profitmandi.dao.entity.nonbillable.InstructionItemDetail;
import com.spice.profitmandi.dao.entity.nonbillable.Item;
import com.spice.profitmandi.dao.entity.nonbillable.PartnerCurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.nonbillable.ScanOutPartnerItem;
import com.spice.profitmandi.dao.entity.nonbillable.Vendor;
import com.spice.profitmandi.dao.entity.nonbillable.Warehouse;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.enumuration.dtr.RoleType;
import com.spice.profitmandi.dao.enumuration.nonbillable.InstructionItemStatus;
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
import com.spice.profitmandi.dao.repository.dtr.RoleRepository;
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
import com.spice.profitmandi.dao.repository.dtr.UserRoleRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminCurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteDetailRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminDeliveryNoteRepository;
import com.spice.profitmandi.dao.repository.nonbillable.AdminInventoryItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.InstructionItemDetailRepository;
import com.spice.profitmandi.dao.repository.nonbillable.InstructionItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.ItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.PartnerCurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.nonbillable.PartnerInventoryItemRepository;
import com.spice.profitmandi.dao.repository.nonbillable.ScanOutPartnerItemRepository;
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.dao.repository.user.AddressRepository;
import com.spice.profitmandi.service.nonbillable.InventoryService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.user.UserService;
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 RoleRepository roleRepository;
        @Autowired
        private UserService userService;
        @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 UserRoleRepository userRoleRepository;
        @Autowired
        private UserWarehouseRepository userWarehouseRepository;

        @Autowired
        private AdminDeliveryNoteRepository adminDeliveryNoteRepository;

        @Autowired
        private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

        @Autowired
        private AddressRepository addressRepository;

        @Autowired
        private PartnerInventoryItemRepository partnerInventoryItemRepository;

        @Autowired
        private ScanOutPartnerItemRepository scanOutPartnerItemRepository;

        @Autowired
        private InstructionItemRepository instructionItemRepository;

        @Autowired
        private InstructionItemDetailRepository instructionItemDetailRepository;

        @Autowired
        private AdminDeliveryNoteDetailRepository adminDeliveryNoteDetailRepository;

        @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> scanOutPartnerItemsToItemIdDescriptionMap(
                        List<ScanOutPartnerItem> scanOutPartnerItems) {
                if (scanOutPartnerItems.isEmpty()) {
                        return new HashMap<>();
                }
                Set<Integer> itemIds = new HashSet<>();
                for (ScanOutPartnerItem scanOutPartnerItem : scanOutPartnerItems) {
                        itemIds.add(scanOutPartnerItem.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;
        }

        private Set<Integer> instructionItemsToWarehouseIds(List<InstructionItem> instructionItems) {
                Set<Integer> warehouseIds = new HashSet<>();
                for (InstructionItem instructionItem : instructionItems) {
                        warehouseIds.add(instructionItem.getWarehouseId());
                }
                return warehouseIds;
        }

        private Set<Integer> instructionItemsToFofoIds(List<InstructionItem> instructionItems) {
                Set<Integer> fofoIds = new HashSet<>();
                for (InstructionItem instructionItem : instructionItems) {
                        fofoIds.add(instructionItem.getFofoId());
                }
                return fofoIds;
        }

        private Set<Integer> instructionItemsToInstructionItemIds(List<InstructionItem> instructionItems) {
                Set<Integer> instructionItemIds = new HashSet<>();
                for (InstructionItem instructionItem : instructionItems) {
                        instructionItemIds.add(instructionItem.getId());
                }
                return instructionItemIds;
        }

        private Map<Integer, Integer> instructionItemDetailsToItemIdQuantityMap(
                        List<InstructionItemDetail> instructionItemDetails) {
                Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
                for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
                        if (!itemIdQuantityMap.containsKey(instructionItemDetail.getItemId())) {
                                itemIdQuantityMap.put(instructionItemDetail.getItemId(), instructionItemDetail.getQuantity());
                        } else {
                                itemIdQuantityMap.put(instructionItemDetail.getItemId(),
                                                itemIdQuantityMap.get(instructionItemDetail.getItemId()) + instructionItemDetail.getQuantity());
                        }
                }
                return itemIdQuantityMap;
        }

        private Map<Integer, List<InstructionItemDetail>> instructionItemsToInstructionItemIdInstructionItemDetailsMap(
                        List<InstructionItemDetail> instructionItemDetails) {
                // Set<Integer> instructionItemIds =
                // this.instructionItemsToInstructionItemIds(instructionItems);
                // List<InstructionItemDetail> instructionItemDetails =
                // instructionItemDetailRepository.selectByInstructionItemIds(instructionItemIds);
                Map<Integer, List<InstructionItemDetail>> instructionIdInstructionItemDetailMap = new HashMap<>();
                for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
                        if (!instructionIdInstructionItemDetailMap.containsKey(instructionItemDetail.getInstructionItemId())) {
                                List<InstructionItemDetail> instructionItemDetailsList = new ArrayList<>();
                                instructionItemDetailsList.add(instructionItemDetail);
                                instructionIdInstructionItemDetailMap.put(instructionItemDetail.getInstructionItemId(),
                                                instructionItemDetailsList);
                        } else {
                                instructionIdInstructionItemDetailMap.get(instructionItemDetail.getInstructionItemId())
                                                .add(instructionItemDetail);
                        }
                }
                return instructionIdInstructionItemDetailMap;
        }

        private Set<Integer> instructionItemDetailsToItemIds(List<InstructionItemDetail> instructionItemDetails) {
                Set<Integer> itemIds = new HashSet<>();
                for (InstructionItemDetail instructionItemDetail : instructionItemDetails) {
                        itemIds.add(instructionItemDetail.getItemId());
                }
                return itemIds;
        }

        private Set<Integer> adminDeliveryNotesToWarehouseIds(List<AdminDeliveryNote> adminDeliveryNotes) {
                Set<Integer> warehouseIds = new HashSet<>();
                for (AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
                        warehouseIds.add(adminDeliveryNote.getWarehouseId());
                }
                return warehouseIds;
        }

        private Set<Integer> adminDeliveryNotesToFofoIds(List<AdminDeliveryNote> adminDeliveryNotes) {
                Set<Integer> fofoIds = new HashSet<>();
                for (AdminDeliveryNote adminDeliveryNote : adminDeliveryNotes) {
                        fofoIds.add(adminDeliveryNote.getFofoId());
                }
                return fofoIds;
        }

        @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<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
                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());
                if (!warehouseIds.isEmpty()) {
                        model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
                }
                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<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
                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());
                if (!warehouseIds.isEmpty()) {
                        model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
                }
                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.POST)
        public String getScanInPartnerItems(HttpServletRequest request,
                        @RequestBody ScanInPartnerItemRequest scanInPartnerItemRequest,
                        @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(scanInPartnerItemRequest, 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";
        }

        private Map<Integer, Integer> partnerCurrentInventorySnapshotsItemIdQuantityMap(
                        List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots) {
                Map<Integer, Integer> itemIdQuantityMap = new HashMap<>();
                for (PartnerCurrentInventorySnapshot partnerCurrentInventorySnapshot : partnerCurrentInventorySnapshots) {
                        itemIdQuantityMap.put(partnerCurrentInventorySnapshot.getItemId(),
                                        partnerCurrentInventorySnapshot.getAvailability());
                }
                return itemIdQuantityMap;
        }

        @RequestMapping(value = "/getScanOutPartnerItems", method = RequestMethod.GET)
        public String getScanOutPartnerItems(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);

                int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
                Address address = addressRepository.selectById(addressId);

                List<PartnerCurrentInventorySnapshot> partnerCurrentInventorySnapshots = partnerCurrentInventorySnapshotRepository
                                .selectByFofoId(loginDetails.getFofoId());
                Map<Integer, Integer> itemIdQuantityMap = this
                                .partnerCurrentInventorySnapshotsItemIdQuantityMap(partnerCurrentInventorySnapshots);
                List<Item> items = itemRepository.selectByIds(itemIdQuantityMap.keySet());

                List<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository
                                .selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
                long size = scanOutPartnerItemRepository.selectCountByFofoId(loginDetails.getFofoId());
                model.addAttribute("items", items);
                // model.addAttribute("stateNames", Utils.getAllStateNames());
                model.addAttribute("retailerStateName", address.getState());
                model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (scanOutPartnerItems.size() < limit) {
                        model.addAttribute("end", offset + scanOutPartnerItems.size());
                } else {
                        model.addAttribute("end", offset + limit);
                }
                return "scan-out-partner-items";
        }

        @RequestMapping(value = "/instructionItem", method = RequestMethod.POST)
        public String instructionItems(HttpServletRequest request,
                        @RequestBody InstructionItemRequest instructionItemRequest,
                        @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(), instructionItemRequest);
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                inventoryService.instructionItem(instructionItemRequest, loginDetails.getFofoId());
                return this.getInstructionItems(request, offset, limit, model);
        }

        @RequestMapping(value = "/getInstructionItems", method = RequestMethod.GET)
        public String getInstructionItems(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<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(),
                                offset, limit);
                LOGGER.info("instructionItems" + instructionItems);
                Set<Integer> instructionItemWarehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
                LOGGER.info("instructionItemWarehouseIds" + instructionItemWarehouseIds);
                List<Warehouse> warehouses = new ArrayList<>();
                if (!instructionItemWarehouseIds.isEmpty()) {

                        warehouses = warehouseRepository.selectByIds(instructionItemWarehouseIds);

                }
                Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);

                List<Integer> warehouseIds = userWarehouseRepository.selectWarehouseIdsByUserId(loginDetails.getFofoId());
                if (!warehouseIds.isEmpty()) {
                        model.addAttribute("warehouses", warehouseRepository.selectByIds(new HashSet<>(warehouseIds)));
                        LOGGER.info(warehouseRepository.selectByIds(new HashSet<>(warehouseIds)) + "warehouseIdNameMap");
                }

                List<Integer> userIds = userRoleRepository
                                .selectUserIdsByRoleId(roleRepository.selectByName(RoleType.FOFO_ADMIN.toString()).getId());
                Map<Integer, String> userIdEmailIdMap = userService.getAllUseUserIdEmailIdMap(userIds);

                model.addAttribute("fofoIdEmailIdMap", userIdEmailIdMap);
                long size = instructionItemRepository.selectCountByAdminId(loginDetails.getFofoId());
                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("instructionItems", instructionItems);
                model.addAttribute("start", offset + 1);
                model.addAttribute("size", size);
                if (instructionItems.size() < limit) {
                        model.addAttribute("end", offset + instructionItems.size());
                } else {
                        model.addAttribute("end", offset + limit);
                }

                return "instruction-items";
        }

        @RequestMapping(value = "/getPaginatedInstructionItems", method = RequestMethod.GET)
        public String getPaginatedInstructionItems(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<InstructionItem> instructionItems = instructionItemRepository.selectAllByAdminId(loginDetails.getFofoId(),
                                offset, limit);

                Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
                List<Warehouse> warehouses = warehouseRepository.selectByIds(warehouseIds);
                Map<Integer, String> warehouseIdNameMap = this.warehouseIdNameMap(warehouses);

                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("instructionItems", instructionItems);
                return "scan-out-partner-items-paginated";
        }

        @RequestMapping(value = "/scanOutPartnerItem", method = RequestMethod.POST)
        public String scanOutPartnerItems(HttpServletRequest request,
                        @RequestBody ScanOutPartnerItemRequest scanOutPartnerItemRequest,
                        @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.scanOutPartnerItem(scanOutPartnerItemRequest, loginDetails.getFofoId());
                return this.scanOutPartnerItems(request, scanOutPartnerItemRequest, offset, limit, model);
        }

        @RequestMapping(value = "/getPaginatedScanOutPartnerItems", method = RequestMethod.GET)
        public String getPaginatedScanOutPartnerItems(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<ScanOutPartnerItem> scanOutPartnerItems = scanOutPartnerItemRepository
                                .selectAllByFofoId(loginDetails.getFofoId(), offset, limit);
                Map<Integer, String> itemIdDescriptionMap = this.scanOutPartnerItemsToItemIdDescriptionMap(scanOutPartnerItems);
                model.addAttribute("scanOutPartnerItems", scanOutPartnerItems);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                return "scan-out-partner-items-paginated";
        }

        @RequestMapping(value = "/deliveryNoteDetails", method = RequestMethod.GET)
        public String deliveryNoteDetails(HttpServletRequest request,
                        @RequestParam(name = ProfitMandiConstants.DELIVERY_NOTE_ID) String deliveryNoteId, Model model)
                        throws ProfitMandiBusinessException {
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                AdminDeliveryNote adminDeliveryNote = adminDeliveryNoteRepository
                                .selectByDeliveryNoteIdAndFofoid(deliveryNoteId, loginDetails.getFofoId());
                if (adminDeliveryNote.getCompleteTimestamp() != null) {
                        throw new ProfitMandiBusinessException(
                                        ProfitMandiConstants.DELIVERY_NOTE_ID + ", " + ProfitMandiConstants.FOFO_ID,
                                        deliveryNoteId + ", " + loginDetails.getFofoId(), "NNBLBL_ITM_1002");
                }
                Warehouse warehouse = warehouseRepository.selectId(adminDeliveryNote.getWarehouseId());
                List<Integer> instructionItemIds = adminDeliveryNoteDetailRepository
                                .selectInstructionItemIdsByDeliveryNoteId(deliveryNoteId);
                List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository
                                .selectByInstructionItemIds(new HashSet<>(instructionItemIds));
                Map<Integer, Integer> itemIdQuantityMap = this
                                .instructionItemDetailsToItemIdQuantityMap(instructionItemDetails);
                Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIdQuantityMap.keySet());
                Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIdQuantityMap.keySet());
                model.addAttribute("deliveryNoteId", deliveryNoteId);
                model.addAttribute("warehouseName", warehouse.getName());
                model.addAttribute("itemIdQuantityMap", itemIdQuantityMap);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("itemIdTypeMap", itemIdTypeMap);
                return "delivery-note-details";
        }

        @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 = "/getInstructionItemsByWarehouseId", method = RequestMethod.GET)
        public String getInstructionItemsByWarehouseId(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-instruction-items";
        }

        @RequestMapping(value = "/getPendingInstructionItems", method = RequestMethod.GET)
        public String getPendingInstructionItems(HttpServletRequest request,
                        @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId,
                        @RequestParam(name = ProfitMandiConstants.USER_ID) int userId, Model model)
                        throws ProfitMandiBusinessException {
                LOGGER.info("Request Received at url {}", request.getRequestURI());
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<InstructionItem> instructionItems = instructionItemRepository.selectByAdminIdWarehouseIdUserIdStatus(
                                loginDetails.getFofoId(), warehouseId, userId, InstructionItemStatus.PENDING);
                Set<Integer> instructionItemIds = this.instructionItemsToInstructionItemIds(instructionItems);
                List<InstructionItemDetail> instructionItemDetails = instructionItemDetailRepository
                                .selectByInstructionItemIds(instructionItemIds);
                Set<Integer> itemIds = this.instructionItemDetailsToItemIds(instructionItemDetails);
                Map<Integer, List<InstructionItemDetail>> instructionItemIdInstructionItemDetailsMap = this
                                .instructionItemsToInstructionItemIdInstructionItemDetailsMap(instructionItemDetails);
                Map<Integer, String> itemIdDescriptionMap = this.itemIdDescriptionMap(itemIds);
                Map<Integer, String> itemIdTypeMap = this.itemIdTypeMap(itemIds);
                model.addAttribute("instructionItems", instructionItems);
                model.addAttribute("instructionItemIdInstructionItemDetailsMap", instructionItemIdInstructionItemDetailsMap);
                model.addAttribute("itemIdDescriptionMap", itemIdDescriptionMap);
                model.addAttribute("itemIdTypeMap", itemIdTypeMap);
                return "pending-instruction-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<AdminCurrentInventorySnapshot> adminCurrentInventorySnapshots =
                // adminCurrentInventorySnapshotRepository.selectAll();
                // Set<Integer> adminIds = this.getAdminIds(adminCurrentInventorySnapshots);
                // Map<Integer, String> adminIdEmailIdMap =
                // retailerService.getAllFofoRetailerIdEmailIdMap(adminIds);
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                List<InstructionItem> instructionItems = instructionItemRepository
                                .selectByAdminIdStatus(loginDetails.getFofoId(), InstructionItemStatus.PENDING);

                List<Warehouse> warehouses = new ArrayList<>();
                Map<Integer, String> fofoIdEmailIdMap = new HashMap<>();
                if (!instructionItems.isEmpty()) {
                        Set<Integer> warehouseIds = this.instructionItemsToWarehouseIds(instructionItems);
                        warehouses = warehouseRepository.selectByIds(warehouseIds);
                        Set<Integer> fofoIds = this.instructionItemsToFofoIds(instructionItems);
                        fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap(fofoIds);
                }

                List<AdminDeliveryNote> adminDeliveryNotes = adminDeliveryNoteRepository.selectAll(offset, limit);
                Map<Integer, String> warehouseIdNameMap = new HashMap<>();
                if (!adminDeliveryNotes.isEmpty()) {
                        List<Warehouse> adminDeliveryNoteWarehouses = warehouseRepository
                                        .selectByIds(this.adminDeliveryNotesToWarehouseIds(adminDeliveryNotes));
                        warehouseIdNameMap = this.warehouseIdNameMap(adminDeliveryNoteWarehouses);
                        fofoIdEmailIdMap = retailerService
                                        .getAllFofoRetailerIdEmailIdMap(this.adminDeliveryNotesToFofoIds(adminDeliveryNotes));
                }
                long size = adminDeliveryNoteRepository.selectAllCount();
                // model.addAttribute("adminIdEmailIdMap", adminIdEmailIdMap);
                model.addAttribute("adminDeliveryNotes", adminDeliveryNotes);
                model.addAttribute("warehouses", warehouses);
                model.addAttribute("warehouseIdNameMap", warehouseIdNameMap);
                model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);
                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);
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                inventoryService.scanOutItem(scanOutItemRequest, loginDetails.getFofoId());
                return this.getScanOutItems(request, offset, limit, model);
        }

        @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 = "/getSerialNumbersByItemIdWarehouseId", method = RequestMethod.GET)
        public String getSerialNumbersByItemIdWarehouseId(HttpServletRequest request,
                        @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId,
                        @RequestParam(name = ProfitMandiConstants.WAREHOUSE_ID) int warehouseId, Model model)
                        throws ProfitMandiBusinessException {
                List<String> itemSerialNumbers = adminInventoryItemRepository
                                .selectSerialNumbersByWarehouseIdItemIdScanType(warehouseId, itemId, ScanType.IN);
                model.addAttribute("itemSerialNumbers", itemSerialNumbers);
                return "item-serial-numbers";
        }

        @RequestMapping(value = "/getSerialNumbersByItemId", method = RequestMethod.GET)
        public String getSerialNumbersByItemId(HttpServletRequest request,
                        @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, Model model)
                        throws ProfitMandiBusinessException {
                List<String> itemSerialNumbers = partnerInventoryItemRepository.selectSerialNumbersByItemIdScanType(itemId,
                                ScanType.IN);
                model.addAttribute("itemSerialNumbers", itemSerialNumbers);
                return "item-serial-numbers-single";
        }

}