Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

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.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.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 javax.transaction.Transactional;

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(rollbackOn = 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.ACTIVATION, SchemeType.SPECIAL_SUPPORT);

    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", "tejbeer.kaur@smartdukaan.com", "raksha.vyas@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

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

                .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() <= 10)

                .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() <= 10)

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

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

            if (schemeRepository.selectById(schemeId) != null)

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

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

                        SchemeItem si = new SchemeItem();

                        si.setCatalogId(catalogId);

                        si.setSchemeId(schemeId);

                        si.setCreateTimestamp(LocalDateTime.now());

                        try {

                            schemeItemRepository.persist(si);

                        } catch (Exception e) {

                            LOGGER.info("Scheme aleady exist");

                        }

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

                    } else {

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

                        throw new ProfitMandiBusinessException("Catalog Id ", catalogId, "Invalid Catalog Id");

                    }

                }

        }

        return "response";

    }

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

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

            throws Exception {

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

            List<Integer> catalogIds = schemeItemRepository.selectCatalogIdsBySchemeId(schemeId);

            if (schemeRepository.selectById(schemeId) != null)

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

                    if (!(catalogIds.contains(catalogId))) {

                        SchemeItem si = new SchemeItem();

                        si.setCatalogId(catalogId);

                        si.setSchemeId(schemeId);

                        si.setCreateTimestamp(LocalDateTime.now());

                        try {

                            schemeItemRepository.persist(si);

                        } catch (Exception e) {

                            LOGGER.info("Scheme already exist");

                        }

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

                    } else {

                        throw new ProfitMandiBusinessException("Catalog exist for scheme",

                                "SchemeId= " + schemeId + ", CatalogId= " + catalogId, "Catalog exist for scheme");

                    }

                }

        }

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

        model.addAttribute("fullAccesss", fullAccesss);

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

                    scheme.setEndDateTime(extendDatetime);

                    schemeRepository.persist(scheme);

                }

            }

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

            return "response";

        }

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

        return "response";

    }

    @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) {

            scheme.setEndDateTime(extendDatetime);

            schemeRepository.persist(scheme);

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

            return "response";

        }

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

        return "response";

    }

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

    public String getSchemes(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,

                             @RequestParam(required = false) LocalDate date,

                             @RequestParam(name = "limit", required = false, defaultValue = "30") int limit,

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

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

                             @RequestParam(name = "partnerType", required = false, defaultValue = "ALL") PartnerType partnerType,

                             @RequestParam(name = "searchImei", required = false, defaultValue = "") String searchImei, Model model)

            throws ProfitMandiBusinessException {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        if (date != null) {

            date = date.isAfter(LocalDate.now()) ? LocalDate.now() : date;

        } else if (!isAdmin) {

            date = LocalDate.now();

        }

        List<Scheme> schemes = null;

        List<SchemeInOut> schemeInOuts = null;

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

        model.addAttribute("fullAccess", fullAccess);

        model.addAttribute("searchImei", searchImei);

        model.addAttribute("isAdmin", isAdmin);

        model.addAttribute("searchModel", searchModel);

        model.addAttribute("searchScheme", searchScheme);

        model.addAttribute("partnerType", partnerType);

        model.addAttribute("date", date);

        final LocalDate date1 = date;

        if (searchScheme > 0) {

            schemes = Arrays.asList(schemeRepository.selectById(searchScheme));

            this.setSchemeAmountModel(schemes);

            if (schemes.size() > 0) {

                model.addAttribute("schemes", schemes);

                List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

                Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(","))));

                model.addAttribute("schemeRegionMap", schemeRegionMap);

                return "schemes";

            } else {

                throw new ProfitMandiBusinessException("SchemeId", searchScheme, "SchemeId Not Found");

            }

        } else if (searchModel > 0) {

            Item item = itemRepository.selectAllByCatalogItemId(searchModel).get(0);

            TagListing tagListing = tagListingRepository.selectByItemId(item.getId());

            if (tagListing != null) {

                model.addAttribute("dp", tagListing.getSellingPrice());

                model.addAttribute("mop", tagListing.getMop());

            }

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

            if (isAdmin) {

                schemes = schemeService

                        .selectSchemeByPartnerType(partnerType, date, searchModel, isAdmin, offset, limit).stream()

                        .filter(x -> x.getId() != 411 && x.getId() != 612).collect(Collectors.toList());

                this.setSchemeAmountModel(schemes);

                model.addAttribute("schemes", schemes);

                List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

                Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(" ,"))));

                model.addAttribute("schemeRegionMap", schemeRegionMap);

                return "schemes";

            } else {

                partnerType = partnerTypeChangeService.getTypeOnDate(loginDetails.getFofoId(), date);

                schemes = schemeService

                        .selectSchemeByPartnerTypeFofoId(partnerType, date, searchModel, loginDetails.getFofoId(), offset, limit).stream()

                        .filter(x -> (x.getId() != 411 && x.getId() != 612)).collect(Collectors.toList());

                // Remove 411 and 612

                // this.setSchemeAmountModel(schemes);

                int nlc = this.getNlc(item, loginDetails.getFofoId(), schemes, tagListing);

                // For 7720(HR) remove investment

                model.addAttribute("schemes", schemes);

                model.addAttribute("nlc", Math.round(nlc));

                Map<Integer, Map<Integer, Long>> offerSlabPayoutMap = new HashMap<>();

                List<CreateOfferRequest> offers = offerService.getPublishedOffers(date, loginDetails.getFofoId(),

                        searchModel);

                if (offers.size() > 0) {

                    for (CreateOfferRequest createOfferRequest : offers) {

                        Map<Integer, Map<Integer, Long>> catalogSlabPayoutMap = offerService

                                .getSlabPayoutMap(createOfferRequest);

                        Map<Integer, Long> slabPayoutMap = catalogSlabPayoutMap.get(searchModel);

                        offerSlabPayoutMap.put(createOfferRequest.getId(), slabPayoutMap);

                    }

                    model.addAttribute("offers", offers);

                    model.addAttribute("offerSlabPayoutMap", offerSlabPayoutMap);

                    LOGGER.info("offer");

                }

                FofoStore fs = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

                model.addAttribute("partnerCode", fs.getCode());

                model.addAttribute("fofoId", fs.getId());

                return "schemes-partner";

            }

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

            LOGGER.info("searchImei" + searchImei);

            InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(searchImei,

                    loginDetails.getFofoId());

            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(loginDetails.getFofoId(),

                        searchImei);

                Map<Integer, CreateOfferRequest> offerRequestMap = offerPayouts.stream()

                        .map(x -> offerService.getOffer(loginDetails.getFofoId(), (int) x.getOfferId()))

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

                schemeInOuts = schemeInOutRepository

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

                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(loginDetails.getFofoId(), searchImei);

                if (priceDropImeis.size() > 0) {

                    for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

                        int priceDropId = priceDropIMEI.getPriceDropId();

                        PriceDrop pd = priceDropRepository.selectById(priceDropId);

                        priceDropIMEI.setPriceDrop(pd);

                    }

                    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("inventoryItem", inventoryItem);

            }

            model.addAttribute("netEarnings", netEarnings);

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

            model.addAttribute("schemeMap", schemeMap);

            model.addAttribute("item", item);

            model.addAttribute("schemeInOut", schemeInOuts);

            return "schemes-partner";

        }

        if (isAdmin) {

            schemes = schemeRepository.selectAll(0, 100);

            this.setSchemeAmountModel(schemes);

            List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

            Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(","))));

            model.addAttribute("schemes", schemes);

            model.addAttribute("schemeRegionMap", schemeRegionMap);

            return "schemes";

        } else {

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

                InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(searchImei,

                        loginDetails.getFofoId());

                List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository

                        .selectByFofoIdImei(loginDetails.getFofoId(), searchImei);

                if (priceDropImeis.size() > 0) {

                    for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

                        int priceDropId = priceDropIMEI.getPriceDropId();

                        PriceDrop pd = priceDropRepository.selectById(priceDropId);

                        priceDropIMEI.setPriceDrop(pd);

                    }

                    model.addAttribute("priceDropImeis", priceDropImeis);

                }

            }

            FofoStore fs = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

            model.addAttribute("partnerCode", fs.getCode());

            model.addAttribute("fofoId", fs.getId());

            return "schemes-partner";

        }

    }

    private int getNlc(Item item, int fofoId, List<Scheme> schemes, TagListing tagListing) {

        if (item.getBrand().equals("Vivo") && fofoStoreRepository.getWarehousePartnerMap().get(7720).stream()

                .filter(x -> x.getId() == fofoId).count() > 0) {

            schemes = schemes.stream().filter(x -> !x.getType().equals(SchemeType.INVESTMENT))

                    .collect(Collectors.toList());

        }

        float nlc = tagListing.getSellingPrice();

        for (Scheme scheme : schemes) {

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

                if (tagListing != null) {

                    float amount = tagListing.getSellingPrice() * scheme.getAmount() / 100;

                    scheme.setAmountModel(FormattingUtils.formatDecimal(amount) + " (" + scheme.getAmount() + "%)");

                    nlc -= amount;

                } else {

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

                }

            } else {

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

                nlc -= scheme.getAmount();

            }

        }

        return Math.round(nlc);

    }

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

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

        String status = "CREDITED";

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentStartMonth = LocalDate.now().atStartOfDay().withDayOfMonth(1);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();

        YearMonth yearMonth = YearMonth.now();

        LOGGER.info("yearMonth" + yearMonth);

        boolean partnerType = partnerTypeChangeService.isPartnerTypeUpgraded(loginDetails.getFofoId(), yearMonth);

        LOGGER.info("partnerType" + partnerType);

        Map<String, Double> lastMonthCategoryUpgradeMarginMap = new HashMap<>();

        if (partnerType) {

            lastMonthCategoryUpgradeMarginMap = schemeInOutRepository

                    .selectLastMonthCategoryUpgradeMarginByBrand(loginDetails.getFofoId(), currentStartMonth,

                            currentDate)

                    .stream().collect(Collectors.toMap(x -> x.getBrand(), x -> x.getAmount()));

        }

        List<LastMonthCreditedIncomeModel> lastMonthCreditedIncomeModels = schemeInOutRepository

                .selectLastMonthCreditedIncomeByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

        List<LastMonthCreditedIncomeModel> lastMonthPurchaseInMargins = schemeInOutRepository

                .selectLastMonthPurchaseInMarginByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

        List<LastMonthCreditedIncomeModel> lastMonthFrontEndIncomes = schemeInOutRepository

                .selectFrontIncomeByBrand(loginDetails.getFofoId(), currentStartMonth, currentDate);

        Map<String, LastMonthCreditedIncomeModel> lastMonthPendingIncomeMap = schemeInOutRepository

                .selectLastMonthPendingIncomeByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate).stream()

                .collect(Collectors.toMap(x -> x.getBrand(), x -> x));

        Map<String, LastMonthCreditedIncomeModel> lastMonthPurchaseInMarginMap = new HashMap<>();

        lastMonthPurchaseInMarginMap = lastMonthPurchaseInMargins.stream()

                .collect(Collectors.toMap(x -> x.getBrand(), x -> x));

        Map<String, LastMonthCreditedIncomeModel> lastMonthSaleMarginMap = lastMonthCreditedIncomeModels.stream()

                .collect(Collectors.toMap(x -> x.getBrand(), x -> x));

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

            if (lastMonthSaleMarginMap.containsKey(x.getBrand())) {

                x.setAmount(lastMonthSaleMarginMap.get(x.getBrand()).getAmount() + x.getAmount());

                lastMonthSaleMarginMap.put(x.getBrand(), x);

            } else {

                lastMonthSaleMarginMap.put(x.getBrand(), x);

            }

        });

        Map<String, Float> totalAmountMap = lastMonthSaleMarginMap.entrySet().stream()

                .collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue().getAmount()));

        Set<String> keySet = new HashSet<>();

        keySet.addAll(lastMonthPurchaseInMarginMap.keySet());

        keySet.addAll(lastMonthSaleMarginMap.keySet());

        keySet.addAll(lastMonthPendingIncomeMap.keySet());

        lastMonthPurchaseInMarginMap.entrySet().stream().forEach(x -> {

            String brand = x.getKey();

            float amount = x.getValue().getAmount();

            if (!totalAmountMap.containsKey(brand)) {

                totalAmountMap.put(brand, 0f);

            }

            totalAmountMap.put(brand, totalAmountMap.get(brand) + amount);

        });

        lastMonthPendingIncomeMap.entrySet().stream().forEach(x -> {

            String brand = x.getKey();

            float amount = x.getValue().getAmount();

            if (!totalAmountMap.containsKey(brand)) {

                totalAmountMap.put(brand, 0f);

            }

            totalAmountMap.put(brand, totalAmountMap.get(brand) + amount);

        });

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

        for (int i = 0; i <= 5; i++) {

            LocalDateTime startOfMonth = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

            monthValueMap.put(i, startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

        }

        model.addAttribute("month", 0);

        model.addAttribute("monthValueMap", monthValueMap);

        model.addAttribute("keySet", keySet);

        model.addAttribute("lastMonthPendingIncomeMap", lastMonthPendingIncomeMap);

        model.addAttribute("lastMonthCategoryUpgradeMarginMap", lastMonthCategoryUpgradeMarginMap);

        model.addAttribute("lastMonthPurchaseInMarginMap", lastMonthPurchaseInMarginMap);

        model.addAttribute("lastMonthSaleMarginMap", lastMonthSaleMarginMap);

        model.addAttribute("status", status);

        model.addAttribute("totalAmountMap", totalAmountMap);

        return "last-month-credited-income";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime currentStartMonth = LocalDate.now().atStartOfDay().withDayOfMonth(1);

        LocalDateTime currentDate = LocalDate.now().atStartOfDay();

        String status = "PENDING";

        LOGGER.info("currentStartMonth" + currentStartMonth);

        LOGGER.info("currentDate" + currentDate);

        List<LastMonthCreditedIncomeModel> lastMonthPendingIncomeModels = schemeInOutRepository

                .selectLastMonthPendingIncomeByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

        Map<String, LastMonthCreditedIncomeModel> lastMonthMarginMap = new HashMap<>();

        for (LastMonthCreditedIncomeModel lastMonthPendingIncomeModel : lastMonthPendingIncomeModels) {

            lastMonthMarginMap.put(lastMonthPendingIncomeModel.getBrand(), lastMonthPendingIncomeModel);

        }

        LOGGER.info("lastMonthPendingIncomeModel" + lastMonthPendingIncomeModels);

        LOGGER.info("lastMonthMarginMap" + lastMonthMarginMap);

        model.addAttribute("lastMonthCreditedIncomeModels", lastMonthPendingIncomeModels);

        model.addAttribute("lastMonthMarginMap", lastMonthMarginMap);

        model.addAttribute("status", status);

        return "last-month-credited-income";

    }

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

    public String getLastMonthImeiWiseIncome(HttpServletRequest request,

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

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

            throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LocalDateTime lastMonthStart = LocalDate.now().minusMonths(month).withDayOfMonth(1).atStartOfDay();

        LocalDateTime lastMonthEnd = lastMonthStart.plusMonths(1);

        HashSet<String> allImeiSet = new LinkedHashSet<>();

        HashSet<String> purchaseSet = new LinkedHashSet<>();

        HashSet<String> saleSet = new LinkedHashSet<>();

        List<LastMonthFrontEndImeiModel> lmfi = schemeInOutRepository

                .selectLastMonthFrontEndImei(loginDetails.getFofoId(), catalogItemId, lastMonthStart, lastMonthEnd);

        List<LastMonthImeiModel> lmpi = schemeInOutRepository.selectLastMonthPurchaseInImei(loginDetails.getFofoId(),

                catalogItemId, lastMonthStart, lastMonthEnd);

        List<LastMonthImeiModel> lmci = schemeInOutRepository.selectLastMonthCreditedImei(loginDetails.getFofoId(),

                catalogItemId, lastMonthStart, lastMonthEnd);

        List<OfferPayoutImeiIncomeModel> offerPayoutImeiIncomeModels = offerPayoutRepository.getTotalPayoutsByPartnerPeriod(YearMonth.of(lastMonthStart.getYear(),

                lastMonthStart.getMonth()), loginDetails.getFofoId(), null, catalogItemId);

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

        Map<String, Double> lastmonthCategoryUpgradeMargin = schemeInOutRepository

                .selectLastMonthCategoryUpgradeMarginByImei(loginDetails.getFofoId(), catalogItemId, lastMonthStart,

                        lastMonthEnd)

                .stream().collect(Collectors.toMap(x -> x.getBrand(), x -> x.getAmount()));

        allImeiSet.addAll(lmpi.stream().map(x -> x.getImei()).collect(Collectors.toList()));

        allImeiSet.addAll(lmci.stream().map(x -> x.getImei()).collect(Collectors.toList()));

        allImeiSet.addAll(lmfi.stream().map(x -> x.getImei()).collect(Collectors.toList()));

        allImeiSet.addAll(offerPayoutImeiIncomeModels.stream().map(x -> x.getImei()).collect(Collectors.toList()));

        List<String> allImeiList = new ArrayList<>(allImeiSet);

        LOGGER.info("allImeiList" + allImeiList);

        LOGGER.info("lmcm" + lastmonthCategoryUpgradeMargin);

        List<LastMonthFrontEndImeiModel> lastMonthFrontEndImeis = schemeInOutRepository

                .selectLastMonthFrontEndByImei(loginDetails.getFofoId(), allImeiList);

        Map<String, LastMonthFrontEndImeiModel> soldMap = lastMonthFrontEndImeis.stream().collect(Collectors.toMap(x -> x.getImei(), x -> x));