Subversion Repositories SmartDukaan

Rev

Rev 29686 | Rev 29785 | 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 java.io.IOException;
import java.io.InputStream;
import java.time.LocalDate;
import java.time.YearMonth;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

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.annotation.Cacheable;
import org.springframework.stereotype.Component;

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.enumuration.catalog.AmountType;
import com.spice.profitmandi.dao.enumuration.catalog.OfferSchemeType;
import com.spice.profitmandi.dao.model.CreateOfferRequest;
import com.spice.profitmandi.dao.model.ItemCriteriaPayout;
import com.spice.profitmandi.dao.repository.catalog.ItemCriteriaRepository;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.OfferRepository;
import com.spice.profitmandi.dao.repository.catalog.OfferTargetSlabRepository;
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
import com.spice.profitmandi.service.user.RetailerService;

@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
        private ItemCriteriaRepository itemCriteriaRepository;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private TagListingRepository tagListingRepository;

        @Autowired
        private OfferTargetSlabRepository targetSlabRepository;

        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.setPayoutType(createOfferRequest.getPayoutType());
                offer.setSchemeType(createOfferRequest.getSchemeType());
                offer.setIncrementalTarget(createOfferRequest.isIncrementalTarget());
                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;
        }

        private 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.setActive(fromOffer.isActive());
                createOfferRequest.setSellinPercentage(fromOffer.getSellinPercentage());
                createOfferRequest.setBrandShareTerms(fromOffer.getBrandSharePercentage());
                createOfferRequest.setOfferNotes(fromOffer.getOfferNotes());
                createOfferRequest.setTerms(fromOffer.getTerms());
                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 = targetSlabRepository
                                .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;

        }

        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) {
                                                String itemCriteriaJson = gson.toJson(itemCriteriaPayout.getItemCriteria());
                                                ItemCriteria 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());
                                                        targetSlabRepository.persist(targetSlab1);
                                                }
                                        }
                                }
                        }

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

        }

        @Override
        public List<CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, int itemId) {
                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 = targetSlabRepository
                                                .getByOfferId(offer.getId());
                                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);
                                createOfferRequest.setTargetSlabs(targetSlabs);
                                Set<com.spice.profitmandi.service.offers.ItemCriteria> itemCriteriaSet = targetSlabs.stream()
                                                .flatMap(x -> x.getItemCriteriaPayouts().stream()).map(x -> x.getItemCriteria()).distinct()
                                                .filter(x -> itemRepository.containsItem(x, itemId)).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());
                                List<Integer> targets = targetPartnersEntry.getKey();

                                createOfferRequest.getPartnerCriteria().setFofoIds(filterFofoIds);
                                int counter = 0;
                                ItemCriteriaPayout itemCriteriaPayout = createOfferRequest.getTargetSlabs().get(0)
                                                .getItemCriteriaPayouts().get(0);
                                for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {
                                        payoutSlab.setOnwardsAmount(targets.get(counter));
                                        counter++;
                                }
                        }
                        this.addOfferService(createOfferRequest);
                }
        }

        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<>();
                                        for (int cellNumber = 1; cellNumber <= existingOffer.getTargetSlabs().size(); 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 = "thirtyMinsTimeOutCacheManager")
        public Map<Integer, Map<Integer, Long>> getSlabPayoutMap(CreateOfferRequest createOfferRequest) {
                Map<Integer, Map<Integer, Long>> itemSlabPayoutMap = new HashMap<>();
                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs();
                com.spice.profitmandi.dao.model.TargetSlab targetSlab = targetSlabs.get(0);
                List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();
                for (ItemCriteriaPayout itemCriteriaPayout : payouts) {
                        com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();
                        List<Integer> itemIds = itemRepository.getItems(itemCriteria);
                        for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {
                                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {
                                        for (Integer itemId : itemIds) {
                                                if (!itemSlabPayoutMap.containsKey(itemId)) {
                                                        itemSlabPayoutMap.put(itemId, new LinkedHashMap<>());
                                                }
                                                itemSlabPayoutMap.get(itemId).put(payoutSlab.getOnwardsAmount(),
                                                                (long) payoutSlab.getPayoutAmount());
                                        }
                                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {
                                        for (Integer itemId : itemIds) {
                                                if (!itemSlabPayoutMap.containsKey(itemId)) {
                                                        itemSlabPayoutMap.put(itemId, new LinkedHashMap<>());
                                                }
                                                itemSlabPayoutMap.get(itemId).put(payoutSlab.getOnwardsAmount(),
                                                                (long) (payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount()));
                                        }
                                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {
                                        List<TagListing> tagListings = tagListingRepository.selectByItemIdsAndTagIds(new HashSet<>(itemIds),
                                                        null);
                                        for (TagListing tagListing : tagListings) {
                                                float taxableSellingPrice = tagListing.getSellingPrice() / (1 + 18f / 100);
                                                if (!itemSlabPayoutMap.containsKey(tagListing.getItemId())) {
                                                        itemSlabPayoutMap.put(tagListing.getItemId(), new LinkedHashMap<>());
                                                }
                                                itemSlabPayoutMap.get(tagListing.getItemId()).put(payoutSlab.getOnwardsAmount(),
                                                                (long) (taxableSellingPrice * payoutSlab.getPayoutAmount() / 100));
                                        }
                                }
                        }
                }
                return itemSlabPayoutMap;
        }

}