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.Logger;
import org.apache.logging.log4j.LogManager;
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.google.common.base.Functions;
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(CurrentInventorySnapshot::getItemId, Functions.identity()));
                        
                        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(CurrentInventorySnapshot::getItemId, Functions.identity()));

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