Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;

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.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.util.ExcelUtils;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.transaction.LineItemImei;
import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
import com.spice.profitmandi.dao.entity.transaction.PriceDropIMEI;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropIMEIRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.pricing.PriceDropService;
import com.spice.profitmandi.service.wallet.WalletService;
import com.spice.profitmandi.web.util.MVCResponseSender;

import in.shop2020.model.v1.order.WalletReferenceType;

@Controller
@Transactional
public class PriceDropController {

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

        @Autowired
        private PriceDropRepository priceDropRepository;

        @Autowired
        private InventoryService inventoryService;

        @Autowired
        private PriceDropIMEIRepository priceDropIMEIRepository;

        @Autowired
        private PriceDropService priceDropService;

        @Autowired
        private MVCResponseSender mvcResponseSender;

        @Autowired
        private WalletService walletService;

        @Autowired
        private LineItemImeisRepository lineItemImeisRepository;

        @Autowired
        @Qualifier("catalogItemRepository")
        private ItemRepository itemRepository;

        private List<Integer> getItemIds() {
                List<Integer> itemIds = new ArrayList<>();
                List<PriceDrop> priceDrops = priceDropRepository.selectAll();
                for (PriceDrop priceDrop : priceDrops) {
                        itemIds.add(priceDrop.getItemId());
                }
                return itemIds;
        }

        @RequestMapping(value = "/getItemDescription", method = RequestMethod.GET)
        public String getItemDescription(HttpServletRequest request, Model model) {

                List<Integer> itemIds = this.getItemIds();
                Map<Integer, String> itemIdDescriptions = inventoryService
                                .getItemIdDescriptionMap(new HashSet<Integer>(itemIds));
                List<PriceDrop> priceDrops = priceDropRepository.selectAll();
                model.addAttribute("itemIdDescriptions", itemIdDescriptions);
                model.addAttribute("priceDrops", priceDrops);
                return "price-drop";

        }

        @RequestMapping(value = "/downloadPriceDropIMEI/{priceDropId}", method = RequestMethod.GET)
        public ResponseEntity<?> downloadPriceDropIMEI(HttpServletRequest request, @PathVariable int priceDropId,
                        Model model) throws ProfitMandiBusinessException {

                PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
                List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository.selectByPriceDropId(priceDrop.getId());
                List<String> imeis = priceDropIMEIs.stream().map(x -> x.getImei()).collect(Collectors.toList());
                List<LineItemImei> lineItemImeis = lineItemImeisRepository.selectByIMEI(imeis);
                Map<String, String> priceDropIMEIfofoId = priceDropService.getIMEIandRetailerName(lineItemImeis, priceDrop);
                if (priceDropIMEIfofoId.size() > 0) {
                        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                        ExcelUtils.writePriceDrop(priceDropIMEIfofoId, priceDrop.getItemId(), byteArrayOutputStream);
                        final HttpHeaders headers = new HttpHeaders();
                        // private static final String CONTENT_TYPE_XLSX =
                        // "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                        headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                        // headers.set("Content-Type", "application/vnd.ms-excel");
                        headers.set("Content-disposition", "inline; filename=priceDrop" + priceDrop.getId() + ".xlsx");
                        headers.setContentLength(byteArrayOutputStream.toByteArray().length);
                        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
                        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
                } else {
                        throw new ProfitMandiBusinessException("priceDropId", priceDropId, "No IMEI is Eligible For PriceDrop");
                }

        }

        @RequestMapping(value = "/paymentAgainstPriceDrop/{priceDropId}/{processedamount}", method = RequestMethod.POST)
        public String paymentAgainstPriceDropIMEI(HttpServletRequest request, @PathVariable int priceDropId,
                        @PathVariable int processedamount, Model model) throws Exception {

                
                int noOfIMEIForPartner = 1;
                Map<Integer, Integer> noOfPriceDropToPartners = new HashMap<>();
                PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
                Item item = itemRepository.selectById(priceDrop.getItemId());
                List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository.selectByPriceDropId(priceDrop.getId());
                List<String> imeis = priceDropIMEIs.stream().map(x -> x.getImei()).collect(Collectors.toList());
                List<LineItemImei> lineItemImeis = lineItemImeisRepository.selectByIMEI(imeis);
                Map<String, Integer> priceDropIMEIfofoIds = priceDropService.getIMEIAndfofoIdForPriceDrop(lineItemImeis,
                                priceDrop);
                if (priceDropIMEIfofoIds.size() > 0) {
                        for (Map.Entry<String, Integer> priceDropIMEIAndFofoId : priceDropIMEIfofoIds.entrySet()) {
                                int fofoId = priceDropIMEIAndFofoId.getValue();
                                if (noOfPriceDropToPartners.containsKey(fofoId)) {
                                        noOfPriceDropToPartners.put(fofoId, noOfPriceDropToPartners.get(fofoId) + 1);
                                } else {
                                        noOfPriceDropToPartners.put(fofoId, noOfIMEIForPartner);
                                }

                        }
                        for (Map.Entry<Integer, Integer> noOfPriceDropToPartner : noOfPriceDropToPartners.entrySet()) {
                                String description = String.format("Price Drop amount added for %s, total %d pcs.",
                                                item.getItemDescription(), noOfPriceDropToPartner.getValue());
                                walletService.addAmountToWallet(noOfPriceDropToPartner.getKey(), priceDrop.getId(),
                                                WalletReferenceType.PRICE_DROP, description,
                                                (noOfPriceDropToPartner.getValue() * processedamount));
                                LOGGER.info(
                                                "Price Drop amount [{}] has been added with retailerId [{}]'s wallet, referenceId [{}], No Of serialNumber [{}]",
                                                (noOfPriceDropToPartner.getValue() * processedamount), noOfPriceDropToPartner.getKey(),
                                                priceDrop.getId(), noOfPriceDropToPartner.getValue());
                        }
                        priceDrop.setProcessTimestamp(LocalDateTime.now());
                        priceDrop.setPartnerPayout(processedamount);
                        priceDropRepository.persist(priceDrop);
                        model.addAttribute("response", mvcResponseSender.createResponseString(true));
                        return "response";
                } else {
                        priceDrop.setProcessTimestamp(LocalDateTime.now());
                        model.addAttribute("response", mvcResponseSender.createResponseString(false));
                        return "false";
                }
        }

        @RequestMapping(value = "/downloadtotalPriceDropIMEI/{priceDropId}", method = RequestMethod.GET)
        public ResponseEntity<?> downloadTotalPriceDropIMEI(HttpServletRequest request, @PathVariable int priceDropId,
                        Model model) throws ProfitMandiBusinessException {

                PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
                Map<String, String> priceDropIMEIAndItemId = this.getpriceDropIMEIAndItemDescription(priceDrop);
                if (priceDropIMEIAndItemId.size() > 0) {
                        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                        ExcelUtils.writePriceDropForAllIMEI(priceDropIMEIAndItemId, byteArrayOutputStream);
                        final HttpHeaders headers = new HttpHeaders();
                        headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                        headers.set("Content-disposition", "inline; filename=totalPriceDropIMEI" + priceDrop.getItemId() + ".xlsx");
                        headers.setContentLength(byteArrayOutputStream.toByteArray().length);
                        final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
                        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
                } else {
                        priceDrop.setProcessTimestamp(LocalDateTime.now());
                        throw new ProfitMandiBusinessException("IMEI", 1, "IMEI not Found For PriceDrop");
                }
        }

        private Map<String, String> getpriceDropIMEIAndItemDescription(PriceDrop priceDrop)
                        throws ProfitMandiBusinessException {
                Map<String, String> priceDropIMEIAndItemId = new LinkedHashMap<>();
                List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository.selectByPriceDropId(priceDrop.getId());
                Item item = itemRepository.selectById(priceDrop.getItemId());
                for (PriceDropIMEI priceDropIMEI : priceDropIMEIs) {
                        priceDropIMEIAndItemId.put(priceDropIMEI.getImei(), item.getItemDescription());
                }
                return priceDropIMEIAndItemId;
        }

}