Subversion Repositories SmartDukaan

Rev

Rev 31747 | Rev 31750 | 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.entity.fofo.Purchase;
import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
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.dao.repository.fofo.PurchaseRepository;
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);
    private PurchaseRepository purchaseRepository;

    @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.setProcessTimestamp(fromOffer.getProcessedTimestamp());
        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<>();
        LOGGER.info("Reversing schemes for fofoId {}, InventoryItems {}", fofoId, inventoryItems);
        //As of now we are not handling non-serialised items
        inventoryItems = inventoryItems.stream().filter(x -> x.getSerialNumber() != null).collect(Collectors.toList());
        Purchase purchase = purchaseRepository.selectById(inventoryItems.get(0).getPurchaseId());
        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()) {
            List<UserWalletHistory> histories = walletService.getAllByReference(fofoId, offerPayoutEntry.getKey().intValue(), WalletReferenceType.ADDITIONAL_SCHEME);
            if (histories.size() > 0) {

                walletService.rollbackAmountFromWallet(fofoId, offerPayoutEntry.getValue().floatValue(), offerPayoutEntry.getKey().intValue(),
                        WalletReferenceType.ADDITIONAL_SCHEME, "Models/Imeis for corresponding schemes were 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;
    }

}