Subversion Repositories SmartDukaan

Rev

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

package com.spice.profitmandi.service.offers;

import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.PartnerTargetModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.entity.catalog.ItemCriteria;
import com.spice.profitmandi.dao.entity.catalog.Offer;
import com.spice.profitmandi.dao.entity.catalog.TagListing;
import com.spice.profitmandi.dao.entity.catalog.TargetSlab;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.entity.fofo.OfferPayout;
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
import com.spice.profitmandi.dao.enumuration.catalog.OfferSchemeType;
import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;
import com.spice.profitmandi.dao.model.CreateOfferRequest;
import com.spice.profitmandi.dao.model.ItemCriteriaPayout;
import com.spice.profitmandi.dao.repository.catalog.*;
import com.spice.profitmandi.dao.repository.fofo.OfferPayoutRepository;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.wallet.WalletService;
import in.shop2020.model.v1.order.WalletReferenceType;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Row.MissingCellPolicy;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.*;
import java.util.stream.Collectors;

@Component
public class OfferServiceImpl implements OfferService {

        private static final List<String> targets = Arrays.asList("Target 1", "Target 2", "Target 3", "Target 4",
                        "Target 5");

        @Autowired
        private Gson gson;

        @Autowired
        private OfferRepository offerRepository;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        OfferPayoutRepository offerPayoutRepository;

        @Autowired
        private ItemCriteriaRepository itemCriteriaRepository;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private TagListingRepository tagListingRepository;

        @Autowired
        private OfferTargetSlabRepository offerTargetSlabRepository;

        @Autowired
        CacheManager thirtyMinsTimeOutCacheManager;


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

        @Override
        public void addOfferService(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {
                LOGGER.info("createOfferRequest  -- {}", createOfferRequest);
                this.createOffer(createOfferRequest);
                this.createTargetSlabs(createOfferRequest);
        }

        private void createOffer(CreateOfferRequest createOfferRequest) {
                Offer offer = new Offer();
                offer.setName(createOfferRequest.getName());
                offer.setTargetType(createOfferRequest.getTargetType());
                offer.setBooster(createOfferRequest.isBooster());
                offer.setPayoutType(createOfferRequest.getPayoutType());
                offer.setSchemeType(createOfferRequest.getSchemeType());
                offer.setBaseCriteia(createOfferRequest.isBaseCriteria());
                offer.setEndDate(createOfferRequest.getEndDate());
                offer.setStartDate(createOfferRequest.getStartDate());
                offer.setBrandSharePercentage(createOfferRequest.getBrandShareTerms());
                offer.setSellinPercentage(createOfferRequest.getSellinPercentage());
                offer.setOfferNotes(createOfferRequest.getOfferNotes());
                offer.setActivationBrands(createOfferRequest.getActivationBrands());
                offer.setTerms(createOfferRequest.getTerms());
                offer.setItemCriteria(gson.toJson(createOfferRequest.getItemCriteria()));
                offer.setPartnerCriteria(gson.toJson(createOfferRequest.getPartnerCriteria()));
                offerRepository.persist(offer);
                createOfferRequest.setId(offer.getId());
        }

        @Override
        public List<CreateOfferRequest> getPublishedOffers(int fofoId, YearMonth yearMonth) {
                List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(yearMonth).get(fofoId);
                List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
                if (publishedOffers != null) {
                        for (Offer offer : publishedOffers) {
                                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
                                createOfferRequests.add(createOfferRequest);
                                setCriteriaPayoutAchieved(fofoId, createOfferRequest);

                        }
                }
                return createOfferRequests;
        }

        private void setCriteriaPayoutAchieved(int fofoId, CreateOfferRequest createOfferRequest) {
                Map<Integer, Long> criteriaTransactionMap = null;
                if (createOfferRequest.getSchemeType().equals(OfferSchemeType.SELLIN)) {
                        criteriaTransactionMap = offerRepository.getPartnerWisePurchaseSum(createOfferRequest).get(fofoId);
                } else {
                        criteriaTransactionMap = offerRepository.getPartnerWiseSalesSum(createOfferRequest).get(fofoId);
                }
                LOGGER.info("I am here ------- {}", createOfferRequest.getId());
                List<com.spice.profitmandi.dao.model.ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest
                                .getTargetSlabs().get(0).getItemCriteriaPayouts();

                for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {
                        itemCriteriaPayout.setNextSlab(null);
                        LOGGER.info("I am here --- {}", itemCriteriaPayout.getPayoutSlabs());
                        long saleAmount = 0;
                        if (criteriaTransactionMap != null
                                        && criteriaTransactionMap.containsKey(itemCriteriaPayout.getItemCriteria().getId())) {
                                saleAmount = criteriaTransactionMap.get(itemCriteriaPayout.getItemCriteria().getId());
                        }
                        itemCriteriaPayout.setAchievedValue(saleAmount);
                        List<com.spice.profitmandi.service.offers.PayoutSlab> payoutSlabs = itemCriteriaPayout.getPayoutSlabs();
                        for (int i = 0; i < payoutSlabs.size(); i++) {
                                com.spice.profitmandi.service.offers.PayoutSlab beginSlab = payoutSlabs.get(i);
                                com.spice.profitmandi.service.offers.PayoutSlab endSlab = null;
                                if (payoutSlabs.size() - 1 > i) {
                                        endSlab = payoutSlabs.get(i + 1);
                                }
                                if (beginSlab.getOnwardsAmount() > saleAmount) {
                                        itemCriteriaPayout.setShortValue(beginSlab.getOnwardsAmount() - saleAmount);
                                        itemCriteriaPayout.setNextSlab(beginSlab);
                                        LOGGER.info("I am here");
                                        break;
                                }
                                if (endSlab != null) {
                                        if (beginSlab.getOnwardsAmount() <= saleAmount && endSlab.getOnwardsAmount() > saleAmount) {
                                                itemCriteriaPayout.setCurrentSlab(beginSlab);
                                                beginSlab.setSelected(true);
                                                itemCriteriaPayout.setNextSlab(endSlab);
                                                itemCriteriaPayout.setShortValue(endSlab.getOnwardsAmount() - saleAmount);
                                                LOGGER.info("I am here");
                                                break;
                                        }
                                        // Last loop
                                } else {
                                        beginSlab.setSelected(true);
                                        itemCriteriaPayout.setCurrentSlab(beginSlab);
                                        LOGGER.info("I am here");
                                }
                        }
                        LOGGER.info("I am here --- {}", itemCriteriaPayout);
                }

        }

        @Override
        @Cacheable(value = "allOffers", cacheManager = "thirtyMinsTimeOutCacheManager")
        public Map<Integer, CreateOfferRequest> getAllOffers(YearMonth yearMonth) {
                List<Offer> allOffers = offerRepository.selectAll(yearMonth, false);
                List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
                for (Offer offer : allOffers) {
                        CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
                        createOfferRequests.add(createOfferRequest);
                }
                return createOfferRequests.stream().collect(Collectors.toMap(CreateOfferRequest::getId, x -> x));
        }

        @Override
        @Cacheable(value = "partnerOffers", cacheManager = "thirtyMinsTimeOutCacheManager")
        public CreateOfferRequest getOffer(int fofoId, int offerId) {
                Offer offer = offerRepository.selectById(offerId);
                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
                if (fofoId > 0) {
                        this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);
                }

                return createOfferRequest;
        }

        @Override
        public CreateOfferRequest getCreateOfferRequest(Offer fromOffer) {
                CreateOfferRequest createOfferRequest = new CreateOfferRequest();
                createOfferRequest.setName(fromOffer.getName());
                createOfferRequest.setTargetType(fromOffer.getTargetType());
                createOfferRequest.setPayoutType(fromOffer.getPayoutType());
                createOfferRequest.setSchemeType(fromOffer.getSchemeType());
                createOfferRequest.setActivationBrands(fromOffer.getActivationBrands());
                createOfferRequest.setEndDate(fromOffer.getEndDate());
                createOfferRequest.setStartDate(fromOffer.getStartDate());
                createOfferRequest.setBooster(fromOffer.isBooster());
                createOfferRequest.setActive(fromOffer.isActive());
                createOfferRequest.setSellinPercentage(fromOffer.getSellinPercentage());
                createOfferRequest.setBrandShareTerms(fromOffer.getBrandSharePercentage());
                createOfferRequest.setOfferNotes(fromOffer.getOfferNotes());
                createOfferRequest.setTerms(fromOffer.getTerms());
                createOfferRequest.setBaseCriteria(fromOffer.isBaseCriteia());
                createOfferRequest.setItemCriteria(
                                gson.fromJson(fromOffer.getItemCriteria(), com.spice.profitmandi.service.offers.ItemCriteria.class));
                createOfferRequest.setPartnerCriteria(gson.fromJson(fromOffer.getPartnerCriteria(), PartnerCriteria.class));
                createOfferRequest.setId(fromOffer.getId());
                createOfferRequest.setCreatedOn(fromOffer.getCreatedTimestamp());
                createOfferRequest.setItemCriteriaString(
                                itemCriteriaRepository.getItemCriteriaDescription(createOfferRequest.getItemCriteria()));
                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository
                                .getByOfferId(fromOffer.getId());
                createOfferRequest.setPartnerCriteriaString(
                                retailerService.getPartnerCriteriaString(createOfferRequest.getPartnerCriteria()));
                createOfferRequest.setTargetSlabs(targetSlabs);
                for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs()
                                .get(0).getItemCriteriaPayouts()) {
                        itemCriteriaPayout.setNextSlab(itemCriteriaPayout.getPayoutSlabs().get(0));
                }
                return createOfferRequest;

        }

        @Autowired
        private WalletService walletService;

        @Override
        public void reverseAdditionalSelloutSchemes(int fofoId, List<InventoryItem> inventoryItems) throws ProfitMandiBusinessException {
                List<OfferPayout> offerPayouts = new ArrayList<>();
                //As of now we are not handling non-serialised items
                inventoryItems = inventoryItems.stream().filter(x -> x.getSerialNumber() != null).collect(Collectors.toList());
                for (InventoryItem inventoryItem : inventoryItems) {
                        offerPayouts.addAll(offerPayoutRepository.selectAllBySerialNumber(inventoryItem.getFofoId(), inventoryItem.getSerialNumber())
                                        .stream()
                                        .filter(x -> x.getRejectTimestamp() != null)
                                        .collect(Collectors.toList()));
                }
                for (OfferPayout offerPayout : offerPayouts) {
                        offerPayout.setStatus(SchemePayoutStatus.REJECTED);
                        offerPayout.setRejectTimestamp(LocalDateTime.now());
                }
                Map<Long, Double> offerPayoutAmountMap = offerPayouts.stream().collect(Collectors.groupingBy(x -> x.getOfferId(), Collectors.summingDouble(x -> x.getAmount())));
                for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutAmountMap.entrySet()) {
                        walletService.rollbackAmountFromWallet(fofoId, offerPayoutEntry.getValue().floatValue(), offerPayoutEntry.getKey().intValue(),
                                        WalletReferenceType.ADDITIONAL_SCHEME, "Imeis for corresponding schemes are returned", LocalDateTime.now());
                }
        }

        private void createTargetSlabs(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {
                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs().stream()
                                .filter(x -> x.validate()).collect(Collectors.toList());
                if (targetSlabs.size() >= 0) {
                        Collections.sort(targetSlabs);
                        for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {
                                if (targetSlab.validate()) {
                                        List<ItemCriteriaPayout> itemCriteriaPayouts = targetSlab.getItemCriteriaPayouts();
                                        for (ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {
                                                ItemCriteria itemCriteria = itemCriteriaRepository.selectById(itemCriteriaPayout.getItemCriteria().getId());
                                                if (itemCriteriaPayout.getItemCriteria().getId() > 0) {
                                                        itemCriteriaPayout.getItemCriteria().setId(0);
                                                } else {

                                                        String itemCriteriaJson = gson.toJson(itemCriteriaPayout.getItemCriteria());
                                                        itemCriteria = itemCriteriaRepository.selectByCriteria(itemCriteriaJson);
                                                        // ItemCriteria Only once
                                                        if (itemCriteria == null) {
                                                                itemCriteria = new ItemCriteria();
                                                                itemCriteria.setCriteria(gson.toJson(itemCriteriaPayout.getItemCriteria()));
                                                                itemCriteriaRepository.persist(itemCriteria);
                                                        }
                                                }
                                                for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
                                                        TargetSlab targetSlab1 = new TargetSlab();
                                                        targetSlab1.setOfferId(createOfferRequest.getId());
                                                        targetSlab1.setOnwardsTarget(targetSlab.getOnwardsAmount());
                                                        targetSlab1.setTargetDescription(targetSlab.getTargetDescription());
                                                        targetSlab1.setPayoutTarget(payoutSlab.getOnwardsAmount());
                                                        targetSlab1.setPayoutValue(payoutSlab.getPayoutAmount());
                                                        targetSlab1.setItemCriteriaId(itemCriteria.getId());
                                                        targetSlab1.setAmountType(itemCriteriaPayout.getAmountType());
                                                        offerTargetSlabRepository.persist(targetSlab1);
                                                }
                                        }
                                }
                        }

                } else {
                        throw new ProfitMandiBusinessException("Invalid Target Slabs", "Invalid Target", "");
                }

        }

        @Override
        public List<CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, int catalogId) {
                List<Offer> publishedOffers = offerRepository.selectAllPublishedMapByPartner(YearMonth.from(date)).get(fofoId);
                List<CreateOfferRequest> createOfferRequests = new ArrayList<>();
                if (publishedOffers != null) {
                        for (Offer offer : publishedOffers) {
                                boolean found = false;
                                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository
                                                .getByOfferId(offer.getId());
                                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
                                createOfferRequest.setTargetSlabs(targetSlabs);
                                this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);
                                Set<com.spice.profitmandi.service.offers.ItemCriteria> itemCriteriaSet = targetSlabs.stream()
                                                .flatMap(x -> x.getItemCriteriaPayouts().stream()).map(x -> x.getItemCriteria()).distinct()
                                                .filter(x -> itemRepository.containsModel(x, catalogId)).collect(Collectors.toSet());

                                for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {
                                        targetSlab.setItemCriteriaPayouts(targetSlab.getItemCriteriaPayouts().stream()
                                                        .filter(x -> itemCriteriaSet.contains(x.getItemCriteria())).collect(Collectors.toList()));
                                        if (targetSlab.getItemCriteriaPayouts().size() > 0) {
                                                found = true;
                                        }
                                }
                                if (found) {
                                        createOfferRequests.add(createOfferRequest);
                                }
                        }
                }

                return createOfferRequests;
        }

        @Override
        public void createOffers(InputStream fileInputStream) throws Exception {
                Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = this.parseFromExcel(fileInputStream);
                for (Map.Entry<CreateOfferRequest, List<PartnerTargetModel>> partnerTargetEntry : offerPartnerTargetMap
                                .entrySet()) {
                        CreateOfferRequest createOfferRequest = partnerTargetEntry.getKey();
                        Map<List<Integer>, List<Integer>> targetPartnerMap = partnerTargetEntry.getValue().stream()
                                        .collect(Collectors.groupingBy(PartnerTargetModel::getTargets,
                                                        Collectors.mapping(PartnerTargetModel::getFofoId, Collectors.toList())));
                        for (Map.Entry<List<Integer>, List<Integer>> targetPartnersEntry : targetPartnerMap.entrySet()) {
                                List<Integer> fofoIds = createOfferRequest.getPartnerCriteria().getFofoIds();
                                List<Integer> filterFofoIds = targetPartnersEntry.getValue().stream().filter(x -> !fofoIds.contains(x))
                                                .collect(Collectors.toList());
                                LOGGER.info("FofoIds {}", filterFofoIds);
                                List<Integer> targets = targetPartnersEntry.getKey();
                                LOGGER.info("Targets  {}", targets);

                                createOfferRequest.getPartnerCriteria().setFofoIds(filterFofoIds);
                                int counter = 0;
                                List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0)
                                                .getItemCriteriaPayouts();
                                List<PayoutSlab> payoutSlabs = itemCriteriaPayouts.stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.toList());
                                for (PayoutSlab payoutSlab : payoutSlabs) {
                                        payoutSlab.setOnwardsAmount(targets.get(counter));
                                        counter++;
                                }
                                this.addOfferService(createOfferRequest);
                        }
                }
                thirtyMinsTimeOutCacheManager.getCache("allOffers").evict(YearMonth.now());

        }

        private Map<CreateOfferRequest, List<PartnerTargetModel>> parseFromExcel(InputStream inputStream)
                        throws ProfitMandiBusinessException {

                Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = new HashMap<>();
                XSSFWorkbook myWorkBook = null;
                try {
                        myWorkBook = new XSSFWorkbook(inputStream);
                        myWorkBook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);
                        for (int i = 0; i < myWorkBook.getNumberOfSheets(); i++) {

                                XSSFSheet mySheet = myWorkBook.getSheetAt(i);
                                int offerId = Integer.parseInt(mySheet.getSheetName());
                                CreateOfferRequest existingOffer = this.getOffer(0, offerId);
                                List<PartnerTargetModel> partnerTargetModels = new ArrayList<>();
                                offerPartnerTargetMap.put(existingOffer, partnerTargetModels);
                                this.printIterator(mySheet);
                                LOGGER.info("rowCellNum {}", mySheet.getLastRowNum());
                                for (int rowNumber = 1; rowNumber <= mySheet.getLastRowNum(); rowNumber++) {
                                        XSSFRow row = mySheet.getRow(rowNumber);
                                        LOGGER.info("row {}", row);
                                        PartnerTargetModel partnerTargetModel = new PartnerTargetModel();

                                        if (row.getCell(0) != null && row.getCell(0).getCellTypeEnum() == CellType.NUMERIC) {
                                                partnerTargetModel.setFofoId((int) row.getCell(0).getNumericCellValue());
                                        } else {
                                                ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(
                                                                "FOFO ID", row.getCell(0).toString(), "TGLSTNG_VE_1010");
                                                LOGGER.error("Excel file parse error : ", profitMandiBusinessException);
                                                throw profitMandiBusinessException;
                                        }
                                        List<Integer> targets = new ArrayList<>();
                                        long targetsSize = existingOffer.getTargetSlabs().get(0).getItemCriteriaPayouts().stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.counting());
                                        for (int cellNumber = 1; cellNumber <= targetsSize; cellNumber++) {
                                                if (row.getCell(cellNumber) != null
                                                                && row.getCell(cellNumber).getCellTypeEnum() == CellType.NUMERIC) {
                                                        targets.add((int) row.getCell(cellNumber).getNumericCellValue());
                                                } else {
                                                        ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(
                                                                        "Target Column issue at " + rowNumber + ", " + cellNumber, row.getCell(cellNumber),
                                                                        "Invalid target");
                                                        LOGGER.error("Excel file parse error : ", profitMandiBusinessException);
                                                        throw profitMandiBusinessException;
                                                }
                                        }
                                        partnerTargetModel.setTargets(targets);
                                        partnerTargetModels.add(partnerTargetModel);
                                }
                        }
                        myWorkBook.close();
                } catch (ProfitMandiBusinessException pbse) {
                        throw pbse;
                } catch (IOException ioException) {
                        ioException.printStackTrace();
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.EXCEL_FILE, ioException.getMessage(),
                                        "EXL_VE_1000");
                } finally {
                        if (myWorkBook != null) {
                                try {
                                        myWorkBook.close();
                                } catch (IOException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                }
                LOGGER.info("offerPartnerTargetMap {}", offerPartnerTargetMap);
                return offerPartnerTargetMap;
        }

        private void printIterator(XSSFSheet sheet) {
                Iterator<Row> rowIterator = sheet.iterator();
                while (rowIterator.hasNext()) {
                        Row row = rowIterator.next();
                        // For each row, iterate through all the columns
                        Iterator<Cell> cellIterator = row.cellIterator();

                        while (cellIterator.hasNext()) {
                                Cell cell = cellIterator.next();
                                // Check the cell type and format accordingly
                                switch (cell.getCellType()) {
                                        case Cell.CELL_TYPE_NUMERIC:
                                                System.out.print(cell.getNumericCellValue() + "t");
                                                break;
                                        case Cell.CELL_TYPE_STRING:
                                                System.out.print(cell.getStringCellValue() + "t");
                                                break;
                                }
                        }
                        System.out.println("");
                }
        }

        @Override
        public Map<Integer, CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, String brand) {
                // TODO Auto-generated method stub
                return null;
        }

        @Override
        @Cacheable(value = "slabPayoutMap", cacheManager = "oneDayCacheManager")
        public Map<Integer, Map<Integer, Long>> getSlabPayoutMap(CreateOfferRequest createOfferRequest) {
                Map<Integer, Map<Integer, Long>> catalogSlabPayoutMap = new HashMap<>();
                com.spice.profitmandi.dao.model.TargetSlab targetSlab = createOfferRequest.getTargetSlabs().get(0);
                List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();

                for (ItemCriteriaPayout itemCriteriaPayout : payouts) {
                        com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();
                        List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);
                        for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {
                                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {
                                        for (Integer catalogId : catalogIds) {
                                                if (!catalogSlabPayoutMap.containsKey(catalogId)) {
                                                        catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
                                                }
                                                catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
                                                                (long) payoutSlab.getPayoutAmount());
                                        }
                                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {
                                        for (Integer catalogId : catalogIds) {
                                                if (!catalogSlabPayoutMap.containsKey(catalogId)) {
                                                        catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());
                                                }
                                                catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),
                                                                (long) (payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount()));
                                        }
                                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {
                                        Map<Integer, TagListing> tagListingsMap = tagListingRepository.selectAllByCatalogIds(catalogIds);
                                        for (Map.Entry<Integer, TagListing> tagListingEntry : tagListingsMap.entrySet()) {
                                                TagListing tagListing = tagListingEntry.getValue();
                                                if (!catalogSlabPayoutMap.containsKey(tagListingEntry.getKey())) {
                                                        catalogSlabPayoutMap.put(tagListingEntry.getKey(), new LinkedHashMap<>());
                                                }
                                                catalogSlabPayoutMap.get(tagListingEntry.getKey()).put(payoutSlab.getOnwardsAmount(),
                                                                (long) (tagListing.getSellingPrice() * payoutSlab.getPayoutAmount() / 100));
                                        }
                                }
                        }
                }
                return catalogSlabPayoutMap;
        }

}