Subversion Repositories SmartDukaan

Rev

Rev 23378 | Rev 23444 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
22653 ashik.ali 1 
package com.spice.profitmandi.service.scheme;
2 
 
22859 ashik.ali 3 
import java.time.LocalDateTime;
23019 ashik.ali 4 
import java.util.ArrayList;
22653 ashik.ali 5 
import java.util.HashMap;
22859 ashik.ali 6 
import java.util.HashSet;
22653 ashik.ali 7 
import java.util.List;
8 
import java.util.Map;
9 
import java.util.Set;
10 
 
22859 ashik.ali 11 
import org.slf4j.Logger;
12 
import org.slf4j.LoggerFactory;
22653 ashik.ali 13 
import org.springframework.beans.factory.annotation.Autowired;
14 
import org.springframework.stereotype.Component;
15 
 
22859 ashik.ali 16 
import com.spice.profitmandi.common.enumuration.DateTimePattern;
22653 ashik.ali 17 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
22859 ashik.ali 18 
import com.spice.profitmandi.common.model.CreateSchemeRequest;
22653 ashik.ali 19 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
23019 ashik.ali 20 
import com.spice.profitmandi.common.model.SchemeModel;
22859 ashik.ali 21 
import com.spice.profitmandi.common.util.StringUtils;
23339 ashik.ali 22 
import com.spice.profitmandi.dao.entity.catalog.Item;
22653 ashik.ali 23 
import com.spice.profitmandi.dao.entity.catalog.RetailerScheme;
24 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
25 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
23365 ashik.ali 26 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
22859 ashik.ali 27 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
22653 ashik.ali 28 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
23339 ashik.ali 29 
import com.spice.profitmandi.dao.entity.fofo.Purchase;
22859 ashik.ali 30 
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
31 
import com.spice.profitmandi.dao.entity.fofo.SchemeItem;
23344 ashik.ali 32 
import com.spice.profitmandi.dao.entity.transaction.Order;
22653 ashik.ali 33 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeAmountType;
34 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
22859 ashik.ali 35 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
22653 ashik.ali 36 
import com.spice.profitmandi.dao.repository.catalog.RetailerSchemeRepository;
37 
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
22859 ashik.ali 38 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
23019 ashik.ali 39 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
40 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
23365 ashik.ali 41 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
22653 ashik.ali 42 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
23339 ashik.ali 43 
import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
22859 ashik.ali 44 
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
45 
import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
23344 ashik.ali 46 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
23365 ashik.ali 47 
import com.spice.profitmandi.service.order.OrderService;
22859 ashik.ali 48 
import com.spice.profitmandi.service.wallet.WalletService;
22653 ashik.ali 49 
 
22859 ashik.ali 50 
import in.shop2020.model.v1.catalog.ItemType;
51 
import in.shop2020.model.v1.order.WalletReferenceType;
52 
 
22653 ashik.ali 53 
@Component
54 
public class SchemeServiceImpl implements SchemeService {
55 
 
22859 ashik.ali 56 
	private static final Logger LOGGER = LoggerFactory.getLogger(SchemeServiceImpl.class);
57 
 
22653 ashik.ali 58 
	@Autowired
59 
	private InventoryItemRepository inventoryItemRepository;
60 
 
61 
	@Autowired
22925 ashik.ali 62 
	private OrderService orderService;
22653 ashik.ali 63 
 
64 
	@Autowired
65 
	private SchemeRepository schemeRepository;
66 
 
67 
	@Autowired
22859 ashik.ali 68 
	private RetailerRepository retailerRepository;
69 
 
70 
	@Autowired
22653 ashik.ali 71 
	private RetailerSchemeRepository retailerSchemeRepository;
72 
 
73 
	@Autowired
22859 ashik.ali 74 
	private SchemeInOutRepository schemeInOutRepository;
22653 ashik.ali 75 
 
76 
	@Autowired
22859 ashik.ali 77 
	private ItemRepository itemRepository;
22653 ashik.ali 78 
 
22859 ashik.ali 79 
	@Autowired
80 
	private SchemeItemRepository schemeItemRepository;
81 
 
82 
	@Autowired
83 
	private WalletService walletService;
84 
 
23019 ashik.ali 85 
	@Autowired
86 
	private FofoOrderItemRepository fofoOrderItemRepository;
87 
 
88 
	@Autowired
89 
	private FofoLineItemRepository fofoLineItemRepository;
90 
 
23339 ashik.ali 91 
	@Autowired
92 
	private PurchaseRepository purchaseRepository;
93 
 
23344 ashik.ali 94 
	@Autowired
95 
	private OrderRepository orderRepository;
96 
 
23365 ashik.ali 97 
	@Autowired
98 
	private FofoOrderRepository fofoOrderRepository;
99 
 
22653 ashik.ali 100 
	@Override
22859 ashik.ali 101 
	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
102 
 
23019 ashik.ali 103 
		this.validateCreateSchemeRequest(createSchemeRequest);
22653 ashik.ali 104 
 
22859 ashik.ali 105 
		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
106 
 
23019 ashik.ali 107 
		if(scheme.getStartDateTime().isAfter(scheme.getEndDateTime())){
108 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE, scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
22653 ashik.ali 109 
		}
110 
 
22859 ashik.ali 111 
		this.validateItemIds(createSchemeRequest);
112 
		schemeRepository.persist(scheme);
113 
		if(!createSchemeRequest.isRetailerAll()){
114 
			this.validateRetailerIds(createSchemeRequest);
115 
			for(int retailerId : createSchemeRequest.getRetailerIds()){
116 
				RetailerScheme retailerScheme = new RetailerScheme();
117 
				retailerScheme.setRetailerId(retailerId);
118 
				retailerScheme.setSchemeId(scheme.getId());
119 
				retailerSchemeRepository.persist(retailerScheme);
120 
			}
22653 ashik.ali 121 
		}
22859 ashik.ali 122 
		for(int itemId : createSchemeRequest.getItemIds()){
123 
			SchemeItem schemeItem = new SchemeItem();
124 
			schemeItem.setSchemeId(scheme.getId());
125 
			schemeItem.setItemId(itemId);
126 
			schemeItemRepository.persist(schemeItem);
127 
		}
128 
 
22653 ashik.ali 129 
	}
22859 ashik.ali 130 
 
23019 ashik.ali 131 
	private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
132 
		if(createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()){
133 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(), "SCHM_VE_1000");
134 
		}
135 
		if(createSchemeRequest.getAmount() <= 0){
136 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "SCHM_VE_1001");
137 
		}
138 
 
139 
		if(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()) == SchemeAmountType.PERCENTAGE && createSchemeRequest.getAmount() > 100){
140 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "SCHM_VE_1002");
141 
		}
142 
 
143 
		if(createSchemeRequest.getStartDateTimeString() == null || createSchemeRequest.getStartDateTimeString().isEmpty()){
144 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDateTimeString(), "SCHM_VE_1003");
145 
		}
146 
 
147 
		if(createSchemeRequest.getEndDateTimeString() == null || createSchemeRequest.getStartDateTimeString().isEmpty()){
148 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDateTimeString(), "SCHM_VE_1004");
149 
		}
150 
	}
151 
 
22859 ashik.ali 152 
	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest){
153 
		Scheme scheme = new Scheme();
154 
		scheme.setName(createSchemeRequest.getName());
155 
		scheme.setDescription(createSchemeRequest.getDescription());
156 
		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));
157 
		scheme.setAmountType(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()));
158 
		scheme.setAmount(createSchemeRequest.getAmount());
23019 ashik.ali 159 
		scheme.setStartDateTime(StringUtils.toDateTime(createSchemeRequest.getStartDateTimeString(), DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
160 
		scheme.setEndDateTime(StringUtils.toDateTime(createSchemeRequest.getEndDateTimeString(), DateTimePattern.DD_MM_YYYY_T_HH_MM_SS));
22859 ashik.ali 161 
		scheme.setCreatedBy(creatorId);
162 
		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());
163 
		return scheme;
164 
	}
165 
 
166 
	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
22925 ashik.ali 167 
		if(createSchemeRequest.getRetailerIds() == null || createSchemeRequest.getRetailerIds().isEmpty()){
168 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "SCHM_1001");
22859 ashik.ali 169 
		}
22870 ashik.ali 170 
		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(createSchemeRequest.getRetailerIds());
22859 ashik.ali 171 
		if(foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()){
172 
			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);
22925 ashik.ali 173 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "SCHM_1002");
22859 ashik.ali 174 
		}
175 
	}
176 
 
177 
	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
178 
		if(createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()){
22925 ashik.ali 179 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "SCHM_1003");
22859 ashik.ali 180 
		}
181 
		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(), ItemType.SERIALIZED);
182 
		if(foundItemIds.size() != createSchemeRequest.getItemIds().size()){
183 
			createSchemeRequest.getItemIds().removeAll(foundItemIds);
22925 ashik.ali 184 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "SCHM_1004");
22859 ashik.ali 185 
		}
186 
	}
187 
 
188 
	@Override
189 
	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
190 
		Scheme scheme = schemeRepository.selectById(schemeId);
191 
		if(!scheme.isRetailerAll()){
23019 ashik.ali 192 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
193 
			scheme.getRetailerIds().addAll(retailerIds);
22859 ashik.ali 194 
		}
195 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
23339 ashik.ali 196 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
197 
		scheme.setItemStringMap(this.toItemStringMap(items));
22859 ashik.ali 198 
		return scheme;
199 
	}
23019 ashik.ali 200 
 
23339 ashik.ali 201 
	public Map<Integer, String> toItemStringMap(List<Item> items){
202 
		Map<Integer, String> itemMap = new HashMap<>();
203 
		for(Item item : items){
204 
			itemMap.put(item.getId(), this.getItemString(item));
205 
		}
206 
		return itemMap;
207 
	}
208 
 
209 
	public String getItemString(Item item){
210 
		StringBuilder itemString = new StringBuilder();
211 
		if(item.getBrand() != null && !item.getBrand().isEmpty()){
212 
			itemString.append(item.getBrand().trim());
213 
		}
214 
		itemString.append(" ");
215 
		if(item.getModelName() != null && !item.getModelName().isEmpty()){
216 
			itemString.append(item.getModelName().trim());
217 
		}
218 
		itemString.append(" ");
219 
		if(item.getModelNumber() != null && !item.getModelNumber().isEmpty()){
220 
			itemString.append(item.getModelNumber().trim());
221 
		}
222 
		itemString.append(" ");
223 
		if(item.getColor() != null && !item.getColor().isEmpty()){
224 
			itemString.append(item.getColor().trim());
225 
		}
226 
		return itemString.toString();
227 
	}
228 
 
229 
	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems){
230 
		Set<Integer> itemIds = new HashSet<>();
231 
		for(SchemeItem schemeItem : schemeItems){
232 
			itemIds.add(schemeItem.getItemId());
233 
		}
234 
		return itemIds;
235 
	}
236 
 
23019 ashik.ali 237 
	@Override
238 
	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
239 
		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
240 
		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
241 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
23339 ashik.ali 242 
		Set<Integer> itemIds = this.schemeItemsToItemIds(schemeItems);
243 
		List<Item> items = itemRepository.selectByIds(itemIds);
244 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
245 
		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
23019 ashik.ali 246 
		List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
247 
		this.addRetailerIdsToSchemes(retailerSchemes, schemeIdSchemeMap);
248 
		return this.toSchemeModels(schemeIdSchemeMap);
249 
	}
250 
 
23339 ashik.ali 251 
	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap, Map<Integer, String> itemStringMap){
23019 ashik.ali 252 
		for(SchemeItem schemeItem : schemeItems){
253 
			schemeIdSchemeMap.get(schemeItem.getSchemeId())
23339 ashik.ali 254 
			.getItemStringMap()
255 
			.put(schemeItem.getItemId(), itemStringMap.get(schemeItem.getItemId()));
23019 ashik.ali 256 
		}
257 
	}
258 
 
259 
	private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap){
260 
		for(RetailerScheme retailerScheme : retailerSchemes){
261 
			schemeIdSchemeMap.get(retailerScheme.getSchemeId())
262 
			.getRetailerIds()
263 
			.add(retailerScheme.getRetailerId());
264 
		}
265 
	}
266 
 
267 
	private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap){
268 
		List<SchemeModel> schemeModels = new ArrayList<>();
269 
		for(Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()){
270 
			schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
271 
		}
272 
		return schemeModels;
273 
	}
274 
 
275 
	private SchemeModel toSchemeModel(Scheme scheme){
276 
		SchemeModel schemeModel = new SchemeModel();
277 
		schemeModel.setSchemeId(scheme.getId());
278 
		schemeModel.setName(scheme.getName());
279 
		schemeModel.setDescription(scheme.getDescription());
280 
		schemeModel.setSchemeType(scheme.getType().toString());
281 
		schemeModel.setAmountType(scheme.getAmountType().toString());
282 
		schemeModel.setAmount(scheme.getAmount());
283 
		schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));
284 
		schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));
285 
		schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));
286 
		schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));
287 
		schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));
288 
		schemeModel.setCreatedBy(scheme.getCreatedBy());
23339 ashik.ali 289 
		schemeModel.setItemStringMap(scheme.getItemStringMap());
23019 ashik.ali 290 
		schemeModel.setRetailerIds(scheme.getRetailerIds());
291 
		return schemeModel;
292 
	}
22653 ashik.ali 293 
 
294 
	@Override
295 
	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
296 
		Scheme scheme = schemeRepository.selectById(schemeId);
297 
		if(scheme.getActiveTimestamp() != null){
22925 ashik.ali 298 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "SCHM_1005");
22653 ashik.ali 299 
		}
300 
		if(scheme.getExpireTimestamp() != null){
22925 ashik.ali 301 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "SCHM_1006");
22653 ashik.ali 302 
		}
22859 ashik.ali 303 
		scheme.setActiveTimestamp(LocalDateTime.now());
304 
		schemeRepository.persist(scheme);
23019 ashik.ali 305 
		if(scheme.getType() == SchemeType.IN){
306 
			this.processPreviousPurchases(scheme);
307 
		}else if(scheme.getType() == SchemeType.OUT){
308 
			this.processPreviousSales(scheme);
309 
		}
22653 ashik.ali 310 
	}
23019 ashik.ali 311 
 
312 
	private void processPreviousPurchases(Scheme scheme) throws ProfitMandiBusinessException{
23378 ashik.ali 313 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectBetweenDates(scheme.getStartDateTime(), scheme.getEndDateTime());
23370 ashik.ali 314 
		if(inventoryItems.isEmpty()) {
315 
			return;
316 
		}
23019 ashik.ali 317 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
23370 ashik.ali 318 
		if(itemIds.isEmpty()) {
319 
			return;
320 
		}
23339 ashik.ali 321 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
322 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
23019 ashik.ali 323 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems, itemIds, true);
23370 ashik.ali 324 
		if(completedInventoryItems.isEmpty()) {
325 
			return;
326 
		}
23019 ashik.ali 327 
		if(scheme.isRetailerAll()){
328 
			for(InventoryItem inventoryItem : completedInventoryItems){
329 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
23339 ashik.ali 330 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_IN, "Added SCHEME_IN for item "+itemStringMap.get(inventoryItem.getItemId())+" against invoiceNumber ["+inventoryItem.getPurchase().getPurchaseReference() +"]", cashback);
23019 ashik.ali 331 
			}
332 
		}else{
333 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
334 
			for(InventoryItem inventoryItem : completedInventoryItems){
335 
				if(retailerIds.contains(inventoryItem.getFofoId())){
336 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
23339 ashik.ali 337 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_IN, "Added SCHEME_IN for item "+itemStringMap.get(inventoryItem.getItemId())+" against invoiceNumber ["+inventoryItem.getPurchase().getPurchaseReference() +"]", cashback);
23019 ashik.ali 338 
				}
339 
			}
340 
		}
341 
 
342 
	}
343 
 
344 
 
345 
 
23297 ashik.ali 346 
	private Map<Integer, Integer> toInventoryItemIdFofoOrderIdMap(List<FofoLineItem> fofoLineItems, Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap){
23019 ashik.ali 347 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = new HashMap<>();
348 
 
349 
		for(FofoLineItem fofoLineItem : fofoLineItems){
350 
			inventoryItemIdFofoOrderIdMap.put(
351 
					fofoLineItem.getInventoryItemId(),
352 
					fofoOrderItemIdFofoOrderItemMap.get(fofoLineItem.getFofoOrderItemId()).getOrderId());
353 
		}
354 
		return inventoryItemIdFofoOrderIdMap;
355 
	}
356 
 
357 
	private void processPreviousSales(Scheme scheme) throws ProfitMandiBusinessException{
23378 ashik.ali 358 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectBetweenDates(scheme.getStartDateTime(), scheme.getEndDateTime());
23019 ashik.ali 359 
 
23370 ashik.ali 360 
		if(fofoOrderItems.isEmpty()){
361 
			return;
362 
		}
363 
 
23019 ashik.ali 364 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = this.toFofoOrderItemIdFofoOrderItemMap(fofoOrderItems);
22653 ashik.ali 365 
 
23019 ashik.ali 366 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIdFofoOrderItemMap.keySet());
367 
 
23370 ashik.ali 368 
		if(fofoLineItems.isEmpty()) {
369 
			return;
370 
		}
371 
 
23297 ashik.ali 372 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = this.toInventoryItemIdFofoOrderIdMap(fofoLineItems, fofoOrderItemIdFofoOrderItemMap);
23019 ashik.ali 373 
 
374 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdFofoOrderIdMap.keySet());
375 
 
23370 ashik.ali 376 
		if(inventoryItems.isEmpty()) {
377 
			return;
378 
		}
379 
 
23019 ashik.ali 380 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
381 
 
23370 ashik.ali 382 
		if(itemIds.isEmpty()) {
383 
			return;
384 
		}
385 
 
23019 ashik.ali 386 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems, itemIds, false);
387 
 
388 
 
389 
		if(scheme.isRetailerAll()){
390 
			for(InventoryItem inventoryItem : completedInventoryItems){
391 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
23297 ashik.ali 392 
				walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(), WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
23019 ashik.ali 393 
			}
394 
		}else{
395 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
396 
			for(InventoryItem inventoryItem : completedInventoryItems){
397 
				if(retailerIds.contains(inventoryItem.getFofoId())){
398 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
23297 ashik.ali 399 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItemIdFofoOrderIdMap.get(inventoryItem.getId()), WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
23019 ashik.ali 400 
				}
401 
			}
402 
		}
403 
	}
404 
 
405 
	private Map<Integer, FofoOrderItem> toFofoOrderItemIdFofoOrderItemMap(List<FofoOrderItem> fofoOrderItems){
406 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = new HashMap<>();
407 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
408 
			fofoOrderItemIdFofoOrderItemMap.put(fofoOrderItem.getId(), fofoOrderItem);
409 
		}
410 
		return fofoOrderItemIdFofoOrderItemMap;
411 
	}
412 
 
413 
	private List<InventoryItem> toFilteredPurchaseCompletedInventoryItems(List<InventoryItem> inventoryItems, List<Integer> itemIds, boolean purchase){
414 
		List<InventoryItem> completedInventoryItems = new ArrayList<>();
415 
		for(InventoryItem inventoryItem : inventoryItems){
416 
			if(purchase && inventoryItem.getPurchase().getCompleteTimestamp() != null && itemIds.contains(inventoryItem.getItemId())){
417 
				completedInventoryItems.add(inventoryItem);
23297 ashik.ali 418 
			}else if(!purchase && itemIds.contains(inventoryItem.getItemId())){
419 
				completedInventoryItems.add(inventoryItem);
23019 ashik.ali 420 
			}
421 
		}
422 
		return completedInventoryItems;
423 
	}
424 
 
22653 ashik.ali 425 
	@Override
426 
	public void expireSchemeById(int schemeId) throws ProfitMandiBusinessException {
427 
		Scheme scheme = schemeRepository.selectById(schemeId);
428 
		if(scheme.getActiveTimestamp() == null){
22925 ashik.ali 429 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "SCHM_1007");
22653 ashik.ali 430 
		}
431 
		if(scheme.getExpireTimestamp() != null){
22925 ashik.ali 432 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "SCHM_1008");
22653 ashik.ali 433 
		}
22859 ashik.ali 434 
		scheme.setExpireTimestamp(LocalDateTime.now());
435 
		schemeRepository.persist(scheme);
22653 ashik.ali 436 
	}
22859 ashik.ali 437 
 
23019 ashik.ali 438 
	private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes){
439 
		Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
22859 ashik.ali 440 
		for(Scheme scheme : schemes){
23019 ashik.ali 441 
			schemeIdSchemeMap.put(scheme.getId(), scheme);
22859 ashik.ali 442 
		}
23019 ashik.ali 443 
		return schemeIdSchemeMap;
22859 ashik.ali 444 
	}
445 
 
446 
	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap){
447 
		Set<Integer> schemeIds = new HashSet<>();
448 
		for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
449 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
450 
				schemeIds.add(scheme.getId());
451 
			}
452 
		}
453 
		return schemeIds;
454 
	}
455 
 
456 
	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap){
457 
		Set<Integer> schemeIds = new HashSet<>();
458 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()){
459 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
460 
				schemeIds.add(scheme.getId());
461 
			}
462 
		}
463 
		return schemeIds;
464 
	}
465 
 
466 
	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems){
467 
		Set<Integer> itemIds = new HashSet<>();
468 
		for(InventoryItem inventoryItem : inventoryItems){
469 
			itemIds.add(inventoryItem.getItemId());
470 
		}
471 
		return itemIds;
472 
	}
473 
 
474 
	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems){
475 
		Set<Integer> itemIds = new HashSet<>();
476 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
477 
			itemIds.add(fofoOrderItem.getItemId());
478 
		}
479 
		return itemIds;
480 
	}
481 
 
482 
	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes){
23019 ashik.ali 483 
		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
22859 ashik.ali 484 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
485 
		for(SchemeItem schemeItem : schemeItems){
486 
			if(!itemIdSchemesMap.containsKey(schemeItem.getItemId())){
487 
				Set<Scheme> schemesSet = new HashSet<>();
488 
				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
489 
				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
490 
			}else{
491 
				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
492 
			}
493 
		}
494 
		return itemIdSchemesMap;
495 
	}
22653 ashik.ali 496 
 
22859 ashik.ali 497 
	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes, List<InventoryItem> inventoryItems){
498 
		Set<Integer> schemeIds = new HashSet<>();
499 
		for(Scheme scheme : schemes){
500 
			schemeIds.add(scheme.getId());
501 
		}
502 
		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
503 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
22653 ashik.ali 504 
 
22859 ashik.ali 505 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
506 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
507 
		for(InventoryItem inventoryItem : inventoryItems){
508 
			if(itemIdSchemesMap.containsKey(inventoryItem.getItemId())){
509 
				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
510 
			}
511 
		}
512 
		return inventoryItemSchemsMap;
513 
	}
514 
 
515 
	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes, List<FofoOrderItem> fofoOrderItems){
516 
		Set<Integer> schemeIds = new HashSet<>();
22653 ashik.ali 517 
		for(Scheme scheme : schemes){
22859 ashik.ali 518 
			schemeIds.add(scheme.getId());
519 
		}
520 
		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
521 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
522 
 
523 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
524 
 
525 
		if(!schemeItems.isEmpty()){
526 
			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
527 
			for(FofoOrderItem fofoOrderItem : fofoOrderItems){
528 
				if(itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())){
529 
					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
530 
				}
22653 ashik.ali 531 
			}
532 
		}
22859 ashik.ali 533 
		return fofoOrderItemSchemsMap;
534 
	}
535 
 
536 
	@Override
23365 ashik.ali 537 
	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
23369 ashik.ali 538 
		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
23344 ashik.ali 539 
		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
23369 ashik.ali 540 
		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
23365 ashik.ali 541 
		if(purchase.getCompleteTimestamp() != null) {
542 
			List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(), retailerId);
23378 ashik.ali 543 
			LocalDateTime billingTimestamp = purchase.getCreateTimestamp();
23365 ashik.ali 544 
			if(!orders.isEmpty()){
545 
				billingTimestamp = orders.get(0).getBillingTimestamp();
546 
			}
547 
			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, billingTimestamp);
548 
			float totalCashback = 0;
549 
			if(schemes.isEmpty()){
550 
				return;
551 
			}
552 
			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
553 
			LOGGER.info("SchemeIn filter inventoryItems {}", inventoryItems);
554 
 
555 
			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes, inventoryItems);
556 
 
557 
			if(inventoryItemSchemesMap.isEmpty()){
558 
				return;
559 
			}
560 
			Map<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesMap = new HashMap<>();
561 
			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
562 
			Set<Integer> itemIds = new HashSet<>();
563 
 
564 
			for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
565 
				Set<Scheme> notAllSchemes = new HashSet<>();
566 
				Set<Scheme> allSchemes = new HashSet<>();
567 
				for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
568 
					if(!scheme.isRetailerAll()){
569 
						notAllSchemes.add(scheme);
570 
					}else{
571 
						allSchemes.add(scheme);
572 
					}
22859 ashik.ali 573 
				}
23365 ashik.ali 574 
				notAllInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), notAllSchemes);
575 
				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
576 
				itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());
22859 ashik.ali 577 
			}
23365 ashik.ali 578 
 
579 
			List<Item> items = itemRepository.selectByIds(itemIds);
580 
			Map<Integer, String> itemStringMap = this.toItemStringMap(items);
581 
 
582 
			Map<Integer, Float> itemIdCashbackMap = new HashMap<>();
583 
			Map<Integer, Integer> itemIdCashbackCountMap = new HashMap<>();
584 
 
585 
			for(Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap.entrySet()){
586 
				for(Scheme scheme : allInventoryItemSchemesEntry.getValue()){
587 
					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
588 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
589 
					if(!itemIdCashbackMap.containsKey(inventoryItem.getItemId())){
590 
						itemIdCashbackMap.put(inventoryItem.getItemId(), cashback);
591 
						itemIdCashbackCountMap.put(inventoryItem.getItemId(), 1);
592 
					}else{
593 
						itemIdCashbackMap.put(inventoryItem.getItemId(), itemIdCashbackMap.get(inventoryItem.getItemId()) + cashback);
594 
						itemIdCashbackCountMap.put(inventoryItem.getItemId(), itemIdCashbackCountMap.get(inventoryItem.getItemId()) + 1);
595 
					}
596 
					totalCashback = totalCashback + cashback;
23339 ashik.ali 597 
				}
22859 ashik.ali 598 
			}
599 
 
23365 ashik.ali 600 
			//Map<Integer, Float> itemIdCashbackMap = new HashMap<>();
601 
 
602 
 
603 
			Set<Integer> schemeIds = this.inventoryItemSchemesMapToSchemeIds(notAllInventoryItemSchemesMap);
604 
			if(!schemeIds.isEmpty()){
605 
				List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
606 
				for(Map.Entry<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesEntry : notAllInventoryItemSchemesMap.entrySet()){
607 
					for(Scheme scheme : notAllInventoryItemSchemesEntry.getValue()){
608 
						if(foundSchemeIds.contains(scheme.getId())){
609 
							InventoryItem inventoryItem = notAllInventoryItemSchemesEntry.getKey();
610 
							float cashback = this.createSchemeInOut(scheme, inventoryItem);
611 
							if(!itemIdCashbackMap.containsKey(inventoryItem.getItemId())){
612 
								itemIdCashbackMap.put(inventoryItem.getItemId(), cashback);
613 
								itemIdCashbackCountMap.put(inventoryItem.getItemId(), 1);
614 
							}else{
615 
								itemIdCashbackMap.put(inventoryItem.getItemId(), itemIdCashbackMap.get(inventoryItem.getItemId()) + cashback);
616 
								itemIdCashbackCountMap.put(inventoryItem.getItemId(), itemIdCashbackCountMap.get(inventoryItem.getItemId()) + 1);
617 
							}
618 
							totalCashback = totalCashback + cashback;
23339 ashik.ali 619 
						}
22653 ashik.ali 620 
					}
621 
				}
622 
			}
23365 ashik.ali 623 
			for(Map.Entry<Integer, Float> itemIdCashbackEntry : itemIdCashbackMap.entrySet()){
624 
				walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,
625 
						itemIdCashbackCountMap.get(itemIdCashbackEntry.getKey())+"pcs of item "+
626 
						itemStringMap.get(itemIdCashbackEntry.getKey()) +
23369 ashik.ali 627 
				" Added for SCHEME_IN against invoiceNumber ["+purchase.getPurchaseReference()+"]", itemIdCashbackEntry.getValue());
23365 ashik.ali 628 
			}
629 
			purchase.setCashback(totalCashback);
630 
			purchaseRepository.persist(purchase);
22653 ashik.ali 631 
		}
632 
	}
633 
 
22859 ashik.ali 634 
	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem){
23443 amit.gupta 635 
		SchemeInOut schemeInOut = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
636 
		float amount = 0;
637 
		if(schemeInOut == null) {
638 
			schemeInOut = new SchemeInOut();
639 
			amount = this.getAmount(inventoryItem, scheme);
640 
			schemeInOut.setSchemeId(scheme.getId());
641 
			schemeInOut.setInventoryItemId(inventoryItem.getId());
642 
			schemeInOut.setAmount(amount);
643 
			schemeInOutRepository.persist(schemeInOut);
644 
		}
22859 ashik.ali 645 
		return amount;
646 
	}
647 
 
648 
	private float getAmount(InventoryItem inventoryItem, Scheme scheme){
22653 ashik.ali 649 
		float amount = 0;
22859 ashik.ali 650 
		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
651 
		float taxableSellingPrice = inventoryItem.getUnitPrice() / (1 + totalTaxRate / 100);
652 
 
22653 ashik.ali 653 
		if(scheme.getAmountType() == SchemeAmountType.PERCENTAGE){
22859 ashik.ali 654 
			amount = taxableSellingPrice * scheme.getAmount() / 100;
22653 ashik.ali 655 
		}else{
656 
			amount = scheme.getAmount();
657 
		}
22859 ashik.ali 658 
		return amount;
22653 ashik.ali 659 
	}
660 
 
22859 ashik.ali 661 
	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems){
662 
		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
663 
		for(InventoryItem inventoryItem : inventoryItems){
664 
			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
22653 ashik.ali 665 
		}
22859 ashik.ali 666 
		return itemIdInventoryItemMap;
22653 ashik.ali 667 
	}
22859 ashik.ali 668 
 
669 
 
670 
	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems){
671 
		Set<Integer> inventoryItemIds = new HashSet<>();
672 
		//Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
673 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
674 
			for(FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()){
675 
				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
676 
			}
677 
		}
678 
		return inventoryItemIds;
679 
	}
22653 ashik.ali 680 
 
681 
	@Override
23365 ashik.ali 682 
	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
683 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
22859 ashik.ali 684 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, LocalDateTime.now());
685 
		LOGGER.info("Active Schemes {}", schemes);
686 
		float totalCashback = 0;
687 
		if(schemes.isEmpty()){
23365 ashik.ali 688 
			return;
22859 ashik.ali 689 
		}
22653 ashik.ali 690 
 
22925 ashik.ali 691 
		List<FofoOrderItem> fofoOrderItems = orderService.getByOrderId(fofoOrderId);
22859 ashik.ali 692 
		//LOGGER.info("fofoOrderItems {}", fofoOrderItems);
693 
 
694 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes, fofoOrderItems);
695 
 
696 
		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
697 
 
698 
		if(fofoOrderItemSchemesMap.isEmpty()){
23365 ashik.ali 699 
			return;
22859 ashik.ali 700 
		}
701 
 
702 
		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
703 
 
704 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
705 
 
706 
		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this.toInventoryItemIdInventoryItemMap(inventoryItems);
707 
 
708 
		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
709 
		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
710 
 
711 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()){
712 
			Set<Scheme> notAllSchemes = new HashSet<>();
713 
			Set<Scheme> allSchemes = new HashSet<>();
714 
			for(Scheme scheme : fofoOrderItemSchemesEntry.getValue()){
715 
				if(!scheme.isRetailerAll()){
716 
					notAllSchemes.add(scheme);
717 
				}else{
718 
					allSchemes.add(scheme);
719 
				}
22653 ashik.ali 720 
			}
22859 ashik.ali 721 
			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
722 
			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
22653 ashik.ali 723 
		}
22859 ashik.ali 724 
 
725 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap.entrySet()){
726 
			for(FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
727 
				for(Scheme scheme : allFofoOrderItemSchemesEntry.getValue()){
728 
					float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
729 
					totalCashback = totalCashback + cashback;
730 
				}
731 
			}
22653 ashik.ali 732 
		}
733 
 
22859 ashik.ali 734 
		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
735 
 
736 
		if(!schemeIds.isEmpty()){
737 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
738 
 
739 
			for(Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap.entrySet()){
740 
				for(FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
741 
					for(Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()){
742 
						if(foundSchemeIds.contains(scheme.getId())){
743 
							float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
744 
							totalCashback = totalCashback + cashback;
22653 ashik.ali 745 
						}
746 
					}
747 
				}
22859 ashik.ali 748 
			}
22653 ashik.ali 749 
		}
22859 ashik.ali 750 
		if(totalCashback > 0){
751 
			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", totalCashback);
23365 ashik.ali 752 
			fofoOrder.setCashback(totalCashback);
753 
			fofoOrderRepository.persist(fofoOrder);
22859 ashik.ali 754 
		}
22653 ashik.ali 755 
	}
23297 ashik.ali 756 
 
22653 ashik.ali 757 
}