Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.service.warehouse.BillingWarehouseService;

import com.fasterxml.jackson.databind.ObjectMapper;

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.*;

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

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

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

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

import com.spice.profitmandi.dao.entity.cs.Position;

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

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.*;

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

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

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.inventory.CatalogMovingEnum;

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

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

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

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.warehouse.WarehousePurchaseOrderRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.catalog.ComboService;

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

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

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

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

import com.spice.profitmandi.service.mail.MailOutboxService;

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.service.transaction.SDCreditService;

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 org.apache.commons.csv.CSVFormat;

import org.apache.commons.csv.CSVParser;

import org.apache.commons.csv.CSVRecord;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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.ByteArrayResource;

import org.springframework.core.io.ClassPathResource;

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.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.*;

import java.net.URISyntaxException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.time.temporal.ChronoUnit;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.Stream;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class InventoryController {

    @Autowired

    private BillingWarehouseService billingWarehouseService;

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

    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("M/d/yyyy H:m:s");

    private static final List<String> imeis = Arrays.asList("351030944216680", "351030944217183", "351030944217886", "351030944507286", "351081710231270", "351081710238713", "351081710238796", "351081710241279", "351081710244737", "355777112655976");

    List<EscalationType> esclationType = Arrays.asList(EscalationType.L3, EscalationType.L4);

    List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com");

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private BrandsRepository brandsRepository;

    @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

    BrandsService brandsService;

    @Autowired

    private Gson gson;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    FofoStoreRepository fofoStoreRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private NotifyItemRepository notifyItemRepository;

    @Autowired

    private NotifyColorChangeRepository notifyColorChangeRepository;

    @Autowired

    private NotifyOrderRespository notifyOrderRespository;

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private NotifyMessageRepository notifyMessageRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private OrderService orderService;

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

    private String host;

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

    private int port;

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

    private String webapp;

    @Autowired

    JavaMailSender gmailRelaySender;

    @Autowired

    MailOutboxService mailOutboxService;

    @Autowired

    private NotifyCancelOrderRepository notifyCancelOrderRepository;

    @Autowired

    private WarehousePurchaseOrderRepository warehousePurchaseOrderRepository;

    @Autowired

    private WarehouseScanRepository warehouseScanRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private FocusedModelByPassRepository focusedModelByPassRepository;

    @Autowired

    private CsService csService;

    @Autowired

    AuthRepository authRepository;

    @Autowired

    private CategorisedCatalogRepository categorisedCatalogRepository;

    @Autowired

    PositionRepository positionRepository;

    @Autowired

    ActivatedImeiRepository activatedImeiRepository;

    @Autowired

    HighDemandItemsRepository highDemandItemsRepository;

    @Autowired

    WebOfferRepository webOfferRepository;

    @Autowired

    ComboModelRepository comboModelRepository;

    @Autowired

    ComboMappedModelRepository comboMappedModelRepository;

    @Autowired

    private ComboOptionRepository comboOptionRepository;

    @Autowired

    private UserRepository userUserRepository;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private CustomerOfferRepository customerOfferRepository;

    @Autowired

    private CatalogRepository catalogRepository;

    @Autowired

    private CustomerOfferItemRepository customerOfferItemRepository;

    @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 = "20") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, @RequestParam(name = "itemId", required = false, defaultValue = "0") int itemId, @RequestParam(name = "accesories", required = false, defaultValue = "0") boolean accesories,

         @RequestParam(name = "brand", required = false, defaultValue = "") String brand, Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (searchTerm == null) {

            searchTerm = "";

        }

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

        model.addAllAttributes(map);

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

        return "catalog";

    }

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

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

        List<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toList());

        model.addAttribute("brands", brands);

        return "categoriesed-catalog";

    }

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

    public String getCatalogMovementByBrand(HttpServletRequest request, Model model, @RequestParam String brand) throws Exception {

        List<CategorisedCatalogListModel> categorisedCatalogListModels = categorisedCatalogRepository.getBrandWiseCatalogMovement(brand);

        List<Catalog> catalogs = new ArrayList<>();

        List<Catalog> mobileCatalogs = catalogRepository.selectAllByBrand(brand, ProfitMandiConstants.MOBILE_CATEGORY_ID);

        List<Catalog> tabletCatalogs = catalogRepository.selectAllByBrand(brand, ProfitMandiConstants.TABLET_CATEGORY_ID);

        catalogs.addAll(mobileCatalogs);

        catalogs.addAll(tabletCatalogs);

        List<CatalogMovingEnum> catalogMovingEnumList = Arrays.asList(CatalogMovingEnum.values());

        model.addAttribute("categorisedCatalogListModels", categorisedCatalogListModels);

        model.addAttribute("catalogs", catalogs);

        model.addAttribute("catalogMovingEnumList", catalogMovingEnumList);

        model.addAttribute("brand", brand);

        return "categoriesed-catalog-list";

    }

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

    public String createUpdateCatalogMovement(HttpServletRequest request, Model model, @RequestParam int catalogId, @RequestParam CatalogMovingEnum status, @RequestParam LocalDate startDate, @RequestParam String brand) throws Exception {

        CategorisedCatalog currentCategorisedCatalog = categorisedCatalogRepository.getCurrentCatalogMovement(catalogId);

        LOGGER.info("currentCategorisedCatalogg - {}", currentCategorisedCatalog);

        if (currentCategorisedCatalog != null) {

            if (currentCategorisedCatalog.getStartDate().isEqual(startDate) && (startDate.isEqual(LocalDate.now()) || startDate.isAfter(LocalDate.now()))) {

                currentCategorisedCatalog.setStatus(status);

            } else if (startDate.isBefore(currentCategorisedCatalog.getStartDate()) || startDate.isEqual(currentCategorisedCatalog.getStartDate())) {

                throw new Exception("Start date cannot be less than or equal to the current catalog's start date(" + currentCategorisedCatalog.getStartDate() + ").");

            }

//            else if (currentCategorisedCatalog.getStatus().equals(status)) {

//                currentCategorisedCatalog.setStartDate(startDate);

//            }

            else {

                currentCategorisedCatalog.setEndDate(startDate.minusDays(1));

                CategorisedCatalog categorisedCatalog = new CategorisedCatalog();

                categorisedCatalog.setCatalogId(catalogId);

                categorisedCatalog.setStatus(status);

                categorisedCatalog.setStartDate(startDate);

                categorisedCatalogRepository.persist(categorisedCatalog);

            }

        } else {

            CategorisedCatalog categorisedCatalog = new CategorisedCatalog();

            categorisedCatalog.setCatalogId(catalogId);

            categorisedCatalog.setStatus(status);

            categorisedCatalog.setStartDate(startDate);

            categorisedCatalogRepository.persist(categorisedCatalog);

        }

        model.addAttribute("response1", true);

        return "response";

    }

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

    public String getCatalogMovementHistory(HttpServletRequest request, Model model, @RequestParam int catalogId) throws Exception {

        List<CategorisedCatalogListModel> categorisedCatalogListModelList = categorisedCatalogRepository.getCatalogMovement(catalogId);

        model.addAttribute("categorisedCatalogListModelList", categorisedCatalogListModelList);

        return "catalog-movement-history";

    }

    @RequestMapping(value = "/getWebOfferByCatalogId")

    public String getCatalog(HttpServletRequest request, @RequestParam int catalogItemId, Model model)

            throws ProfitMandiBusinessException {

        List<WebOffer> webOffers = webOfferRepository.selectAllActiveOffers().get(catalogItemId);

        LocalDateTime todayDateTime = LocalDateTime.now();

        LocalDate todayDate = LocalDate.now();

        List<CustomerOffer> customerOffers = customerOfferRepository.selectOffersByDate(todayDateTime);

        List<Integer> customerOfferIds = customerOffers.stream().map(CustomerOffer::getId).collect(Collectors.toList());

        // Retrieve customer offer items

        List<CustomerOfferItem> customerOfferItems = customerOfferItemRepository.selectByOfferIds(customerOfferIds, catalogItemId, todayDate);

        // Filter customer offer items with endDate greater than today

        List<CustomerOfferItem> filteredCustomerOfferItems = customerOfferItems.stream()

                .filter(x -> x.getEndDate() != null && !x.getEndDate().isBefore(todayDate))

                .collect(Collectors.toList());

        model.addAttribute("webOffers", webOffers);

        model.addAttribute("customerOfferItems", filteredCustomerOfferItems);

        return "web-offer-model";

    }

    // 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 = "20") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, @RequestParam(name = "itemId", required = false, defaultValue = "0") int itemId, @RequestParam(name = "accesories", required = false, defaultValue = "0") boolean accesories, @RequestParam(name = "brand", required = false, defaultValue = "") String brand, Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (searchTerm == null) {

            searchTerm = "";

        }

        Map<String, Object> map = inventoryService.getPaginatedCatalog(loginDetails.getFofoId(), offset, limit, searchTerm, itemId, brand, accesories);

        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<InvoicePdfModel> pdfModels = new ArrayList<>();

        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 = "/activatedImeis")

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByActivatedNotSold(loginDetails.getFofoId());

        inventoryItems.stream().forEach(x -> {

            try {

                x.setItem(itemRepository.selectById(x.getItemId()));

            } catch (Exception e) {

                e.printStackTrace();

            }

        });

        model.addAttribute("inventoryItems", inventoryItems);

        return "activated-imeis";

    }

    @RequestMapping(value = "/agedAppleImeis")

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime beforeDate = LocalDate.now().atStartOfDay()

                .minusDays(ProfitMandiConstants.AGED_STOCK_APPLE_DAYS);

        List<InventoryItem> inventoryItems =

                inventoryItemRepository.selectAgedAppleStock(loginDetails.getFofoId(), beforeDate);

        inventoryItems.stream().forEach(x -> {

            try {

                x.setItem(itemRepository.selectById(x.getItemId()));

            } catch (Exception e) {

                e.printStackTrace();

            }

        });

        model.addAttribute("inventoryItems", inventoryItems);

        model.addAttribute("agedDays", ProfitMandiConstants.AGED_STOCK_APPLE_DAYS);

        return "aged-apple-imeis";

    }

    @RequestMapping(value = "/activated-imeis-grn-pending")

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        List<Order> openOrders = orderRepository.selectGrnTimestampNull(loginDetails.getFofoId(), Arrays.asList(OrderStatus.DELIVERY_SUCCESS));

        List<ImeiActivationTimestampModel> imeiActivationTimestampModels = activatedImeiRepository.selectActivatedImeisByOrders(openOrders.stream().map(x -> x.getId()).collect(Collectors.toList()));

        Map<Integer, Order> ordersMap = openOrders.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        model.addAttribute("ordersMap", ordersMap);

        model.addAttribute("imeiActivationTimestampModels", imeiActivationTimestampModels);

        return "activated-imeis-grn-pending";

    }

    @RequestMapping(value = "/view-invoices")

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

        return "view-dummy-invoices";

    }

    @RequestMapping(value = "/dummy-invoices")

    public ResponseEntity<?> downloadInvoices(HttpServletRequest request, @RequestParam String serialNumber, Model model) throws ProfitMandiBusinessException {

        byte[] bytes = null;

        if (!imeis.contains(serialNumber)) {

            InvoicePdfModel pdfModel = orderService.getDummyPdfModel(serialNumber);

            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

            PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);

            bytes = byteArrayOutputStream.toByteArray();

        } else {

            ClassPathResource resource = new ClassPathResource("/META-INF/" + serialNumber + ".pdf");

            try {

                bytes = FileUtils.readFileToByteArray(resource.getFile());

            } catch (Exception e) {

            }

        }

        final HttpHeaders headers = new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

        headers.set("Content-disposition", "inline; filename=invoice-" + serialNumber + ".pdf");

        headers.setContentLength(bytes.length);

        final InputStream inputStream = new ByteArrayInputStream(bytes);

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

    }

    @RequestMapping(value = "/dummy-invoices-bulk")

    public ResponseEntity<?> downloadInvoicesBulk(HttpServletRequest request, @RequestParam List<String> serialNumbers, Model model) throws Exception {

        byte[] bytes = null;

        List<Attachment> attachments = new ArrayList<>();

        for (String serialNumber : serialNumbers) {

            if (!imeis.contains(serialNumber)) {

                InvoicePdfModel pdfModel = null;

                try {

                    pdfModel = orderService.getDummyPdfModel(serialNumber);

                } catch (Exception e) {

                    continue;

                }

                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

                PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);

                bytes = byteArrayOutputStream.toByteArray();

            } else {

                ClassPathResource resource = new ClassPathResource("/META-INF/" + serialNumber + ".pdf");

                try {

                    bytes = FileUtils.readFileToByteArray(resource.getFile());

                } catch (Exception e) {

                    continue;

                }

            }

            attachments.add(new Attachment("invoice-" + serialNumber + ".pdf", new ByteArrayResource(bytes)));

        }

        mailOutboxService.queueMailWithAttachments(new String[]{"kuldeep.kumar@smartdukaan.com"}, null, "Invoices List", "PFA", "InventoryController.downloadInvoicesBulk", attachments.toArray(new Attachment[attachments.size()]));

        return new ResponseEntity<Boolean>(true, HttpStatus.OK);

    }

    @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 = "1000") 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);

    }

    @RequestMapping(value = "/aging-report", method = RequestMethod.GET)

    public ResponseEntity<?> downloadInventoryItemAgingByInterval(HttpServletRequest request) throws ProfitMandiBusinessException {

        List<Integer> intervals = Arrays.asList(5, 15, 30, 45);

        List<InventoryItemAgingModel> inventoryItemAgingModels = inventoryService.getItemAgingByInterval(intervals).values().stream().flatMap(Collection::stream).collect(Collectors.toList());

        LOGGER.info("Fofo Id {}", inventoryItemAgingModels.get(0).getFofoId());

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

    }

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

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

        List<TagRanking> 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> catalogDescriptionMap = items.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x.getItemDescription(), (description1, description2) -> description1));

            LOGGER.info("catalogDescription" + catalogDescriptionMap);

            model.addAttribute("catalogDescriptionsMap", catalogDescriptionMap);

        }

        model.addAttribute("tagRanking", tagRanking);

        return "feature";

    }

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

    public String uploadContent(HttpServletRequest request, @RequestPart("file") MultipartFile file, Model model) throws Exception {

        /*

         * if(brand==null) { throw new

         * ProfitMandiBusinessException("Please select brand", "Brand empty",

         * "Brand required"); }

         */

        List<CSVRecord> masterDataList = readFile(file);

        Map<String, LocalDateTime> imeisActivationMap = masterDataList.stream().collect(Collectors.toMap(x -> x.get(0).trim(), x -> {

            if (!StringUtils.isEmpty(x.get(1).trim())) {

                return LocalDateTime.parse((String) (x.get(1).trim()), formatter);

            } else {

                return null;

            }

        }));

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();

        AuthUser authUser = authRepository.selectByEmailOrMobile(email);

        inventoryService.addActivatedImeis(imeisActivationMap, authUser.getId());

        model.addAttribute("response1", true);

        return "response";

    }

    private List<CSVRecord> readFile(MultipartFile file) throws Exception {

        List<CSVRecord> records = null;

        try (CSVParser parser = new CSVParser(new InputStreamReader(file.getInputStream()), CSVFormat.DEFAULT)) {

            records = parser.getRecords();

            if (records.size() < 2) {

                throw new ProfitMandiBusinessException("Uploaded File", "", "No records Found");

            }

            records.remove(0);

        } catch (Exception e) {

            throw new ProfitMandiBusinessException("Parsing Failed", "parse failed", "file parse failed");

        }

        return records;

    }

    @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("response1", 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("response1", 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> customRetailerMap = retailerService.getAllFofoRetailers();

        Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

        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("response1", 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> inProcessOrders = orderRepository.selectAllOrder(Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.LOW_INV_PO_RAISED));

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

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

        if (!inProcessOrders.isEmpty()) {

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

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

                }

            }

            Map<Integer, Optional<NotifyOrder>> notifyOrders = notifyOrderRespository.selectByorderIds(orderIds).stream().collect(Collectors.groupingBy(NotifyOrder::getOrderId, Collectors.maxBy((x1, x2) -> x1.getId() - x2.getId())));

            Map<Integer, NotifyCancel> notifyCancelOrders = notifyCancelOrderRepository.selectByOrderIds(orderIds).stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));

            Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream().collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

            model.addAttribute("inProcessorder", inProcessOrders);

            model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

            model.addAttribute("latestNotifyOrders", notifyOrders);

            model.addAttribute("notifyCancelOrders", notifyCancelOrders);

        } else {

            model.addAttribute("inProcessorder", inProcessOrders);

        }

        return "review_order";

    }

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

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

        List<com.spice.profitmandi.dao.entity.transaction.Order> pendingPaymentorder = orderRepository.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusMonths(3), LocalDateTime.now(), OrderStatus.PAYMENT_PENDING);

        List<com.spice.profitmandi.dao.entity.transaction.Order> failedPaymentorder = orderRepository.selectAllOrderDatesBetweenByStatus(LocalDateTime.now().minusMonths(3), LocalDateTime.now(), OrderStatus.PAYMENT_FAILED);

        pendingPaymentorder.addAll(failedPaymentorder);

        model.addAttribute("pendingPaymentorder", pendingPaymentorder);

        return "payment-pending-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(Arrays.asList(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("response1", mvcResponseSender.createResponseString(true));

        } else {

            model.addAttribute("response1", 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> inProcessSelectedOrders = orderRepository.selectByItemIdOrderStatus(itemId, OrderStatus.SUBMITTED_FOR_PROCESSING);

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

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

            retailerIds.add(order.getRetailerId());

        }

        Map<Integer, String> storeIdAndFofoIdMap = fofoStoreRepository.selectByRetailerIds(retailerIds).stream().collect(Collectors.toMap(FofoStore::getId, FofoStore::getCode));

        model.addAttribute("inProcessCancelOrders", inProcessSelectedOrders);

        model.addAttribute("storeIdAndFofoIdMap", storeIdAndFofoIdMap);

        return "cancel-order-modal";

    }

    @Autowired

    SDCreditService sdCreditService;

    @Autowired

    ComboService comboService;

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

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

                              @RequestParam(required = false, defaultValue = "false") boolean confirmed,

                              Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        try {

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

            if (!orders.isEmpty()) {

                ComboCancellationResult comboCheck = comboService.checkOrderCancellationForCombo(orders);

                if (comboCheck.isConfirmationRequired() && !confirmed) {

                    model.addAttribute("response1", mvcResponseSender.createResponseString(comboCheck));

                    return "response";

                }

                List<Integer> allOrderIds = comboCheck.getAllOrderIdsToCancel(orderCancellationModel.getOrderIds());

                List<Order> allOrders = allOrderIds.size() > orderCancellationModel.getOrderIds().size()

                        ? orderRepository.selectByOrderIdsOrdersStatus(allOrderIds, OrderStatus.SUBMITTED_FOR_PROCESSING)

                        : orders;

                for (Order order : allOrders) {

                    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().equals(NotifyStatus.pending)) {

                            notifyOrder.setStatus(NotifyStatus.rejected);

                        }

                    }

                    sendCancellationNotificationToPartner(order, orderCancellationModel.getReason());

                    sdCreditService.settleBlockedLoan(order.getTransactionId(), order.getWalletAmount());

                }

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

            }

        } catch (Exception e) {

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

        }

        return "response";

    }

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

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