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

                        }
                        notifyOrders = notifyOrderRespository.selectByorderIds(orderIds);
                        Set<Integer> oldItemIds = new HashSet<>();
                        List<Integer> fofoIds = new ArrayList<>();
                        List<Integer> notifyIds = new ArrayList<>();
                        if (!notifyOrders.isEmpty()) {
                                for (NotifyOrder notifyOrder : notifyOrders) {
                                        oldItemIds.add(notifyOrder.getItemId());
                                        fofoIds.add(notifyOrder.getFofoId());
                                        notifyIds.add(notifyOrder.getNotifyId());
                                }

                                List<NotifyColorChange> notifyColorChanges = notifyColorChangeRepository.selectByNotifyId(notifyIds);
                                Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = this
                                                .notifyOrdersToNotifyId(notifyColorChanges);
                                Map<Integer, CustomRetailer> fofoIdsAndRetailerName = retailerService.getFofoRetailers(fofoIds);
                                Map<Integer, String> itemdescription = inventoryService.getItemIdDescriptionMap(oldItemIds);

                                model.addAttribute("notifyOrders", notifyOrders);
                                model.addAttribute("notifyIdNotifyColorMap", notifyIdNotifyColorMap);
                                model.addAttribute("itemdescription", itemdescription);
                                model.addAttribute("fofoIdsAndRetailerName", fofoIdsAndRetailerName);

                        } else {
                                model.addAttribute("notifyOrders", notifyOrders);
                        }
                } else {
                        model.addAttribute("notifyOrders", notifyOrders);
                }
                return "notify_order";
        }

        private Map<Integer, NotifyColorChange> notifyOrdersToNotifyId(List<NotifyColorChange> notifyColorChanges) {
                Map<Integer, NotifyColorChange> notifyIdNotifyColorMap = new HashMap<>();
                for (NotifyColorChange notifyColorChange : notifyColorChanges) {
                        notifyIdNotifyColorMap.put(notifyColorChange.getId(), notifyColorChange);
                }
                return notifyIdNotifyColorMap;
        }

}