Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

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.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 com.spice.profitmandi.common.enumuration.IndentStatus;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.ItemIdQuantity;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;

import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;

import com.spice.profitmandi.dao.entity.fofo.Indent;

import com.spice.profitmandi.dao.entity.fofo.IndentItem;

import com.spice.profitmandi.dao.repository.catalog.CategoryRepository;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

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

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

import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.service.indent.IndentService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class IndentController {

	private static final Logger LOGGER = LogManager.getLogger(IndentController.class);

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private CategoryRepository categoryRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private IndentRepository indentRepository;

	@Autowired

	private IndentItemRepository indentItemRepository;

	@Autowired

	private IndentService indentService;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@RequestMapping(value = "/indent-item/save", method = RequestMethod.PUT)

	public String saveIndentItem(HttpServletRequest request, @RequestBody ItemIdQuantity itemIdQuantity, Model model)

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LOGGER.info("Item id is {}, And quantity is {}", itemIdQuantity.getItemId(), itemIdQuantity.getItemId());

		int fofoId = loginDetails.getFofoId();

		boolean response = indentService.updateOpenIndentItem(fofoId, itemIdQuantity.getItemId(),

				itemIdQuantity.getQuantity());

		model.addAttribute("response", mvcResponseSender.createResponseString(response));

		return "response";

	}

	@RequestMapping(value = "/open-indent/save", method = RequestMethod.PUT)

	public String saveOpenIndent(HttpServletRequest request, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<Indent> openIndents = indentRepository.selectIndentByStatus(fofoId, IndentStatus.OPEN);

		if (openIndents.size() > 0) {

			Indent openIndent = openIndents.get(0);

			if (indentItemRepository.selectIndentItems(Arrays.asList(openIndent.getId())).size() == 0) {

				model.addAttribute("response", mvcResponseSender.createResponseString(false));

			}

			openIndent.setCreateTimestamp(LocalDateTime.now());

			openIndent.setStatus(IndentStatus.ALLOCATED);

			indentRepository.persist(openIndent);

			model.addAttribute("response", mvcResponseSender.createResponseString(true));

		}

		return "response";

	}

	@RequestMapping(value = "/migrate", method = RequestMethod.PUT)

	public String migrate(HttpServletRequest request, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<TagListing> tagListings = tagListingRepository.selectAll();

		for(TagListing tagListing : tagListings) {

			int itemId = tagListing.getItemId();

		}

		return "";

	}

	@RequestMapping(value = "/indent/inProcess")

	public String loadInProcessIndents(HttpServletRequest request, Model model) throws ProfitMandiBusinessException{

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<Integer> pendingIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.PENDING).stream().map(x->x.getId()).collect(Collectors.toList());

		List<Integer> allocatedIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.ALLOCATED).stream().map(x->x.getId()).collect(Collectors.toList());

		pendingIndentIds.addAll(allocatedIndentIds);

		if(pendingIndentIds.size() > 0) {

			Map<Integer, IndentItem> pendingIndentItemIdMap = indentItemRepository.selectIndentItems(pendingIndentIds).stream().collect(Collectors.toMap(x->x.getItemId(), x->x));

			List<TagListing> tagListings = tagListingRepository.selectByItemIdsAndTagIds(pendingIndentItemIdMap.keySet(), new HashSet<>(Arrays.asList(4)));

			List<FofoOrderItem> fofoOrderItems = fofoOrderRepository.selectByFofoItemIds(fofoId, pendingIndentIds, LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(30), LocalDateTime.now());

			Map<Integer, Integer> itemQuantity = fofoOrderItems.stream().collect(

					Collectors.groupingBy(FofoOrderItem::getItemId, Collectors.summingInt(FofoOrderItem::getQuantity)));

			List<CurrentInventorySnapshot> cis = currentInventorySnapshotRepository.selectByFofoId(fofoId);

			Map<Integer, CurrentInventorySnapshot> itemIdSnapshotMap = cis.stream().collect(Collectors.toMap(x->x.getItemId(), x->x));

			for(TagListing tagListing : tagListings){

				Integer itemId = tagListing.getItemId();

				tagListing.setItemDescription(itemRepository.selectById(itemId).getItemDescription());

				if(itemQuantity.containsKey(itemId)) {

					tagListing.setLast30DaysSale(itemQuantity.get(itemId));

				}

				if(itemIdSnapshotMap.containsKey(itemId)){

					tagListing.setStockInHand(itemIdSnapshotMap.get(itemId).getAvailability());

				}

			}

			model.addAttribute("pendingIndentItemIdMap", pendingIndentItemIdMap);

			model.addAttribute("tagListings", tagListings);

		}

		return "pending-indent";

	}

	@RequestMapping(value = "/indent/loadIndent")

	public String loadOpenIndent(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<Indent> openIndents = indentRepository.selectIndentByStatus(fofoId, IndentStatus.OPEN);

		Indent openIndent = null;

		if (openIndents.size() > 0) {

			openIndent = openIndents.get(0);

		} else {

			LOGGER.info("Indent does not exist");

		}

		Map<Integer, IndentItem> itemIndentMap = new HashMap<>();

		if (openIndent != null) {

			List<IndentItem> openIndentItems = indentItemRepository

					.selectIndentItems(Arrays.asList(openIndent.getId()));

			if (openIndentItems.size() > 0) {

				itemIndentMap = openIndentItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x));

			}

		}

		List<TagListing> tagListings = tagListingRepository.selectAll();

		List<Integer> itemIds = new ArrayList<>();

		for (TagListing tagListing : tagListings) {

			itemIds.add(tagListing.getItemId());

		}

		List<FofoOrderItem> fofoOrderItems = fofoOrderRepository.selectByFofoItemIds(fofoId, itemIds,

				LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(30), LocalDateTime.now());

		Map<Integer, Integer> itemQuantity = fofoOrderItems.stream().collect(

				Collectors.groupingBy(FofoOrderItem::getItemId, Collectors.summingInt(FofoOrderItem::getQuantity)));

		List<CurrentInventorySnapshot> cis = currentInventorySnapshotRepository.selectByFofoId(fofoId);

		Map<Integer, CurrentInventorySnapshot> itemIdSnapshotMap = cis.stream()

				.collect(Collectors.toMap(x->x.getItemId(), x->x));

		List<Integer> pendingIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.PENDING).stream()

				.map(x -> x.getId()).collect(Collectors.toList());

		List<Integer> allocatedIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.ALLOCATED)

				.stream().map(x -> x.getId()).collect(Collectors.toList());

		pendingIndentIds.addAll(allocatedIndentIds);

		if (pendingIndentIds.size() > 0) {

			List<Integer> pendingItemIds = indentItemRepository.selectIndentItems(pendingIndentIds).stream()

					.map(x -> x.getItemId()).collect(Collectors.toList());

			tagListings = tagListings.stream().filter(x -> pendingItemIds.indexOf(x.getItemId()) == -1)

					.collect(Collectors.toList());

		}

		for (TagListing tagListing : tagListings) {

			Integer itemId = tagListing.getItemId();

			tagListing.setItemDescription(itemRepository.selectById(itemId).getItemDescription());

			if (itemQuantity.containsKey(itemId)) {

				tagListing.setLast30DaysSale(itemQuantity.get(itemId));

			}

			if (itemIdSnapshotMap.containsKey(itemId)) {

				tagListing.setStockInHand(itemIdSnapshotMap.get(itemId).getAvailability());

			}

		}

		model.addAttribute("tagListings", tagListings);

		model.addAttribute("itemIndentMap", itemIndentMap);

		return "open-indent";

	}

}