Subversion Repositories SmartDukaan

Rev

Rev 24581 | Rev 24976 | 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;
23968 amit.gupta 10 
import java.util.stream.Collectors;
22653 ashik.ali 11 
 
23781 ashik.ali 12 
import org.apache.logging.log4j.LogManager;
23568 govind 13 
import org.apache.logging.log4j.Logger;
22653 ashik.ali 14 
import org.springframework.beans.factory.annotation.Autowired;
23781 ashik.ali 15 
import org.springframework.beans.factory.annotation.Qualifier;
22653 ashik.ali 16 
import org.springframework.stereotype.Component;
17 
 
24307 amit.gupta 18 
import com.spice.profitmandi.common.enumuration.ItemType;
22653 ashik.ali 19 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
22859 ashik.ali 20 
import com.spice.profitmandi.common.model.CreateSchemeRequest;
22653 ashik.ali 21 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
23019 ashik.ali 22 
import com.spice.profitmandi.common.model.SchemeModel;
22859 ashik.ali 23 
import com.spice.profitmandi.common.util.StringUtils;
23339 ashik.ali 24 
import com.spice.profitmandi.dao.entity.catalog.Item;
22653 ashik.ali 25 
import com.spice.profitmandi.dao.entity.catalog.RetailerScheme;
26 
import com.spice.profitmandi.dao.entity.catalog.Scheme;
27 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
23365 ashik.ali 28 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
22859 ashik.ali 29 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
22653 ashik.ali 30 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
23339 ashik.ali 31 
import com.spice.profitmandi.dao.entity.fofo.Purchase;
22859 ashik.ali 32 
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
33 
import com.spice.profitmandi.dao.entity.fofo.SchemeItem;
23344 ashik.ali 34 
import com.spice.profitmandi.dao.entity.transaction.Order;
23527 ashik.ali 35 
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
22653 ashik.ali 36 
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
22859 ashik.ali 37 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
22653 ashik.ali 38 
import com.spice.profitmandi.dao.repository.catalog.RetailerSchemeRepository;
39 
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
23995 amit.gupta 40 
import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
23968 amit.gupta 41 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
23019 ashik.ali 42 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
43 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
23365 ashik.ali 44 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
22653 ashik.ali 45 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
23339 ashik.ali 46 
import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
22859 ashik.ali 47 
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
48 
import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
23344 ashik.ali 49 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
23798 amit.gupta 50 
import com.spice.profitmandi.service.authentication.RoleManager;
23365 ashik.ali 51 
import com.spice.profitmandi.service.order.OrderService;
22859 ashik.ali 52 
import com.spice.profitmandi.service.wallet.WalletService;
22653 ashik.ali 53 
 
22859 ashik.ali 54 
import in.shop2020.model.v1.order.WalletReferenceType;
55 
 
22653 ashik.ali 56 
@Component
57 
public class SchemeServiceImpl implements SchemeService {
58 
 
23568 govind 59 
	private static final Logger LOGGER = LogManager.getLogger(SchemeServiceImpl.class);
23444 amit.gupta 60 
 
22653 ashik.ali 61 
	@Autowired
23781 ashik.ali 62 
	@Qualifier("fofoInventoryItemRepository")
22653 ashik.ali 63 
	private InventoryItemRepository inventoryItemRepository;
23444 amit.gupta 64 
 
22653 ashik.ali 65 
	@Autowired
22925 ashik.ali 66 
	private OrderService orderService;
23444 amit.gupta 67 
 
22653 ashik.ali 68 
	@Autowired
69 
	private SchemeRepository schemeRepository;
23444 amit.gupta 70 
 
22653 ashik.ali 71 
	@Autowired
23798 amit.gupta 72 
	private RoleManager roleManager;
73 
 
74 
	@Autowired
22859 ashik.ali 75 
	private RetailerRepository retailerRepository;
24562 amit.gupta 76 
 
23995 amit.gupta 77 
	@Autowired
78 
	private TagListingRepository tagListingRepository;
23444 amit.gupta 79 
 
22859 ashik.ali 80 
	@Autowired
22653 ashik.ali 81 
	private RetailerSchemeRepository retailerSchemeRepository;
23444 amit.gupta 82 
 
22653 ashik.ali 83 
	@Autowired
22859 ashik.ali 84 
	private SchemeInOutRepository schemeInOutRepository;
23444 amit.gupta 85 
 
22653 ashik.ali 86 
	@Autowired
23781 ashik.ali 87 
	@Qualifier("catalogItemRepository")
22859 ashik.ali 88 
	private ItemRepository itemRepository;
23444 amit.gupta 89 
 
22859 ashik.ali 90 
	@Autowired
91 
	private SchemeItemRepository schemeItemRepository;
23444 amit.gupta 92 
 
22859 ashik.ali 93 
	@Autowired
94 
	private WalletService walletService;
23444 amit.gupta 95 
 
23019 ashik.ali 96 
	@Autowired
97 
	private FofoOrderItemRepository fofoOrderItemRepository;
23444 amit.gupta 98 
 
23019 ashik.ali 99 
	@Autowired
100 
	private FofoLineItemRepository fofoLineItemRepository;
23444 amit.gupta 101 
 
23339 ashik.ali 102 
	@Autowired
103 
	private PurchaseRepository purchaseRepository;
23444 amit.gupta 104 
 
23344 ashik.ali 105 
	@Autowired
106 
	private OrderRepository orderRepository;
23444 amit.gupta 107 
 
23365 ashik.ali 108 
	@Autowired
109 
	private FofoOrderRepository fofoOrderRepository;
23796 amit.gupta 110 
 
22653 ashik.ali 111 
	@Override
22859 ashik.ali 112 
	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
23444 amit.gupta 113 
 
23019 ashik.ali 114 
		this.validateCreateSchemeRequest(createSchemeRequest);
23444 amit.gupta 115 
 
22859 ashik.ali 116 
		Scheme scheme = this.toScheme(creatorId, createSchemeRequest);
23444 amit.gupta 117 
 
118 
		if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {
119 
			throw new ProfitMandiBusinessException(
120 
					ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,
121 
					scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
22653 ashik.ali 122 
		}
23444 amit.gupta 123 
 
22859 ashik.ali 124 
		this.validateItemIds(createSchemeRequest);
125 
		schemeRepository.persist(scheme);
23444 amit.gupta 126 
		if (!createSchemeRequest.isRetailerAll()) {
22859 ashik.ali 127 
			this.validateRetailerIds(createSchemeRequest);
23444 amit.gupta 128 
			for (int retailerId : createSchemeRequest.getRetailerIds()) {
22859 ashik.ali 129 
				RetailerScheme retailerScheme = new RetailerScheme();
130 
				retailerScheme.setRetailerId(retailerId);
131 
				retailerScheme.setSchemeId(scheme.getId());
132 
				retailerSchemeRepository.persist(retailerScheme);
133 
			}
22653 ashik.ali 134 
		}
23444 amit.gupta 135 
		for (int itemId : createSchemeRequest.getItemIds()) {
22859 ashik.ali 136 
			SchemeItem schemeItem = new SchemeItem();
137 
			schemeItem.setSchemeId(scheme.getId());
138 
			schemeItem.setItemId(itemId);
139 
			schemeItemRepository.persist(schemeItem);
140 
		}
23444 amit.gupta 141 
 
22653 ashik.ali 142 
	}
23444 amit.gupta 143 
 
144 
	private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)
145 
			throws ProfitMandiBusinessException {
146 
		if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {
147 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),
148 
					"SCHM_VE_1000");
23019 ashik.ali 149 
		}
23444 amit.gupta 150 
		if (createSchemeRequest.getAmount() <= 0) {
151 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
152 
					"SCHM_VE_1001");
23019 ashik.ali 153 
		}
23444 amit.gupta 154 
 
23527 ashik.ali 155 
		if (AmountType.valueOf(createSchemeRequest.getAmountType()) == AmountType.PERCENTAGE
23444 amit.gupta 156 
				&& createSchemeRequest.getAmount() > 100) {
157 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),
158 
					"SCHM_VE_1002");
23019 ashik.ali 159 
		}
23444 amit.gupta 160 
 
23886 amit.gupta 161 
		if (createSchemeRequest.getStartDate() == null) {
23983 amit.gupta 162 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDate(),
163 
					"SCHM_VE_1003");
23019 ashik.ali 164 
		}
23886 amit.gupta 165 
		if (createSchemeRequest.getEndDate() == null) {
23983 amit.gupta 166 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDate(),
167 
					"SCHM_VE_1004");
23019 ashik.ali 168 
		}
169 
	}
23444 amit.gupta 170 
 
171 
	private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {
22859 ashik.ali 172 
		Scheme scheme = new Scheme();
173 
		scheme.setName(createSchemeRequest.getName());
174 
		scheme.setDescription(createSchemeRequest.getDescription());
175 
		scheme.setType(SchemeType.valueOf(createSchemeRequest.getType()));
23527 ashik.ali 176 
		scheme.setAmountType(AmountType.valueOf(createSchemeRequest.getAmountType()));
22859 ashik.ali 177 
		scheme.setAmount(createSchemeRequest.getAmount());
23886 amit.gupta 178 
		scheme.setStartDateTime(createSchemeRequest.getStartDate());
179 
		scheme.setEndDateTime(createSchemeRequest.getEndDate());
22859 ashik.ali 180 
		scheme.setCreatedBy(creatorId);
181 
		scheme.setRetailerAll(createSchemeRequest.isRetailerAll());
182 
		return scheme;
183 
	}
23444 amit.gupta 184 
 
185 
	private void validateRetailerIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
186 
		if (createSchemeRequest.getRetailerIds() == null || createSchemeRequest.getRetailerIds().isEmpty()) {
187 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,
188 
					createSchemeRequest.getRetailerIds(), "SCHM_1001");
22859 ashik.ali 189 
		}
22870 ashik.ali 190 
		List<Integer> foundRetailerIds = retailerRepository.selectIdsByIds(createSchemeRequest.getRetailerIds());
23444 amit.gupta 191 
		if (foundRetailerIds.size() != createSchemeRequest.getRetailerIds().size()) {
22859 ashik.ali 192 
			createSchemeRequest.getRetailerIds().removeAll(foundRetailerIds);
23444 amit.gupta 193 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID,
194 
					createSchemeRequest.getRetailerIds(), "SCHM_1002");
22859 ashik.ali 195 
		}
196 
	}
23444 amit.gupta 197 
 
198 
	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
199 
		if (createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()) {
200 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
201 
					"SCHM_1003");
22859 ashik.ali 202 
		}
23444 amit.gupta 203 
		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(),
204 
				ItemType.SERIALIZED);
205 
		if (foundItemIds.size() != createSchemeRequest.getItemIds().size()) {
22859 ashik.ali 206 
			createSchemeRequest.getItemIds().removeAll(foundItemIds);
23444 amit.gupta 207 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
208 
					"SCHM_1004");
22859 ashik.ali 209 
		}
210 
	}
23444 amit.gupta 211 
 
22859 ashik.ali 212 
	@Override
213 
	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
214 
		Scheme scheme = schemeRepository.selectById(schemeId);
23444 amit.gupta 215 
		if (!scheme.isRetailerAll()) {
23019 ashik.ali 216 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
217 
			scheme.getRetailerIds().addAll(retailerIds);
22859 ashik.ali 218 
		}
219 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
23914 govind 220 
		if (itemIds.size() > 0) {
221 
			List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
222 
			scheme.setItemStringMap(this.toItemStringMap(items));
23983 amit.gupta 223 
		}
22859 ashik.ali 224 
		return scheme;
225 
	}
23444 amit.gupta 226 
 
227 
	public Map<Integer, String> toItemStringMap(List<Item> items) {
23339 ashik.ali 228 
		Map<Integer, String> itemMap = new HashMap<>();
23444 amit.gupta 229 
		for (Item item : items) {
23339 ashik.ali 230 
			itemMap.put(item.getId(), this.getItemString(item));
231 
		}
232 
		return itemMap;
233 
	}
23444 amit.gupta 234 
 
235 
	public String getItemString(Item item) {
23339 ashik.ali 236 
		StringBuilder itemString = new StringBuilder();
23444 amit.gupta 237 
		if (item.getBrand() != null && !item.getBrand().isEmpty()) {
23339 ashik.ali 238 
			itemString.append(item.getBrand().trim());
239 
		}
240 
		itemString.append(" ");
23444 amit.gupta 241 
		if (item.getModelName() != null && !item.getModelName().isEmpty()) {
23339 ashik.ali 242 
			itemString.append(item.getModelName().trim());
243 
		}
244 
		itemString.append(" ");
23444 amit.gupta 245 
		if (item.getModelNumber() != null && !item.getModelNumber().isEmpty()) {
23339 ashik.ali 246 
			itemString.append(item.getModelNumber().trim());
247 
		}
248 
		itemString.append(" ");
23444 amit.gupta 249 
		if (item.getColor() != null && !item.getColor().isEmpty()) {
23339 ashik.ali 250 
			itemString.append(item.getColor().trim());
251 
		}
252 
		return itemString.toString();
253 
	}
23444 amit.gupta 254 
 
255 
	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems) {
23339 ashik.ali 256 
		Set<Integer> itemIds = new HashSet<>();
23444 amit.gupta 257 
		for (SchemeItem schemeItem : schemeItems) {
23339 ashik.ali 258 
			itemIds.add(schemeItem.getItemId());
259 
		}
260 
		return itemIds;
261 
	}
23444 amit.gupta 262 
 
23019 ashik.ali 263 
	@Override
264 
	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
265 
		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
266 
		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
267 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
23339 ashik.ali 268 
		Set<Integer> itemIds = this.schemeItemsToItemIds(schemeItems);
269 
		List<Item> items = itemRepository.selectByIds(itemIds);
270 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
271 
		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
23019 ashik.ali 272 
		List<RetailerScheme> retailerSchemes = retailerSchemeRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
273 
		this.addRetailerIdsToSchemes(retailerSchemes, schemeIdSchemeMap);
274 
		return this.toSchemeModels(schemeIdSchemeMap);
275 
	}
23444 amit.gupta 276 
 
277 
	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
278 
			Map<Integer, String> itemStringMap) {
279 
		for (SchemeItem schemeItem : schemeItems) {
280 
			schemeIdSchemeMap.get(schemeItem.getSchemeId()).getItemStringMap().put(schemeItem.getItemId(),
281 
					itemStringMap.get(schemeItem.getItemId()));
23019 ashik.ali 282 
		}
283 
	}
23444 amit.gupta 284 
 
285 
	private void addRetailerIdsToSchemes(List<RetailerScheme> retailerSchemes, Map<Integer, Scheme> schemeIdSchemeMap) {
286 
		for (RetailerScheme retailerScheme : retailerSchemes) {
287 
			schemeIdSchemeMap.get(retailerScheme.getSchemeId()).getRetailerIds().add(retailerScheme.getRetailerId());
23019 ashik.ali 288 
		}
289 
	}
23444 amit.gupta 290 
 
291 
	private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {
23019 ashik.ali 292 
		List<SchemeModel> schemeModels = new ArrayList<>();
23444 amit.gupta 293 
		for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {
23019 ashik.ali 294 
			schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));
295 
		}
296 
		return schemeModels;
297 
	}
23444 amit.gupta 298 
 
299 
	private SchemeModel toSchemeModel(Scheme scheme) {
23019 ashik.ali 300 
		SchemeModel schemeModel = new SchemeModel();
301 
		schemeModel.setSchemeId(scheme.getId());
302 
		schemeModel.setName(scheme.getName());
303 
		schemeModel.setDescription(scheme.getDescription());
304 
		schemeModel.setSchemeType(scheme.getType().toString());
305 
		schemeModel.setAmountType(scheme.getAmountType().toString());
306 
		schemeModel.setAmount(scheme.getAmount());
307 
		schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));
308 
		schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));
309 
		schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));
310 
		schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));
311 
		schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));
312 
		schemeModel.setCreatedBy(scheme.getCreatedBy());
23339 ashik.ali 313 
		schemeModel.setItemStringMap(scheme.getItemStringMap());
23019 ashik.ali 314 
		schemeModel.setRetailerIds(scheme.getRetailerIds());
315 
		return schemeModel;
316 
	}
22653 ashik.ali 317 
 
318 
	@Override
319 
	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
320 
		Scheme scheme = schemeRepository.selectById(schemeId);
23444 amit.gupta 321 
		if (scheme.getActiveTimestamp() != null) {
322 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
323 
					"SCHM_1005");
22653 ashik.ali 324 
		}
23444 amit.gupta 325 
		if (scheme.getExpireTimestamp() != null) {
326 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
327 
					"SCHM_1006");
22653 ashik.ali 328 
		}
22859 ashik.ali 329 
		scheme.setActiveTimestamp(LocalDateTime.now());
330 
		schemeRepository.persist(scheme);
23444 amit.gupta 331 
		if (scheme.getType() == SchemeType.IN) {
23019 ashik.ali 332 
			this.processPreviousPurchases(scheme);
23444 amit.gupta 333 
		} else if (scheme.getType() == SchemeType.OUT) {
23019 ashik.ali 334 
			this.processPreviousSales(scheme);
335 
		}
22653 ashik.ali 336 
	}
23444 amit.gupta 337 
 
338 
	private void processPreviousPurchases(Scheme scheme) throws ProfitMandiBusinessException {
339 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectBetweenDates(scheme.getStartDateTime(),
340 
				scheme.getEndDateTime());
341 
		if (inventoryItems.isEmpty()) {
23370 ashik.ali 342 
			return;
343 
		}
23019 ashik.ali 344 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
23444 amit.gupta 345 
		if (itemIds.isEmpty()) {
23370 ashik.ali 346 
			return;
347 
		}
23339 ashik.ali 348 
		List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
349 
		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
23444 amit.gupta 350 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,
351 
				itemIds, true);
352 
		if (completedInventoryItems.isEmpty()) {
23370 ashik.ali 353 
			return;
354 
		}
23444 amit.gupta 355 
		if (scheme.isRetailerAll()) {
356 
			for (InventoryItem inventoryItem : completedInventoryItems) {
23019 ashik.ali 357 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
24562 amit.gupta 358 
				if (cashback > 0) {
359 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
360 
							WalletReferenceType.SCHEME_IN,
361 
							"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())
362 
									+ " against invoiceNumber " + inventoryItem.getPurchase().getPurchaseReference(),
363 
							cashback);
364 
				}
23019 ashik.ali 365 
			}
23444 amit.gupta 366 
		} else {
23019 ashik.ali 367 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
23444 amit.gupta 368 
			for (InventoryItem inventoryItem : completedInventoryItems) {
369 
				if (retailerIds.contains(inventoryItem.getFofoId())) {
23019 ashik.ali 370 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
24562 amit.gupta 371 
					if (cashback > 0) {
372 
						walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
373 
								WalletReferenceType.SCHEME_IN,
374 
								"Added SCHEME_IN for item " + itemStringMap.get(inventoryItem.getItemId())
375 
										+ " against invoiceNumber "
376 
										+ inventoryItem.getPurchase().getPurchaseReference(),
377 
								cashback);
378 
					}
23019 ashik.ali 379 
				}
380 
			}
381 
		}
23444 amit.gupta 382 
 
23019 ashik.ali 383 
	}
23444 amit.gupta 384 
 
385 
	private Map<Integer, Integer> toInventoryItemIdFofoOrderIdMap(List<FofoLineItem> fofoLineItems,
386 
			Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap) {
23019 ashik.ali 387 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = new HashMap<>();
23444 amit.gupta 388 
 
389 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
390 
			inventoryItemIdFofoOrderIdMap.put(fofoLineItem.getInventoryItemId(),
23019 ashik.ali 391 
					fofoOrderItemIdFofoOrderItemMap.get(fofoLineItem.getFofoOrderItemId()).getOrderId());
392 
		}
393 
		return inventoryItemIdFofoOrderIdMap;
394 
	}
23444 amit.gupta 395 
 
396 
	private void processPreviousSales(Scheme scheme) throws ProfitMandiBusinessException {
397 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectBetweenDates(scheme.getStartDateTime(),
398 
				scheme.getEndDateTime());
399 
 
400 
		if (fofoOrderItems.isEmpty()) {
23370 ashik.ali 401 
			return;
402 
		}
22653 ashik.ali 403 
 
23444 amit.gupta 404 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = this
405 
				.toFofoOrderItemIdFofoOrderItemMap(fofoOrderItems);
406 
 
407 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository
408 
				.selectByFofoOrderItemIds(fofoOrderItemIdFofoOrderItemMap.keySet());
409 
 
410 
		if (fofoLineItems.isEmpty()) {
23370 ashik.ali 411 
			return;
412 
		}
23444 amit.gupta 413 
 
414 
		Map<Integer, Integer> inventoryItemIdFofoOrderIdMap = this.toInventoryItemIdFofoOrderIdMap(fofoLineItems,
415 
				fofoOrderItemIdFofoOrderItemMap);
416 
 
417 
		List<InventoryItem> inventoryItems = inventoryItemRepository
418 
				.selectByIds(inventoryItemIdFofoOrderIdMap.keySet());
419 
 
420 
		if (inventoryItems.isEmpty()) {
23370 ashik.ali 421 
			return;
422 
		}
23444 amit.gupta 423 
 
23019 ashik.ali 424 
		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
23444 amit.gupta 425 
 
426 
		if (itemIds.isEmpty()) {
23370 ashik.ali 427 
			return;
428 
		}
23444 amit.gupta 429 
 
430 
		List<InventoryItem> completedInventoryItems = this.toFilteredPurchaseCompletedInventoryItems(inventoryItems,
431 
				itemIds, false);
432 
 
433 
		if (scheme.isRetailerAll()) {
434 
			for (InventoryItem inventoryItem : completedInventoryItems) {
23019 ashik.ali 435 
				float cashback = this.createSchemeInOut(scheme, inventoryItem);
24562 amit.gupta 436 
				if (cashback > 0) {
437 
					walletService.addAmountToWallet(inventoryItem.getFofoId(), inventoryItem.getPurchaseId(),
438 
							WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
439 
				}
23019 ashik.ali 440 
			}
23444 amit.gupta 441 
		} else {
23019 ashik.ali 442 
			List<Integer> retailerIds = retailerSchemeRepository.selectRetailerIdsBySchemeId(scheme.getId());
23444 amit.gupta 443 
			for (InventoryItem inventoryItem : completedInventoryItems) {
444 
				if (retailerIds.contains(inventoryItem.getFofoId())) {
23019 ashik.ali 445 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
24562 amit.gupta 446 
					if (cashback > 0) {
447 
						walletService.addAmountToWallet(inventoryItem.getFofoId(),
448 
								inventoryItemIdFofoOrderIdMap.get(inventoryItem.getId()),
449 
								WalletReferenceType.SCHEME_OUT, "Added for SCHEME_OUT", cashback);
450 
					}
23019 ashik.ali 451 
				}
452 
			}
453 
		}
454 
	}
23444 amit.gupta 455 
 
456 
	private Map<Integer, FofoOrderItem> toFofoOrderItemIdFofoOrderItemMap(List<FofoOrderItem> fofoOrderItems) {
23019 ashik.ali 457 
		Map<Integer, FofoOrderItem> fofoOrderItemIdFofoOrderItemMap = new HashMap<>();
23444 amit.gupta 458 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
23019 ashik.ali 459 
			fofoOrderItemIdFofoOrderItemMap.put(fofoOrderItem.getId(), fofoOrderItem);
460 
		}
461 
		return fofoOrderItemIdFofoOrderItemMap;
462 
	}
23444 amit.gupta 463 
 
464 
	private List<InventoryItem> toFilteredPurchaseCompletedInventoryItems(List<InventoryItem> inventoryItems,
465 
			List<Integer> itemIds, boolean purchase) {
23019 ashik.ali 466 
		List<InventoryItem> completedInventoryItems = new ArrayList<>();
23444 amit.gupta 467 
		for (InventoryItem inventoryItem : inventoryItems) {
468 
			if (purchase && inventoryItem.getPurchase().getCompleteTimestamp() != null
469 
					&& itemIds.contains(inventoryItem.getItemId())) {
23019 ashik.ali 470 
				completedInventoryItems.add(inventoryItem);
23444 amit.gupta 471 
			} else if (!purchase && itemIds.contains(inventoryItem.getItemId())) {
23297 ashik.ali 472 
				completedInventoryItems.add(inventoryItem);
23019 ashik.ali 473 
			}
474 
		}
475 
		return completedInventoryItems;
476 
	}
23444 amit.gupta 477 
 
22653 ashik.ali 478 
	@Override
479 
	public void expireSchemeById(int schemeId) throws ProfitMandiBusinessException {
480 
		Scheme scheme = schemeRepository.selectById(schemeId);
23444 amit.gupta 481 
		if (scheme.getActiveTimestamp() == null) {
482 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),
483 
					"SCHM_1007");
22653 ashik.ali 484 
		}
23444 amit.gupta 485 
		if (scheme.getExpireTimestamp() != null) {
486 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),
487 
					"SCHM_1008");
22653 ashik.ali 488 
		}
22859 ashik.ali 489 
		scheme.setExpireTimestamp(LocalDateTime.now());
490 
		schemeRepository.persist(scheme);
22653 ashik.ali 491 
	}
23444 amit.gupta 492 
 
493 
	private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {
23019 ashik.ali 494 
		Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();
23444 amit.gupta 495 
		for (Scheme scheme : schemes) {
23019 ashik.ali 496 
			schemeIdSchemeMap.put(scheme.getId(), scheme);
22859 ashik.ali 497 
		}
23019 ashik.ali 498 
		return schemeIdSchemeMap;
22859 ashik.ali 499 
	}
23444 amit.gupta 500 
 
501 
	private Set<Integer> inventoryItemSchemesMapToSchemeIds(Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap) {
22859 ashik.ali 502 
		Set<Integer> schemeIds = new HashSet<>();
23444 amit.gupta 503 
		for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
504 
			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
22859 ashik.ali 505 
				schemeIds.add(scheme.getId());
506 
			}
507 
		}
508 
		return schemeIds;
509 
	}
23444 amit.gupta 510 
 
511 
	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap) {
22859 ashik.ali 512 
		Set<Integer> schemeIds = new HashSet<>();
23444 amit.gupta 513 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()) {
514 
			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
22859 ashik.ali 515 
				schemeIds.add(scheme.getId());
516 
			}
517 
		}
518 
		return schemeIds;
519 
	}
23444 amit.gupta 520 
 
521 
	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems) {
22859 ashik.ali 522 
		Set<Integer> itemIds = new HashSet<>();
23444 amit.gupta 523 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 524 
			itemIds.add(inventoryItem.getItemId());
525 
		}
526 
		return itemIds;
527 
	}
23444 amit.gupta 528 
 
529 
	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems) {
22859 ashik.ali 530 
		Set<Integer> itemIds = new HashSet<>();
23444 amit.gupta 531 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
22859 ashik.ali 532 
			itemIds.add(fofoOrderItem.getItemId());
533 
		}
534 
		return itemIds;
535 
	}
23444 amit.gupta 536 
 
537 
	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
23019 ashik.ali 538 
		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
22859 ashik.ali 539 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
23444 amit.gupta 540 
		for (SchemeItem schemeItem : schemeItems) {
541 
			if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {
22859 ashik.ali 542 
				Set<Scheme> schemesSet = new HashSet<>();
543 
				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
544 
				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
23444 amit.gupta 545 
			} else {
22859 ashik.ali 546 
				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
547 
			}
548 
		}
549 
		return itemIdSchemesMap;
550 
	}
22653 ashik.ali 551 
 
23444 amit.gupta 552 
	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,
553 
			List<InventoryItem> inventoryItems) {
22859 ashik.ali 554 
		Set<Integer> schemeIds = new HashSet<>();
23444 amit.gupta 555 
		for (Scheme scheme : schemes) {
22859 ashik.ali 556 
			schemeIds.add(scheme.getId());
557 
		}
558 
		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
559 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
23444 amit.gupta 560 
 
22859 ashik.ali 561 
		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
562 
		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
23444 amit.gupta 563 
		for (InventoryItem inventoryItem : inventoryItems) {
564 
			if (itemIdSchemesMap.containsKey(inventoryItem.getItemId())) {
22859 ashik.ali 565 
				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
566 
			}
567 
		}
568 
		return inventoryItemSchemsMap;
569 
	}
23444 amit.gupta 570 
 
571 
	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes,
572 
			List<FofoOrderItem> fofoOrderItems) {
22859 ashik.ali 573 
		Set<Integer> schemeIds = new HashSet<>();
23444 amit.gupta 574 
		for (Scheme scheme : schemes) {
22859 ashik.ali 575 
			schemeIds.add(scheme.getId());
576 
		}
577 
		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
578 
		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
23444 amit.gupta 579 
 
22859 ashik.ali 580 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
23444 amit.gupta 581 
 
582 
		if (!schemeItems.isEmpty()) {
22859 ashik.ali 583 
			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
23444 amit.gupta 584 
			for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
585 
				if (itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())) {
22859 ashik.ali 586 
					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
587 
				}
22653 ashik.ali 588 
			}
589 
		}
22859 ashik.ali 590 
		return fofoOrderItemSchemsMap;
591 
	}
23444 amit.gupta 592 
 
22859 ashik.ali 593 
	@Override
23365 ashik.ali 594 
	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
23369 ashik.ali 595 
		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
23344 ashik.ali 596 
		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
23369 ashik.ali 597 
		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
23444 amit.gupta 598 
		if (purchase.getCompleteTimestamp() != null) {
599 
			List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(),
600 
					retailerId);
23378 ashik.ali 601 
			LocalDateTime billingTimestamp = purchase.getCreateTimestamp();
23444 amit.gupta 602 
			if (!orders.isEmpty()) {
23365 ashik.ali 603 
				billingTimestamp = orders.get(0).getBillingTimestamp();
604 
			}
605 
			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, billingTimestamp);
606 
			float totalCashback = 0;
23444 amit.gupta 607 
			if (schemes.isEmpty()) {
23365 ashik.ali 608 
				return;
609 
			}
610 
			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
23444 amit.gupta 611 
 
612 
			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,
613 
					inventoryItems);
614 
 
615 
			if (inventoryItemSchemesMap.isEmpty()) {
23365 ashik.ali 616 
				return;
617 
			}
618 
			Map<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesMap = new HashMap<>();
619 
			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
620 
			Set<Integer> itemIds = new HashSet<>();
23444 amit.gupta 621 
 
622 
			for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
23365 ashik.ali 623 
				Set<Scheme> notAllSchemes = new HashSet<>();
624 
				Set<Scheme> allSchemes = new HashSet<>();
23444 amit.gupta 625 
				for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
626 
					if (!scheme.isRetailerAll()) {
23365 ashik.ali 627 
						notAllSchemes.add(scheme);
23444 amit.gupta 628 
					} else {
23365 ashik.ali 629 
						allSchemes.add(scheme);
630 
					}
22859 ashik.ali 631 
				}
23365 ashik.ali 632 
				notAllInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), notAllSchemes);
633 
				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
634 
				itemIds.add(inventoryItemSchemesEntry.getKey().getItemId());
22859 ashik.ali 635 
			}
23444 amit.gupta 636 
 
637 
			int itemsCount = 0;
638 
			for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
639 
					.entrySet()) {
640 
				float inventoryItemCashback = 0;
641 
				for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
23365 ashik.ali 642 
					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
643 
					float cashback = this.createSchemeInOut(scheme, inventoryItem);
23444 amit.gupta 644 
					inventoryItemCashback += cashback;
23339 ashik.ali 645 
				}
23444 amit.gupta 646 
				if (inventoryItemCashback > 0) {
647 
					totalCashback += inventoryItemCashback;
648 
					itemsCount++;
649 
				}
22859 ashik.ali 650 
			}
23444 amit.gupta 651 
 
23365 ashik.ali 652 
			Set<Integer> schemeIds = this.inventoryItemSchemesMapToSchemeIds(notAllInventoryItemSchemesMap);
23444 amit.gupta 653 
			if (!schemeIds.isEmpty()) {
23365 ashik.ali 654 
				List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
23444 amit.gupta 655 
				for (Map.Entry<InventoryItem, Set<Scheme>> notAllInventoryItemSchemesEntry : notAllInventoryItemSchemesMap
656 
						.entrySet()) {
657 
					float inventoryItemCashback = 0;
658 
					for (Scheme scheme : notAllInventoryItemSchemesEntry.getValue()) {
659 
						if (foundSchemeIds.contains(scheme.getId())) {
23365 ashik.ali 660 
							InventoryItem inventoryItem = notAllInventoryItemSchemesEntry.getKey();
661 
							float cashback = this.createSchemeInOut(scheme, inventoryItem);
23444 amit.gupta 662 
							inventoryItemCashback += cashback;
23339 ashik.ali 663 
						}
22653 ashik.ali 664 
					}
23444 amit.gupta 665 
					if (inventoryItemCashback > 0) {
666 
						totalCashback += inventoryItemCashback;
667 
						itemsCount++;
668 
					}
22653 ashik.ali 669 
				}
670 
			}
23511 amit.gupta 671 
			LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
23796 amit.gupta 672 
			if (itemsCount > 0) {
23508 amit.gupta 673 
				walletService.addAmountToWallet(retailerId, purchaseId, WalletReferenceType.SCHEME_IN,
23796 amit.gupta 674 
						"Added for SCHEME IN against invoice " + purchase.getPurchaseReference() + " (total "
675 
								+ itemsCount + " pcs)",
676 
						totalCashback);
677 
				LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
678 
						purchase.getPurchaseReference(), itemsCount);
23508 amit.gupta 679 
				purchase.setCashback(purchase.getCashback() + totalCashback);
680 
				purchaseRepository.persist(purchase);
681 
			}
22653 ashik.ali 682 
		}
683 
	}
23444 amit.gupta 684 
 
685 
	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem) {
24562 amit.gupta 686 
		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
23443 amit.gupta 687 
		float amount = 0;
24581 amit.gupta 688 
		if (schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null).collect(Collectors.toList())
24562 amit.gupta 689 
				.size() == 0) {
690 
			SchemeInOut schemeInOut = new SchemeInOut();
23443 amit.gupta 691 
			amount = this.getAmount(inventoryItem, scheme);
692 
			schemeInOut.setSchemeId(scheme.getId());
693 
			schemeInOut.setInventoryItemId(inventoryItem.getId());
694 
			schemeInOut.setAmount(amount);
695 
			schemeInOutRepository.persist(schemeInOut);
696 
		}
22859 ashik.ali 697 
		return amount;
698 
	}
23444 amit.gupta 699 
 
700 
	private float getAmount(InventoryItem inventoryItem, Scheme scheme) {
22653 ashik.ali 701 
		float amount = 0;
22859 ashik.ali 702 
		float totalTaxRate = inventoryItem.getIgstRate() + inventoryItem.getSgstRate() + inventoryItem.getCgstRate();
23527 ashik.ali 703 
		if (scheme.getAmountType() == AmountType.PERCENTAGE) {
24562 amit.gupta 704 
			if (scheme.getType().equals(SchemeType.IN)) {
23995 amit.gupta 705 
				amount = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
706 
			} else {
707 
				try {
708 
					amount = tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice();
24562 amit.gupta 709 
				} catch (Exception e) {
23995 amit.gupta 710 
					LOGGER.info("Could not find tag Listing entry in {}", inventoryItem.getItemId());
711 
					e.printStackTrace();
712 
				}
713 
			}
714 
			float taxableSellingPrice = amount / (1 + totalTaxRate / 100);
22859 ashik.ali 715 
			amount = taxableSellingPrice * scheme.getAmount() / 100;
23444 amit.gupta 716 
		} else {
22653 ashik.ali 717 
			amount = scheme.getAmount();
718 
		}
22859 ashik.ali 719 
		return amount;
22653 ashik.ali 720 
	}
23444 amit.gupta 721 
 
722 
	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems) {
22859 ashik.ali 723 
		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
23444 amit.gupta 724 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 725 
			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
22653 ashik.ali 726 
		}
22859 ashik.ali 727 
		return itemIdInventoryItemMap;
22653 ashik.ali 728 
	}
23444 amit.gupta 729 
 
730 
	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems) {
22859 ashik.ali 731 
		Set<Integer> inventoryItemIds = new HashSet<>();
23444 amit.gupta 732 
		// Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap =
733 
		// this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
734 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
735 
			for (FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()) {
22859 ashik.ali 736 
				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
737 
			}
738 
		}
739 
		return inventoryItemIds;
740 
	}
22653 ashik.ali 741 
 
742 
	@Override
23365 ashik.ali 743 
	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
744 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
24245 amit.gupta 745 
		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, fofoOrder.getCreateTimestamp());
22859 ashik.ali 746 
		LOGGER.info("Active Schemes {}", schemes);
747 
		float totalCashback = 0;
23512 amit.gupta 748 
		int count = 0;
23444 amit.gupta 749 
		if (schemes.isEmpty()) {
23365 ashik.ali 750 
			return;
22859 ashik.ali 751 
		}
23444 amit.gupta 752 
 
22925 ashik.ali 753 
		List<FofoOrderItem> fofoOrderItems = orderService.getByOrderId(fofoOrderId);
23444 amit.gupta 754 
		// LOGGER.info("fofoOrderItems {}", fofoOrderItems);
755 
 
756 
		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes,
757 
				fofoOrderItems);
758 
 
22859 ashik.ali 759 
		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
23444 amit.gupta 760 
 
761 
		if (fofoOrderItemSchemesMap.isEmpty()) {
23365 ashik.ali 762 
			return;
22859 ashik.ali 763 
		}
23444 amit.gupta 764 
 
22859 ashik.ali 765 
		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
23444 amit.gupta 766 
 
22859 ashik.ali 767 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
23444 amit.gupta 768 
 
769 
		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this
770 
				.toInventoryItemIdInventoryItemMap(inventoryItems);
771 
 
22859 ashik.ali 772 
		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
773 
		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
23444 amit.gupta 774 
 
775 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()) {
22859 ashik.ali 776 
			Set<Scheme> notAllSchemes = new HashSet<>();
777 
			Set<Scheme> allSchemes = new HashSet<>();
23444 amit.gupta 778 
			for (Scheme scheme : fofoOrderItemSchemesEntry.getValue()) {
779 
				if (!scheme.isRetailerAll()) {
22859 ashik.ali 780 
					notAllSchemes.add(scheme);
23444 amit.gupta 781 
				} else {
22859 ashik.ali 782 
					allSchemes.add(scheme);
783 
				}
22653 ashik.ali 784 
			}
22859 ashik.ali 785 
			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
786 
			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
22653 ashik.ali 787 
		}
23444 amit.gupta 788 
 
789 
		for (Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap
790 
				.entrySet()) {
791 
			for (FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
23796 amit.gupta 792 
				float itemCashback = 0;
23444 amit.gupta 793 
				for (Scheme scheme : allFofoOrderItemSchemesEntry.getValue()) {
23796 amit.gupta 794 
					itemCashback += this.createSchemeInOut(scheme,
23444 amit.gupta 795 
							inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
22859 ashik.ali 796 
				}
23796 amit.gupta 797 
				if (itemCashback > 0) {
798 
					totalCashback += itemCashback;
799 
					count += 1;
800 
				}
22859 ashik.ali 801 
			}
22653 ashik.ali 802 
		}
23444 amit.gupta 803 
 
22859 ashik.ali 804 
		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
23444 amit.gupta 805 
 
806 
		if (!schemeIds.isEmpty()) {
22859 ashik.ali 807 
			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
23444 amit.gupta 808 
 
809 
			for (Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap
810 
					.entrySet()) {
811 
				for (FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
23796 amit.gupta 812 
					float itemCashback = 0;
23444 amit.gupta 813 
					for (Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()) {
814 
						if (foundSchemeIds.contains(scheme.getId())) {
23796 amit.gupta 815 
							itemCashback += this.createSchemeInOut(scheme,
23444 amit.gupta 816 
									inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
22653 ashik.ali 817 
						}
818 
					}
23796 amit.gupta 819 
					if (itemCashback > 0) {
820 
						totalCashback += itemCashback;
821 
						count += 1;
822 
					}
22653 ashik.ali 823 
				}
23444 amit.gupta 824 
			}
22653 ashik.ali 825 
		}
23444 amit.gupta 826 
		if (totalCashback > 0) {
827 
			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT,
23796 amit.gupta 828 
					"Sales margin for invoice number " + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",
829 
					totalCashback);
23365 ashik.ali 830 
			fofoOrder.setCashback(totalCashback);
831 
			fofoOrderRepository.persist(fofoOrder);
22859 ashik.ali 832 
		}
22653 ashik.ali 833 
	}
23444 amit.gupta 834 
 
23508 amit.gupta 835 
	@Override
23796 amit.gupta 836 
	public void rollbackSchemes(List<Integer> inventoryItemIds, int rollbackReference, String rollbackReason)
837 
			throws Exception {
23638 amit.gupta 838 
		Set<Integer> inventoryItemIdSet = new HashSet<>(inventoryItemIds);
23508 amit.gupta 839 
		float amountToRollback = 0;
840 
		List<SchemeInOut> schemes = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIdSet);
23796 amit.gupta 841 
		for (SchemeInOut schemeInOut : schemes) {
23983 amit.gupta 842 
			if (schemeInOut.getRolledBackTimestamp() == null) {
843 
				schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
844 
				schemeInOutRepository.persist(schemeInOut);
845 
				amountToRollback += schemeInOut.getAmount();
846 
			}
23508 amit.gupta 847 
		}
23983 amit.gupta 848 
		if (amountToRollback > 0) {
23638 amit.gupta 849 
			int inventoryItemId = inventoryItemIds.get(0);
850 
			Integer fofoId = inventoryItemRepository.selectById(inventoryItemId).getFofoId();
23796 amit.gupta 851 
			walletService.rollbackAmountFromWallet(fofoId, amountToRollback, rollbackReference,
852 
					WalletReferenceType.SCHEME_IN, rollbackReason);
23638 amit.gupta 853 
		}
23508 amit.gupta 854 
	}
23884 amit.gupta 855 
 
23781 ashik.ali 856 
	@Override
23796 amit.gupta 857 
	public Map<String, Object> getSchemes(Set<Integer> roleIds, int offset, int limit)
858 
			throws ProfitMandiBusinessException {
23781 ashik.ali 859 
		Map<String, Object> map = new HashMap<>();
860 
		List<Scheme> schemes = null;
861 
		long size = 0;
23798 amit.gupta 862 
		if (roleManager.isAdmin(roleIds)) {
23781 ashik.ali 863 
			schemes = schemeRepository.selectAll(offset, limit);
864 
			size = schemeRepository.selectAllCount();
23796 amit.gupta 865 
		} else {
23781 ashik.ali 866 
			schemes = schemeRepository.selectActiveAll(offset, limit);
867 
			size = schemeRepository.selectAllActiveCount();
868 
		}
869 
		map.put("schemes", schemes);
870 
		map.put("start", offset + 1);
871 
		map.put("size", size);
23796 amit.gupta 872 
		if (schemes.size() < limit) {
23781 ashik.ali 873 
			map.put("end", offset + schemes.size());
23796 amit.gupta 874 
		} else {
23781 ashik.ali 875 
			map.put("end", offset + limit);
876 
		}
877 
		return map;
878 
	}
23796 amit.gupta 879 
 
23781 ashik.ali 880 
	@Override
23796 amit.gupta 881 
	public List<Scheme> getPaginatedSchemes(Set<Integer> roleIds, int offset, int limit)
882 
			throws ProfitMandiBusinessException {
23781 ashik.ali 883 
		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);
884 
		List<Scheme> schemes = null;
23798 amit.gupta 885 
		if (roleManager.isAdmin(roleIds)) {
23781 ashik.ali 886 
			schemes = schemeRepository.selectAll(offset, limit);
23796 amit.gupta 887 
		} else {
23781 ashik.ali 888 
			schemes = schemeRepository.selectActiveAll(offset, limit);
889 
		}
890 
		return schemes;
891 
	}
23508 amit.gupta 892 
 
23968 amit.gupta 893 
	@Override
894 
	public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason)
895 
			throws Exception {
896 
		float amountToCredit = 0;
23995 amit.gupta 897 
		float amountToDebit = 0;
23968 amit.gupta 898 
		Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()
899 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
900 
		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
901 
		List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
902 
		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size()).stream()
903 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
904 
		for (SchemeInOut schemeInOut : schemeInOuts) {
23980 amit.gupta 905 
			InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());
23968 amit.gupta 906 
			Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
23995 amit.gupta 907 
			if (scheme.getAmountType().equals(AmountType.FIXED)) {
23983 amit.gupta 908 
				continue;
23995 amit.gupta 909 
			}
24562 amit.gupta 910 
			if (schemeInOut.getRolledBackTimestamp() == null) {
23995 amit.gupta 911 
				float newAmount = getAmount(ii, scheme);
24562 amit.gupta 912 
				if (schemeInOut.getAmount() - newAmount >= 0.01f) {
23998 amit.gupta 913 
					schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
914 
					schemeInOutRepository.persist(schemeInOut);
23995 amit.gupta 915 
					SchemeInOut sioNew = new SchemeInOut();
916 
					sioNew.setAmount(newAmount);
917 
					sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());
918 
					sioNew.setSchemeId(schemeInOut.getSchemeId());
919 
					schemeInOutRepository.persist(sioNew);
920 
					amountToCredit += sioNew.getAmount();
921 
					amountToDebit += schemeInOut.getAmount();
922 
				}
24562 amit.gupta 923 
 
23986 amit.gupta 924 
			}
23968 amit.gupta 925 
		}
23995 amit.gupta 926 
		int fofoId = inventoryItems.get(0).getFofoId();
927 
		if (amountToDebit > 0) {
23983 amit.gupta 928 
			walletService.addAmountToWallet(fofoId, reversalReference, WalletReferenceType.PRICE_DROP, reversalReason,
23995 amit.gupta 929 
					-amountToDebit);
23968 amit.gupta 930 
		}
23995 amit.gupta 931 
		if (amountToCredit > 0) {
24562 amit.gupta 932 
			walletService.addAmountToWallet(fofoId, reversalReference, WalletReferenceType.PRICE_DROP, reversalReason,
933 
					amountToCredit);
23995 amit.gupta 934 
		}
23968 amit.gupta 935 
	}
24562 amit.gupta 936 
 
24264 amit.gupta 937 
	@Override
24562 amit.gupta 938 
	public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason,
939 
			SchemeType schemeType) throws ProfitMandiBusinessException {
24264 amit.gupta 940 
		Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()
941 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
942 
		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
943 
		List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
944 
		float amount = 0;
945 
		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size()).stream()
946 
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
947 
		for (SchemeInOut schemeInOut : schemeInOuts) {
948 
			Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
24562 amit.gupta 949 
			if (scheme.getType().equals(schemeType)) {
950 
				if (schemeInOut.getRolledBackTimestamp() == null) {
24264 amit.gupta 951 
					schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
952 
					schemeInOutRepository.persist(schemeInOut);
953 
					amount += schemeInOut.getAmount();
954 
				}
955 
			}
956 
		}
957 
		int fofoId = inventoryItems.get(0).getFofoId();
24562 amit.gupta 958 
		WalletReferenceType walletReferenceType = schemeType.equals(SchemeType.OUT) ? WalletReferenceType.SCHEME_OUT
959 
				: WalletReferenceType.SCHEME_IN;
960 
		if (amount > 0) {
961 
			walletService.rollbackAmountFromWallet(fofoId, amount, reversalReference, walletReferenceType,
962 
					reversalReason);
24268 amit.gupta 963 
		}
24264 amit.gupta 964 
	}
23968 amit.gupta 965 
 
24563 amit.gupta 966 
/*	@Override
24562 amit.gupta 967 
	public void updateSchmesForModel(int catalogId) throws ProfitMandiBusinessException {
968 
		List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);
969 
		Map<Integer, Scheme> schemes = schemeRepository
970 
				.selectAllByItemIds(items.stream().map(x -> x.getId()).collect(Collectors.toList()));
971 
 
24563 amit.gupta 972 
	}*/
24562 amit.gupta 973 
 
22653 ashik.ali 974 
}