Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.fofo.ScanType;

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

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

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

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

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

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

import com.spice.profitmandi.service.transaction.invoicing.InvoiceService;

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

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

import org.apache.commons.io.IOUtils;

import org.apache.http.entity.ContentType;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

import javax.servlet.http.HttpServletRequest;

import java.io.*;

import java.time.LocalTime;

import java.time.YearMonth;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class PurchaseController {

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

    @Autowired

    RestClient restClient;

    @Autowired

    private PurchaseService purchaseService;

    @Autowired

    private PurchaseRepository purchaseRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private ResponseSender responseSender;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private InvoiceService invoiceService;

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

    public String purchase(HttpServletRequest request) throws Exception {

        return "purchase";

    }

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

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

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LOGGER.info("Request Received at url {}", request.getRequestURI());

        List<Order> pendingGrns = orderRepository.selectShipmentToDeliveredByRetailerId(fofoDetails.getFofoId());

        model.addAttribute("pendingGrns", pendingGrns);

        return "pending-grn";

    }

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

    public ResponseEntity<?> validatePurchaseImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        return responseSender.ok(this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel));

    }

    private Map<String, Boolean> getImeiValidationMap(int fofoId, ImeiInoviceModel imeiInoviceModel) throws ProfitMandiBusinessException {

        LOGGER.info("serialNumbers - {}", imeiInoviceModel.getSerialNumbers());

        Set<String> serialNumbers = new HashSet<>(orderRepository.selectSerialNumbers(imeiInoviceModel.getInvoiceNumber(), fofoId, imeiInoviceModel.getSerialNumbers()));

        Map<String, Boolean> imeiValidationMap = new HashMap<>();

        imeiInoviceModel.getSerialNumbers().stream().forEach(x -> {

            imeiValidationMap.put(x, true);

        });

        if (serialNumbers.size() > 0) {

            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, new HashSet<>(serialNumbers), false);

            //Should consider sold out imeis from previous purchases as grned as well and considered invalidated.

            Set<String> grnedSerialNumberSet = inventoryItems.stream().filter(x->(x.getGoodQuantity() + x.getBadQuantity())==1 || x.getLastScanType().equals(ScanType.SALE)).map(x->x.getSerialNumber()).collect(Collectors.toSet());

            imeiInoviceModel.getSerialNumbers().stream().forEach(imei -> {

                if (grnedSerialNumberSet.contains(imei)) {

                    imeiValidationMap.put(imei, false);

                }

            });

        }

        return imeiValidationMap;

    }

    @RequestMapping(value = "/purchase/grn-imeis", method = RequestMethod.POST)

    public ResponseEntity<?> grnImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        Map<String, Boolean> imeiValidationMap = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel);

        if (imeiValidationMap.values().stream().filter(x -> !x).findFirst().isPresent()) {

            throw new ProfitMandiBusinessException("Found invalid imeis cant proceed", "invalid imeis", "invalid imeis");

        }

        Map<Integer, List<String>> itemSerialNumberMap = orderRepository.selectItemSerialNumberMap(imeiInoviceModel.getInvoiceNumber(), fofoDetails.getFofoId(), imeiInoviceModel.getSerialNumbers());

        for (Map.Entry<Integer, List<String>> itemSerialNumberEntry : itemSerialNumberMap.entrySet()) {

            ScanSerializedRequest scanSerializedRequest = new ScanSerializedRequest();

            scanSerializedRequest.setSerialNumbers(itemSerialNumberEntry.getValue());

            scanSerializedRequest.setInvoiceNumber(imeiInoviceModel.getInvoiceNumber());

            scanSerializedRequest.setItemId(itemSerialNumberEntry.getKey());

            purchaseService.scanSerializedItems(scanSerializedRequest, fofoDetails.getFofoId());

        }

        return responseSender.ok(true);

    }

    @RequestMapping(value = "/purchase/get-imeis", method = RequestMethod.GET)

    public ResponseEntity<?> getImeis(HttpServletRequest request, @RequestParam String invoiceNumber, @RequestParam int itemId) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<String> serialNumbers = orderRepository.selectSerialNumbersByInvoiceItem(invoiceNumber, itemId, fofoDetails.getFofoId());

        ImeiInoviceModel imeiInoviceModel = new ImeiInoviceModel();

        imeiInoviceModel.setInvoiceNumber(invoiceNumber);

        imeiInoviceModel.setSerialNumbers(serialNumbers);

        List<String> validSerialNumbers = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel).entrySet().stream().filter(x -> x.getValue()).map(x -> x.getKey()).collect(Collectors.toList());

        return responseSender.ok(validSerialNumbers);

    }

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

    public String pendingGrnDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LOGGER.info("Request Received at url [{}] with orderId [{}]", request.getRequestURI(), orderId);

        model.addAttribute("pendingGrnDetails", purchaseService.getShippingDetailByOrderId(orderId, fofoDetails.getFofoId()));

        return "pending-grn-details";

    }

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

    public String purchaseByAirwayBillOrInvoiceNumber(HttpServletRequest request,

                                                      @RequestParam(name = ProfitMandiConstants.AIRWAY_BILL_OR_INVOICE_NUMBER)

                                                      String airwayBillOrInvoiceNumber, Model model) throws ProfitMandiBusinessException {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        LOGGER.info("Request Received at url {} with airwayBillOrInvoiceNumber {}", request.getRequestURI(), airwayBillOrInvoiceNumber);

        Map<String, Object> map = purchaseService.purchaseByInvoiceNumber(airwayBillOrInvoiceNumber, fofoDetails.getFofoId());

        model.addAllAttributes(map);

        return "purchase";

    }

    @RequestMapping(value = "/purchase-invoice/{invoiceNumber}", method = RequestMethod.GET)

    public ResponseEntity<?> downloadInvoice(HttpServletRequest request, @PathVariable String invoiceNumber, Model model) throws Exception {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        List<String> invoiceNumbers = null;

        try {

            YearMonth ym = YearMonth.parse(invoiceNumber);

            if (!roleManager.isAdmin(fofoDetails.getRoleIds())) {

                List<Order> orders = orderRepository.selectAllByBillingDatesBetween(fofoDetails.getFofoId(), ym.atDay(1).atStartOfDay(),

                        ym.atEndOfMonth().atTime(LocalTime.MAX));

                invoiceNumbers = orders.stream().map(x -> x.getInvoiceNumber()).filter(Utils.distinctByKey(Function.identity())).collect(Collectors.toList());

            }

        } catch (Exception e) {

            invoiceNumbers = Arrays.asList(invoiceNumber.replaceAll(" ", "").split(","));

        }

        LOGGER.info("Invoice Number - {}", invoiceNumber);

        Map<String, List<Order>> invoiceOrdersMap = orderRepository.selectByInvoiceNumbers(invoiceNumbers).stream().collect(Collectors.groupingBy(x -> x.getInvoiceNumber()));

        if (invoiceOrdersMap.size() > 0) {

            if (roleManager.isAdmin(fofoDetails.getRoleIds()) || invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0).getRetailerId() == fofoDetails.getFofoId()) {

                if (invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0).getRetailerId() == fofoDetails.getFofoId()) {

                    invoiceOrdersMap = invoiceOrdersMap.entrySet().stream().filter(x -> x.getValue().get(0).getRetailerId() == fofoDetails.getFofoId()).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));

                }

                final HttpHeaders headers = new HttpHeaders();

                if (invoiceNumbers.size() == 1) {

                    Order order = invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0);

                    File invoiceFile = invoiceService.getInvoiceFile(order);

                    headers.setContentType(MediaType.APPLICATION_PDF);

                    headers.set("Content-Type", "application/pdf");

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

                    InputStreamResource is = new InputStreamResource(new FileInputStream(invoiceFile));

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

                } else {

                    ByteArrayOutputStream fos = new ByteArrayOutputStream();

                    ZipOutputStream zipOut = new ZipOutputStream(fos);

                    for (String singleInvoiceNumber : invoiceNumbers) {

                        LOGGER.info("Single Invoice Number  - {}", singleInvoiceNumber);

                        Order order = invoiceOrdersMap.get(singleInvoiceNumber).get(0);

                        File invoiceFile = invoiceService.getInvoiceFile(order);

                        this.addFileToZip(zipOut, new FileInputStream(invoiceFile), singleInvoiceNumber + ".pdf");

                    }

                    zipOut.close();

                    byte[] byteArray = fos.toByteArray();

                    headers.set("Content-Type", ContentType.APPLICATION_OCTET_STREAM.getMimeType());

                    headers.set("Content-disposition", "attachment; filename=invoices.zip");

                    headers.setContentLength(byteArray.length);

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

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

                }

            }

        } else {

            throw new ProfitMandiBusinessException("Invalid Invoice", invoiceNumber, "Please check with your manager");

        }

        return null;

    }

    private void addFileToZip(ZipOutputStream outZip, InputStream inputStream, String fileName) throws Exception {

        ZipEntry entry = new ZipEntry(fileName);

        outZip.putNextEntry(entry);

        IOUtils.copy(inputStream, outZip);

        outZip.closeEntry();

    }

}