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.nonbillable.InstructionItemStatus;

import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;

import com.spice.profitmandi.dao.repository.dtr.UserRepository;

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.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 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);

        Set<Integer> instructionItemWarehouseIds = this.instructionItemsToWarehouseIds(instructionItems);

        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)));

		}

        Map<Integer, String> fofoIdEmailIdMap = retailerService.getAllFofoRetailerIdEmailIdMap();

        model.addAttribute("fofoIdEmailIdMap", fofoIdEmailIdMap);

        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";

    }

}