WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/scheme/SchemeServiceImpl.java

 package com.spice.profitmandi.service.scheme;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
 import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
 import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
 import com.spice.profitmandi.dao.entity.fofo.Purchase;
+import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
 import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
 import com.spice.profitmandi.dao.entity.fofo.SchemeItem;
-import com.spice.profitmandi.dao.entity.transaction.Order;
 import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
 import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
 import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
 import com.spice.profitmandi.dao.repository.catalog.RetailerSchemeRepository;
 import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
 import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
 import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
 import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
 import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
 import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
+import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
 import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
 import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;
-import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
 import com.spice.profitmandi.service.authentication.RoleManager;
-import com.spice.profitmandi.service.order.OrderService;
 import com.spice.profitmandi.service.wallet.WalletService;
 import in.shop2020.model.v1.order.WalletReferenceType;
 @Component
 	@Autowired
 	@Qualifier("fofoInventoryItemRepository")
 	private InventoryItemRepository inventoryItemRepository;
 	@Autowired
-	private OrderService orderService;
+	private ScanRecordRepository scanRecordRepository;
 	@Autowired
 	private SchemeRepository schemeRepository;
 	@Autowired
 	@Autowired
 	private PurchaseRepository purchaseRepository;
 	@Autowired
-	private OrderRepository orderRepository;
-	@Autowired
 	private FofoOrderRepository fofoOrderRepository;
 	@Override
 	public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
+			}
+		}
 		return schemeIds;
+	}
-	private Set<Integer> fofoLineItemSchemesMapToSchemeIds(Map<FofoOrderItem, Set<Scheme>> fofoLineItemSchemesMap) {
-		Set<Integer> schemeIds = new HashSet<>();
-		for (Map.Entry<FofoOrderItem, Set<Scheme>> inventoryItemSchemesEntry : fofoLineItemSchemesMap.entrySet()) {
-			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
-				schemeIds.add(scheme.getId());
-			}
-		}
-		return schemeIds;
-	}
 	private Set<Integer> inventoryItemsToItemIds(List<InventoryItem> inventoryItems) {
 		Set<Integer> itemIds = new HashSet<>();
 		for (InventoryItem inventoryItem : inventoryItems) {
 			itemIds.add(inventoryItem.getItemId());
+		}
 		return itemIds;
+	}
-	private Set<Integer> fofoOrderItemsToItemIds(List<FofoOrderItem> fofoOrderItems) {
-		Set<Integer> itemIds = new HashSet<>();
-		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-			itemIds.add(fofoOrderItem.getItemId());
-		}
-		return itemIds;
-	}
 	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
 		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
 		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
 		for (SchemeItem schemeItem : schemeItems) {
 			if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {
+			}
+		}
 		return inventoryItemSchemsMap;
+	}
-	private Map<FofoOrderItem, Set<Scheme>> toFofoOrderItemSchemesMap(List<Scheme> schemes,
-			List<FofoOrderItem> fofoOrderItems) {
-		Set<Integer> schemeIds = new HashSet<>();
-		for (Scheme scheme : schemes) {
-			schemeIds.add(scheme.getId());
-		}
-		Set<Integer> itemIds = this.fofoOrderItemsToItemIds(fofoOrderItems);
-		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
-		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemsMap = new HashMap<>();
-		if (!schemeItems.isEmpty()) {
-			Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
-			for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-				if (itemIdSchemesMap.containsKey(fofoOrderItem.getItemId())) {
-					fofoOrderItemSchemsMap.put(fofoOrderItem, itemIdSchemesMap.get(fofoOrderItem.getItemId()));
-				}
-			}
-		}
-		return fofoOrderItemSchemsMap;
-	}
 	@Override
 	public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {
 		LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);
 		Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);
 		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
 		if (purchase.getCompleteTimestamp() != null) {
+			/*
+			 * List<Order> orders =
-			List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(),
+			 * orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.
-					retailerId);
-			LocalDateTime billingTimestamp = purchase.getCreateTimestamp();
+			 * getPurchaseReference(), retailerId);
+			 */
+			/*
-			if (!orders.isEmpty()) {
+			 * if (!orders.isEmpty()) { billingTimestamp =
-				billingTimestamp = orders.get(0).getBillingTimestamp();
+			 * orders.get(0).getBillingTimestamp(); }
-			}
+			 */
-			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, billingTimestamp);
+			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, purchase.getCompleteTimestamp());
 			float totalCashback = 0;
 			if (schemes.isEmpty()) {
 				return;
+			}
 			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
+				}
+			}
 			float taxableSellingPrice = amount / (1 + totalTaxRate / 100);
 			amount = taxableSellingPrice * scheme.getAmount() / 100;
 		} else {
+			/*
-			/*List<SchemeInOut> sios = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItem.getId())));
+			 * List<SchemeInOut> sios = schemeInOutRepository.selectByInventoryItemIds(new
+			 * HashSet<>(Arrays.asList(inventoryItem.getId()))); List<Integer> schemeIds =
-			List<Integer> schemeIds = sios.stream().filter(x->x.getSchemeType().equals(SchemeType.IN)).map(x->x.getSchemeId()).collect(Collectors.toList());
+			 * sios.stream().filter(x->x.getSchemeType().equals(SchemeType.IN)).map(x->x.
+			 * getSchemeId()).collect(Collectors.toList()); List<Scheme> schemes =
-			List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds, 0, 0);
+			 * schemeRepository.selectBySchemeIds(schemeIds, 0, 0); if(schemes.
-			if(schemes.*/
+			 */
 			amount = scheme.getAmount();
+		}
 		return amount;
+	}
-	private Map<Integer, InventoryItem> toInventoryItemIdInventoryItemMap(List<InventoryItem> inventoryItems) {
-		Map<Integer, InventoryItem> itemIdInventoryItemMap = new HashMap<>();
-		for (InventoryItem inventoryItem : inventoryItems) {
-			itemIdInventoryItemMap.put(inventoryItem.getId(), inventoryItem);
-		}
-		return itemIdInventoryItemMap;
-	}
-	private Set<Integer> toInventoryItemIds(Set<FofoOrderItem> fofoOrderItems) {
-		Set<Integer> inventoryItemIds = new HashSet<>();
-		// Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap =
-		// this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
-		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
-			for (FofoLineItem fofoLineItem : fofoOrderItem.getFofoLineItems()) {
-				inventoryItemIds.add(fofoLineItem.getInventoryItemId());
-			}
-		}
-		return inventoryItemIds;
-	}
 	@Override
 	public void processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {
 		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);
-		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, fofoOrder.getCreateTimestamp());
-		LOGGER.info("Active Schemes {}", schemes);
-		float totalCashback = 0;
-		int count = 0;
-		if (schemes.isEmpty()) {
-			return;
-		}
-		List<FofoOrderItem> fofoOrderItems = orderService.getByOrderId(fofoOrderId);
+		List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);
+		Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())
-		// LOGGER.info("fofoOrderItems {}", fofoOrderItems);
+				.collect(Collectors.toSet());
+		Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
+				.filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))
+				.collect(Collectors.toSet());
-		Map<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesMap = this.toFofoOrderItemSchemesMap(schemes,
-				fofoOrderItems);
-		LOGGER.info("fofoOrderItemSchemesMap {}", fofoOrderItemSchemesMap);
-		if (fofoOrderItemSchemesMap.isEmpty()) {
+		if (inventoryItems.size() == 0) {
 			return;
+		}
-		Set<Integer> inventoryItemIds = this.toInventoryItemIds(fofoOrderItemSchemesMap.keySet());
-		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
-		Map<Integer, InventoryItem> inventoryItemIdInventoryItemMap = this
-				.toInventoryItemIdInventoryItemMap(inventoryItems);
-		Map<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesMap = new HashMap<>();
-		Map<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesMap = new HashMap<>();
-		for (Map.Entry<FofoOrderItem, Set<Scheme>> fofoOrderItemSchemesEntry : fofoOrderItemSchemesMap.entrySet()) {
-			Set<Scheme> notAllSchemes = new HashSet<>();
-			Set<Scheme> allSchemes = new HashSet<>();
-			for (Scheme scheme : fofoOrderItemSchemesEntry.getValue()) {
-				if (!scheme.isRetailerAll()) {
-					notAllSchemes.add(scheme);
-				} else {
-					allSchemes.add(scheme);
-				}
-			}
-			notAllFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), notAllSchemes);
-			allFofoOrderItemSchemesMap.put(fofoOrderItemSchemesEntry.getKey(), allSchemes);
-		}
-		for (Map.Entry<FofoOrderItem, Set<Scheme>> allFofoOrderItemSchemesEntry : allFofoOrderItemSchemesMap
-				.entrySet()) {
-			for (FofoLineItem fofoLineItem : allFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
-				float itemCashback = 0;
+		float totalCashback = 0;
-				for (Scheme scheme : allFofoOrderItemSchemesEntry.getValue()) {
-					itemCashback += this.createSchemeInOut(scheme,
-							inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
-				}
-				if (itemCashback > 0) {
-					totalCashback += itemCashback;
-					count += 1;
+		int count = 0;
-				}
-			}
-		}
-		Set<Integer> schemeIds = this.fofoLineItemSchemesMapToSchemeIds(notAllFofoOrderItemSchemesMap);
-		if (!schemeIds.isEmpty()) {
-			List<Integer> foundSchemeIds = retailerSchemeRepository.selectSchemeIds(schemeIds, retailerId);
-			for (Map.Entry<FofoOrderItem, Set<Scheme>> notAllFofoOrderItemSchemesEntry : notAllFofoOrderItemSchemesMap
+		for (InventoryItem inventoryItem : inventoryItems) {
-					.entrySet()) {
+			int itemCashback = 0;
-				for (FofoLineItem fofoLineItem : notAllFofoOrderItemSchemesEntry.getKey().getFofoLineItems()) {
+			Purchase purchase = purchaseRepository.selectByIdAndFofoId(inventoryItem.getPurchaseId(), retailerId);
-					float itemCashback = 0;
+			Set<Integer> schemeIds = new HashSet<>(
-					for (Scheme scheme : notAllFofoOrderItemSchemesEntry.getValue()) {
+					schemeItemRepository.selectSchemeIdByItemId(inventoryItem.getItemId()));
+			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.OUT, purchase.getCompleteTimestamp())
-						if (foundSchemeIds.contains(scheme.getId())) {
+					.stream().filter(x -> schemeIds.contains(x.getId())).collect(Collectors.toList());
-							itemCashback += this.createSchemeInOut(scheme,
+			for (Scheme scheme : schemes) {
-									inventoryItemIdInventoryItemMap.get(fofoLineItem.getInventoryItemId()));
+				itemCashback += this.createSchemeInOut(scheme, inventoryItem);
-						}
-					}
+			}
-					if (itemCashback > 0) {
+			if (itemCashback > 0) {
+				count++;
-						totalCashback += itemCashback;
+				totalCashback += itemCashback;
-						count += 1;
-					}
-				}
+			}
+		}
-		if (totalCashback > 0) {
+		if (count > 0) {
 			walletService.addAmountToWallet(retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT,
 					"Sales margin for invoice number " + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",
 					totalCashback);
 			fofoOrder.setCashback(totalCashback);
 			fofoOrderRepository.persist(fofoOrder);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/scheme/SchemeServiceImpl.java – Rev 24976 → 25043