Subversion Repositories SmartDukaan

Rev

Rev 31650 | Rev 31903 | Go to most recent revision | View as "text/plain" | Blame | Compare with Previous | Last modification | View Log | RSS feed

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
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.services.ReporticoService;
import com.spice.profitmandi.common.util.FileUtil;
import com.spice.profitmandi.common.util.FormattingUtils;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.catalog.TagListing;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.PartnerType;
import com.spice.profitmandi.dao.entity.inventory.ItemPricingHistory;
import com.spice.profitmandi.dao.entity.inventory.VendorItemPricing;
import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
import com.spice.profitmandi.dao.entity.transaction.PriceDropIMEI;
import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.Mongo;
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;
import com.spice.profitmandi.dao.repository.inventory.ItemPricingHistoryRepository;
import com.spice.profitmandi.dao.repository.inventory.VendorItemPricingRepository;
import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropIMEIRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
import com.spice.profitmandi.service.NotificationService;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.pricecircular.PriceCircularItemModel;
import com.spice.profitmandi.service.pricecircular.PriceCircularModel;
import com.spice.profitmandi.service.pricecircular.PriceCircularService;
import com.spice.profitmandi.service.pricing.PriceDropService;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.service.transaction.TransactionService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.wallet.WalletService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
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.Serializable;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class PriceDropController {

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

        @Autowired
        private CsService csService;

        @Autowired
        private UserRepository dtrUserRepository;

        @Autowired
        private PriceDropRepository priceDropRepository;

        @Autowired
        private ObjectMapper objectMapper;

        @Autowired
        private VendorItemPricingRepository vendorItemPricingRepository;

        @Autowired
        @Qualifier("fofoInventoryService")
        private InventoryService inventoryService;

        @Autowired
        private MVCResponseSender mvcResponseSender;

        @Autowired
        private PriceDropService priceDropService;

        @Autowired
        private ItemPricingHistoryRepository itemPricingHistoryRepository;

        @Autowired
        private WalletService walletService;

        @Autowired
        private TagListingRepository tagListingRepository;

        @Autowired
        private TransactionService transactionService;

        @Autowired
        private PriceDropIMEIRepository priceDropIMEIRepository;

        @Autowired
        private RoleManager roleManager;

        @Autowired
        @Qualifier("catalogItemRepository")
        private ItemRepository itemRepository;

        @Autowired
        private SchemeService schemeService;

        @Autowired
        ReporticoService reporticoService;

        @Autowired
        LineItemImeisRepository lineItemImeisRepository;

        @Autowired
        private Mongo mongoClient;

        @Autowired
        private CookiesProcessor cookiesProcessor;

        @Autowired
        private PartnerTypeChangeService partnerTypeChangeService;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private NotificationService notificationService;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        private static final List<String> SELLINS = Arrays.asList("Base Payout", "Cash Discount", "Upfront Margin", "Modelwise");
        private static final List<String> SELLOUTS = Arrays.asList("Tertiary Payout", "Hygiene Payout", "Investment Payout", "Category Payout", "Activation Margin", "Special Support");
        private static final List<String> ALL_MARGINS = Arrays.asList(SELLINS, SELLOUTS).stream().flatMap(x -> x.stream()).collect(Collectors.toList());

        @RequestMapping(value = "/getItemDescription", method = RequestMethod.GET)
        public String getItemDescription(HttpServletRequest request, Model model) throws Throwable {
                List<PriceDrop> priceDrops = priceDropRepository.selectAllIncomplete();
                Set<Integer> catalogIds = priceDrops.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.getItemDescriptionNoColor(), (description1, description2) -> description1));
                model.addAttribute("priceDrops", priceDrops);
                model.addAttribute("catalogDescription", catalogDescription);
                return "price-drop";
        }

        @RequestMapping(value = "/getClosedPricedropItemDescription", method = RequestMethod.GET)
        public String getClosedPricedropItemDescription(HttpServletRequest request, Model model) throws Throwable {
                List<PriceDrop> priceDrops = priceDropRepository.selectAllComplete();
                int processOn = 1;

                List<PriceDrop> completePriceDrops = priceDrops.stream().filter(x -> x.getCompleteTimestamp() != null)
                                .collect(Collectors.toList());

                Set<Integer> catalogIds = completePriceDrops.stream().map(x -> x.getCatalogItemId())
                                .collect(Collectors.toSet());
                List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);
                LOGGER.info("catalogIds" + catalogIds);

                Map<Integer, String> catalogDescription = items.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(),
                                x -> x.getItemDescriptionNoColor(), (description1, description2) -> description1));
                model.addAttribute("priceDrops", completePriceDrops);
                model.addAttribute("processOn", processOn);
                model.addAttribute("catalogDescription", catalogDescription);
                return "price-drop";
        }

        @RequestMapping(value = "/item-pricing/{itemId}", method = RequestMethod.GET)
        public String getItemPricing(HttpServletRequest request, Model model, @PathVariable int itemId) throws Throwable {

                TagListing tagListing;
                PriceDropModel pm = new PriceDropModel();
                try {
                        tagListing = tagListingRepository.selectByItemId(itemId);
                        if (tagListing != null) {
                                pm.setMop(tagListing.getMop());
                                pm.setDp(tagListing.getSellingPrice());
                                pm.setMrp(tagListing.getMrp());
                                List<VendorItemPricing> vips = vendorItemPricingRepository.selectAll(itemId);
                                if (vips.size() > 0) {
                                        VendorItemPricing vip = vips.get(0);
                                        pm.setNlc(vip.getNlc());
                                        pm.setTp(vip.getTp());
                                } else {
                                        throw new ProfitMandiBusinessException("Item Id", itemId, "Vendor item pricing does not exist");
                                }
                        }
                } catch (Exception e) {
                        LOGGER.info("Chose item that doesn't exist");
                }
                model.addAttribute("response1", mvcResponseSender.createResponseString(pm));
                return "response";
        }

        @RequestMapping(value = "/item", method = RequestMethod.GET)
        public String getItemPricing(HttpServletRequest request, Model model, @RequestParam String query,
                                                                 @RequestParam boolean anyColor) throws Throwable {
                String query1 = query.toLowerCase();

                List<ItemDescriptionModel> partnersItemDescription = inventoryService
                                .getAllPartnerItemStringDescription(anyColor).parallelStream()
                                .filter(x -> x.getItemDescription().toLowerCase().matches(".*?" + query1 + ".*?"))
                                .collect(Collectors.toList());
                LOGGER.info("partnersItemDescription" + partnersItemDescription);

                model.addAttribute("response1", mvcResponseSender.createResponseString(partnersItemDescription));
                return "response";
        }

        @RequestMapping(value = "/price-drop/imes/download")
        public ResponseEntity<ByteArrayResource> downloadPriceDropImeis(HttpServletRequest request,
                                                                                                                                        @RequestParam LocalDateTime affectedDate, @RequestParam int itemId) throws Exception {
                Item item = itemRepository.selectById(itemId);
                ByteArrayOutputStream baos = getByteArrayOutputStream(affectedDate, item.getCatalogItemId(), null);
                final HttpHeaders headers = new HttpHeaders();
                headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                headers.set("Content-disposition", "inline; filename=\"imei-" + item.getItemDescriptionNoColor() + ".csv\"");
                byte[] byteArray = baos.toByteArray();
                headers.setContentLength(byteArray.length);
                return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(byteArray), headers, HttpStatus.OK);
        }

        @RequestMapping(value = "/price-drop/addPayout", method = RequestMethod.POST)
        public String updatePriceDrop(HttpServletRequest request, @RequestBody PriceDropProcessModel priceDropProcessModel,
                                                                  Model model) throws Exception {
                boolean response = false;
                PriceDrop priceDrop = priceDropRepository.selectById(priceDropProcessModel.getPriceDropId());
                if (priceDrop.getProcessTimestamp() == null) {
                        priceDrop.setPartnerPayout(priceDropProcessModel.getPartnerPayout());
                        priceDrop.setPriceDropIn(priceDropProcessModel.getPriceDropIn());
                        // priceDrop.setProcessTimestamp(LocalDateTime.now());
                        priceDropRepository.persist(priceDrop);
                        response = true;
                }
                model.addAttribute("response1", mvcResponseSender.createResponseString(response));
                return "response";
        }

        @RequestMapping(value = "/priceDropImeis/{priceDropId}", method = RequestMethod.GET)
        public String priceDropStatus(HttpServletRequest request, @PathVariable int priceDropId, Model model)
                        throws Exception {

                PriceDropImeisModel priceDropImeisModel = new PriceDropImeisModel();

                // This call is used to persit imeis to pricedrop imeis in case its not there.
                // This should be called while creating price drop.
                // priceDropService.priceDropStatus(priceDropId);

                List<String> pendingImeis = new ArrayList<>();
                List<String> approvedImeis = new ArrayList<>();
                List<String> rejectedImeis = new ArrayList<>();
                List<String> holdImeis = new ArrayList<>();
                List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository.selectByPriceDropId(priceDropId);
                for (PriceDropIMEI priceDropIMEI : priceDropImeis) {
                        if (priceDropIMEI.getStatus().equals(PriceDropImeiStatus.PENDING)) {
                                pendingImeis.add(priceDropIMEI.getImei());
                        } else if (priceDropIMEI.getStatus().equals(PriceDropImeiStatus.APPROVED)) {
                                approvedImeis.add(priceDropIMEI.getImei());
                        }
                        if (priceDropIMEI.getStatus().equals(PriceDropImeiStatus.REJECTED)) {
                                rejectedImeis.add(priceDropIMEI.getImei());
                        } else if (priceDropIMEI.getStatus().equals(PriceDropImeiStatus.HOLD)) {
                                holdImeis.add(priceDropIMEI.getImei());

                        }
                }
                LOGGER.info("pendingImeis" + pendingImeis);
                LOGGER.info("approvedImeis" + approvedImeis);
                LOGGER.info("rejectedImeis" + rejectedImeis);
                LOGGER.info("priceDropImeis" + priceDropImeis);

                priceDropImeisModel.setPendingImeis(pendingImeis);
                priceDropImeisModel.setPriceDropId(priceDropId);
                priceDropImeisModel.setApprovedImeis(approvedImeis);
                priceDropImeisModel.setHoldImeis(holdImeis);
                priceDropImeisModel.setRejectedImeis(rejectedImeis);
                model.addAttribute("response1", mvcResponseSender.createResponseString(priceDropImeisModel));
                return "response";
        }

        @RequestMapping(value = "/processPriceDrop", method = RequestMethod.POST)
        public String processPriceDrop(HttpServletRequest request, @RequestBody PriceDropProcessModel priceDropProcessModel,
                                                                   Model model) throws Exception {
                PriceDrop priceDrop = priceDropRepository.selectById(priceDropProcessModel.getPriceDropId());
                boolean response = false;
                if (priceDrop.getPartnerPayout() == 0) {
                        priceDrop.setPartnerPayout(priceDropProcessModel.getPartnerPayout());
                }
                priceDrop.setProcessTimestamp(LocalDateTime.now());
                priceDropRepository.persist(priceDrop);
                priceDropService.processPriceDrop(priceDrop.getId(), priceDropProcessModel.isActivatedOnly());
                response = true;
                model.addAttribute("response1", mvcResponseSender.createResponseString(response));
                return "response";
        }

        @RequestMapping(value = "/priceDrop", method = RequestMethod.POST)
        public String addPriceDrop(HttpServletRequest request, Model model, @RequestBody PriceDropModel priceDropModel)
                        throws Exception {
                boolean response = false;
                priceDropModel.setAllColors(true);
                if (this.validatePriceDrop(priceDropModel)) {
                        TagListing tagListing = tagListingRepository.selectByItemId(priceDropModel.getItemId());
                        float oldDp = tagListing.getSellingPrice();
                        float oldMop = tagListing.getMop();
                        float oldTp = 0;
                        float newDp = priceDropModel.getDp();

                        if (newDp != oldDp) {
                                List<Item> allItems = null;
                                Item currentItem = itemRepository.selectById(priceDropModel.getItemId());
                                if (priceDropModel.isAllColors()) {
                                        allItems = itemRepository.selectAllByCatalogItemId(currentItem.getCatalogItemId());

                                } else {
                                        allItems = Arrays.asList(currentItem);
                                }
                                for (Item item : allItems) {
                                        TagListing itemTagListing = tagListingRepository.selectByItemId(item.getId());
                                        if (itemTagListing == null)
                                                continue;
                                        itemTagListing.setSellingPrice(newDp);
                                        itemTagListing.setMop(priceDropModel.getMop());
                                        List<VendorItemPricing> vipList = vendorItemPricingRepository.selectAll(item.getId());
                                        for (VendorItemPricing vip : vipList) {
                                                oldTp = vip.getNlc();
                                                vip.setDp(newDp);
                                                vip.setMop(priceDropModel.getMop());
                                                //Lets not update NLC/TP as it has to be managed by Category Tea,
                                                //vip.setNlc(priceDropModel.getTp());
                                                //vip.setTp(priceDropModel.getTp());
                                                vendorItemPricingRepository.persist(vip);
                                        }
                                        transactionService.updatePriceDrop(item.getId(), newDp);
                                }

                                // Add to itemPricing history
                                ItemPricingHistory iph = new ItemPricingHistory();
                                iph.setCatalogId(currentItem.getCatalogItemId());
                                iph.setTp(priceDropModel.getTp());
                                iph.setDp(priceDropModel.getDp());
                                iph.setMop(priceDropModel.getMop());
                                // TODO: changedBy
                                iph.setChangedBy("me");
                                iph.setCreateTimestamp(LocalDateTime.now());
                                itemPricingHistoryRepository.persist(iph);

                                PriceDrop priceDrop = new PriceDrop();
                                priceDrop.setAffectedOn(priceDropModel.getAffectedDate());
                                priceDrop.setTp(oldTp);
                                priceDrop.setNlc(oldTp);
                                priceDrop.setMop(oldMop);
                                priceDrop.setOldDp(oldDp);
                                priceDrop.setAmount(oldDp - newDp);
                                priceDrop.setNewDp(newDp);
                                priceDrop.setCreatedOn(LocalDateTime.now());
                                priceDrop.setCatalogItemId(currentItem.getCatalogItemId());
                                priceDropRepository.persist(priceDrop);
                                priceDropService.priceDropStatus(priceDrop.getId());
                                response = true;

                                this.sendPriceChangeNotification(priceDrop);
                        } else {
                                throw new ProfitMandiBusinessException("Price Drop", priceDropModel.getPd(),
                                                "Price Drop Should be greater than 0");
                        }
                }
                model.addAttribute("response1", mvcResponseSender.createResponseString(response));
                return "response";
        }

        private void sendPriceChangeNotification(PriceDrop priceDrop) throws ProfitMandiBusinessException {
                List<Item> items = itemRepository.selectAllByCatalogItemId(priceDrop.getCatalogItemId());
                String title = "Price has been %s for %s";


                SendNotificationModel sendNotificationModel = new SendNotificationModel();
                sendNotificationModel.setCampaignName("pricechange");
                sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
                sendNotificationModel.setTitle("");
                StringBuffer sb = new StringBuffer();
                String message = null;
                if (priceDrop.getDropAmount() > 0) {
                        title = String.format(title, "dropped", items.get(0).getItemDescriptionNoColor());
                        message = String.format("Price has been dropped from Rs.%s. Old DP - Rs.%s, New DP - Rs.%s", FormattingUtils.formatDecimal(priceDrop.getDropAmount()),
                                        FormattingUtils.formatDecimal(priceDrop.getOldDp()), FormattingUtils.formatDecimal(priceDrop.getNewDp()));
                } else {
                        title = String.format(title, "increased", items.get(0).getItemDescriptionNoColor());
                        message = String.format("Price has been increased from Rs.%s. Old DP - Rs.%s, New DP - Rs.%s", FormattingUtils.formatDecimal(-priceDrop.getDropAmount()),
                                        FormattingUtils.formatDecimal(priceDrop.getOldDp()), FormattingUtils.formatDecimal(priceDrop.getNewDp()));
                }
                sendNotificationModel.setTitle(title);
                sendNotificationModel.setMessage(message);
                sendNotificationModel.setMessageType(MessageType.pricechange);
                notificationService.sendNotificationToAll(sendNotificationModel);
        }

        @RequestMapping(value = "/downloadtotalPriceDropIMEI/{priceDropId}", method = RequestMethod.GET)
        public ResponseEntity<?> downloadTotalPriceDropIMEI(HttpServletRequest request, @PathVariable int priceDropId,
                                                                                                                Model model) throws ProfitMandiBusinessException, Exception {

                PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
                Map<String, PriceDropIMEI> priceDropIMEIsMap = priceDropIMEIRepository.selectByPriceDropId(priceDropId).stream()
                                .collect(Collectors.toMap(x -> x.getImei(), x -> x));
                LOGGER.info("PriceDropImeis {}, priceDropId {}", priceDropIMEIsMap, priceDropId);
                Item item = itemRepository.selectAllByCatalogItemId(priceDrop.getCatalogItemId()).get(0);
                final HttpHeaders headers = new HttpHeaders();
                headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                headers.set("Content-disposition",
                                "inline; filename=pricedrop-" + item.getItemDescriptionNoColor().replaceAll("\\s?,\\s?", " ") + "-"
                                                + FormattingUtils.formatDate(priceDrop.getAffectedOn()) + ".csv");
                ByteArrayOutputStream baos = null;
                if (priceDropIMEIsMap.size() == 0) {
                        priceDropService.priceDropStatus(priceDrop.getId());
                        baos = FileUtil.getCSVByteStream(Arrays.asList("IMEI Number", "Store Name", "Store Code", "Item ID", "Brand",
                                        "Model Name", "Model Number", "Color", "Status", "Rejection Reason", "Last Scanned", "Vendor Name",
                                        "Grn On", "Activation Timestamp", "Activation Added On"), new ArrayList<>());
                } else {

                        LOGGER.info("In else block");
                        baos = getByteArrayOutputStream(priceDrop.getAffectedOn(), priceDrop.getCatalogItemId(),
                                        priceDropIMEIsMap);
                }
                byte[] byteArray = baos.toByteArray();
                headers.setContentLength(byteArray.length);
                return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(byteArray), headers, HttpStatus.OK);

        }

        @RequestMapping(value = "/updatePriceDropImeis", method = RequestMethod.POST)
        public String updatePriceDropImeis(HttpServletRequest request, @RequestBody PriceDropImeisModel priceDropImeisModel,
                                                                           Model model) throws ProfitMandiBusinessException, Exception {
                PriceDropImeiStatus status = PriceDropImeiStatus.PENDING;

                switch (priceDropImeisModel.getUpdatedStatus()) {
                        case "approved": {
                                status = PriceDropImeiStatus.APPROVED;
                                break;
                        }
                        case "hold": {
                                status = PriceDropImeiStatus.HOLD;
                                break;
                        }
                        case "rejected": {
                                status = PriceDropImeiStatus.REJECTED;
                                break;
                        }
                }
                PriceDropImeiStatus finalStatus = status;

                if (PriceDropImeiStatus.PENDING.equals(status)) {

                        List<PriceDropIMEI> priceDropIMEIsToHolds = new ArrayList<>();
                        List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository.selectByIdAndStatus(PriceDropImeiStatus.HOLD,
                                        priceDropImeisModel.getPriceDropId());
                        LOGGER.info("hello" + priceDropIMEIs);
                        for (PriceDropIMEI priceDropHoldIMEI : priceDropIMEIs) {
                                if (priceDropHoldIMEI.getStatus().equals(PriceDropImeiStatus.HOLD)) {
                                        if (!priceDropImeisModel.getUpdatedImeis().contains(priceDropHoldIMEI.getImei())
                                                        || priceDropHoldIMEI.getStatus().equals(status)) {
                                                continue;
                                        }
                                        priceDropIMEIsToHolds.add(priceDropHoldIMEI);
                                        priceDropHoldIMEI.setStatus(PriceDropImeiStatus.PENDING);
                                        //priceDropHoldIMEI.setUpdateTimestamp(LocalDateTime.now());
                                } else {
                                        throw new ProfitMandiBusinessException("INVALID STATUS", "PENDING",
                                                        "Pending Status is allowed  only for Hold IMIEs");
                                }
                        }
                        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
                        return "response";
                }

                // TODO:PD
                List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository
                                .selectByPriceDropId(priceDropImeisModel.getPriceDropId());

                List<PriceDropIMEI> priceDropIMEIsToProcess = priceDropIMEIs.stream()
                                .filter(x -> priceDropImeisModel.getUpdatedImeis().contains(x.getImei()))
                                .filter(x -> !x.getStatus().equals(finalStatus)).collect(Collectors.toList());

        /*for (PriceDropIMEI priceDropIMEI : priceDropIMEIsToProcess) {
                        priceDropIMEI.setUpdateTimestamp(LocalDateTime.now());
                }*/

                if (status.equals(PriceDropImeiStatus.APPROVED)) {
                        priceDropService.processPriceDrop(priceDropImeisModel.getPriceDropId(),
                                        priceDropImeisModel.getUpdatedImeis());
                }
                for (PriceDropIMEI priceDropImei : priceDropIMEIsToProcess) {
                        if (status.equals(PriceDropImeiStatus.REJECTED)
                                        && priceDropImei.getStatus().equals(PriceDropImeiStatus.PENDING)) {
                                priceDropImei.setStatus(PriceDropImeiStatus.REJECTED);
                                priceDropImei.setRejectionReason(priceDropImeisModel.getRejectionReason());
                                priceDropImei.setRejectTimestamp(LocalDateTime.now());
                        } else if (status.equals(PriceDropImeiStatus.HOLD)) {
                                if (priceDropImei.getStatus().equals(PriceDropImeiStatus.PENDING)) {
                                        priceDropImei.setStatus(PriceDropImeiStatus.HOLD);
                                } else {
                                        throw new ProfitMandiBusinessException("INVALID STATUS", status, "only  allowed For PENDING IMEIs");
                                }

                        }

                }

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

        }

        private ByteArrayOutputStream getByteArrayOutputStream(LocalDateTime affectedOn, Integer catalogItemId,
                                                                                                                   Map<String, PriceDropIMEI> priceDropImeis) throws Exception {
                List<ImeiDropSummaryModel> imeiDropSummaryModelList = priceDropService
                                .getAllSerialNumbersByAffectedDate(affectedOn, catalogItemId);
                List<List<?>> rows = new ArrayList<>();
                for (ImeiDropSummaryModel imeiDropSummaryModel : imeiDropSummaryModelList) {
                        if (priceDropImeis == null) {
                                rows.add(this.getRow(imeiDropSummaryModel, null));
                        } else if (priceDropImeis.get(imeiDropSummaryModel.getSerialNumber()) != null) {
                                rows.add(this.getRow(imeiDropSummaryModel, priceDropImeis.get(imeiDropSummaryModel.getSerialNumber())));
                        }
                }
                return FileUtil.getCSVByteStream(Arrays.asList("IMEI Number", "Store Name", "Store Code", "Item ID", "Brand",
                                "Model Name", "Model Number", "Color", "Status", "Rejection Reason", "Last Scanned", "Vendor Name",
                                "Grn On", "Activation Timestamp", "Activation Added On"), rows);
        }

        private List<? extends Serializable> getRow(ImeiDropSummaryModel imeiDropSummaryModel,
                                                                                                PriceDropIMEI priceDropIMEI) {
                List<Serializable> row = new ArrayList<>();
                row.add(imeiDropSummaryModel.getSerialNumber());
                row.add(imeiDropSummaryModel.getStoreName());
                row.add(imeiDropSummaryModel.getPartnerCode());
                row.add(imeiDropSummaryModel.getItemId());
                row.add(imeiDropSummaryModel.getBrand());
                row.add(imeiDropSummaryModel.getModelName());
                row.add(imeiDropSummaryModel.getModelNumber());
                row.add(imeiDropSummaryModel.getColor());
                if (priceDropIMEI != null) {
                        row.add(priceDropIMEI.getStatus());
                        row.add(priceDropIMEI.getRejectionReason());
                } else {
                        row.add(PriceDropImeiStatus.PENDING);
                        row.add("");
                }
                row.add(FormattingUtils.formatReporitcoDate(imeiDropSummaryModel.getLastScanned()));
                row.add(imeiDropSummaryModel.getVendorName());
                row.add(FormattingUtils.formatReporitcoDate(imeiDropSummaryModel.getGrnOn()));
                row.add(imeiDropSummaryModel.getActivationTimestamp());
                row.add(imeiDropSummaryModel.getActivationAddedOn());
                return row;
        }

        private boolean validatePriceDrop(PriceDropModel priceDropModel) throws ProfitMandiBusinessException {
                if (priceDropModel.getMop() > 0 && priceDropModel.getDp() > 0 && priceDropModel.getTp() > 0) {
                        return true;
                }
                return false;
        }

        @RequestMapping(value = "/priceCircular")
        public String priceCircular(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                int fofoId = Utils.SYSTEM_PARTNER_ID;
                Set<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
                                .collect(Collectors.toSet());
                brands.addAll(mongoClient.getMongoBrands(fofoId, null, 6).stream().map(x -> (String) x.get("name"))
                                .collect(Collectors.toSet()));

                model.addAttribute("brands", brands);
                model.addAttribute("isAdmin", true);
                model.addAttribute("date", FormattingUtils.format(LocalDateTime.now()));

                return "partner-price-circular";
        }

        @RequestMapping(value = "/partnerPriceCircular")
        public String partnerPriceCircular(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                int fofoId = Utils.SYSTEM_PARTNER_ID;
                Set<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
                                .collect(Collectors.toSet());
                brands.addAll(mongoClient.getMongoBrands(fofoId, null, 6).stream().map(x -> (String) x.get("name"))
                                .collect(Collectors.toSet()));
                model.addAttribute("brands", brands);
                model.addAttribute("isAdmin", false);

                return "partner-price-circular";
        }

        @Autowired
        PriceCircularService priceCircularService;

        @RequestMapping(value = "/priceCircularByBrand")
        public String priceCircularByBrand(HttpServletRequest request, @RequestParam String brand, Model model, @RequestParam(defaultValue = "0", required = false) int fofoId)
                        throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                if (fofoId > 0 && roleManager.isAdmin(loginDetails.getRoleIds())) {
                } else {
                        fofoId = loginDetails.getFofoId();
                }
                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, LocalDate.now());
                List<PartnerType> partnerTypes = new ArrayList<>();
                partnerTypes.add(partnerType);
                partnerTypes.add(PartnerType.ALL);
                PriceCircularModel priceCircular = priceCircularService.getPriceCircularByOffer(fofoId, brand);
                PriceCircularItemModel summaryModel = this.getSummaryModel(priceCircular);
                List<String> allMargins = ALL_MARGINS.stream().filter(payoutType -> summaryModel.getByPayoutType(payoutType) > 0).collect(Collectors.toList());
                List<String> sellins = SELLINS.stream().filter(x -> allMargins.contains(x)).collect(Collectors.toList());
                List<String> sellouts = SELLOUTS.stream().filter(x -> allMargins.contains(x)).collect(Collectors.toList());
                LOGGER.info("All margins - {}", allMargins);
                LOGGER.info("Sellins - {}", sellins);
                LOGGER.info("Sellouts - {}", sellouts);
                FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);
                model.addAttribute("priceCircular", priceCircular.getPriceCircularItemModels());
                model.addAttribute("allMargins", allMargins);
                model.addAttribute("sellins", sellins);
                model.addAttribute("sellouts", sellouts);
                model.addAttribute("offers", priceCircular.getOffers());
                model.addAttribute("upgradeOffer", priceCircular.isUpgradeOffer());
                model.addAttribute("partnerCode", fs.getCode());
                return "price-circular-detail";
        }

        //private static final List<String> SELLINS = Arrays.asList("Base Payout", "Cash Discount", "Upfront Margin");
        //private static final List<String> SELLOUTS = Arrays.asList("Tertiary Payout", "Hygiene Payout", "Investment Payout", "Category Payout", "Activation Margin", "Special Support");
        private PriceCircularItemModel getSummaryModel(PriceCircularModel priceCircular) {

                PriceCircularItemModel summaryModel = new PriceCircularItemModel();
                priceCircular.getPriceCircularItemModels().stream().forEach(x -> {
                        if (summaryModel.getBasePayout() == 0 && x.getBasePayout() > 0) {
                                summaryModel.setBasePayout(1);
                        }
                        if (summaryModel.getCashDiscount() == 0 && x.getCashDiscount() > 0) {
                                summaryModel.setCashDiscount(1);
                        }
                        if (summaryModel.getSpecialSupport() == 0 && x.getSpecialSupport() > 0) {
                                summaryModel.setSpecialSupport(1);
                        }
                        if (summaryModel.getCategoryPayout() == 0 && x.getCategoryPayout() > 0) {
                                summaryModel.setCategoryPayout(1);
                        }
                        if (summaryModel.getTertiaryPayout() == 0 && x.getTertiaryPayout() > 0) {
                                summaryModel.setTertiaryPayout(1);
                        }
                        if (summaryModel.getModelSpecfic() == 0 && x.getModelSpecfic() > 0) {
                                summaryModel.setModelSpecfic(1);
                        }
                        if (summaryModel.getUpfrontMargin() == 0 && x.getUpfrontMargin() > 0) {
                                summaryModel.setUpfrontMargin(1);
                        }
                        if (summaryModel.getHygienePayout() == 0 && x.getHygienePayout() > 0) {
                                summaryModel.setHygienePayout(1);
                        }
                        if (summaryModel.getInvestmentPayout() == 0 && x.getInvestmentPayout() > 0) {
                                summaryModel.setInvestmentPayout(1);
                        }
                        if (summaryModel.getModelWise() == 0 && x.getModelWise() > 0) {
                                summaryModel.setModelWise(1);
                        }
                });

                LOGGER.info("Summary Model {}", summaryModel);

                return summaryModel;
        }


        @RequestMapping(value = "/downloadNlcByBrand")
        public ResponseEntity<ByteArrayResource> downloadNlcByBrand(HttpServletRequest request,
                                                                                                                                @RequestParam String brand, Model model, @RequestParam(defaultValue = "0", required = false) int fofoId) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                if (fofoId > 0 && roleManager.isAdmin(loginDetails.getRoleIds())) {
                } else {
                        fofoId = loginDetails.getFofoId();
                }
                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, LocalDate.now());
                List<PartnerType> partnerTypes = new ArrayList<>();
                partnerTypes.add(partnerType);
                partnerTypes.add(PartnerType.ALL);
                PriceCircularModel priceCircular = priceCircularService.getPriceCircularByOffer(fofoId, brand);
                ByteArrayOutputStream baos = getNlcBaos(brand, priceCircular);
                final HttpHeaders headers = new HttpHeaders();
                headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                headers.set("Content-disposition", "inline; filename=\"" + brand + ".csv\"");
                byte[] byteArray = baos.toByteArray();
                headers.setContentLength(byteArray.length);
                return new ResponseEntity<>(new ByteArrayResource(byteArray), headers, HttpStatus.OK);
        }

        private ByteArrayOutputStream getNlcBaos(String brand, PriceCircularModel priceCircular) throws Exception {
                List<List<?>> rows = new ArrayList<>();
                for (PriceCircularItemModel priceCircularItemModel : priceCircular.getPriceCircularItemModels()) {
                        List<Serializable> row = new ArrayList<>();
                        row.add(priceCircularItemModel.getCatalogId());
                        row.add(brand);
                        row.add(priceCircularItemModel.getModelName());
                        row.add(priceCircularItemModel.getModelNumber());
                        row.add(priceCircularItemModel.getNetPrice());
                        rows.add(row);
                }
                return FileUtil.getCSVByteStream(Arrays.asList("Model Id", "Brand", "Model Name", "Model Number", "Partner Landing"), rows);
        }

        @RequestMapping(value = "/selectPriceDropStatus", method = RequestMethod.GET)
        public String selectPriceDropStatus(HttpServletRequest request,
                                                                                @RequestParam(name = "selectedStatus", required = true, defaultValue = "") String selectedStatus,
                                                                                Model model) throws Exception {

                model.addAttribute("selectedStatus", selectedStatus);
                return "pricedrop-status-change";
        }

}