Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.spice.profitmandi.common.enumuration.OfferType;

import com.spice.profitmandi.common.enumuration.ReporticoProject;

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.offers.OfferService;

import com.spice.profitmandi.service.offers.PartnerCriteria;

import com.spice.profitmandi.service.pricecircular.PriceCircularModel;

import com.spice.profitmandi.service.pricecircular.PriceCircularService;

import com.spice.profitmandi.service.scheme.SchemeService;

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

import org.apache.commons.csv.CSVRecord;

import org.apache.commons.lang.StringUtils;

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

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 org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.time.*;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class SchemeController {

    // LED TV

    private static final List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.MOBILE_CATEGORY_ID,

            ProfitMandiConstants.TABLET_CATEGORY_ID, 14202);

    private static List<SchemeType> EXCLUDE_EXTEND_SCHEMES = Arrays.asList(SchemeType.SELLOUT, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLIN);

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

    @Autowired

    WalletService walletService;

    @Autowired

    PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    InventoryItemRepository inventoryItemRepository;

    @Autowired

    PriceDropIMEIRepository priceDropIMEIRepository;

    @Autowired

    PriceDropRepository priceDropRepository;

    @Autowired

    SchemeInOutRepository schemeInOutRepository;

    List<String> adminEmail = Arrays.asList("tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com", "amit.gupta@smartdukaan.com", "vikas.jangra@smartdukaan.com", "deena.nath@smartdukaan.com");

    @Autowired

    SchemeRegionRepository schemeRegionRepository;

    @Autowired

    RegionRepository regionRepository;

    @Autowired

    TransactionRepository transactionRepository;

    @Autowired

    private SchemeService schemeService;

    @Autowired

    private OfferService offerService;

    @Autowired

    private StateGstRateRepository stateGstRateRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private ReporticoService reporticoService;

    @Autowired

    private SchemeRepository schemeRepository;

    @Autowired

    private SchemeItemRepository schemeItemRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    @Qualifier("fofoInventoryService")

    private InventoryService inventoryService;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private OfferPayoutRepository offerPayoutRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private PartnerTypeChangeService partnerTypeChangeService;

    @Autowired

    private CustomerOfferRepository customerOfferRepository;

    @Autowired

    private CustomerOfferItemRepository customerOfferItemRepository;

    @Autowired

    private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private CategoryRepository categoryRepository;

    @Autowired

    PriceCircularService priceCircularService;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private PurchaseRepository purchaseRepository;

    @Autowired

    private Gson gson;

    private boolean getAccess(String emailId) {

        boolean fullAccesss = false;

        List<String> emails = csService

                .getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY, EscalationType.L3).stream()

                .map(x -> x.getEmailId()).collect(Collectors.toList());

        emails.addAll(

                csService.getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY, EscalationType.L2)

                        .stream().map(x -> x.getEmailId()).collect(Collectors.toList()));

        if (adminEmail.contains(emailId)) {

            fullAccesss = true;

        }

        if (emails.contains(emailId)) {

            fullAccesss = false;

        }

        return fullAccesss;

    }

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

    public String getTagListingItemsByBrand(HttpServletRequest request, @RequestParam int categoryId, Model model)

            throws Exception {

        Set<String> brands = inventoryService.getAllTagListingBrands(categoryId);

        model.addAttribute("brands", brands);

        model.addAttribute("categoryId", categoryId);

        return "tag-listing-brands";

    }

    @RequestMapping(value = "/schemes/update-schemes-page", method = RequestMethod.GET)

    public String updateShcemes(HttpServletRequest request) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

            throw new ProfitMandiBusinessException("User", loginDetails.getEmailId(), "Unauthorised access");

        }

        return "update-schemes-page";

    }

    @RequestMapping(value = "/schemes/process-sellout", method = RequestMethod.POST)

    public String processSellout(HttpServletRequest request, Model model, @RequestBody List<String> invoiceNumbers) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

            throw new ProfitMandiBusinessException("User", loginDetails.getEmailId(), "Unauthorised access");

        }

        for (String invoiceNumber : invoiceNumbers) {

            FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

            schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());

        }

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

        return "response";

    }

    @RequestMapping(value = "/schemes/process-sellin", method = RequestMethod.POST)

    public String processSellin(HttpServletRequest request, Model model, @RequestBody List<String> invoiceNumbers) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

            throw new ProfitMandiBusinessException("User", loginDetails.getEmailId(), "Unauthorised access");

        }

        for (String invoiceNumber : invoiceNumbers) {

            Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);

            schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());

        }

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

        return "response";

    }

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

    public void payMonthlyInvestment(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

        LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

        LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

        int referenceId = Integer.parseInt(FormattingUtils.getYearMonth(startOfPreviousMonth.atStartOfDay()));

        LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

        List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

                .selectAll(startOfPreviousMonth, lastOfPreviousMonth);

        Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

                .filter(x -> x.getShortPercentage() <= ProfitMandiConstants.OK_INVESTMENT_SHORT_PERCENTAGE)

                .collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

        LOGGER.info("investmentMaintainedDaysMap {}", investmentMaintainedDaysMap);

        List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectAllPending(SchemeType.INVESTMENT,

                startOfPreviousMonth.atStartOfDay(), firstDateOfCurrentMonth.atStartOfDay());

        if (schemeInOuts.isEmpty()) {

            throw new ProfitMandiBusinessException("Investment Payout", "", "No data Found");

        }

        Map<Integer, List<SchemeInOut>> inventoryItemIdSchemeMap = schemeInOuts.stream()

                .collect(Collectors.groupingBy(x -> x.getInventoryItemId()));

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdSchemeMap.keySet());

        Map<Integer, List<Integer>> retailerInventoryItemIdMap = inventoryItems.stream().collect(

                Collectors.groupingBy(x -> x.getFofoId(), Collectors.mapping(x -> x.getId(), Collectors.toList())));

        System.out.println("Fofo Id\tInvestment Maintained Days\tEligible payout");

        for (Map.Entry<Integer, List<Integer>> retailerEntry : retailerInventoryItemIdMap.entrySet()) {

            int fofoId = retailerEntry.getKey();

            long investmentMaintainedDays = investmentMaintainedDaysMap.get(fofoId) == null ? 0

                    : investmentMaintainedDaysMap.get(fofoId);

            List<SchemeInOut> schemeInouts = retailerEntry.getValue().stream().map(x -> inventoryItemIdSchemeMap.get(x))

                    .flatMap(List::stream)

                    .filter(x -> x.getStatus().equals(SchemePayoutStatus.PENDING) && x.getRolledBackTimestamp() == null)

                    .collect(Collectors.toList());

            float totalAmount = 0;

            LocalDateTime firstBillingDate = transactionRepository.getFirstBillingDate(fofoId);

            boolean sameYearMonth = firstBillingDate.getMonth() == startOfPreviousMonth.getMonth()

                    && firstBillingDate.getYear() == startOfPreviousMonth.getYear();

            for (SchemeInOut sio : schemeInouts) {

                if (sameYearMonth) {

                    sio.setStatusDescription("Investment payout fully disbursed for first month");

                    sio.setStatus(SchemePayoutStatus.CREDITED);

                    sio.setCreditTimestamp(LocalDateTime.now());

                    totalAmount += sio.getAmount();

                } else {

                    if (investmentMaintainedDays < 8) {

                        sio.setStatus(SchemePayoutStatus.REJECTED);

                        // sio.setRolledBackTimestamp(LocalDateTime.now());

                        sio.setStatusDescription(

                                "Investment maintained for " + investmentMaintainedDays + "(< 8) days");

                    } else if (investmentMaintainedDays < 12) {

                        sio.setStatus(SchemePayoutStatus.CREDITED);

                        sio.setAmount(sio.getAmount() / 2);

                        sio.setCreditTimestamp(LocalDateTime.now());

                        sio.setStatusDescription(

                                "Investment maintained for " + investmentMaintainedDays + "(< 12) days");

                        totalAmount += sio.getAmount();

                    } else {

                        sio.setStatus(SchemePayoutStatus.CREDITED);

                        sio.setCreditTimestamp(LocalDateTime.now());

                        totalAmount += sio.getAmount();

                    }

                }

            }

            if (totalAmount > 0) {

                String description = "Investment margin paid for "

                        + FormattingUtils.formatYearMonth(startOfPreviousMonth.atStartOfDay());

                if (investmentMaintainedDays < 12) {

                    description += ", as maintained for " + investmentMaintainedDays + "(< 12) days";

                }

                walletService.addAmountToWallet(fofoId, referenceId, WalletReferenceType.INVESTMENT_PAYOUT, description,

                        totalAmount, lastOfPreviousMonth.atTime(LocalTime.MAX));

            }

            // Its ok to process Margins Pending for activation

            schemeService.processActivation();

            System.out.printf("%d\t%d\t%f%n", fofoId, investmentMaintainedDays, totalAmount);

        }

    }

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

    public ResponseEntity<?> evaluateActualInvestmentPayout(HttpServletRequest request, Model model) throws Exception {

        List<List<?>> rows = new ArrayList<>();

        LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

        LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

        LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

        List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

                .selectAll(startOfPreviousMonth, lastOfPreviousMonth);

        Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

                .filter(x -> x.getShortPercentage() <= ProfitMandiConstants.OK_INVESTMENT_SHORT_PERCENTAGE)

                .collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

        LOGGER.info("investmentMaintainedDaysMap {}", investmentMaintainedDaysMap);

        List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectAllPending(SchemeType.INVESTMENT,

                startOfPreviousMonth.atStartOfDay(), firstDateOfCurrentMonth.atStartOfDay());

        Map<Integer, List<SchemeInOut>> inventoryItemIdSchemeMap = schemeInOuts.stream()

                .collect(Collectors.groupingBy(x -> x.getInventoryItemId()));

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdSchemeMap.keySet());

        Map<Integer, List<Integer>> retailerInventoryItemIdMap = inventoryItems.stream().collect(

                Collectors.groupingBy(x -> x.getFofoId(), Collectors.mapping(x -> x.getId(), Collectors.toList())));

        System.out.println("Fofo Id\tInvestment Maintained Days\tEligible payout");

        for (Map.Entry<Integer, List<Integer>> retailerEntry : retailerInventoryItemIdMap.entrySet()) {

            int fofoId = retailerEntry.getKey();

            List<SchemeInOut> schemeInouts = retailerEntry.getValue().stream().map(x -> inventoryItemIdSchemeMap.get(x))

                    .flatMap(List::stream).collect(Collectors.toList());

            double totalAmount = schemeInouts.stream().filter(x -> x.getRolledBackTimestamp() == null)

                    .collect(Collectors.summingDouble(x -> x.getAmount()));

            long investmentMaintainedDays = investmentMaintainedDaysMap.get(fofoId) == null ? 0

                    : investmentMaintainedDaysMap.get(fofoId);

            if (investmentMaintainedDays < 8) {

                totalAmount = 0;

            } else if (investmentMaintainedDays < 12) {

                totalAmount = totalAmount / 2;

            }

            System.out.printf("%d\t%d\t%f%n", fofoId, investmentMaintainedDays, totalAmount);

            CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

            rows.add(Arrays.asList(fofoId, customRetailer.getBusinessName(), customRetailer.getCode(),

                    investmentMaintainedDays, totalAmount));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("fofoId", "Name", "Code", "investmentMaintainedDays", "totalAmount"), rows);

        final HttpHeaders headers = new HttpHeaders();

        headers.set("Content-Type", "text/csv");

        headers.set("Content-disposition", "inline; filename=investmentMaintainedDays.csv");

        headers.setContentLength(baos.toByteArray().length);

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

    }

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

    public ResponseEntity<?> processInvestmentDryRun(HttpServletRequest request, Model model) throws Exception {

        LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

        LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

        LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

        List<List<?>> rows = new ArrayList<>();

        Map<String, String> params = new HashMap<>();

        params.put("MANUAL_datesBetween_FROMDATE", startOfPreviousMonth.toString());

        params.put("MANUAL_datesBetween_TODATE", lastOfPreviousMonth.toString());

        params.put("type", "INVESTMENT");

        List<EvaluateSchemeInvestmentPayoutModel> evaluateSchemeInvestmentPayouts = reporticoService.getReports(

                EvaluateSchemeInvestmentPayoutModel.class, ReporticoProject.FOCO, "schemepayout.xml", params);

        int referenceId = Integer.parseInt(FormattingUtils.getYearMonth(startOfPreviousMonth.atStartOfDay()));

        List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

                .selectAll(startOfPreviousMonth, lastOfPreviousMonth);

        Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

                .filter(x -> x.getShortPercentage() <= ProfitMandiConstants.OK_INVESTMENT_SHORT_PERCENTAGE)

                .collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

        for (EvaluateSchemeInvestmentPayoutModel esip : evaluateSchemeInvestmentPayouts) {

            long investmentMaintainedDays = investmentMaintainedDaysMap.get(esip.getFofoId()) == null ? 0

                    : investmentMaintainedDaysMap.get(esip.getFofoId());

            esip.setInvestmentDays(investmentMaintainedDays);

            float processAmount = esip.getPaidAmount();

            if (investmentMaintainedDays < 8) {

                processAmount = 0;

            } else if (investmentMaintainedDays < 12) {

                processAmount = processAmount / 2;

            }

            esip.setProcessAmount(processAmount);

            rows.add(Arrays.asList(esip.getCode(), esip.getStoreName(), esip.getFofoId(), esip.getItemId(),

                    esip.getBrand(), esip.getModelName(), esip.getModelNumber(), esip.getColor(), esip.getSchemeInDp(),

                    esip.getSchemeOutDp(), esip.getSchemeId(), esip.getName(), esip.getType(), esip.getPartnerType(),

                    esip.getAmountType(), esip.getAmount(), esip.getPurchaseInvoice(), esip.getSaleInovoice(),

                    esip.getPaidAmount(), esip.getCreateTimestamp(), esip.getRolledBackTimestamp(),

                    esip.getSerialNumber(), esip.getInRef(), esip.getOutRef(), esip.getBusinessDate(), esip.getStatus(),

                    esip.getDescription(), esip.getProcessAmount(), esip.getInvestmentDays()));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil

                .getCSVByteStream(Arrays.asList("Code", "Store Name", "Fofo Id", "Item Id", "Brand", "Model Name",

                        "Model Number", "Color", "Scheme In Dp", "Scheme Out Dp", "Scheme Id", "Name", "Type",

                        "Partner Type", "Amount Type", "Amount", "Purchase Invoice", "Sale Inovoice", "Paid Amount",

                        "Create Timestamp", "Rolled Back Timestamp", "Serial Number", "In Ref", "Out Ref",

                        "Business Date", "Status", "Description", "Process Amount", "Investment Days"), rows);

        final HttpHeaders headers = new HttpHeaders();

        headers.set("Content-Type", "text/csv");

        headers.set("Content-disposition", "inline; filename=schemePayout.csv");

        headers.setContentLength(baos.toByteArray().length);

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

    }

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

    public String updateShcemes(HttpServletRequest request, @RequestBody SchemeItems schemeItems, Model model)

            throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        for (int schemeId : schemeItems.getSchemeIds()) {

            Scheme scheme = schemeRepository.selectById(schemeId);

            if (scheme != null)

                for (int catalogId : schemeItems.getCatalogIds()) {

                    if (tagListingRepository.selectAllByCatalogIds(Arrays.asList(catalogId)).size() > 0) {

                        try {

                            schemeService.addSchemeItemWithDates(schemeId, catalogId,

                                    scheme.getStartDateTime(), scheme.getEndDateTime(), loginDetails.getFofoId());

                        } catch (ProfitMandiBusinessException e) {

                            LOGGER.info("Scheme already exists for schemeId={}, catalogId={}", schemeId, catalogId);

                        }

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

                    } else {

                        LOGGER.info("Invalid catalog Id - {}", catalogId);

                    }

                }

        }

        return "response";

    }

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

    public String updateScheme(HttpServletRequest request, @RequestBody SchemeItems schemeItems, Model model)

            throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        for (int schemeId : schemeItems.getSchemeIds()) {

            Scheme scheme = schemeRepository.selectById(schemeId);

            if (scheme != null) {

                for (int catalogId : schemeItems.getCatalogIds()) {

                    // Use dates from request if provided, else default to scheme's window

                    LocalDateTime startDate = schemeItems.getStartDate() != null ? schemeItems.getStartDate() : scheme.getStartDateTime();

                    LocalDateTime endDate = schemeItems.getEndDate() != null ? schemeItems.getEndDate() : scheme.getEndDateTime();

                    try {

                        schemeService.addSchemeItemWithDates(schemeId, catalogId, startDate, endDate, loginDetails.getFofoId());

                    } catch (ProfitMandiBusinessException e) {

                        throw e;

                    } catch (Exception e) {

                        LOGGER.info("Scheme already exist for schemeId={}, catalogId={}", schemeId, catalogId);

                    }

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

                }

            }

        }

        return "response";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LocalDate currentdate = LocalDate.now();

        Month month = currentdate.getMonth().minus(1);

        model.addAttribute("month", month);

        // Map<Integer, String> itemIdItemDescriptionMap =

        // inventoryService.getAllItemIdItemDescriptionMap();

        // model.addAttribute("itemIdItemDescriptionMap", itemIdItemDescriptionMap);

        // List<Category> categories = inventoryService.getAllCategories();

        List<Category> categories = categoryRepository.selectByIds(categoryIds);

        categories = categories.stream().sorted(Comparator.comparing(Category::getId)).collect(Collectors.toList());

        // Set<String> brands =

        // inventoryService.getAllTagListingBrands(ProfitMandiConstants.MOBILE_CATEGORY_ID);

        // brands.addAll(inventoryService.getAllTagListingBrands(14206));

        boolean fullAccesss = this.getAccess(loginDetails.getEmailId());

        List<Region> regionList = regionRepository.selectAll();

        List<SchemeType> schemeTypes = fullAccesss ? Arrays.stream(SchemeType.values()).collect(Collectors.toList()) : SchemeType.RESTRICTED_SCHEMES_TYPES;

        model.addAttribute("schemeTypes", schemeTypes);

        model.addAttribute("regionList", regionList);

        model.addAttribute("categories", categories);

        model.addAttribute("retailerTypes", PartnerType.values());

        return "create-scheme";

    }

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

    public String extendAllScheme(HttpServletRequest request, @RequestBody LocalDateTime extendDatetime, Model model)

            throws Exception {

        List<Scheme> schemes = schemeRepository.selectActiveAll();

        //Filter scheme types ACTIVATION/SPECIAL SUPPORT/SELLOUT from extending

        schemes = schemes.stream().filter(x -> !EXCLUDE_EXTEND_SCHEMES.contains(x.getType())).collect(Collectors.toList());

        if (schemes.size() > 0) {

            for (Scheme scheme : schemes) {

                if (scheme.getExpireTimestamp() == null) {

                    if (extendDatetime.isBefore(scheme.getStartDateTime())) {

                        throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE,

                                extendDatetime.toString(), "End date cannot be before start date");

                    }

                    LocalDateTime originalEndDate = scheme.getEndDateTime();

                    scheme.setEndDateTime(extendDatetime);

                    schemeRepository.persist(scheme);

                    propagateEndDateToSchemeItems(scheme.getId(), originalEndDate, extendDatetime);

                }

            }

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

            return "response";

        }

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

        return "response";

    }

    // When a scheme's end date is extended, carry the new end date over to the scheme_item rows

    // that were tracking the scheme window (item end_date == the scheme's previous end date).

    // Items with a custom window (different end_date) are left untouched, matching expireSchemeById.

    private void propagateEndDateToSchemeItems(int schemeId, LocalDateTime originalEndDate, LocalDateTime newEndDate) {

        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeId(schemeId);

        for (SchemeItem schemeItem : schemeItems) {

            if (schemeItem.getEndDate() != null && schemeItem.getEndDate().equals(originalEndDate)) {

                schemeItem.setEndDate(newEndDate);

                schemeItemRepository.persist(schemeItem);

            }

        }

    }

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

    public String getTagListingItemsByBrand(HttpServletRequest request, @RequestParam int categoryId,

                                            @RequestParam List<String> brands, Model model) throws Exception {

        Map<Integer, String> catalogIdItemDescriptionMap = inventoryService.getModelDescriptionMap(categoryId, brands);

        model.addAttribute("catalogIdItemDescriptionMap", catalogIdItemDescriptionMap);

        // model.addAttribute("brands", inventoryService.getAllBrands());

        return "tag-listing-items-description";

    }

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

    public String createScheme(HttpServletRequest request, @RequestBody CreateSchemeRequest createSchemeRequest,

                               Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LOGGER.info("CreateSchemeRequest {}", createSchemeRequest);

        schemeService.saveScheme(loginDetails.getFofoId(), createSchemeRequest);

        return getDefaultSchemes(request, model);

    }

    private String getDefaultSchemes(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

        return getSchemes(request, 0, null, 30, 0, 0, PartnerType.ALL, "", model);

    }

    private List<Scheme> setSchemeAmountModel(List<Scheme> schemes) {

        for (Scheme scheme : schemes) {

            if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

                scheme.setAmountModel(scheme.getAmount() + "%");

            } else {

                scheme.setAmountModel(scheme.getAmount() + "");

            }

        }

        return schemes;

    }

    // Show 20 recents

    @RequestMapping(value = "/schemes/delete", method = RequestMethod.DELETE)

    public String deleteShcemes(HttpServletRequest request,

                                @RequestParam(name = "schemeId", required = false, defaultValue = "0") int schemeId,

                                @RequestParam(name = "catalogId", required = false, defaultValue = "0") int catalogId, Model model)

            throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (schemeId > 0 && catalogId > 0) {

            schemeItemRepository.deleteByCatalogIdsAndSchemeIds(catalogId, schemeId);

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

            model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));

        }

        return "response";

    }

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

    public String extendSchemeById(HttpServletRequest request,

                                   @RequestParam(name = ProfitMandiConstants.SCHEME_ID) int schemeId,

                                   @RequestBody LocalDateTime extendDatetime, Model model) throws Exception {

        Scheme scheme = schemeRepository.selectById(schemeId);

        if ((!(scheme.getActiveTimestamp() == null)) && scheme.getExpireTimestamp() == null) {

            if (extendDatetime.isBefore(scheme.getStartDateTime())) {

                throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE,

                        extendDatetime.toString(), "End date cannot be before start date");

            }

            LocalDateTime originalEndDate = scheme.getEndDateTime();

            scheme.setEndDateTime(extendDatetime);

            schemeRepository.persist(scheme);

            propagateEndDateToSchemeItems(scheme.getId(), originalEndDate, extendDatetime);

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

            return "response";

        }

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

        return "response";

    }

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

    public String getSchemesByImei(HttpServletRequest request,

                                   @RequestParam(defaultValue = "") String searchImei,

                                   @RequestParam(defaultValue = "false") boolean modal, Model model) throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (org.apache.commons.lang3.StringUtils.isNotEmpty(searchImei)) {

            List<Scheme> schemes = null;

            List<SchemeInOut> schemeInOuts = null;

            InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(searchImei);

            int fofoId = inventoryItem.getFofoId();

           List<ItemPurchaseSummaryModel> itemPurchaseSummaryModels = inventoryItemRepository.selectPurchaseSummary(new ArrayList<>(Arrays.asList(inventoryItem.getId())));

            List<FofoOrder> fofoOrders=fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchImei ,null, null, 0, 0);

            LOGGER.info("fofoOrder count: {}", fofoOrders.size());

            List<FofoOrder> filterOrders = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).collect(Collectors.toList());

            CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

            Item item = itemRepository.selectById(inventoryItem.getItemId());

            Map<Integer, Scheme> schemeMap = new HashMap<>();

            double netEarnings = 0;

            if (inventoryItem != null) {

                // Offer payout

                List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllBySerialNumber(fofoId, searchImei);

                Map<Integer, CreateOfferRequest> offerRequestMap = offerPayouts.stream().map(x -> x.getOfferId())

                        .distinct().map(offerId -> {

                            try {

                                return offerService.getOffer(fofoId, offerId.intValue());

                            } catch (ProfitMandiBusinessException e) {

                                throw new RuntimeException(e);

                            }

                        }).collect(Collectors.toMap(x -> x.getId(), x -> x));

                schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItem.getId())));

                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(searchImei);

                if (!schemeInOuts.isEmpty()) {

                    netEarnings += schemeInOuts.stream().filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED)).collect(Collectors.summingDouble(x -> x.getAmount()));

                    List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());

                    schemes = schemeRepository.selectBySchemeIds(schemeIds);

                    for (Scheme scheme : schemes) {

                        if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

                            scheme.setAmountModel(scheme.getAmount() + "%");

                        } else {

                            scheme.setAmountModel(scheme.getAmount() + "");

                        }

                    }

                    schemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                }

                List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository.selectByFofoIdImei(fofoId, searchImei);

                if (priceDropImeis.size() > 0) {

                    List<Integer> priceDropIds = priceDropImeis.stream().map(PriceDropIMEI::getPriceDropId).distinct().collect(Collectors.toList());

                    List<PriceDrop> priceDrops = priceDropRepository.selectByIds(priceDropIds);

                    Map<Integer, PriceDrop> priceDropMap = priceDrops.stream().collect(Collectors.toMap(PriceDrop::getId, x -> x));

                    for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

                        priceDropIMEI.setPriceDrop(priceDropMap.get(priceDropIMEI.getPriceDropId()));

                    }

                    model.addAttribute("priceDropImeis", priceDropImeis);

                }

                netEarnings += offerPayouts.stream().collect(Collectors.summingDouble(x -> x.getAmount()));

                model.addAttribute("offerPayouts", offerPayouts);

                model.addAttribute("offerRequestMap", offerRequestMap);

                model.addAttribute("inventoryItem", inventoryItem);

                model.addAttribute("itemPurchaseSummaryModels", itemPurchaseSummaryModels);

                model.addAttribute("fofoOrders", filterOrders);

                model.addAttribute("activatedImei", activatedImei);

            }

            LOGGER.info("Net Earnings {}", netEarnings);

            model.addAttribute("netEarnings", netEarnings);

            model.addAttribute("fofoId", fofoId);

            model.addAttribute("schemeMap", schemeMap);

            model.addAttribute("item", item);

            model.addAttribute("schemeInOut", schemeInOuts);

            model.addAttribute("schemes", schemes);

            model.addAttribute("customRetailer", customRetailer);

            model.addAttribute("searchImei", searchImei);

            // Return IMEI results only when modal and searchImei provided

            if (modal) {

                return "scheme-imei-results-modal";

            }

        }

        if (modal) {

            return "scheme-imei-history-modal";

        }

        return "scheme-imei-history";

    }

    /**

     * New endpoint for modal IMEI-wise margin search

     * Returns shell when searchImei is empty, results when searchImei is provided

     */

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

    public String getImeiMarginModal(HttpServletRequest request,

                                     @RequestParam(defaultValue = "") String searchImei,

                                     @RequestParam(name = "fofoId") int fofoId,

                                     Model model) throws ProfitMandiBusinessException {

        if (org.apache.commons.lang3.StringUtils.isEmpty(searchImei)) {

            // Return empty shell with search boxes

            return "scheme-imei-history-modal";

        }

        // Fetch IMEI margin data

        List<Scheme> schemes = null;

        List<SchemeInOut> schemeInOuts = null;

        InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(searchImei);

        if (inventoryItem == null) {

            model.addAttribute("searchImei", searchImei);

            return "scheme-imei-results-modal";

        }

        int itemFofoId = inventoryItem.getFofoId();

        List<ItemPurchaseSummaryModel> itemPurchaseSummaryModels = inventoryItemRepository.selectPurchaseSummary(new ArrayList<>(Arrays.asList(inventoryItem.getId())));

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(itemFofoId, searchImei, null, null, 0, 0);

        List<FofoOrder> filterOrders = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).collect(Collectors.toList());

        CustomRetailer customRetailer = retailerService.getFofoRetailer(itemFofoId);

        Item item = itemRepository.selectById(inventoryItem.getItemId());

        Map<Integer, Scheme> schemeMap = new HashMap<>();

        double netEarnings = 0;

        // Offer payout

        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllBySerialNumber(itemFofoId, searchImei);

        Map<Integer, CreateOfferRequest> offerRequestMap = offerPayouts.stream().map(x -> x.getOfferId())

                .distinct().map(offerId -> {

                    try {

                        return offerService.getOffer(itemFofoId, offerId.intValue());

                    } catch (ProfitMandiBusinessException e) {

                        throw new RuntimeException(e);

                    }

                }).collect(Collectors.toMap(x -> x.getId(), x -> x));

        schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItem.getId())));

        ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(searchImei);

        if (!schemeInOuts.isEmpty()) {

            netEarnings += schemeInOuts.stream().filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED)).collect(Collectors.summingDouble(x -> x.getAmount()));

            List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());

            schemes = schemeRepository.selectBySchemeIds(schemeIds);

            for (Scheme scheme : schemes) {

                if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

                    scheme.setAmountModel(scheme.getAmount() + "%");

                } else {

                    scheme.setAmountModel(scheme.getAmount() + "");

                }

            }

            schemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        }

        List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository.selectByFofoIdImei(itemFofoId, searchImei);

        if (priceDropImeis.size() > 0) {

            List<Integer> priceDropIds = priceDropImeis.stream().map(PriceDropIMEI::getPriceDropId).distinct().collect(Collectors.toList());

            List<PriceDrop> priceDrops = priceDropRepository.selectByIds(priceDropIds);

            Map<Integer, PriceDrop> priceDropMap = priceDrops.stream().collect(Collectors.toMap(PriceDrop::getId, x -> x));

            for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

                priceDropIMEI.setPriceDrop(priceDropMap.get(priceDropIMEI.getPriceDropId()));

            }

            model.addAttribute("priceDropImeis", priceDropImeis);

        }

        netEarnings += offerPayouts.stream().collect(Collectors.summingDouble(x -> x.getAmount()));

        model.addAttribute("offerPayouts", offerPayouts);

        model.addAttribute("offerRequestMap", offerRequestMap);

        model.addAttribute("inventoryItem", inventoryItem);

        model.addAttribute("itemPurchaseSummaryModels", itemPurchaseSummaryModels);

        model.addAttribute("fofoOrders", filterOrders);

        model.addAttribute("activatedImei", activatedImei);

        model.addAttribute("netEarnings", netEarnings);

        model.addAttribute("fofoId", itemFofoId);

        model.addAttribute("schemeMap", schemeMap);

        model.addAttribute("item", item);

        model.addAttribute("schemeInOut", schemeInOuts);

        model.addAttribute("schemes", schemes);

        model.addAttribute("customRetailer", customRetailer);

        model.addAttribute("searchImei", searchImei);

        return "scheme-imei-results-modal";

    }

    /**

     * Scheme-only net-margin modal for an IMEI, priced at the IMEI's

     * purchase-billed date (the date schemes were locked in when the

     * partner was billed-in). Offers are intentionally excluded.

     */

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

    public String getImeiNetMarginModal(HttpServletRequest request,

                                        @RequestParam(defaultValue = "") String searchImei,

                                        @RequestParam int fofoId,

                                        Model model) throws ProfitMandiBusinessException {

        model.addAttribute("searchImei", searchImei);

        model.addAttribute("fofoId", fofoId);

        if (StringUtils.isBlank(searchImei)) {

            model.addAttribute("errorMessage", "Please enter an IMEI.");

            return "imei-net-margin-modal";

        }

        InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(searchImei);

        if (inventoryItem == null) {

            model.addAttribute("errorMessage", "IMEI not found.");

            return "imei-net-margin-modal";

        }

        if (inventoryItem.getFofoId() != fofoId) {

            model.addAttribute("errorMessage", "IMEI not found for this partner.");

            return "imei-net-margin-modal";

        }

        List<ItemPurchaseSummaryModel> purchaseSummaries = inventoryItemRepository

                .selectPurchaseSummary(Arrays.asList(inventoryItem.getId()));

        if (purchaseSummaries.isEmpty() || purchaseSummaries.get(0).getInvoiceDate() == null) {

            model.addAttribute("errorMessage", "IMEI not yet billed-in — margin unavailable.");

            return "imei-net-margin-modal";

        }

        ItemPurchaseSummaryModel purchaseSummary = purchaseSummaries.get(0);

        LocalDate billedDate = purchaseSummary.getInvoiceDate().toLocalDate();

        Item item = purchaseSummary.getItem() != null

                ? purchaseSummary.getItem()

                : itemRepository.selectById(inventoryItem.getItemId());

        int catalogId = item.getCatalogItemId();

        PriceCircularModel priceCircularModel = priceCircularService

                .getPriceCircularByOffer(fofoId, Arrays.asList(catalogId), billedDate);

        com.spice.profitmandi.service.pricecircular.PriceCircularItemModelNew itemModel = null;

        if (priceCircularModel != null && priceCircularModel.getPriceCircularItemModelNews() != null) {

            itemModel = priceCircularModel.getPriceCircularItemModelNews().stream()

                    .filter(x -> x.getCatalogId() == catalogId)

                    .findFirst().orElse(null);

        }

        // Use the same DP basis as SchemeServiceImpl.createSchemeInOut →

        // PriceCircularService.getPayouts: actual purchase price stamped on

        // inventory_item at GRN time, minus any price-drop credited against

        // it. This is what the persisted scheme_in_out.amount values were

        // computed against.

        double purchasePrice = inventoryItem.getUnitPrice();

        double priceDropAmount = Math.max(0d, inventoryItem.getPriceDropAmount());

        double effectiveDP = purchasePrice - priceDropAmount;

        // Pull per-IMEI price-drop history for reference display.

        List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository

                .selectByFofoIdImei(fofoId, searchImei);

        if (priceDropImeis != null && !priceDropImeis.isEmpty()) {

            List<Integer> priceDropIds = priceDropImeis.stream()

                    .map(PriceDropIMEI::getPriceDropId).distinct().collect(Collectors.toList());

            Map<Integer, PriceDrop> priceDropMap = priceDropRepository.selectByIds(priceDropIds)

                    .stream().collect(Collectors.toMap(PriceDrop::getId, x -> x));

            for (PriceDropIMEI pdi : priceDropImeis) {

                pdi.setPriceDrop(priceDropMap.get(pdi.getPriceDropId()));

            }

        }

        model.addAttribute("imei", searchImei);

        model.addAttribute("billedDate", billedDate);

        model.addAttribute("invoiceNumber", purchaseSummary.getInvoiceNumber());

        model.addAttribute("modelName", item.getItemDescriptionNoColor());

        model.addAttribute("purchasePrice", fmt2(purchasePrice));

        model.addAttribute("priceDropAmount", fmt2(priceDropAmount));

        model.addAttribute("hasPriceDrop", priceDropAmount > 0d);

        model.addAttribute("priceDropImeis", priceDropImeis == null ? Collections.emptyList() : priceDropImeis);

        if (itemModel == null || itemModel.getSchemeSummaryModels() == null

                || itemModel.getSchemeSummaryModels().isEmpty()) {

            model.addAttribute("noSchemes", true);

            model.addAttribute("dp", fmt2(effectiveDP));

            model.addAttribute("schemeSummaryModels", Collections.emptyList());

            model.addAttribute("contributionMap", Collections.emptyMap());

            model.addAttribute("rateMap", Collections.emptyMap());

            model.addAttribute("fixedSchemeAmount", fmt2(0d));

            model.addAttribute("percentageSchemeAmount", fmt2(0d));

            model.addAttribute("nlc", fmt2(effectiveDP));

            model.addAttribute("netMargin", fmt2(0d));

            return "imei-net-margin-modal";

        }

        double fixedTotal = itemModel.getFixedSchemeAmount();

        double percentageTotal = itemModel.getPercentageSchemeAmount();

        // Recompute NLC against effectiveDP — do NOT reuse

        // PriceCircularItemModelNew.getNlc() because it is derived from the

        // current TagListing list-DP, not the partner's actual purchase price.

        double nlc = (effectiveDP - fixedTotal) / (1d + percentageTotal / 100d);

        double netMargin = effectiveDP - nlc;

        Map<Integer, String> contributionMap = new HashMap<>();

        Map<Integer, String> rateMap = new HashMap<>();

        for (com.spice.profitmandi.service.pricecircular.SchemeSummaryModel ssm : itemModel.getSchemeSummaryModels()) {

            double contribution;

            if (ssm.getAmountType() == AmountType.FIXED) {

                contribution = ssm.getAmount() == null ? 0d : ssm.getAmount();

            } else if (ssm.getAmountType() == AmountType.PERCENTAGE && percentageTotal > 0) {

                double pct = ssm.getAmount() == null ? 0d : ssm.getAmount();

                contribution = effectiveDP * (pct / (100d + percentageTotal));

            } else {

                contribution = 0d;

            }

            contributionMap.put(ssm.getSchemeId(), fmt2(contribution));

            double rate = ssm.getAmount() == null ? 0d : ssm.getAmount();

            String rateStr = ssm.getAmountType() == AmountType.PERCENTAGE

                    ? fmt2(rate) + "%"

                    : "₹ " + fmt2(rate);

            rateMap.put(ssm.getSchemeId(), rateStr);

        }

        model.addAttribute("noSchemes", false);

        model.addAttribute("dp", fmt2(effectiveDP));

        model.addAttribute("schemeSummaryModels", itemModel.getSchemeSummaryModels());

        model.addAttribute("contributionMap", contributionMap);

        model.addAttribute("rateMap", rateMap);

        model.addAttribute("fixedSchemeAmount", fmt2(fixedTotal));

        model.addAttribute("percentageSchemeAmount", fmt2(percentageTotal));

        model.addAttribute("nlc", fmt2(nlc));

        model.addAttribute("netMargin", fmt2(netMargin));

        return "imei-net-margin-modal";

    }

    private static String fmt2(double v) {

        return String.format(Locale.ENGLISH, "%.2f", v);

    }

    /**

     * New endpoint for modal model-wise margin search

     * Accepts fofoId as parameter to work for both admin and partner views

     */

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

    public String getModelMarginModal(HttpServletRequest request,

                                      @RequestParam(name = "searchModel") int searchModel,

                                      @RequestParam(name = "fofoId") int fofoId,

                                      @RequestParam(required = false) LocalDate date,

                                      Model model) throws ProfitMandiBusinessException {