Subversion Repositories SmartDukaan

Rev

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

package com.spice.profitmandi.service.scheme;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import com.spice.profitmandi.common.enumuration.ItemType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.model.SchemeModel;
import com.spice.profitmandi.common.util.StringUtils;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.catalog.RetailerScheme;
import com.spice.profitmandi.dao.entity.catalog.Scheme;
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.entity.fofo.PartnerType;
import com.spice.profitmandi.dao.entity.fofo.Purchase;
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
import com.spice.profitmandi.dao.entity.fofo.SchemeItem;
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
import com.spice.profitmandi.dao.model.CreateSchemeRequest;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;
import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
import com.spice.profitmandi.service.authentication.RoleManager;
import com.spice.profitmandi.service.wallet.WalletService;

import in.shop2020.model.v1.order.WalletReferenceType;

@Component
public class SchemeServiceImpl implements SchemeService {

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

        @Autowired
        @Qualifier("fofoInventoryItemRepository")
        private InventoryItemRepository inventoryItemRepository;

        @Autowired
        private PartnerTypeChangeService partnerTypeChangeService;

        @Autowired
        private ScanRecordRepository scanRecordRepository;

        @Autowired
        private SchemeRepository schemeRepository;

        @Autowired
        private RoleManager roleManager;

        @Autowired
        private RetailerRepository retailerRepository;

        @Autowired
        private TagListingRepository tagListingRepository;

        @Autowired
        private SchemeInOutRepository schemeInOutRepository;

        @Autowired
        @Qualifier("catalogItemRepository")
        private ItemRepository itemRepository;

        @Autowired
        private SchemeItemRepository schemeItemRepository;

        @Autowired
        private WalletService walletService;

        @Autowired
        private FofoOrderItemRepository fofoOrderItemRepository;

        @Autowired
        private FofoLineItemRepository fofoLineItemRepository;

        @Autowired
        private PurchaseRepository purchaseRepository;

        @Autowired
        private FofoOrderRepository fofoOrderRepository;

        @Override
        public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

                this.validateCreateSchemeRequest(createSchemeRequest);

                Scheme scheme = this.toScheme(creatorId, createSchemeRequest);

                if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {
                        throw new ProfitMandiBusinessException(
                                        ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,
                                        scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
                }

                //this.validateItemIds(createSchemeRequest);
                schemeRepository.persist(scheme);
                for (int itemId : createSchemeRequest.getItemIds()) {
                        SchemeItem schemeItem = new SchemeItem();
                        schemeItem.setSchemeId(scheme.getId());
                        schemeItem.setItemId(itemId);
                        schemeItemRepository.persist(schemeItem);
                }

        }

        private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)
                        throws ProfitMandiBusinessException {
                if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),
                                        "SCHM_VE_1000");
                }
                if (createSchemeRequest.getAmount() <= 0) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
                                        "SCHM_VE_1001");
                }

                if (createSchemeRequest.getAmountType().equals(AmountType.PERCENTAGE)
                                && createSchemeRequest.getAmount() > 100) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
                                        "SCHM_VE_1002");
                }

                if (createSchemeRequest.getStartDate() == null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDate(),
                                        "SCHM_VE_1003");
                }
                if (createSchemeRequest.getEndDate() == null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDate(),
                                        "SCHM_VE_1004");
                }
        }

        private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {
                Scheme scheme = new Scheme();
                scheme.setName(createSchemeRequest.getName());
                scheme.setDescription(createSchemeRequest.getDescription());
                scheme.setType(createSchemeRequest.getType());
                scheme.setAmountType(createSchemeRequest.getAmountType());
                scheme.setAmount(createSchemeRequest.getAmount());
                scheme.setPartnerType(createSchemeRequest.getPartnerType());
                scheme.setStartDateTime(createSchemeRequest.getStartDate());
                scheme.setEndDateTime(createSchemeRequest.getEndDate());
                scheme.setCreatedBy(creatorId);
                return scheme;
        }

        private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
                if (createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
                                        "SCHM_1003");
                }
                List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(),
                                ItemType.SERIALIZED);
                if (foundItemIds.size() != createSchemeRequest.getItemIds().size()) {
                        createSchemeRequest.getItemIds().removeAll(foundItemIds);
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
                                        "SCHM_1004");
                }
        }

        @Override
        public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
                Scheme scheme = schemeRepository.selectById(schemeId);
                List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
                if (itemIds.size() > 0) {
                        List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
                        scheme.setItemStringMap(this.toItemStringMap(items));
                }
                return scheme;
        }

        public Map<Integer, String> toItemStringMap(List<Item> items) {
                Map<Integer, String> itemMap = new HashMap<>();
                for (Item item : items) {
                        itemMap.put(item.getId(), this.getItemString(item));
                }
                return itemMap;
        }

        public String getItemString(Item item) {
                StringBuilder itemString = new StringBuilder();
                if (item.getBrand() != null && !item.getBrand().isEmpty()) {
                        itemString.append(item.getBrand().trim());
                }
                itemString.append(" ");
                if (item.getModelName() != null && !item.getModelName().isEmpty()) {
                        itemString.append(item.getModelName().trim());
                }
                itemString.append(" ");
                if (item.getModelNumber() != null && !item.getModelNumber().isEmpty()) {
                        itemString.append(item.getModelNumber().trim());
                }
                itemString.append(" ");
                if (item.getColor() != null && !item.getColor().isEmpty()) {
                        itemString.append(item.getColor().trim());
                }
                return itemString.toString();
        }

        private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems) {
                Set<Integer> itemIds = new HashSet<>();
                for (SchemeItem schemeItem : schemeItems) {
                        itemIds.add(schemeItem.getItemId());
                }
                return itemIds;
        }

        @Override
        public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
                List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
                Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
                List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
                Set<Integer> itemIds = this.schemeItemsToItemIds(schemeItems);
                List<Item> items = itemRepository.selectByIds(itemIds);
                Map<Integer, String> itemStringMap = this.toItemStringMap(items);
                this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
                return this.toSchemeModels(schemeIdSchemeMap);
        }

        private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
                        Map<Integer, String> itemStringMap) {
                for (SchemeItem schemeItem : schemeItems) {
                        schemeIdSchemeMap.get(schemeItem.getSchemeId()).getItemStringMap().put(schemeItem.getItemId(),
                                        itemStringMap.get(schemeItem.getItemId()));
                }
        }

        private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap) {
                for (RetailerScheme retailerScheme : retailerSchemes) {
                        schemeIdSchemeMap.get(retailerScheme.getSchemeId()).getRetailerIds().add(retailerScheme.getRetailerId());
                }
        }

        private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {
                List<SchemeModel> schemeModels = new ArrayList<>();
                for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {
                        schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
                }
                return schemeModels;
        }

        private SchemeModel toSchemeModel(Scheme scheme) {
                SchemeModel schemeModel = new SchemeModel();
                schemeModel.setSchemeId(scheme.getId());
                schemeModel.setName(scheme.getName());
                schemeModel.setDescription(scheme.getDescription());
                schemeModel.setSchemeType(scheme.getType().toString());
                schemeModel.setAmountType(scheme.getAmountType().toString());
                schemeModel.setAmount(scheme.getAmount());
                schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));
                schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));
                schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));
                schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));
                schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));
                schemeModel.setCreatedBy(scheme.getCreatedBy());
                schemeModel.setItemStringMap(scheme.getItemStringMap());
                schemeModel.setRetailerIds(scheme.getRetailerIds());
                return schemeModel;
        }

        @Override
        public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
                Scheme scheme = schemeRepository.selectById(schemeId);
                if (scheme.getActiveTimestamp() != null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
                                        "SCHM_1005");
                }
                if (scheme.getExpireTimestamp() != null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
                                        "SCHM_1006");
                }
                scheme.setActiveTimestamp(LocalDateTime.now());
                schemeRepository.persist(scheme);
                /*
                 * if (scheme.getType() == SchemeType.IN) {
                 * this.processPreviousPurchases(scheme); } else if (scheme.getType() ==
                 * SchemeType.OUT) { this.processPreviousSales(scheme); }
                 */
        }

        @Override
        public void expireSchemeById(int schemeId, LocalDateTime expiryTime) throws ProfitMandiBusinessException {
                Scheme scheme = schemeRepository.selectById(schemeId);
                if (scheme == null || scheme.getActiveTimestamp() == null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
                                        "SCHM_1007");
                }
                if (scheme.getExpireTimestamp() != null) {
                        throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
                                        "SCHM_1008");
                }
                scheme.setExpireTimestamp(LocalDateTime.now());
                scheme.setEndDateTime(expiryTime);
                schemeRepository.persist(scheme);
        }

        private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {
                Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
                for (Scheme scheme : schemes) {
                        schemeIdSchemeMap.put(scheme.getId(), scheme);
                }
                return schemeIdSchemeMap;
        }

        private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems) {
                Set<Integer> itemIds = new HashSet<>();
                for (InventoryItem inventoryItem : inventoryItems) {
                        itemIds.add(inventoryItem.getItemId());
                }
                return itemIds;
        }

        private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
                Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
                Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
                for (SchemeItem schemeItem : schemeItems) {
                        if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {
                                Set<Scheme> schemesSet = new HashSet<>();
                                schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
                                itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
                        } else {
                                itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
                        }
                }
                return itemIdSchemesMap;
        }

        private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,
                        List<InventoryItem> inventoryItems) {
                Set<Integer> schemeIds = new HashSet<>();
                for (Scheme scheme : schemes) {
                        schemeIds.add(scheme.getId());
                }
                Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
                List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);

                Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
                Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
                for (InventoryItem inventoryItem : inventoryItems) {
                        if (itemIdSchemesMap.containsKey(inventoryItem.getItemId())) {
                                inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
                        }
                }
                return inventoryItemSchemsMap;
        }

        @Override
        public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
                LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
                Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,
                                purchase.getCreateTimestamp().toLocalDate());
                LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
                if (purchase.getCompleteTimestamp() != null) {
                        List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, partnerType,
                                        purchase.getCompleteTimestamp());
                        float totalCashback = 0;
                        if (schemes.isEmpty()) {
                                return;
                        }
                        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
                        inventoryItems.stream().filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD)
                                        && !x.getLastScanType().equals(ScanType.PURCHASE_RET));
                        LOGGER.info(inventoryItems);
                        if (inventoryItems.size() == 0)
                                return;
                        Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,
                                        inventoryItems);

                        if (inventoryItemSchemesMap.isEmpty()) {
                                return;
                        }
                        Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
                        Set<Integer> itemIds = new HashSet<>();

                        for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
                                Set<Scheme> allSchemes = new HashSet<>();
                                for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
                                        allSchemes.add(scheme);
                                }
                                allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
                                itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());
                        }

                        int itemsCount = 0;
                        for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
                                        .entrySet()) {
                                float inventoryItemCashback = 0;
                                for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
                                        InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
                                        float cashback = this.createSchemeInOut(scheme, inventoryItem);
                                        inventoryItemCashback += cashback;
                                }
                                if (inventoryItemCashback > 0) {
                                        totalCashback += inventoryItemCashback;
                                        itemsCount++;
                                }
                        }

                        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
                        if (itemsCount > 0) {
                                walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,
                                                "Added for SCHEME IN against invoice " + purchase.getPurchaseReference() + " (total "
                                                                + itemsCount + " pcs)",
                                                totalCashback);
                                LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
                                                purchase.getPurchaseReference(), itemsCount);
                                purchase.setCashback(purchase.getCashback() + totalCashback);
                                purchaseRepository.persist(purchase);
                        }
                }
        }

        private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem) {
                List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
                float amount = 0;
                if (schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null).collect(Collectors.toList())
                                .size() == 0) {
                        SchemeInOut schemeInOut = new SchemeInOut();
                        amount = this.getAmount(inventoryItem, scheme);
                        schemeInOut.setSchemeId(scheme.getId());
                        schemeInOut.setInventoryItemId(inventoryItem.getId());
                        schemeInOut.setAmount(amount);
                        schemeInOutRepository.persist(schemeInOut);
                }
                return amount;
        }

        // We are maintaining price drop after grn
        private float getAmount(InventoryItem inventoryItem, Scheme scheme) {
                float amount = 0;
                float dpForCalc = 0;
                float taxableSellingPrice = 0;
                float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
                if (scheme.getAmountType() == AmountType.PERCENTAGE) {
                        if (scheme.getType().equals(SchemeType.IN)) {
                                dpForCalc = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
                        } else {
                                try {
                                        dpForCalc = tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice();
                                } catch (Exception e) {
                                        LOGGER.info("Could not find tag Listing entry in {}", inventoryItem.getItemId());
                                        e.printStackTrace();
                                }
                        }
                        taxableSellingPrice = dpForCalc / (1 + totalTaxRate / 100);
                        amount = taxableSellingPrice * scheme.getAmount() / 100;
                        System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%s\t%f\t%f\t%f\t%f", inventoryItem.getId(),
                                        inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),
                                        scheme.getType(), scheme.getAmountType(), scheme.getPartnerType(), dpForCalc, taxableSellingPrice, scheme.getAmount(),
                                        amount));
                } else {
                        amount = scheme.getAmount();
                        System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%s\t%f\t%f\t%d\t%f", inventoryItem.getId(),
                                        inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),
                                        scheme.getType(), scheme.getAmountType(), scheme.getPartnerType(), dpForCalc, taxableSellingPrice, 0, amount));
                }

                return amount;
        }

        @Override
        public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
                FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);

                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,
                                fofoOrder.getCreateTimestamp().toLocalDate());

                List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);
                Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())
                                .collect(Collectors.toSet());
                Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
                                .filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))
                                .collect(Collectors.toSet());

                if (inventoryItems.size() == 0) {
                        return;
                }

                float totalCashback = 0;
                int count = 0;

                Set<Scheme> allFixedSchemes = schemeRepository
                                .selectActiveAll(SchemeType.OUT, partnerType, fofoOrder.getCreateTimestamp()).stream()
                                .filter(scheme -> scheme.getAmountType().equals(AmountType.FIXED)).collect(Collectors.toSet());

                for (InventoryItem inventoryItem : inventoryItems) {
                        float itemCashback = 0;
                        Purchase purchase = purchaseRepository.selectByIdAndFofoId(inventoryItem.getPurchaseId(), retailerId);
                        Set<Integer> schemeIds = new HashSet<>(
                                        schemeItemRepository.selectSchemeIdByItemId(inventoryItem.getItemId()));
                        List<Scheme> schemes = null;
                        if(purchase.getCompleteTimestamp()==null) {
                                continue;
                        }
                        if (purchase.getCompleteTimestamp().isAfter(LocalDate.of(2019, 9, 1).atStartOfDay())) {
                                schemes = schemeRepository.selectActiveAll(SchemeType.OUT, partnerType, fofoOrder.getCreateTimestamp());
                        } else {
                                schemes = schemeRepository.selectActiveAll(SchemeType.OUT, partnerType,
                                                purchase.getCompleteTimestamp());
                        }
                        Set<Scheme> schemesSet = schemes.stream().filter(x -> x.getAmountType().equals(AmountType.PERCENTAGE))
                                        .collect(Collectors.toSet());
                        schemesSet.addAll(allFixedSchemes);
                        schemesSet = schemesSet.stream().filter(x -> schemeIds.contains(x.getId())).collect(Collectors.toSet());
                        for (Scheme scheme : schemesSet) {
                                itemCashback += this.createSchemeInOut(scheme, inventoryItem);
                        }
                        if (itemCashback > 0) {
                                count++;
                                totalCashback += itemCashback;
                        }
                }
                if (count > 0) {
                        walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT,
                                        "Sales margin for invoice number " + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",
                                        totalCashback);
                        fofoOrder.setCashback(totalCashback);
                        fofoOrderRepository.persist(fofoOrder);
                }
        }

        @Override
        public void rollbackSchemes(List<Integer> inventoryItemIds, int rollbackReference, String rollbackReason)
                        throws Exception {
                Set<Integer> inventoryItemIdSet = new HashSet<>(inventoryItemIds);
                float amountToRollback = 0;
                List<SchemeInOut> schemes = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIdSet);
                for (SchemeInOut schemeInOut : schemes) {
                        if (schemeInOut.getRolledBackTimestamp() == null) {
                                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
                                schemeInOutRepository.persist(schemeInOut);
                                amountToRollback += schemeInOut.getAmount();
                        }
                }
                if (amountToRollback > 0) {
                        int inventoryItemId = inventoryItemIds.get(0);
                        Integer fofoId = inventoryItemRepository.selectById(inventoryItemId).getFofoId();
                        walletService.rollbackAmountFromWallet(fofoId, amountToRollback, rollbackReference,
                                        WalletReferenceType.SCHEME_IN, rollbackReason);
                }
        }

        @Override
        public Map<String, Object> getSchemes(Set<Integer> roleIds, int offset, int limit)
                        throws ProfitMandiBusinessException {
                Map<String, Object> map = new HashMap<>();
                List<Scheme> schemes = null;
                long size = 0;
                if (roleManager.isAdmin(roleIds)) {
                        schemes = schemeRepository.selectAll(offset, limit);
                        size = schemeRepository.selectAllCount();
                } else {
                        schemes = schemeRepository.selectActiveAll(offset, limit);
                        size = schemeRepository.selectAllActiveCount();
                }
                map.put("schemes", schemes);
                map.put("start", offset + 1);
                map.put("size", size);
                if (schemes.size() < limit) {
                        map.put("end", offset + schemes.size());
                } else {
                        map.put("end", offset + limit);
                }
                return map;
        }

        @Override
        public List<Scheme> getPaginatedSchemes(Set<Integer> roleIds, int offset, int limit)
                        throws ProfitMandiBusinessException {
                LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);
                List<Scheme> schemes = null;
                if (roleManager.isAdmin(roleIds)) {
                        schemes = schemeRepository.selectAll(offset, limit);
                } else {
                        schemes = schemeRepository.selectActiveAll(offset, limit);
                }
                return schemes;
        }

        @Override
        public void reverseSchemes(List<InventoryItem> inventoryItems, int priceDropId, String reversalReason)
                        throws Exception {

                Map<Integer, List<InventoryItem>> purchaseInventoryListMap = inventoryItems.stream()
                                .collect(Collectors.groupingBy(InventoryItem::getPurchaseId, Collectors.toList()));

                for (Map.Entry<Integer, List<InventoryItem>> purchaseEntry : purchaseInventoryListMap.entrySet()) {
                        float amountToCredit = 0;
                        float amountToDebit = 0;
                        int purchaseId = purchaseEntry.getKey();
                        List<InventoryItem> purchaseInventoryItemList = purchaseEntry.getValue();

                        Map<Integer, InventoryItem> inventoryItemsMap = purchaseInventoryItemList.stream()
                                        .collect(Collectors.toMap(x -> x.getId(), x -> x));

                        List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
                        List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
                        Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())
                                        .stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
                        for (SchemeInOut schemeInOut : schemeInOuts) {
                                InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());
                                Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
                                if (scheme.getType().equals(SchemeType.OUT))
                                        continue;
                                if (scheme.getAmountType().equals(AmountType.FIXED)) {
                                        continue;
                                }
                                if (schemeInOut.getRolledBackTimestamp() == null) {
                                        float newAmount = getAmount(ii, scheme);
                                        if (schemeInOut.getAmount() - newAmount >= 0.01f) {
                                                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
                                                schemeInOutRepository.persist(schemeInOut);
                                                SchemeInOut sioNew = new SchemeInOut();
                                                sioNew.setAmount(newAmount);
                                                sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());
                                                sioNew.setSchemeId(schemeInOut.getSchemeId());
                                                schemeInOutRepository.persist(sioNew);
                                                amountToCredit += sioNew.getAmount();
                                                amountToDebit += schemeInOut.getAmount();
                                        }

                                }
                        }
                        int fofoId = inventoryItems.get(0).getFofoId();
                        if (amountToDebit > 0) {
                                walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN, reversalReason,
                                                -amountToDebit);
                        }
                        if (amountToCredit > 0) {
                                walletService.addAmountToWallet(fofoId, purchaseId, WalletReferenceType.SCHEME_IN, reversalReason,
                                                amountToCredit);
                        }
                }
        }

        @Override
        public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason,
                        SchemeType schemeType) throws ProfitMandiBusinessException {
                Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()
                                .collect(Collectors.toMap(x -> x.getId(), x -> x));
                List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
                List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
                float amount = 0;
                Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size()).stream()
                                .collect(Collectors.toMap(x -> x.getId(), x -> x));
                for (SchemeInOut schemeInOut : schemeInOuts) {
                        Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
                        if (scheme.getType().equals(schemeType)) {
                                if (schemeInOut.getRolledBackTimestamp() == null) {
                                        schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
                                        schemeInOutRepository.persist(schemeInOut);
                                        amount += schemeInOut.getAmount();
                                }
                        }
                }
                int fofoId = inventoryItems.get(0).getFofoId();
                WalletReferenceType walletReferenceType = schemeType.equals(SchemeType.OUT) ? WalletReferenceType.SCHEME_OUT
                                : WalletReferenceType.SCHEME_IN;
                if (amount > 0) {
                        walletService.rollbackAmountFromWallet(fofoId, amount, reversalReference, walletReferenceType,
                                        reversalReason);
                }
        }

        /*
         * @Override public void updateSchmesForModel(int catalogId) throws
         * ProfitMandiBusinessException { List<Item> items =
         * itemRepository.selectAllByCatalogItemId(catalogId); Map<Integer, Scheme>
         * schemes = schemeRepository .selectAllByItemIds(items.stream().map(x ->
         * x.getId()).collect(Collectors.toList()));
         * 
         * }
         */

}