Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.awt.RenderingHints;

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.time.Instant;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.imageio.ImageIO;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.velocity.app.VelocityEngine;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.CacheManager;

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.ui.velocity.VelocityEngineUtils;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.PostMapping;

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

import org.springframework.web.multipart.MultipartFile;

import org.xhtmlrenderer.simple.Graphics2DRenderer;

import org.xhtmlrenderer.swing.Java2DRenderer;

import com.google.gson.Gson;

import com.jcraft.jsch.ChannelSftp;

import com.jcraft.jsch.JSch;

import com.jcraft.jsch.JSchException;

import com.jcraft.jsch.Session;

import com.jcraft.jsch.SftpATTRS;

import com.jcraft.jsch.SftpException;

import com.spice.profitmandi.common.enumuration.MessageType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.common.model.SendNotificationModel;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.web.util.ResponseSender;

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

import com.spice.profitmandi.dao.entity.fofo.PartnerType;

import com.spice.profitmandi.dao.enumuration.catalog.ItemCriteriaType;

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.dtr.Mongo;

import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;

import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.offers.OfferService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class OfferController {

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

	@Autowired

	private OfferRepository offerRepository;

	@Autowired

	private OfferMarginRepository offerMarginRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private ResponseSender responseSender;

	@Autowired

	private OfferPartnerRepository offerPartnerRepository;

	private static final String IMAGE_REMOTE_DIR = "/var/www/dtrdashboard/uploads/campaigns/";

	private static final String IMAGE_STATIC_SERVER_URL = "https://images.smartdukaan.com/uploads/campaigns";

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private Gson gson;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private NotificationService notificationService;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private OfferService offerService;

	@Autowired

	private CacheManager thirtyMinsTimeOutCacheManager;

	@Autowired

	private CacheManager oneDayCacheManager;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

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

	public String getCreateOffer(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())

				.collect(Collectors.toList());

		Set<String> brands = mongoClient.getMongoBrands(loginDetails.getFofoId(), null, 3).stream()

				.map(x -> (String) x.get("name")).collect(Collectors.toSet());

		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);

		model.addAttribute("customRetailersMap", customRetailersMap);

		model.addAttribute("itemCriteriaType", ItemCriteriaType.values());

		model.addAttribute("brands", brands);

		model.addAttribute("partnerCategories", PartnerType.values());

		model.addAttribute("warehouseRegion", ProfitMandiConstants.WAREHOUSE_MAP);

		return "scheme_offer";

	}

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

	public String createOffer(HttpServletRequest request, @RequestBody CreateOfferRequest createOfferRequest,

							  Model model) throws Exception {

		LOGGER.info("createOfferRequest [{}]", createOfferRequest);

		offerService.addOfferService(createOfferRequest);

		thirtyMinsTimeOutCacheManager.getCache("allOffers").evict(YearMonth.now());

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

		return "response";

	}

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

	public String getPublishedOffers(HttpServletRequest request, @RequestParam int fofoId, Model model)

			throws Exception {

		LOGGER.info("Published");

		offerService.getPublishedOffers(fofoId, YearMonth.from(LocalDateTime.now()));

		return "scheme_offer/published";

	}

	@RequestMapping(value = "/offer/active/{offerId}", method = RequestMethod.GET)

	public String activateOffer(HttpServletRequest request, @PathVariable int offerId, Model model,

								@RequestParam(defaultValue = "true") boolean active) throws ProfitMandiBusinessException, Exception {

		Offer offer = offerRepository.selectById(offerId);

		boolean alreadyActive = offer.isActive();

		if (alreadyActive != active) {

			offer.setActive(active);

			oneDayCacheManager.getCache("catalog.published_yearmonth").evict(YearMonth.now());

		}

		if (active && !alreadyActive) {

			this.sendNotification(offer);

		}

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

		return "response";

		// CreateOfferRequest createOfferRequest =

		// offerService.getCreateOfferRequest(offer);

		// model.addAttribute("offer", createOfferRequest);

		// return "offer_margin_detail_partner2";

	}

	@RequestMapping(value = "/offer/testimage/{offerId}", method = RequestMethod.GET)

	public String testOffer(HttpServletRequest request, @PathVariable int offerId, Model model,

							@RequestParam(defaultValue = "true") boolean active) throws ProfitMandiBusinessException, Exception {

		Offer offer = offerRepository.selectById(offerId);

		// model.addAttribute("response", mvcResponseSender.createResponseString(true));

		// return "response";

		CreateOfferRequest createOfferRequest = offerService.getCreateOfferRequest(offer);

		model.addAttribute("offer", createOfferRequest);

		return "offer_margin_detail_partner2";

	}

	@Autowired

	private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;

	@RequestMapping(value = "/offer/active/fofo/{fofoId}", method = RequestMethod.GET)

	public String sendOfferNotification(HttpServletRequest request, @PathVariable int fofoId, Model model,

										@RequestParam(defaultValue = "true") boolean active) throws ProfitMandiBusinessException, Exception {

		List<Offer> offers = offerRepository.selectAllPublishedMapByPartner(YearMonth.now()).get(fofoId);

		for (Offer offer : offers) {

			this.sendNotification(offer);

		}

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

		return "response";

	}

	@Autowired

	UserAccountRepository userAccountRepository;

	private void sendNotification(Offer offer) throws Exception {

		String fileName = "offer-" + offer.getId() + ".png";

		CreateOfferRequest createOfferRequest = offerService.getCreateOfferRequest(offer);

		SendNotificationModel sendNotificationModel = new SendNotificationModel();

		sendNotificationModel.setCampaignName("SchemeOffer");

		sendNotificationModel.setTitle(offer.getName());

		sendNotificationModel.setMessage(createOfferRequest.getSchemeType().name() + " of select models, "

				+ FormattingUtils.formatDateMonth(offer.getStartDate()) + " to "

				+ FormattingUtils.formatDateMonth(offer.getEndDate()));

		sendNotificationModel.setType("url");

		sendNotificationModel.setImageUrl(IMAGE_STATIC_SERVER_URL + "/" + "image" + LocalDate.now() + "/" + fileName);

		sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");

		sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));

		sendNotificationModel.setMessageType(MessageType.scheme);

		Map<Integer, List<Offer>> offersMap = offerRepository.selectAllPublishedMapByPartner(YearMonth.now());

		List<Integer> fofoIds = offersMap.entrySet().stream().filter(x -> x.getValue().contains(offer))

				.map(x -> x.getKey()).collect(Collectors.toList());

		List<Integer> userIds = userAccountRepository.selectUserIdsByRetailerIds(fofoIds);

		sendNotificationModel.setUserIds(userIds);

		Map<String, InputStream> fileStreamsMap = new HashMap<>();

		Map<String, Object> model = new HashMap<>();

		model.put("offer", createOfferRequest);

		String htmlContent = this.getContentFromTemplate("offer_margin_detail_partner.vm", model);

		LOGGER.info("this.getContentFromTemplate {}", htmlContent);

		fileStreamsMap.put(fileName, this.getImageBuffer(htmlContent));

		this.uploadFile(fileStreamsMap);

		notificationService.sendNotification(sendNotificationModel);

	}

	private InputStream asInputStream(BufferedImage bi) throws Exception {

		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		ImageIO.write(bi, "png", baos);

		return new ByteArrayInputStream(baos.toByteArray());

	}

	private ChannelSftp setupJsch() throws JSchException {

		JSch jsch = new JSch();

		Session jschSession = jsch.getSession("root", "192.168.179.131");

		// Session jschSession = jsch.getSession("root", "173.255.254.24");

		LOGGER.info("getClass().getResource(\"id_rsa\") {}",

				getClass().getClassLoader().getResource("id_rsa").getPath());

		jsch.addIdentity(getClass().getClassLoader().getResource("id_rsa").getPath());

		// jschSession.setPassword("spic@2015static0");

		jschSession.setConfig("StrictHostKeyChecking", "no");

		jschSession.connect();

		return (ChannelSftp) jschSession.openChannel("sftp");

	}

	private void fileUpload(ChannelSftp channelSftp, Map<String, InputStream> streamsFileMap, String destinationPath)

			throws SftpException, FileNotFoundException {

		channelSftp.cd(destinationPath);

		String folderName = "image" + LocalDate.now();

		channelSftp.cd(destinationPath);

		SftpATTRS attrs = null;

		// check if the directory is already existing

		try {

			attrs = channelSftp.stat(folderName);

		} catch (Exception e) {

			System.out.println(destinationPath + "/" + folderName + " not found");

		}

		// else create a directory

		if (attrs == null) {

			channelSftp.mkdir(folderName);

			channelSftp.chmod(0755, ".");

		}

		channelSftp.cd(folderName);

		for (Map.Entry<String, InputStream> streamsFileEntry : streamsFileMap.entrySet()) {

			channelSftp.put(streamsFileEntry.getValue(), streamsFileEntry.getKey(), ChannelSftp.OVERWRITE);

		}

	}

	private void uploadFile(Map<String, InputStream> fileStreamsMap) throws Exception {

		ChannelSftp channelSftp = setupJsch();

		channelSftp.connect();

		this.fileUpload(channelSftp, fileStreamsMap, IMAGE_REMOTE_DIR + "");

		channelSftp.exit();

	}

	private InputStream getImageBuffer(String html) throws Exception {

		String fileName = "/tmp/" + Instant.now().toEpochMilli();

		FileUtils.writeStringToFile(new File(fileName), html, "UTF-8");

		String address = "file:" + fileName;

		Java2DRenderer renderer = new Java2DRenderer(address, 400);

		RenderingHints hints = new RenderingHints(RenderingHints.KEY_COLOR_RENDERING,

				RenderingHints.VALUE_COLOR_RENDER_QUALITY);

		hints.add(new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY));

		hints.add(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));

		hints.add(new RenderingHints(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC));

		renderer.setRenderingHints(hints);

		BufferedImage img = renderer.getImage();

		ByteArrayOutputStream os = new ByteArrayOutputStream();

		ImageIO.write(img, "png", os);

		return new ByteArrayInputStream(os.toByteArray());

	}

	@Autowired

	VelocityEngine velocityEngine;

	private String getContentFromTemplate(String template, Map<String, Object> model) {

		StringBuffer content = new StringBuffer();

		try {

			content.append(VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, template, model));

		} catch (Exception e) {

			e.printStackTrace();

		}

		return content.toString();

	}

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

	public String getPaginatedOffers(HttpServletRequest request, @RequestParam YearMonth yearMonth, Model model)

			throws ProfitMandiBusinessException {

		List<CreateOfferRequest> publishedOffers = offerService.getAllOffers(yearMonth).values().stream()

				.sorted(Comparator.comparing(CreateOfferRequest::getId).reversed()).collect(Collectors.toList());

		model.addAttribute("offers", publishedOffers);

		model.addAttribute("yearMonth", yearMonth);

		return "offer_history";

	}

	@RequestMapping(value = "/offer-details", method = RequestMethod.GET)

	public String schemeDetails(HttpServletRequest request, @RequestParam int offerId, Model model)

			throws ProfitMandiBusinessException {

		CreateOfferRequest createOfferRequest = offerService.getOffer(0, offerId);

		model.addAttribute("offer", createOfferRequest);

		return "offer-details";

	}

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

	public ResponseEntity<?> dowloadOfferSummary(HttpServletRequest request, @RequestParam int offerId, Model model)

			throws Exception {

		List<List<?>> listOfRows = new ArrayList<>();

		final HttpHeaders headers = new HttpHeaders();

		headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

		headers.set("Content-disposition", "inline; filename=offer-" + offerId + ".csv");

		CreateOfferRequest createOfferRequest = offerService.getOffer(0, offerId);

		Collection<OfferRowModel> offerRowModels = offerRepository.getOfferRows(createOfferRequest);

		for (OfferRowModel offerRowModel : offerRowModels) {

			CustomRetailer customRetailer = retailerService.getFofoRetailer(offerRowModel.getFofoId());

			listOfRows.add(Arrays.asList(createOfferRequest.getId(), createOfferRequest.getName(),

					createOfferRequest.getTargetType(), createOfferRequest.getSchemeType(),

					createOfferRequest.getBrandShareTerms(), createOfferRequest.getSellinPercentage(),

					createOfferRequest.getPartnerCriteriaString(), createOfferRequest.getItemCriteriaString(),

					createOfferRequest.getStartDate(), createOfferRequest.getEndDate(),

					createOfferRequest.getCreatedOn(), customRetailer.getPartnerId(), customRetailer.getBusinessName(),

					customRetailer.getCode(), offerRowModel.getTotalSale(), offerRowModel.getEligibleSale(),

					offerRowModel.getAchievedTarget(), offerRowModel.getNextTarget(), offerRowModel.getEligibleSaleDp(),

					offerRowModel.getTotalPurchaseValue(), offerRowModel.getCurrentPayoutTarget(),

					offerRowModel.getPayoutTargetAchieved(), offerRowModel.getAmountType(),

					offerRowModel.getPayoutValue(), offerRowModel.getPayoutValueDp(), offerRowModel.getFinalPayout(),

					String.join(", ", offerRowModel.getPendingImeis())));

		}

		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

				Arrays.asList("Id", "Name", "Target Type", "Scheme Type", "Brand %", "Sellin %", "Partner Criteria",

						"Item Criteria", "Start", "End", "Created", "Partner Id", "Partner Name", "Partner Code",

						"Total Sale", "Eligible Sale", "Achieved Target", "Next Target", "Eligible Sale DP",

						"Total Purchase DP", "Current Payout Target", "Payout Target Achieved", "Payout Amount Type",

						"Payout Value", "Payout Value DP", "Amount to be credited", "IMEIs pending for Activation"

						// "Payout Sale Qty", "Activated Value", "Activated Qty",

				), listOfRows);

		final InputStream inputStream = new ByteArrayInputStream(baos.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);

	}

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

	public String offerById(HttpServletRequest request, int offerId, Model model) throws ProfitMandiBusinessException {

		Offer offer = offerRepository.selectById(offerId);

		model.addAttribute("offer", offer);

		return "offer-edit";

	}

	@RequestMapping(value = "/published-offers/{yearMonth}", method = RequestMethod.GET)

	public String publishedOffersOnMonthBefore(HttpServletRequest request, @PathVariable int yearMonth, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<CreateOfferRequest> createOffers = offerService.getPublishedOffers(fofoId,

				YearMonth.from(LocalDate.now()).minusMonths(yearMonth));

		model.addAttribute("publishedOffers", createOffers);

		return "published-offers";

	}

	@PostMapping(value = "/offers/upload")

	public String uploadOffers(HttpServletRequest request, @RequestPart("file") MultipartFile targetFile, Model model)

			throws Exception {

		offerService.createOffers(targetFile.getInputStream());

		model.addAttribute("response", true);

		return "response";

	}

	@Autowired

	RoleManager roleManager;

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

	public String getOfferMargins(HttpServletRequest request,

								  @RequestParam(name = "offerId", defaultValue = "0") int offerId, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

		CreateOfferRequest createOfferRequest = offerService.getOffer(isAdmin ? 0 : loginDetails.getFofoId(), offerId);

		model.addAttribute("offer", createOfferRequest);

		return "offer_margin_detail_partner";

	}

}