Subversion Repositories SmartDukaan

Rev

Rev 21657 | Rev 21728 | Go to most recent revision | View as "text/plain" | Blame | Compare with Previous | Last modification | View Log | RSS feed 

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomCurrentInventorySnapshot;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.util.StringUtils;
import com.spice.profitmandi.dao.entity.FofoItemId;
import com.spice.profitmandi.dao.entity.InventoryItem;
import com.spice.profitmandi.dao.entity.Item;
import com.spice.profitmandi.dao.entity.LineItem;
import com.spice.profitmandi.dao.entity.Order;
import com.spice.profitmandi.dao.entity.Purchase;
import com.spice.profitmandi.dao.repository.CurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.InventoryItemRepository;
import com.spice.profitmandi.dao.repository.ItemRepository;
import com.spice.profitmandi.dao.repository.OrderRepository;
import com.spice.profitmandi.dao.repository.PurchaseRepository;
import com.spice.profitmandi.web.model.FofoDetails;
import com.spice.profitmandi.web.util.CookiesFetcher;
import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller
@Transactional
public class InventoryController {
        
        private static final Logger LOGGER = LoggerFactory.getLogger(InventoryController.class);
        
        @Autowired
        CurrentInventorySnapshotRepository  currentInventorySnapshotRepository;
        
        @Autowired
        InventoryItemRepository inventoryItemRepository;
        
        @Autowired
        PurchaseRepository purchaseRepository;
        
        @Autowired
        ItemRepository itemRepository;
        
        @Autowired
        OrderRepository orderRepository;
        
        @Autowired
        MVCResponseSender mvcResponseSender;
        
        @Autowired
        CookiesFetcher cookiesFetcher;
        
        @RequestMapping(value = "/checkCurrentAvailability")
        public String getCurrentAvailability(HttpServletRequest request, @ModelAttribute ModelMap model) throws Exception{
                FofoDetails fofoDetails;
                try {
                        fofoDetails = cookiesFetcher.getCookiesObject(request);
                } catch (ProfitMandiBusinessException e) {
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
                        return "response";
                }
                List<Object[]> rows = currentInventorySnapshotRepository.selectCustomByFofoId(fofoDetails.getFofoId());
                
                model.addAttribute("currentInventorySnapshots", this.getCustomCurrentInventorySnapshots(rows));
                return "dashboard";
        }
        
        private Set<CustomCurrentInventorySnapshot> getCustomCurrentInventorySnapshots(List<Object[]> rows){
                Set<CustomCurrentInventorySnapshot> currentInventorySnapshots = new HashSet<>();
                for(Object[] row : rows){
                        currentInventorySnapshots.add(this.createCustomCurrentInventorySnapshop(row));
                }
                return currentInventorySnapshots;
        }
        
        private CustomCurrentInventorySnapshot createCustomCurrentInventorySnapshop(Object[] row)
        {
                CustomCurrentInventorySnapshot currentInventorySnapshot = new CustomCurrentInventorySnapshot();
                currentInventorySnapshot.setItemId((Integer)row[0]);
                currentInventorySnapshot.setAvailability((Integer)row[1]);
                currentInventorySnapshot.setBrand((String)row[2]);
                currentInventorySnapshot.setModelName((String)row[3]);
                currentInventorySnapshot.setModelNumber((String)row[4]);
                currentInventorySnapshot.setColor((String)row[5]);
                return currentInventorySnapshot;
        }
        @RequestMapping(value = "/checkItemAvailability")
        public String getItemAvailability(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, @ModelAttribute Model model) throws Exception{
                FofoDetails fofoDetails;
                try {
                        fofoDetails = cookiesFetcher.getCookiesObject(request);
                } catch (ProfitMandiBusinessException e) {
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
                        return "response";
                }
                try{
                        FofoItemId fofoItemId = new FofoItemId();
                        fofoItemId.setFofoId(fofoDetails.getFofoId());
                        fofoItemId.setItemId(itemId);
                        Object[] row = currentInventorySnapshotRepository.selectCustomByFofoItemId(fofoItemId);
                        model.addAttribute("currentInventorySnapshots", this.createCustomCurrentInventorySnapshop(row));
                        return "dashboard";
                }catch(ProfitMandiBusinessException profitMandiBusinessException){
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("INVNTRY_SNPSHT", false, "/dashboard"));
                        return "response";
                }
        }
        
        @RequestMapping(value = "/grnHistoryByFofoId")
        public String grnHistoryByFofoId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.START_TIME, required = false) String startTimeString, @RequestParam(name = ProfitMandiConstants.END_TIME, required = false) String endTimeString, @RequestParam(name = ProfitMandiConstants.PAGE_NUMBER) int pageNumber, @RequestParam(name = ProfitMandiConstants.PAGE_SIZE) int pageSize, Model model) throws Exception{
                FofoDetails fofoDetails;
                try {
                        fofoDetails = cookiesFetcher.getCookiesObject(request);
                } catch (ProfitMandiBusinessException e) {
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
                        return "response";
                }
                
                LocalDateTime startDateTime = StringUtils.toDateTime(startTimeString);
                LocalDateTime endDateTime = StringUtils.toDateTime(endTimeString);
                
                model.addAttribute("grnHistories", purchaseRepository.selectByFofoId(fofoDetails.getFofoId(), startDateTime, endDateTime, pageNumber, pageSize));
                return "";
        }
        
        @RequestMapping(value = "/grnHistoryDetailByPurchaseId")
        public String grnHistoryByPurchaseId(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.PURCHASE_ID) int purchaseId, Model model) throws Exception{
                FofoDetails fofoDetails;
                try {
                        fofoDetails = cookiesFetcher.getCookiesObject(request);
                } catch (ProfitMandiBusinessException e) {
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
                        return "response";
                }
                Purchase purchase = null;
                try {
                        purchase = purchaseRepository.selectById(purchaseId);
                } catch (ProfitMandiBusinessException e) {
                        
                }
                model.addAttribute("grnHistories", this.grnHistoryDetails(purchase, fofoDetails.getFofoId()));
                return "";
        }
        
        @RequestMapping(value = "/grnHistoryDetailByPurchaseReference")
        public String grnHistoryByPurchaseReference(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE) String purchaseReference, Model model) throws Exception{
                FofoDetails fofoDetails;
                try {
                        fofoDetails = cookiesFetcher.getCookiesObject(request);
                } catch (ProfitMandiBusinessException e) {
                        model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
                        return "response";
                }
                Purchase purchase = null;
                try {
                        purchase = purchaseRepository.selectByPurchaseReference(purchaseReference);
                } catch (ProfitMandiBusinessException e) {
                        
                }
                model.addAttribute("grnHistories", this.grnHistoryDetails(purchase, fofoDetails.getFofoId()));
                return "";
        }
        
        private Map<Integer, Map<String, Object>> grnHistoryDetails(Purchase purchase, int fofoId){
                Set<Integer> itemIds = new HashSet<>();
                Set<Item> inventoryItemDetails = new HashSet<>();
                List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchase.getId());
                for(InventoryItem inventoryItem : inventoryItems){
                        inventoryItemDetails.add(inventoryItem.getItem());
                        itemIds.add(inventoryItem.getItemId());
                }
                
                Map<Integer, Map<String, Object>> grnHistoryDetails = new HashMap<>();
                this.createGrnHistoryDetails(grnHistoryDetails, inventoryItems);
                Map<Integer, Map<String, Object>> completedItemDetails = this.toMap(inventoryItemDetails);
                                
                this.writeItemDetailstoGrnHistories(grnHistoryDetails, completedItemDetails);
                
                if(!purchase.isCompleted()){
                        List<Order> orders = orderRepository.selectByInvoiceNumberRetailerIdNotItemIds(purchase.getPurchaseReference(), fofoId, itemIds);
                        for(Order order : orders){
                                LineItem lineItem = order.getLineItem();
                                //orderItemDetails.add(lineItem.getItem());
                                Item item = lineItem.getItem();
                                if(!grnHistoryDetails.containsKey(item.getId())){
                                        Map<String, Object> grnHistoryDetail = new HashMap<>();
                                        grnHistoryDetail.put(ProfitMandiConstants.QUANTITY, lineItem.getQuantity());
                                        grnHistoryDetail.put(ProfitMandiConstants.BRAND, item.getBrand());
                                        grnHistoryDetail.put(ProfitMandiConstants.MODEL_NAME, item.getModelName());
                                        grnHistoryDetail.put(ProfitMandiConstants.MODEL_NUMBER, item.getModelNumber());
                                        grnHistoryDetail.put(ProfitMandiConstants.COLOR, item.getColor());
                                        grnHistoryDetail.put(ProfitMandiConstants.COMPLETED, false);
                                        if(lineItem.getSerialNumber() == null || lineItem.getSerialNumber().equals("")){
                                                grnHistoryDetail.put(ProfitMandiConstants.SERIALIZED, false);
                                        }else{
                                                grnHistoryDetail.put(ProfitMandiConstants.SERIALIZED, true);
                                                Set<String> serialNumbers = new HashSet<>();
                                                serialNumbers.add(lineItem.getSerialNumber());
                                                grnHistoryDetail.put(ProfitMandiConstants.SERIAL_NUMBERS, serialNumbers);
                                        }
                                        grnHistoryDetails.put(item.getId(), grnHistoryDetail);
                                }else{
                                        Map<String, Object> grnHistoryDetail = grnHistoryDetails.get(item.getId());
                                        if((boolean)grnHistoryDetail.get(ProfitMandiConstants.SERIALIZED)){
                                                @SuppressWarnings("unchecked")
                                                Set<String> serialNumbers = (Set<String>)grnHistoryDetail.get(ProfitMandiConstants.SERIAL_NUMBERS);
                                                serialNumbers.add(lineItem.getSerialNumber());
                                        }
                                }
                        }
                }
                return grnHistoryDetails;
        }
        
        private void writeItemDetailstoGrnHistories(Map<Integer, Map<String, Object>> grnHistoryDetails, Map<Integer, Map<String, Object>> itemDetails){
                for(int key : grnHistoryDetails.keySet()){
                        Map<String, Object> grnHistoryDetail = grnHistoryDetails.get(key);
                        grnHistoryDetail.putAll(itemDetails.get(key));
                }
        }
        
        private Map<Integer, Map<String, Object>> toMap(Set<Item> items){
                Map<Integer, Map<String, Object>> map = new HashMap<>();
                for(Item item : items){
                        Map<String, Object> detailMap = new HashMap<>();
                        detailMap.put(ProfitMandiConstants.BRAND, item.getBrand());
                        detailMap.put(ProfitMandiConstants.MODEL_NAME, item.getModelName());
                        detailMap.put(ProfitMandiConstants.MODEL_NUMBER, item.getModelNumber());
                        detailMap.put(ProfitMandiConstants.COLOR, item.getColor());
                        map.put(item.getId(), detailMap);
                }
                return map;
        }
        
        private void createGrnHistoryDetails(Map<Integer, Map<String, Object>> grnHistoryDetails, List<InventoryItem> inventoryItems){
                //Map<Integer, Map<String, Object>> grnHistoryDetails = new HashMap<>();
                for(InventoryItem inventoryItem : inventoryItems){
                        if(!grnHistoryDetails.containsKey(inventoryItem.getItemId())){
                                Map<String, Object> grnHistoryDetail = new HashMap<>();
                                grnHistoryDetail.put(ProfitMandiConstants.QUANTITY, inventoryItem.getInitialQuantity());
                                grnHistoryDetail.put(ProfitMandiConstants.COMPLETED, true);
                                if(inventoryItem.getSerialNumber() == null || inventoryItem.getSerialNumber().equals("")){
                                        grnHistoryDetail.put(ProfitMandiConstants.SERIALIZED, false);
                                }else{
                                        grnHistoryDetail.put(ProfitMandiConstants.SERIALIZED, true);
                                        Set<String> serialNumbers = new HashSet<>();
                                        serialNumbers.add(inventoryItem.getSerialNumber());
                                        grnHistoryDetail.put(ProfitMandiConstants.SERIAL_NUMBERS, serialNumbers);
                                }
                                grnHistoryDetails.put(inventoryItem.getItemId(), grnHistoryDetail);
                                //itemIds.add(inventoryItem.getItemId());
                        }else{
                                Map<String, Object> grnHistoryDetail = grnHistoryDetails.get(inventoryItem.getItemId());
                                if((boolean)grnHistoryDetail.get(ProfitMandiConstants.SERIALIZED)){
                                        @SuppressWarnings("unchecked")
                                        Set<String> serialNumbers = (Set<String>)grnHistoryDetail.get(ProfitMandiConstants.SERIAL_NUMBERS);
                                        LOGGER.info("serialNumbers {}", serialNumbers);
                                        serialNumbers.add(inventoryItem.getSerialNumber());
                                        grnHistoryDetail.put(ProfitMandiConstants.QUANTITY, (int)grnHistoryDetail.get(ProfitMandiConstants.QUANTITY) + inventoryItem.getInitialQuantity());
                                }
                        }
                        
                }
                //return null;
        }
        
        public List<Item> getItemsByItemIds(Set<Integer> itemIds){
                return null;
        }
        
        /*@RequestMapping(value = "/grnHist")
        public String grnHist(HttpServletRequest request) throws Exception{
                LOGGER.info("result {}", orderRepository.selectByInvoiceNumber("58400149931", 963490));
                return null;
        }*/
        
        @RequestMapping(value = "/grnHist")
        public String grnHist(HttpServletRequest request ) throws Exception{
                Purchase purchase = null;
                try {
                        purchase = purchaseRepository.selectById(2);
                } catch (ProfitMandiBusinessException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                LOGGER.info("grnHistoryDetails {}", StringUtils.toString(this.grnHistoryDetails(purchase, 963490)));
                return null;
        }
        
}