Subversion Repositories SmartDukaan

Rev

Rev 22653 | Rev 22870 | 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;
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;
22859 ashik.ali 20 
import com.spice.profitmandi.common.util.StringUtils;
22653 ashik.ali 21 
import com.spice.profitmandi.dao.entity.catalog.RetailerScheme;
22 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
23 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
22859 ashik.ali 24 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
22653 ashik.ali 25 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
22859 ashik.ali 26 
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
27 
import com.spice.profitmandi.dao.entity.fofo.SchemeItem;
22653 ashik.ali 28 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeAmountType;
29 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
22859 ashik.ali 30 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
22653 ashik.ali 31 
import com.spice.profitmandi.dao.repository.catalog.RetailerSchemeRepository;
32 
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
22859 ashik.ali 33 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
22653 ashik.ali 34 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
22859 ashik.ali 35 
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
36 
import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
37 
import com.spice.profitmandi.service.sale.FofoOrderItemService;
38 
import com.spice.profitmandi.service.wallet.WalletService;
22653 ashik.ali 39 
 
22859 ashik.ali 40 
import in.shop2020.model.v1.catalog.ItemType;
41 
import in.shop2020.model.v1.order.WalletReferenceType;
42 
 
22653 ashik.ali 43 
@Component
44 
public class SchemeServiceImpl implements SchemeService {
45 
 
22859 ashik.ali 46 
	private static final Logger LOGGER = LoggerFactory.getLogger(SchemeServiceImpl.class);
47 
 
22653 ashik.ali 48 
	@Autowired
49 
	private InventoryItemRepository inventoryItemRepository;
50 
 
51 
	@Autowired
22859 ashik.ali 52 
	private FofoOrderItemService fofoOrderItemService;
22653 ashik.ali 53 
 
54 
	@Autowired
55 
	private SchemeRepository schemeRepository;
56 
 
57 
	@Autowired
22859 ashik.ali 58 
	private RetailerRepository retailerRepository;
59 
 
60 
	@Autowired
22653 ashik.ali 61 
	private RetailerSchemeRepository retailerSchemeRepository;
62 
 
63 
	@Autowired
22859 ashik.ali 64 
	private SchemeInOutRepository schemeInOutRepository;
22653 ashik.ali 65 
 
66 
	@Autowired
22859 ashik.ali 67 
	private ItemRepository itemRepository;
22653 ashik.ali 68 
 
22859 ashik.ali 69 
	@Autowired
70 
	private SchemeItemRepository schemeItemRepository;
71 
 
72 
	@Autowired
73 
	private WalletService walletService;
74 
 
22653 ashik.ali 75 
	@Override
22859 ashik.ali 76 
	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
77 
 
78 
		if(createSchemeRequest.getName().isEmpty()){
79 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(), "");
22653 ashik.ali 80 
		}
22859 ashik.ali 81 
		if(createSchemeRequest.getAmount() <= 0){
82 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "");
22653 ashik.ali 83 
		}
84 
 
22859 ashik.ali 85 
		if(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()) == SchemeAmountType.PERCENTAGE && createSchemeRequest.getAmount() > 100){
86 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(), "");
22653 ashik.ali 87 
		}
88 
 
22859 ashik.ali 89 
		if(createSchemeRequest.getStartDateString() == null || createSchemeRequest.getStartDateString().isEmpty()){
90 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDateString(), "");
22653 ashik.ali 91 
		}
92 
 
22859 ashik.ali 93 
		if(createSchemeRequest.getEndDateString() == null || createSchemeRequest.getStartDateString().isEmpty()){
94 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDateString(), "");
22653 ashik.ali 95 
		}
96 
 
22859 ashik.ali 97 
		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
98 
 
22653 ashik.ali 99 
		if(scheme.getStartDate().isAfter(scheme.getEndDate())){
100 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE, scheme.getStartDate() + ", " + scheme.getEndDate(), "");
101 
		}
102 
 
22859 ashik.ali 103 
		this.validateItemIds(createSchemeRequest);
104 
		schemeRepository.persist(scheme);
105 
		if(!createSchemeRequest.isRetailerAll()){
106 
			this.validateRetailerIds(createSchemeRequest);
107 
			for(int retailerId : createSchemeRequest.getRetailerIds()){
108 
				RetailerScheme retailerScheme = new RetailerScheme();
109 
				retailerScheme.setRetailerId(retailerId);
110 
				retailerScheme.setSchemeId(scheme.getId());
111 
				retailerSchemeRepository.persist(retailerScheme);
112 
			}
22653 ashik.ali 113 
		}
22859 ashik.ali 114 
		for(int itemId : createSchemeRequest.getItemIds()){
115 
			SchemeItem schemeItem = new SchemeItem();
116 
			schemeItem.setSchemeId(scheme.getId());
117 
			schemeItem.setItemId(itemId);
118 
			schemeItemRepository.persist(schemeItem);
119 
		}
120 
 
22653 ashik.ali 121 
	}
22859 ashik.ali 122 
 
123 
	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest){
124 
		Scheme scheme = new Scheme();
125 
		scheme.setName(createSchemeRequest.getName());
126 
		scheme.setDescription(createSchemeRequest.getDescription());
127 
		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));
128 
		scheme.setAmountType(SchemeAmountType.valueOf(createSchemeRequest.getAmountType()));
129 
		scheme.setAmount(createSchemeRequest.getAmount());
130 
		scheme.setStartDate(StringUtils.toDateTime(createSchemeRequest.getStartDateString(), DateTimePattern.YYYY_MM_DD_T_HH_MM));
131 
		scheme.setEndDate(StringUtils.toDateTime(createSchemeRequest.getEndDateString(), DateTimePattern.YYYY_MM_DD_T_HH_MM));
132 
		if(createSchemeRequest.isActive()){
133 
			scheme.setActiveTimestamp(LocalDateTime.now());
134 
		}
135 
		scheme.setCreatedBy(creatorId);
136 
		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());
137 
		return scheme;
138 
	}
139 
 
140 
	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
141 
		if(createSchemeRequest.getRetailerIds().isEmpty()){
142 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "");
143 
		}
144 
		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(new ArrayList<>(createSchemeRequest.getRetailerIds()));
145 
		if(foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()){
146 
			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);
147 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, createSchemeRequest.getRetailerIds(), "");
148 
		}
149 
	}
150 
 
151 
	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException{
152 
		if(createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()){
153 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "");
154 
		}
155 
		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(), ItemType.SERIALIZED);
156 
		if(foundItemIds.size() != createSchemeRequest.getItemIds().size()){
157 
			createSchemeRequest.getItemIds().removeAll(foundItemIds);
158 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(), "");
159 
		}
160 
	}
161 
 
162 
	@Override
163 
	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
164 
		Scheme scheme = schemeRepository.selectById(schemeId);
165 
		if(!scheme.isRetailerAll()){
166 
			List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeId(scheme.getId());
167 
			for(RetailerScheme retailerScheme : retailerSchemes){
168 
				scheme.getRetailerIds().add(retailerScheme.getRetailerId());
169 
			}
170 
		}
171 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
172 
		scheme.setItemIds(new HashSet<>(itemIds));
173 
		return scheme;
174 
	}
22653 ashik.ali 175 
 
176 
	@Override
177 
	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
178 
		Scheme scheme = schemeRepository.selectById(schemeId);
179 
		if(scheme.getActiveTimestamp() != null){
180 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "");
181 
		}
182 
		if(scheme.getExpireTimestamp() != null){
183 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "");
184 
		}
22859 ashik.ali 185 
		scheme.setActiveTimestamp(LocalDateTime.now());
186 
		schemeRepository.persist(scheme);
22653 ashik.ali 187 
	}
188 
 
189 
	@Override
190 
	public void expireSchemeById(int schemeId) throws ProfitMandiBusinessException {
191 
		Scheme scheme = schemeRepository.selectById(schemeId);
192 
		if(scheme.getActiveTimestamp() == null){
193 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(), "");
194 
		}
195 
		if(scheme.getExpireTimestamp() != null){
196 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(), "");
197 
		}
22859 ashik.ali 198 
		scheme.setExpireTimestamp(LocalDateTime.now());
199 
		schemeRepository.persist(scheme);
22653 ashik.ali 200 
	}
22859 ashik.ali 201 
 
202 
	private Map<Integer, Scheme> toSchemeIdSchemesMap(List<Scheme> schemes){
203 
		Map<Integer, Scheme> schemeIdSchemesMap = new HashMap<>();
204 
		for(Scheme scheme : schemes){
205 
			schemeIdSchemesMap.put(scheme.getId(), scheme);
206 
		}
207 
		return schemeIdSchemesMap;
208 
	}
209 
 
210 
	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap){
211 
		Set<Integer> schemeIds = new HashSet<>();
212 
		for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
213 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
214 
				schemeIds.add(scheme.getId());
215 
			}
216 
		}
217 
		return schemeIds;
218 
	}
219 
 
220 
	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap){
221 
		Set<Integer> schemeIds = new HashSet<>();
222 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()){
223 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
224 
				schemeIds.add(scheme.getId());
225 
			}
226 
		}
227 
		return schemeIds;
228 
	}
229 
 
230 
	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems){
231 
		Set<Integer> itemIds = new HashSet<>();
232 
		for(InventoryItem inventoryItem : inventoryItems){
233 
			itemIds.add(inventoryItem.getItemId());
234 
		}
235 
		return itemIds;
236 
	}
237 
 
238 
	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems){
239 
		Set<Integer> itemIds = new HashSet<>();
240 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
241 
			itemIds.add(fofoOrderItem.getItemId());
242 
		}
243 
		return itemIds;
244 
	}
245 
 
246 
	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes){
247 
		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemesMap(schemes);
248 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
249 
		for(SchemeItem schemeItem : schemeItems){
250 
			if(!itemIdSchemesMap.containsKey(schemeItem.getItemId())){
251 
				Set<Scheme> schemesSet = new HashSet<>();
252 
				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
253 
				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
254 
			}else{
255 
				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
256 
			}
257 
		}
258 
		return itemIdSchemesMap;
259 
	}
22653 ashik.ali 260 
 
22859 ashik.ali 261 
	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes, List<InventoryItem> inventoryItems){
262 
		Set<Integer> schemeIds = new HashSet<>();
263 
		for(Scheme scheme : schemes){
264 
			schemeIds.add(scheme.getId());
265 
		}
266 
		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
267 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
22653 ashik.ali 268 
 
22859 ashik.ali 269 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
270 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
271 
		for(InventoryItem inventoryItem : inventoryItems){
272 
			if(itemIdSchemesMap.containsKey(inventoryItem.getItemId())){
273 
				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
274 
			}
275 
		}
276 
		return inventoryItemSchemsMap;
277 
	}
278 
 
279 
	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes, List<FofoOrderItem> fofoOrderItems){
280 
		Set<Integer> schemeIds = new HashSet<>();
22653 ashik.ali 281 
		for(Scheme scheme : schemes){
22859 ashik.ali 282 
			schemeIds.add(scheme.getId());
283 
		}
284 
		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
285 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
286 
 
287 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
288 
 
289 
		if(!schemeItems.isEmpty()){
290 
			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
291 
			for(FofoOrderItem fofoOrderItem : fofoOrderItems){
292 
				if(itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())){
293 
					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
294 
				}
22653 ashik.ali 295 
			}
296 
		}
22859 ashik.ali 297 
		return fofoOrderItemSchemsMap;
298 
	}
299 
 
300 
	@Override
301 
	public float processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
302 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, LocalDateTime.now());
303 
		float totalCashback = 0;
304 
		if(schemes.isEmpty()){
305 
			return 0;
22653 ashik.ali 306 
		}
22859 ashik.ali 307 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
308 
		LOGGER.info("SchemeIn filter inventoryItems {}", inventoryItems);
22653 ashik.ali 309 
 
22859 ashik.ali 310 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes, inventoryItems);
311 
 
312 
		if(inventoryItemSchemesMap.isEmpty()){
313 
			return 0;
314 
		}
315 
		Map<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesMap = new HashMap<>();
316 
		Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
317 
 
318 
		for(Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()){
319 
			Set<Scheme> notAllSchemes = new HashSet<>();
320 
			Set<Scheme> allSchemes = new HashSet<>();
321 
			for(Scheme scheme : inventoryItemSchemesEntry.getValue()){
322 
				if(!scheme.isRetailerAll()){
323 
					notAllSchemes.add(scheme);
324 
				}else{
325 
					allSchemes.add(scheme);
326 
				}
327 
			}
328 
			notAllInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), notAllSchemes);
329 
			allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
330 
		}
331 
 
332 
		for(Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap.entrySet()){
333 
			for(Scheme scheme : allInventoryItemSchemesEntry.getValue()){
334 
				float cashback = this.createSchemeInOut(scheme, allInventoryItemSchemesEntry.getKey());
335 
				totalCashback = totalCashback + cashback;
336 
			}
337 
		}
338 
 
339 
		Set<Integer> schemeIds = this.inventoryItemSchemesMapToSchemeIds(notAllInventoryItemSchemesMap);
340 
		if(!schemeIds.isEmpty()){
341 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
342 
 
343 
			for(Map.Entry<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesEntry : notAllInventoryItemSchemesMap.entrySet()){
344 
				for(Scheme scheme : notAllInventoryItemSchemesEntry.getValue()){
345 
					if(foundSchemeIds.contains(scheme.getId())){
346 
						float cashback = this.createSchemeInOut(scheme, notAllInventoryItemSchemesEntry.getKey());
347 
						totalCashback = totalCashback + cashback;
22653 ashik.ali 348 
					}
349 
				}
350 
			}
351 
		}
22859 ashik.ali 352 
		if(totalCashback > 0){
353 
			walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME_IN", totalCashback);
354 
		}
355 
		return totalCashback;
22653 ashik.ali 356 
	}
357 
 
22859 ashik.ali 358 
	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem){
359 
		float amount = this.getAmount(inventoryItem, scheme);
360 
		SchemeInOut schemeInOut = new SchemeInOut();
361 
		schemeInOut.setSchemeId(scheme.getId());
362 
		schemeInOut.setInventoryItemId(inventoryItem.getId());
363 
		schemeInOut.setAmount(amount);
364 
		schemeInOutRepository.persist(schemeInOut);
365 
		return amount;
366 
	}
367 
 
368 
	private float getAmount(InventoryItem inventoryItem, Scheme scheme){
22653 ashik.ali 369 
		float amount = 0;
22859 ashik.ali 370 
		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
371 
		float taxableSellingPrice = inventoryItem.getUnitPrice() / (1 + totalTaxRate / 100);
372 
 
22653 ashik.ali 373 
		if(scheme.getAmountType() == SchemeAmountType.PERCENTAGE){
22859 ashik.ali 374 
			amount = taxableSellingPrice * scheme.getAmount() / 100;
22653 ashik.ali 375 
		}else{
376 
			amount = scheme.getAmount();
377 
		}
22859 ashik.ali 378 
		return amount;
22653 ashik.ali 379 
	}
380 
 
22859 ashik.ali 381 
	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems){
382 
		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
383 
		for(InventoryItem inventoryItem : inventoryItems){
384 
			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
22653 ashik.ali 385 
		}
22859 ashik.ali 386 
		return itemIdInventoryItemMap;
22653 ashik.ali 387 
	}
22859 ashik.ali 388 
 
389 
	/*private Set<Integer> toFofoOrderItemIds(Set<FofoOrderItem> fofoOrderItems){
390 
		Set<Integer> fofoOrderItemIds = new HashSet<>();
391 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
392 
			fofoOrderItemIds.add(fofoOrderItem.getId());
393 
		}
394 
		return fofoOrderItemIds;
395 
	}*/
396 
 
397 
	/*private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(Set<FofoOrderItem> fofoOrderItems){
398 
		Set<Integer> fofoOrderItemIds = this.toFofoOrderItemIds(fofoOrderItems);
399 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);
400 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = new HashMap<>();
401 
		for(FofoLineItem fofoLineItem : fofoLineItems){
402 
			if(!fofoOrderItemIdFofoLineItemsMap.containsKey(fofoLineItem.getFofoOrderItemId())){
403 
				Set<FofoLineItem> fofoLineItems2 = new HashSet<>();
404 
				fofoLineItems.add(fofoLineItem);
405 
				fofoOrderItemIdFofoLineItemsMap.put(fofoLineItem.getFofoOrderItemId(), fofoLineItems2);
406 
			}else{
407 
				fofoOrderItemIdFofoLineItemsMap.get(fofoLineItem.getFofoOrderItemId()).add(fofoLineItem);
408 
			}
409 
		}
410 
		return fofoOrderItemIdFofoLineItemsMap;
411 
	}*/
412 
 
413 
	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems){
414 
		Set<Integer> inventoryItemIds = new HashSet<>();
415 
		//Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
416 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
417 
			for(FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()){
418 
				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
419 
			}
420 
		}
421 
		return inventoryItemIds;
422 
	}
22653 ashik.ali 423 
 
424 
	@Override
22859 ashik.ali 425 
	public float processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
426 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, LocalDateTime.now());
427 
		LOGGER.info("Active Schemes {}", schemes);
428 
		float totalCashback = 0;
429 
		if(schemes.isEmpty()){
430 
			return 0;
431 
		}
22653 ashik.ali 432 
 
22859 ashik.ali 433 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemService.getByOrderId(fofoOrderId);
434 
		//LOGGER.info("fofoOrderItems {}", fofoOrderItems);
435 
 
436 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes, fofoOrderItems);
437 
 
438 
		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
439 
 
440 
		if(fofoOrderItemSchemesMap.isEmpty()){
441 
			return 0;
442 
		}
443 
 
444 
		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
445 
 
446 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
447 
 
448 
		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this.toInventoryItemIdInventoryItemMap(inventoryItems);
449 
 
450 
		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
451 
		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
452 
 
453 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()){
454 
			Set<Scheme> notAllSchemes = new HashSet<>();
455 
			Set<Scheme> allSchemes = new HashSet<>();
456 
			for(Scheme scheme : fofoOrderItemSchemesEntry.getValue()){
457 
				if(!scheme.isRetailerAll()){
458 
					notAllSchemes.add(scheme);
459 
				}else{
460 
					allSchemes.add(scheme);
461 
				}
22653 ashik.ali 462 
			}
22859 ashik.ali 463 
			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
464 
			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
22653 ashik.ali 465 
		}
22859 ashik.ali 466 
 
467 
		//Map<Integer, Set<FofoLineItem>> allFofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(allFofoOrderItemSchemesMap.keySet());
468 
 
469 
		for(Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap.entrySet()){
470 
			for(FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
471 
				for(Scheme scheme : allFofoOrderItemSchemesEntry.getValue()){
472 
					float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
473 
					totalCashback = totalCashback + cashback;
474 
				}
475 
			}
22653 ashik.ali 476 
		}
477 
 
22859 ashik.ali 478 
		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
479 
 
480 
		if(!schemeIds.isEmpty()){
481 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
482 
 
483 
			//Map<Integer, Set<FofoLineItem>> notAllFofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(allFofoOrderItemSchemesMap.keySet());
484 
 
485 
			for(Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap.entrySet()){
486 
				for(FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()){
487 
					for(Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()){
488 
						if(foundSchemeIds.contains(scheme.getId())){
489 
							float cashback = this.createSchemeInOut(scheme, inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
490 
							totalCashback = totalCashback + cashback;
22653 ashik.ali 491 
						}
492 
					}
493 
				}
22859 ashik.ali 494 
			}
22653 ashik.ali 495 
		}
22859 ashik.ali 496 
		if(totalCashback > 0){
497 
			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", totalCashback);
498 
		}
499 
		return totalCashback;
22653 ashik.ali 500 
	}
501 
 
502 
}