Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

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 org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

import com.spice.profitmandi.dao.entity.inventory.Vendor;

import com.spice.profitmandi.dao.entity.inventory.VendorCatalogPricing;

import com.spice.profitmandi.dao.entity.inventory.VendorCatalogPricingLog;

import com.spice.profitmandi.dao.entity.warehouse.Supplier;

import com.spice.profitmandi.dao.enumuration.inventory.VendorCatalogPricingStatus;

import com.spice.profitmandi.dao.model.VendorCatalogPricingModel;

import com.spice.profitmandi.dao.model.VendorPriceCircularModel;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

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

import com.spice.profitmandi.dao.repository.inventory.VendorCatalogPricingLogRepository;

import com.spice.profitmandi.dao.repository.inventory.VendorCatalogPricingRepository;

import com.spice.profitmandi.dao.repository.inventory.VendorRepository;

import com.spice.profitmandi.dao.repository.warehouse.SupplierRepository;

import com.spice.profitmandi.service.inventory.VendorCatalogPricingService;

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 VendorController {

    @Autowired

    VendorRepository vendorRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private VendorCatalogPricingService vendorCatalogPricingService;

    @Autowired

    private VendorCatalogPricingLogRepository vendorCatalogPricingLogRepository;

    @Autowired

    private VendorCatalogPricingRepository vendorCatalogPricingRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private SupplierRepository supplierRepository;

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

    @RequestMapping(value = "/vendorCatalogPricing", method = RequestMethod.GET)

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

        return "vendor-catalog-pricing";

    }

    @RequestMapping(value = "/getVendorCatalogPricingByModel", method = RequestMethod.GET)

    public String getVendorCatalogPricingByModel(HttpServletRequest request, @RequestParam int catalogId, Model model) throws Exception {

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

        Map<Integer, VendorCatalogPricing> vendorCatalogPricingMap = new HashMap<>();

        Map<Integer, VendorCatalogPricingLog> vendorCatalogPricingLogMap = new HashMap<>();

        List<VendorCatalogPricing> vendorCatalogPricing = vendorCatalogPricingRepository.selectByCatalogId(catalogId);

        if (!vendorCatalogPricing.isEmpty()) {

            vendorIds.addAll(vendorCatalogPricing.stream().distinct().map(x -> x.getVendorId()).collect(Collectors.toList()));

            vendorCatalogPricingMap = vendorCatalogPricing.stream().collect(Collectors.toMap(x -> x.getVendorId(), x -> x));

        }

        List<VendorCatalogPricingLog> vendorCatalogPricingLog = vendorCatalogPricingLogRepository.selectByCatalogId(catalogId, VendorCatalogPricingStatus.PENDING);

        if (!vendorCatalogPricingLog.isEmpty()) {

            vendorIds.addAll(vendorCatalogPricingLog.stream().distinct().map(x -> x.getVendorId()).collect(Collectors.toList()));

            vendorCatalogPricingLogMap = vendorCatalogPricingLog.stream().filter(x -> x.getStatus().equals(VendorCatalogPricingStatus.PENDING)).collect(Collectors.toMap(x -> x.getVendorId(), x -> x));

        }

        LOGGER.info("VendorIds {}", vendorIds);

        List<Supplier> suppliers = new ArrayList<Supplier>();

        if (!vendorIds.isEmpty()) {

            suppliers.addAll(supplierRepository.selectBySupplierIds(vendorIds));

        }

        LOGGER.info("suppliers {}", suppliers);

        model.addAttribute("suppliers", suppliers);

        model.addAttribute("vendorCatalogPricingMap", vendorCatalogPricingMap);

        model.addAttribute("vendorCatalogPricingLogMap", vendorCatalogPricingLogMap);

        model.addAttribute("catalogId", catalogId);

        return "vendor-catalog-pricing-view";

    }

    @RequestMapping(value = "/vendors", method = RequestMethod.GET)

    public String getVendor(HttpServletRequest request, Model model, @RequestParam String query) throws Throwable {

        List<Supplier> vendors = supplierRepository.selectAll().stream().filter(x -> x.getName().toLowerCase().matches(".*?" + query.toLowerCase() + ".*?")).collect(Collectors.toList());

        model.addAttribute("response1", mvcResponseSender.createResponseString(vendors));

        return "response";

    }

    @RequestMapping(value = "/createVendorCatalogPricing", method = RequestMethod.POST)

    public String createVendorCatalogPricing(HttpServletRequest request, @RequestBody VendorCatalogPricingModel vendorCatalogPricingModel, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        vendorCatalogPricingModel.setAuthId(authUser.getId());

        LOGGER.info("vendorCatalogPricingModel {}", vendorCatalogPricingModel);

        vendorCatalogPricingService.createVendorCatalogPricingLog(vendorCatalogPricingModel);

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

        return "response";

    }

    @RequestMapping(value = "/vendorCatalogPricingRequests", method = RequestMethod.GET)

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

        List<VendorCatalogPricingLog> vendorCatalogPricingRequests = vendorCatalogPricingLogRepository.selectByStatus(VendorCatalogPricingStatus.PENDING);

        Map<Integer, AuthUser> authUserMap = authRepository.selectAllActiveUser().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        model.addAttribute("vendorCatalogPricingRequests", vendorCatalogPricingRequests);

        if (!vendorCatalogPricingRequests.isEmpty()) {

            Set<Integer> catalogIds = vendorCatalogPricingRequests.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

            List<Integer> vendorIds = vendorCatalogPricingRequests.stream().map(x -> x.getVendorId()).collect(Collectors.toList());

            Map<Integer, List<Item>> itemMap = itemRepository.selectAllByCatalogIds(catalogIds).stream().collect(Collectors.groupingBy(x -> x.getCatalogItemId()));

            model.addAttribute("itemMap", itemMap);

        }

        Map<Integer, Vendor> vendorMap = vendorRepository.selectAll().stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        model.addAttribute("authMap", authUserMap);

        model.addAttribute("vendorMap", vendorMap);

        model.addAttribute("vendorPricingStatus", VendorCatalogPricingStatus.values());

        return "vendor-catalog-pricing-request";

    }

    @RequestMapping(value = "/verifyVendorCatalogPricingRequest", method = RequestMethod.POST)

    public String verifyVendorCatalogPricingRequest(HttpServletRequest request, @RequestParam int id, @RequestParam VendorCatalogPricingStatus status, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

        VendorCatalogPricingLog vendorCatalogPricingLog = vendorCatalogPricingLogRepository.selectById(id);

        vendorCatalogPricingLog.setStatus(status);

        vendorCatalogPricingLog.setUpdatedTimestamp(LocalDateTime.now());

        if (vendorCatalogPricingLog.getStatus().equals(VendorCatalogPricingStatus.APPROVED)) {

            vendorCatalogPricingLog.setApprovedBy(authUser.getId());

            vendorCatalogPricingLog.setApprovedTimestamp(LocalDateTime.now());

            vendorCatalogPricingService.createVendorCatalogPricing(vendorCatalogPricingLog);

        }

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

        return "response";

    }

    @RequestMapping(value = "/vendorPriceCircular", method = RequestMethod.GET)

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

        return "vendor-price-circular";

    }

    @RequestMapping(value = "/getVendorPriceCircular", method = RequestMethod.GET)

    public String getVendorPriceCircular(HttpServletRequest request, @RequestParam int vendorId, @RequestParam LocalDate effectedDate, Model model) throws Exception {

        List<VendorPriceCircularModel> vendorCatalogPricings = vendorCatalogPricingLogRepository.selectByVendorAndEffectedDate(vendorId, effectedDate);

        if (!vendorCatalogPricings.isEmpty()) {

            Set<Integer> catalogIds = vendorCatalogPricings.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

            Map<Integer, List<Item>> itemMap = itemRepository.selectAllByCatalogIds(catalogIds).stream().collect(Collectors.groupingBy(x -> x.getCatalogItemId()));

            model.addAttribute("itemMap", itemMap);

        }

        model.addAttribute("vendorCatalogPricings", vendorCatalogPricings);

        return "vendor-price-circular-view";

    }

    @RequestMapping(value = "/getPricing", method = RequestMethod.GET)

    public String getPricing(HttpServletRequest request, @RequestParam int vendorId, @RequestParam int itemId, Model model) throws Exception {

        Item item = itemRepository.selectById(itemId);

        VendorCatalogPricing vendorCatalogPricing = vendorCatalogPricingRepository.selectByVendorAndCatalogId(vendorId, item.getCatalogItemId());

        LOGGER.info("vendorCatalogPricing {}", vendorCatalogPricing);

        model.addAttribute("response1", mvcResponseSender.createResponseString(vendorCatalogPricing));

        return "response";

    }

}