Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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;

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.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.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.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 in.shop2020.model.v1.order.TransactionServiceException;

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.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.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 {

    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

    @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 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 mailSender;

    @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

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

        }

        Utils.sendMailWithAttachments(mailSender, new String[]{"kuldeep.kumar@smartdukaan.com"}, null, "Invoices List", "PFA", 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 = 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";

    }

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

            }

        }));

        inventoryService.addActivatedImeis(imeisActivationMap);

        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;

    @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("response1", mvcResponseSender.createResponseString(true));

                }

                sdCreditService.settleBlockedLoan(orders.get(0).getTransactionId());

            }

        } catch (TransactionServiceException | TException 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());

        String title = "Order Cancellation";

        String message = String.format("Order %s %d(Pcs) has been cancelled", item.getItemDescription(), order.getLineItem().getQuantity());

        com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(order.getRetailerId());

        Address address = addressRepository.selectById(user.getAddressId());

        SendNotificationModel sendNotificationModel = new SendNotificationModel();

        sendNotificationModel.setCampaignName(title);

        sendNotificationModel.setTitle(message);

        sendNotificationModel.setType("url");

        sendNotificationModel.setMessage(reason);

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

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

        sendNotificationModel.setMessageType(MessageType.notification);

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

        sendNotificationModel.setUserIds(Arrays.asList(userId));

        notificationService.sendNotification(sendNotificationModel);

        // notificationService.sendWhatsappMessage(message, title,

        // address.getPhoneNumber());

    }

    @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.equals(notifyOrder.getStatus())) {

                        notifyOrder.setStatus(NotifyStatus.rejected);

                        notifyOrder.setUpdateTimestamp(LocalDateTime.now());

                    }

                }

            }

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

            String title = "Alert!";

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

            com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectById(order.getRetailerId());

            Address address = addressRepository.selectById(user.getAddressId());

            SendNotificationModel sendNotificationModel = new SendNotificationModel();

            sendNotificationModel.setCampaignName("Notify Partner");

            sendNotificationModel.setMessage(message.getNotifyMessages());

            sendNotificationModel.setType("url");