Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.stream.Collectors;

import javax.mail.MessagingException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.thrift.TException;

import org.json.JSONObject;

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

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

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

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

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.google.gson.Gson;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.dtr.NotificationCampaign;

import com.spice.profitmandi.dao.entity.dtr.PushNotifications;

import com.spice.profitmandi.dao.entity.dtr.UserCampaign;

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

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

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

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

import com.spice.profitmandi.dao.entity.transaction.NotifyColorChange;

import com.spice.profitmandi.dao.entity.transaction.NotifyMessage;

import com.spice.profitmandi.dao.entity.transaction.NotifyOrder;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.user.Device;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.transaction.NotifyColorChangeRepository;

import com.spice.profitmandi.dao.repository.transaction.NotifyItemRepository;

import com.spice.profitmandi.dao.repository.transaction.NotifyMessageRepository;

import com.spice.profitmandi.dao.repository.transaction.NotifyOrderRespository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

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

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;

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

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

@Controller

@Transactional(rollbackFor = Throwable.class)

public class InventoryController {

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

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	@Qualifier("fofoInventoryService")

	private InventoryService inventoryService;

	@Autowired

	TagListingRepository tagListingRepository;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private TagRankingRepository tagRankingRepository;

	@Autowired

	private InventoryItemRepository inventoryItemRepository;

	@Autowired

	private LiveDemoBillingRespository liveDemoBillingRespository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private NotifyItemRepository notifyItemRespository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private UserRepository saholicUserRepository;

	@Autowired

	private NotifyItemRepository notifyItemRepository;

	@Autowired

	private NotifyColorChangeRepository notifyColorChangeRepository;

	@Autowired

	private NotifyOrderRespository notifyOrderRespository;

	@Autowired

	private NotifyMessageRepository notifyMessageRepository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Value("${saholic.api.host}")

	private String host;

	@Value("${saholic.api.port}")

	private int port;

	@Value("${saholic.api.webapp}")

	private String webapp;

	@Autowired

	JavaMailSender mailSender;

	@Autowired

	private NotificationCampaignRepository notificationCampaignRepository;

	@Autowired

	private DeviceRepository deviceRepository;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private PushNotificationRepository pushNotificationRepository;

	@Autowired

	private UserCampaignRepository userCampaignRepository;

	@Autowired

	private Gson gson;

	@RequestMapping(value = "/getCurrentInventorySnapshot")

	public String getCurrentAvailability(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getCurrentInventorySnapshot(loginDetails.getFofoId(), offset, limit,

				searchTerm);

		model.addAllAttributes(map);

		return "inventory-snapshot";

	}

	@RequestMapping(value = "/getBadInventorySnapshot")

	public String getBadAvailability(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)

			throws ProfitMandiBusinessException {

		if (searchTerm == null) {

			searchTerm = "";

		}

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getBadInventorySnapshot(loginDetails.getFofoId(), offset, limit,

				searchTerm);

		model.addAllAttributes(map);

		return "bad-inventory-snapshot";

	}

	@RequestMapping(value = "/getPaginatedCurrentInventorySnapshot")

	public String getPaginatedCurrentInventorySnapshot(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)

			throws ProfitMandiBusinessException {

		if (searchTerm == null) {

			searchTerm = "";

		}

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getPaginatedCurrentInventorySnapshot(loginDetails.getFofoId(),

				offset, limit, searchTerm);

		model.addAllAttributes(map);

		return "inventory-snapshot-paginated";

	}

	@RequestMapping(value = "/getCatalog")

	public String getCatalog(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (searchTerm == null) {

			searchTerm = "";

		}

		Map<String, Object> map = inventoryService.getCatalog(loginDetails.getFofoId(), offset, limit, searchTerm);

		model.addAllAttributes(map);

		model.addAttribute("hasGift", hasGift(loginDetails.getFofoId()));

		return "catalog";

	}

	// This method is currently hardcoded to faciliate watches sold as gift.

	private boolean hasGift(int fofoId) {

		try {

			return currentInventorySnapshotRepository.selectByItemIdAndFofoId(ProfitMandiConstants.GIFT_ID, fofoId)

					.getAvailability() > 0;

		} catch (ProfitMandiBusinessException e) {

			return false;

		}

	}

	@RequestMapping(value = "/getPaginatedCatalog")

	public String getCatalogPaginated(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (searchTerm == null) {

			searchTerm = "";

		}

		Map<String, Object> map = inventoryService.getPaginatedCatalog(loginDetails.getFofoId(), offset, limit,

				searchTerm);

		model.addAllAttributes(map);

		return "catalog-paginated";

	}

	@RequestMapping(value = "/checkItemAvailability")

	public String getItemAvailability(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.ITEM_ID) int itemId, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		CustomCurrentInventorySnapshot customCurrentInventorySnapshot = inventoryService.checkItemAvailability(itemId,

				loginDetails.getFofoId());

		/*customCurrentInventorySnapshot

				.setIconUrl(Utils.getIconUrl(customCurrentInventorySnapshot.getCatalogItemId(), host, port, webapp));*/

		model.addAttribute("currentInventorySnapshot", new Gson().toJson(customCurrentInventorySnapshot));

		return "current-item-availability";

	}

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

	public String addToCart(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.addToCart(cartData, loginDetails.getFofoId());

		model.addAllAttributes(map);

		return "cart";

	}

	@RequestMapping(value = "/validate-cart", method = RequestMethod.POST)

	public String validateCart(HttpServletRequest request, HttpServletResponse response,

			@RequestParam(name = "cartData") String cartData, Model model) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.validateCart(cartData, loginDetails.getFofoId());

		model.addAllAttributes(map);

		return "validate-cart";

	}

	@RequestMapping(value = "/grnHistory")

	public String getGrnHistory(HttpServletRequest request, @RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,

			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getGrnHistory(loginDetails.getFofoId(), startTime, endTime, offset,

				limit, purchaseReference, searchType);

		model.addAllAttributes(map);

		return "grn-history";

	}

	@RequestMapping(value = "/downloadPurchaseInvoices")

	public ResponseEntity<?> downloadPurchaseInvoices(HttpServletRequest request,

			@RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,

			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getGrnHistory(loginDetails.getFofoId(), startTime, endTime, offset,

				limit, purchaseReference, searchType);

		List<FofoOrder> fofoOrders = (List<FofoOrder>) map.get("saleHistories");

		if (fofoOrders.size() == 0) {

			throw new ProfitMandiBusinessException("Search criteria", "", "No orders found for criteria");

		}

		final HttpHeaders headers = new HttpHeaders();

		headers.setContentType(MediaType.APPLICATION_PDF);

		headers.set("Content-disposition", "inline; filename=invoices.pdf");

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		List<PdfModel> pdfModels = new ArrayList<>();

		/*

		 * for (FofoOrder fofoOrder : fofoOrders) { try {

		 * pdfModels.add(orderService.getInvoicePdfModel(fofoOrder.getId())); } catch

		 * (Exception e) {

		 * LOGGER.info("could not create invoice for {}, invoice number {}",

		 * fofoOrder.getId(), fofoOrder.getInvoiceNumber()); } }

		 */

		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

		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);

	}

	@RequestMapping(value = "/getPaginatedGrnHistory")

	public String getPaginatedGrnHistory(HttpServletRequest request,

			@RequestParam(required = false) LocalDateTime startTime,

			@RequestParam(required = false) LocalDateTime endTime,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE, defaultValue = "") String purchaseReference,

			@RequestParam(name = "searchType", defaultValue = "") String searchType, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getPaginatedGrnHistory(loginDetails.getFofoId(), startTime, endTime,

				offset, limit);

		model.addAllAttributes(map);

		return "grn-history-paginated";

	}

	@RequestMapping(value = "/grnHistoryDetailByPurchaseId")

	public String grnHistoryByPurchaseId(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.PURCHASE_ID) int purchaseId, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getGrnHistoryDetail(loginDetails.getFofoId(), purchaseId, host, port,

				webapp);

		model.addAllAttributes(map);

		return "grn-details";

	}

	@RequestMapping(value = "/grnHistoryDetailByPurchaseReference")

	public String grnHistoryByPurchaseReference(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.PURCHASE_REFERENCE) String purchaseReference, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getGrnHistoryDetail(loginDetails.getFofoId(), purchaseReference,

				host, port, webapp);

		model.addAllAttributes(map);

		return "grn-details";

	}

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

	public String getInventoryItemAgingByInterval(HttpServletRequest request, @RequestBody List<Integer> intervals,

			Model model, @RequestParam(name = "searchContent", defaultValue = "") String searchContent,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<String, Object> map = inventoryService.getPaginatedItemAgingByInterval(loginDetails.getFofoId(), intervals,

				searchContent, offset, limit);

		model.addAllAttributes(map);

		return "item-aging";

	}

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

	public ResponseEntity<?> downloadInventoryItemAgingByInterval(HttpServletRequest request,

			@RequestBody List<Integer> intervals, Model model) throws ProfitMandiBusinessException {

		LOGGER.info("Request received at url{} with body {}", request.getRequestURI(), intervals);

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		List<InventoryItemAgingModel> inventoryItemAgingModels = inventoryService

				.getItemAgingByInterval(fofoDetails.getFofoId(), intervals);

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		ExcelUtils.writeInventoryItemAgingModels(inventoryItemAgingModels, intervals, 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=InventoryItemAging.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);

		// return

		// responseSender.ok(ResponseCodeHolder.getMessage("ITM_AGNG_OK_1000"));

	}

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

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

		List<TagRanking> tagRanking = null;

		tagRanking = tagRankingRepository.getAllTagRanking();

		LOGGER.info("tagRanking" + tagRanking);

		if (!tagRanking.isEmpty()) {

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

			List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);

			Map<Integer, String> catalogDescription = items.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(),

					x -> x.getItemDescription(), (description1, description2) -> description1));

			LOGGER.info("catalogDescription" + catalogDescription);

			model.addAttribute("tagRanking", tagRanking);

			model.addAttribute("catalogDescription", catalogDescription);

		} else {

			model.addAttribute("tagRanking", tagRanking);

		}

		return "feature";

	}

	/*

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

	 * public String getPaginatedFeaturePanel(HttpServletRequest request,

	 * 

	 * @RequestParam(name = "offset", defaultValue = "0") int offset,

	 * 

	 * @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)

	 * throws ProfitMandiBusinessException {

	 * LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);

	 * List<TagRanking> tagRanking = null;

	 * 

	 * 

	 * long size = 0; tagRanking = tagRankingRepository.selectAllTagRanking(offset,

	 * limit); if (!tagRanking.isEmpty()) {

	 * 

	 * model.addAttribute("tagRanking", tagRanking); model.addAttribute("start",

	 * offset + 1); model.addAttribute("size", size); model.addAttribute("url",

	 * "/getPaginatedfeature");

	 * 

	 * } else { model.addAttribute("tagRanking", tagRanking); } return

	 * "feature-paginated"; }

	 */

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

	public String Itemfeature(HttpServletRequest request, @RequestBody ItemFeatureDataModel itemFeatureDatatModel,

			Model model) throws Exception {

		TagRanking tagRanking = tagRankingRepository.selectBycatalogItemId(itemFeatureDatatModel.getCatalogItemId());

		LOGGER.info("tagRanking" + tagRanking);

		if (tagRanking == null) {

			tagRanking = new TagRanking();

			tagRanking.setCatalogItemId(itemFeatureDatatModel.getCatalogItemId());

		}

		tagRanking.setFeature(itemFeatureDatatModel.getFeature());

		tagRanking.setRankPoints(itemFeatureDatatModel.getRankPoints());

		tagRankingRepository.persist(tagRanking);

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

		return "response";

	}

	@RequestMapping(value = "/removeFeature", method = RequestMethod.DELETE)

	public String removeTagRankingEnteries(HttpServletRequest request,

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

		tagRankingRepository.deleteById(id);

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

		return "response";

	}

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

	public String DemoListbyFofoId(HttpServletRequest request,

			@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {

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

				.collect(Collectors.toList());

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

		String customRetailers = JSONObject.valueToString(customRetailersMap.values());

		List<String> serailNumberList = liveDemoBillingRespository.selectAllSerialNumber();

		LOGGER.info("serailNumberList" + serailNumberList);

		List<InventoryItem> inventoryItem = null;

		List<InventoryItem> inventoryItem1 = new ArrayList<>();

		if (fofoId > 0) {

			List<Item> items = itemRepository.selectAllByBrand("Live Demo");

			Set<Integer> itemIds = new HashSet<>();

			for (Item Item : items) {

				itemIds.add(Item.getId());

			}

			inventoryItem = inventoryItemRepository.selectByFofoIdItemIds(fofoId, itemIds);

			Set<String> serial = new HashSet<>();

			for (InventoryItem invItem : inventoryItem) {

				if (!serailNumberList.contains(invItem.getSerialNumber())) {

					inventoryItem1.add(invItem);

				}

			}

			LOGGER.info("inventoyItem" + inventoryItem1);

			model.addAttribute("customRetailers", customRetailers);

			model.addAttribute("liveDemo", inventoryItem1);

			CustomRetailer fofoIdsAndRetailerName = retailerService.getFofoRetailer(fofoId);

			model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);

		}

		else {

			model.addAttribute("customRetailers", customRetailers);

			model.addAttribute("liveDemo", inventoryItem1);

		}

		return "live_demo_billing";

	}

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

	public String EnableliveDemoSerailNumber(HttpServletRequest request, @RequestParam String serial_number,

			Model model) throws Exception {

		LiveDemoSerialNumber liveDemoSerialNumber = new LiveDemoSerialNumber();

		liveDemoSerialNumber.setSerialNumber(serial_number);

		liveDemoBillingRespository.persist(liveDemoSerialNumber);

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

		return "response";

	}

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

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

		List<com.spice.profitmandi.dao.entity.transaction.Order> inProcessorder = orderRepository

				.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);

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

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

		if (!inProcessorder.isEmpty()) {

			for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessorder) {

				retailerIds.add(order.getRetailerId());

				orderIds.add(order.getId());

			}

			List<NotifyOrder> notify = notifyOrderRespository.selectByorderIds(orderIds);

			for (NotifyOrder notifyOrder : notify) {

				Order orderdetail = orderRepository.selectById(notifyOrder.getOrderId());

				if (!orderdetail.getStatus().equals(OrderStatus.SUBMITTED_FOR_PROCESSING)) {

					notifyOrder.setStatus(NotifyStatus.rejected);

				}

			}

			/*

			 * for (NotifyOrder notifyOrder : notify) { List<NotifyItem> notifyItems =

			 * notifyItemRepository.selectByNotifyId(notifyOrder.getNotifyId());

			 * Iterator<NotifyItem> notifyItemsIterator = notifyItems.iterator();

			 * 

			 * while (notifyItemsIterator.hasNext()) { NotifyItem notifyItem =

			 * notifyItemsIterator.next(); if

			 * (LocalDateTime.now().isAfter(notifyItem.getResponseTime())) {

			 * notifyItemsIterator.remove(); } } if (notifyItems.size() == 0) { if

			 * (NotifyStatus.pending == notifyOrder.getStatus()) {

			 * notifyOrder.setStatus(NotifyStatus.rejected); } }

			 * 

			 * }

			 */

			Map<Integer, Optional<NotifyOrder>> notifyOrders = notifyOrderRespository.selectByorderIds(orderIds)

					.stream().collect(Collectors.groupingBy(NotifyOrder::getOrderId,

							Collectors.maxBy((x1, x2) -> x1.getId() - x2.getId())));

			Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()

					.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

			List<com.spice.profitmandi.dao.entity.transaction.Order> pendingPaymentorder = orderRepository

					.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusDays(30), LocalDateTime.now(),

							OrderStatus.PAYMENT_PENDING);

			List<com.spice.profitmandi.dao.entity.transaction.Order> failedPaymentorder = orderRepository

					.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusDays(30), LocalDateTime.now(),

							OrderStatus.PAYMENT_FAILED);

			pendingPaymentorder.addAll(failedPaymentorder);

			model.addAttribute("inProcessorder", inProcessorder);

			model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

			model.addAttribute("pendingPaymentorder", pendingPaymentorder);

			model.addAttribute("latestNotifyOrders", notifyOrders);

		} else {

			model.addAttribute("inProcessorder", inProcessorder);

		}

		return "review_order";

	}

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

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

		List<com.spice.profitmandi.dao.entity.transaction.Order> keepatab = orderRepository

				.selectAllOrder(OrderStatus.KEEP_A_TAB);

		model.addAttribute("keepatab", keepatab);

		return "keep-a-tab";

	}

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

	public String closeOrder(HttpServletRequest request, @RequestParam int orderId, Model model) throws Exception {

		Order order = orderRepository.selectById(orderId);

		if (order != null) {

			order.setStatus(OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);

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

		} else {

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

		}

		return "response";

	}

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

	public String getcancelOrderItems(HttpServletRequest request, @RequestParam int itemId, Model model)

			throws Exception {

		List<Order> inProcessselectedOrder = orderRepository.selectByItemIdOrderStatus(itemId,

				OrderStatus.SUBMITTED_FOR_PROCESSING);

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

		for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessselectedOrder) {

			retailerIds.add(order.getRetailerId());

		}

		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()

				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

		model.addAttribute("inProcessCancelOrder", inProcessselectedOrder);

		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

		return "cancel-order-modal";

	}

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

	public String cancelOrder(HttpServletRequest request, @RequestBody OrderCancellationModel orderCancellationModel,

			Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LOGGER.info("orderId" + orderCancellationModel.getOrderIds());

		try {

			// List<Order> orders =

			// orderRepository.selectByOrderIds(orderCancellationModel.getOrderIds());

			List<Order> orders = orderRepository.selectByOrderIdsOrdersStatus(orderCancellationModel.getOrderIds(),

					OrderStatus.SUBMITTED_FOR_PROCESSING);

			if (!orders.isEmpty()) {

				for (Order order : orders) {

					orderRepository.refundOrder(order.getId(), loginDetails.getEmailId(),

							orderCancellationModel.getReason(), OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);

					List<NotifyOrder> notifyOrders = notifyOrderRespository.selectByOrder(order.getId());

					for (NotifyOrder notifyOrder : notifyOrders) {

						if (notifyOrder.getStatus() == NotifyStatus.pending) {

							notifyOrder.setStatus(NotifyStatus.rejected);

						}

					}

					sendCancellationNotificationToPartner(order, orderCancellationModel.getReason());

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

				}

			}

		} catch (TransactionServiceException | TException e) {

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

		}

		return "response";

	}

	private void sendCancellationNotificationToPartner(Order order, String reason) throws Exception {

		Item item = itemRepository.selectById(order.getLineItem().getItemId());

		SimpleCampaignParams scp = new SimpleCampaignParams();

		scp.setTitle(String.format("Order %s %d(Pcs) cancelled", item.getItemDescription(),

				order.getLineItem().getQuantity()));

		scp.setMessage(reason);

		scp.setType("url");

		scp.setUrl("/pages/home/orderDetails");

		scp.setExpireTimestamp(LocalDateTime.now().plusDays(2));

		SimpleCampaign sc = new SimpleCampaign(scp);

		sc.setSimpleCampaignParams(scp);

		NotificationCampaign nc = new NotificationCampaign();

		nc.setName("Order Cancellation");

		nc.setImplementationType("SimpleCampaign");

		nc.setImplementationParams(gson.toJson(scp));

		nc.setMessageType(MessageType.notification);

		nc.setCreatedTimestamp(LocalDateTime.now());

		notificationCampaignRepository.persist(nc);

		int userId = userAccountRepository.selectUserIdByRetailerId(order.getRetailerId());

		UserCampaign uc = new UserCampaign();

		uc.setCampaignId(nc.getId());

		uc.setUserId(userId);

		uc.setPushTimestamp(LocalDateTime.now());

		userCampaignRepository.persist(uc);

		List<Device> devices = deviceRepository.selectByUserIdAndModifiedTimestamp(userId,

				LocalDateTime.now().minusMonths(3), LocalDateTime.now());

		pushNotification(nc.getId(), devices);

	}

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

	public String getNotifyItemColor(HttpServletRequest request, @RequestParam int catalogItemId,

			@RequestParam int itemId, Model model) throws ProfitMandiBusinessException {

		List<Item> availableColorItems = itemRepository.selectAllByCatalogItemId(catalogItemId);

		Iterator<Item> itemsIterator = availableColorItems.iterator();

		while (itemsIterator.hasNext()) {

			Item item = itemsIterator.next();

			TagListing itemTagListing = tagListingRepository.selectByItemId(item.getId());

			if (itemTagListing == null) {

				itemsIterator.remove();

			}

			else if (!itemTagListing.isActive()) {

				itemsIterator.remove();

			}

		}

		List<Order> inProcessselectedOrder = orderRepository.selectByItemIdOrderStatus(itemId,

				OrderStatus.SUBMITTED_FOR_PROCESSING);

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

		for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessselectedOrder) {

			retailerIds.add(order.getRetailerId());

		}

		Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream()

				.collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

		LOGGER.info("item" + availableColorItems);

		model.addAttribute("item", availableColorItems);

		model.addAttribute("inProcessselectedOrder", inProcessselectedOrder);

		model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

		return "notify-order-modal";

	}

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

	public String NotifyOrder(HttpServletRequest request, @RequestBody NotifyOrderModel notifyOrderModel, Model model)

			throws Exception {

		com.spice.profitmandi.dao.entity.transaction.NotifyItem notifyItem = null;

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

		NotifyColorChange notifytimestamp = new NotifyColorChange();

		notifytimestamp.setCreated(LocalDateTime.now());

		notifyColorChangeRepository.persist(notifytimestamp);

		NotifyMessage notifyMessage = new NotifyMessage();

		notifyMessage.setNotifyId(notifytimestamp.getId());

		notifyMessage.setNotifyMessages(notifyOrderModel.getMessage());

		notifyMessageRepository.persist(notifyMessage);

		for (NotifyItemIdModel itemid : notifyOrderModel.getItemIds()) {

			notifyItem = new com.spice.profitmandi.dao.entity.transaction.NotifyItem();

			notifyItem.setItemId(itemid.getItemId());

			notifyItem.setResponseTime(itemid.getResponseTime());

			notifyItem.setProcuredDate(itemid.getProcuredTime());

			notifyItem.setNotifyColorchangeId(notifytimestamp.getId());

			notifyItemRepository.persist(notifyItem);

			LOGGER.info("notifyItem" + notifyItem);

		}

		for (NotifyOrderIdModel st : notifyOrderModel.getOrderIds()) {

			List<NotifyOrder> existingOrder = notifyOrderRespository.selectByOrder(st.getOrderId());

			if (!existingOrder.isEmpty()) {

				LOGGER.info("existingOrder" + existingOrder);

				for (NotifyOrder notifyOrder : existingOrder) {

					if (NotifyStatus.pending == notifyOrder.getStatus()) {

						notifyOrder.setStatus(NotifyStatus.rejected);

					}

				}

			}

			NotifyOrder orderStatus = new NotifyOrder();

			orderStatus.setOrderId(st.getOrderId());

			orderStatus.setNotifyId(notifytimestamp.getId());

			orderStatus.setItemId(st.getOlditemId());

			Order id = orderRepository.selectById(st.getOrderId());

			orderStatus.setFofoId(id.getRetailerId());

			orderStatus.setStatus(NotifyStatus.pending);

			notifyOrderRespository.persist(orderStatus);

			LOGGER.info("itemStatus" + orderStatus);

			orderIds.add(st.getOrderId());

		}

		LOGGER.info("orderIds" + orderIds);

		List<Order> orders = orderRepository.selectByOrderIds(orderIds);

		for (Order order : orders) {

			LOGGER.info("order" + order.getId());

			NotifyMessage message = notifyMessageRepository.selectByNotifyId(notifytimestamp.getId());

			SimpleCampaignParams scp = new SimpleCampaignParams();

			scp.setMessage(message.getNotifyMessages());

			scp.setTitle("Alert");

			scp.setType("url");

			scp.setUrl("/pages/home/notifyOrder");

			scp.setExpireTimestamp(LocalDateTime.now().plusDays(2));

			SimpleCampaign sc = new SimpleCampaign(scp);

			sc.setSimpleCampaignParams(scp);

			NotificationCampaign nc = new NotificationCampaign();

			nc.setName("Notify Partner");

			nc.setImplementationType("SimpleCampaign");

			nc.setImplementationParams(gson.toJson(scp));

			nc.setCreatedTimestamp(LocalDateTime.now());

			nc.setMessageType(MessageType.notification);

			notificationCampaignRepository.persist(nc);

			int userId = userAccountRepository.selectUserIdByRetailerId(order.getRetailerId());

			UserCampaign uc = new UserCampaign();

			uc.setCampaignId(nc.getId());

			uc.setUserId(userId);

			uc.setPushTimestamp(LocalDateTime.now());

			userCampaignRepository.persist(uc);

			List<Device> devices = deviceRepository.selectByUserIdAndModifiedTimestamp(userId,

					LocalDateTime.now().minusMonths(3), LocalDateTime.now());

			pushNotification(nc.getId(), devices);

		}

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

		return "response";

	}

	public void pushNotification(int cid, List<Device> devices) {

		for (Device device : devices) {

			PushNotifications pn = new PushNotifications();

			pn.setNotificationCampaignid(cid);

			pn.setDeviceId(device.getId());

			pn.setUserId(device.getUser_id());

			pushNotificationRepository.persist(pn);

		}

	}

	private void sendMailOfHtmlFomat(String email, String messageText, String subject)

			throws MessagingException, ProfitMandiBusinessException, IOException {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message);

		helper.setSubject(subject);

		helper.setText(messageText, true);

		helper.setTo(email);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	/*

	 * private String getMessage(List<NotifyOrderModel> notifyOrderModels, Order

	 * order) throws ProfitMandiBusinessException {

	 * 

	 * StringBuilder sb = new StringBuilder(); sb.

	 * append("<html><body><p>Notify Partner</p><p>Which have order out stock following model:-</p>"

	 * + "<div>" + order.getLineItem().getItem().getItemDescription() +

	 * "</div> <div>choose the model from following:- </div><br/><table style='border:1px solid black ;padding: 5px';>"

	 * ); sb.append("<tbody>\n" + "	    				<tr>\n" +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Color</th>\n"

	 * +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Procured Time</th>\n"

	 * +

	 * "	    					<th style='border:1px solid black;padding: 5px'>Response Time</th>\n"

	 * + "	    				</tr>"); for (NotifyOrderModel notifyOrderModel :

	 * notifyOrderModels) { Item item =

	 * itemRepository.selectById(notifyOrderModel.getItemId()); sb.append("<tr>");

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * item.getColor() + "</td>");

	 * 

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * notifyOrderModel.getFormattedProcuredTime() + "</td>");

	 * 

	 * sb.append("<td style='border:1px solid black;padding: 5px'>" +

	 * notifyOrderModel.getFormattedResponseTime() + "</td>");

	 * 

	 * sb.append("</tr>"); }

	 * 

	 * sb.append("</tbody></table></body></html>"); return sb.toString(); }

	 */

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

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

		List<NotifyOrder> notifyOrders = null;

		List<com.spice.profitmandi.dao.entity.transaction.Order> inProcessorder = orderRepository

				.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);

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

		if (!inProcessorder.isEmpty()) {

			for (com.spice.profitmandi.dao.entity.transaction.Order order : inProcessorder) {

				orderIds.add(order.getId());

			}