Subversion Repositories SmartDukaan

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 javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.query.Query;

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 SessionFactory sessionFactory;

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

			// Only consider inventory items that were not returned

			inventoryItems = inventoryItems.stream().filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD)

					&& !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());

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

		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 double getTotalMargin(int itemId, PartnerType partnerType, LocalDateTime dateTime) {

		Session session = sessionFactory.getCurrentSession();

		CriteriaBuilder cb = session.getCriteriaBuilder();

		CriteriaQuery<Double> criteriaQuery = cb.createQuery(Double.class);

		Root<SchemeItem> schemeItem = criteriaQuery.from(SchemeItem.class);

		Root<Scheme> scheme = criteriaQuery.from(Scheme.class);

		Predicate schemePredicate = cb.equal(scheme.get(ProfitMandiConstants.AMOUNT_TYPE), AmountType.PERCENTAGE);

		Predicate lessThanPredicate = cb.lessThanOrEqualTo(scheme.get(ProfitMandiConstants.END_DATE_TIME), dateTime);

		Predicate greaterThanPredicate = cb.greaterThanOrEqualTo(scheme.get(ProfitMandiConstants.START_DATE_TIME),

				dateTime);

		Predicate joinPredicate = cb.equal(scheme.get("id"), schemeItem.get("schemeId"));

		Predicate schemeItemPredicate = cb.equal(schemeItem.get(ProfitMandiConstants.ITEM_ID), itemId);

		criteriaQuery.select(cb.sum(scheme.get(ProfitMandiConstants.AMOUNT))).where(schemePredicate, lessThanPredicate,

				greaterThanPredicate, schemeItemPredicate, joinPredicate);

		Query<Double> query = session.createQuery(criteriaQuery);

		return query.getSingleResult() + ProfitMandiConstants.SCHEME_INVESTMENT_MARGIN;

	}

	/*

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

	 * 

	 * }

	 */

}