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;

	}

}