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

 import com.spice.profitmandi.common.model.SchemeModel;
 import com.spice.profitmandi.common.model.SendNotificationModel;
 import com.spice.profitmandi.common.services.ReporticoService;
 import com.spice.profitmandi.common.util.FormattingUtils;
 import com.spice.profitmandi.common.util.StringUtils;
+import com.spice.profitmandi.common.util.Utils;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.Scheme;
 import com.spice.profitmandi.dao.entity.fofo.*;
 import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
 import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
 	private ScanRecordRepository scanRecordRepository;
 	@Autowired
 	private SessionFactory sessionFactory;
-	private Set<Integer> tagIds = new HashSet<Integer>(Arrays.asList(4));
+	private static final Set<Integer> tagIds = new HashSet<Integer>(Arrays.asList(4));
 	@Autowired
 	private SchemeRepository schemeRepository;
 	@Autowired
 	@Autowired
 	private WalletService walletService;
 	@Autowired
-	private FofoOrderItemRepository fofoOrderItemRepository;
-	@Autowired
-	private FofoLineItemRepository fofoLineItemRepository;
-	@Autowired
 	private PurchaseRepository purchaseRepository;
 	@Autowired
 	private FofoOrderRepository fofoOrderRepository;
 					scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");
+		}
 		// this.validateItemIds(createSchemeRequest);
 		schemeRepository.persist(scheme);
-		for (int itemId : createSchemeRequest.getItemIds()) {
+		for (int catalogId : createSchemeRequest.getCatalogIds()) {
 			SchemeItem schemeItem = new SchemeItem();
 			schemeItem.setSchemeId(scheme.getId());
-			schemeItem.setItemId(itemId);
+			schemeItem.setCatalogId(catalogId);
 			schemeItemRepository.persist(schemeItem);
+		}
+	}
 		return scheme;
+	}
 	private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {
-		if (createSchemeRequest.getItemIds() == null || createSchemeRequest.getItemIds().isEmpty()) {
+		if (createSchemeRequest.getCatalogIds() == null || createSchemeRequest.getCatalogIds().isEmpty()) {
-			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
+			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),
 					"SCHM_1003");
+		}
-		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getItemIds(),
+		List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getCatalogIds(),
 				ItemType.SERIALIZED);
-		if (foundItemIds.size() != createSchemeRequest.getItemIds().size()) {
+		if (foundItemIds.size() != createSchemeRequest.getCatalogIds().size()) {
-			createSchemeRequest.getItemIds().removeAll(foundItemIds);
+			createSchemeRequest.getCatalogIds().removeAll(foundItemIds);
-			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getItemIds(),
+			throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),
 					"SCHM_1004");
+		}
+	}
 	@Override
 	public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {
 		Scheme scheme = schemeRepository.selectById(schemeId);
-		List<Integer> itemIds = schemeItemRepository.selectItemIdsBySchemeId(scheme.getId());
+		List<Integer> catalogIds = schemeItemRepository.selectCatalogIdsBySchemeId(scheme.getId());
-		if (itemIds.size() > 0) {
+		if (catalogIds.size() > 0) {
-			List<Item> items = itemRepository.selectByIds(new HashSet<>(itemIds));
+			List<Item> items = itemRepository.selectAllByCatalogIds(new HashSet<>(catalogIds));
-			scheme.setItemStringMap(this.toItemStringMap(items));
+			scheme.setCatalogStringMap(this.toCatalogStringMap(items));
+		}
 		return scheme;
+	}
-	public Map<Integer, String> toItemStringMap(List<Item> items) {
+	public Map<Integer, String> toCatalogStringMap(List<Item> items) {
-		Map<Integer, String> itemMap = new HashMap<>();
+		Map<Integer, String> catalogMap = new HashMap<>();
 		for (Item item : items) {
-			itemMap.put(item.getId(), this.getItemString(item));
-		}
-		return itemMap;
-	}
-	public String getItemString(Item item) {
-		StringBuilder itemString = new StringBuilder();
-		if (item.getBrand() != null && !item.getBrand().isEmpty()) {
+			if (!catalogMap.containsKey(item.getCatalogItemId())) {
-			itemString.append(item.getBrand().trim());
-		}
-		itemString.append(" ");
-		if (item.getModelName() != null && !item.getModelName().isEmpty()) {
-			itemString.append(item.getModelName().trim());
-		}
-		itemString.append(" ");
-		if (item.getModelNumber() != null && !item.getModelNumber().isEmpty()) {
-			itemString.append(item.getModelNumber().trim());
+				catalogMap.put(item.getCatalogItemId(), item.getItemDescriptionNoColor());
-		}
+			}
-		itemString.append(" ");
-		if (item.getColor() != null && !item.getColor().isEmpty()) {
-			itemString.append(item.getColor().trim());
+		}
-		return itemString.toString();
+		return catalogMap;
+	}
-	private Set<Integer> schemeItemsToItemIds(List<SchemeItem> schemeItems) {
+	private Set<Integer> schemeItemsToCatalogIds(List<SchemeItem> schemeItems) {
-		Set<Integer> itemIds = new HashSet<>();
+		Set<Integer> catalogId = new HashSet<>();
 		for (SchemeItem schemeItem : schemeItems) {
-			itemIds.add(schemeItem.getItemId());
+			catalogId.add(schemeItem.getCatalogId());
+		}
-		return itemIds;
+		return catalogId;
+	}
 	@Override
 	public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {
 		List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);
-		Map<Integer, Scheme> schemeIdSchemeMap = this.toSchemeIdSchemeMap(schemes);
+		Map<Integer, Scheme> schemeIdSchemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
 		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());
-		Set<Integer> itemIds = this.schemeItemsToItemIds(schemeItems);
+		Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
-		List<Item> items = itemRepository.selectByIds(itemIds);
+		List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);
-		Map<Integer, String> itemStringMap = this.toItemStringMap(items);
+		Map<Integer, String> catalogStringMap = this.toCatalogStringMap(items);
-		this.addItemIdsToSchemes(schemeItems, schemeIdSchemeMap, itemStringMap);
+		this.addCatalogIdsToSchemes(schemeItems, schemeIdSchemeMap, catalogStringMap);
 		return this.toSchemeModels(schemeIdSchemeMap);
+	}
 	@Autowired
 	NotificationService notificationService;
 		schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));
 		schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));
 		schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));
 		schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));
 		schemeModel.setCreatedBy(scheme.getCreatedBy());
-		schemeModel.setItemStringMap(scheme.getItemStringMap());
+		schemeModel.setCatalogStringMap(scheme.getCatalogStringMap());
 		schemeModel.setRetailerIds(scheme.getRetailerIds());
 		return schemeModel;
+	}
-	private void addItemIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
+	private void addCatalogIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,
-									 Map<Integer, String> itemStringMap) {
+										Map<Integer, String> catalogStringMap) {
 		for (SchemeItem schemeItem : schemeItems) {
-			schemeIdSchemeMap.get(schemeItem.getSchemeId()).getItemStringMap().put(schemeItem.getItemId(),
+			Scheme scheme = schemeIdSchemeMap.get(schemeItem.getSchemeId());
-					itemStringMap.get(schemeItem.getItemId()));
+			scheme.getCatalogStringMap().put(schemeItem.getCatalogId(), catalogStringMap.get(schemeItem.getCatalogId()));
+		}
+	}
 	@Override
 	public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {
 	private void sendSchemeNotification(Scheme scheme) throws ProfitMandiBusinessException {
 		if (scheme.getType().equals(SchemeType.ACTIVATION)) {
 			SendNotificationModel sendNotificationModel = new SendNotificationModel();
 			List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(Collections.singleton(scheme.getId()));
-			Set<Integer> itemIds = schemeItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
+			Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());
-			List<String> itemDescriptions = itemRepository.selectByIds(itemIds).stream().map(x -> x.getItemDescriptionNoColor()).distinct().collect(Collectors.toList());
+			List<String> itemDescriptions = itemRepository.selectAllByCatalogIds(catalogIds).stream().filter(Utils.distinctByKey(Item::getCatalogItemId))
+					.map(x -> x.getItemDescriptionNoColor()).collect(Collectors.toList());
 			String title = "Activation scheme of Rs." + FormattingUtils.formatDecimal(scheme.getAmount()) + " for " + String.join(", ", itemDescriptions);
 			String message = "Duration from - " + FormattingUtils.formatDateMonth(scheme.getStartDateTime()) + " - " + FormattingUtils.formatDateMonth(scheme.getEndDateTime());
 			sendNotificationModel.setCampaignName("activationscheme");
 			itemIds.add(inventoryItem.getItemId());
+		}
 		return itemIds;
+	}
-	private Map<Integer, Set<Scheme>> toItemIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
+	private Map<Integer, Set<Scheme>> toCatalogIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {
 		Map<Integer, Scheme> schemeIdSchemesMap = this.toSchemeIdSchemeMap(schemes);
-		Map<Integer, Set<Scheme>> itemIdSchemesMap = new HashMap<>();
+		Map<Integer, Set<Scheme>> catalogIdSchemesMap = new HashMap<>();
 		for (SchemeItem schemeItem : schemeItems) {
-			if (!itemIdSchemesMap.containsKey(schemeItem.getItemId())) {
+			if (!catalogIdSchemesMap.containsKey(schemeItem.getCatalogId())) {
 				Set<Scheme> schemesSet = new HashSet<>();
 				schemesSet.add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
-				itemIdSchemesMap.put(schemeItem.getItemId(), schemesSet);
+				catalogIdSchemesMap.put(schemeItem.getCatalogId(), schemesSet);
 			} else {
-				itemIdSchemesMap.get(schemeItem.getItemId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
+				catalogIdSchemesMap.get(schemeItem.getCatalogId()).add(schemeIdSchemesMap.get(schemeItem.getSchemeId()));
+			}
+		}
-		return itemIdSchemesMap;
+		return catalogIdSchemesMap;
+	}
 	private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,
 																	  List<InventoryItem> inventoryItems) {
 		Set<Integer> schemeIds = new HashSet<>();
 		for (Scheme scheme : schemes) {
 			schemeIds.add(scheme.getId());
+		}
 		Set<Integer> itemIds = this.inventoryItemsToItemIds(inventoryItems);
-		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndItemIds(schemeIds, itemIds);
+		List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndCatalogIds(schemeIds, itemIds);
-		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toItemIdSchemesMap(schemeItems, schemes);
+		Map<Integer, Set<Scheme>> itemIdSchemesMap = this.toCatalogIdSchemesMap(schemeItems, schemes);
 		Map<InventoryItem, Set<Scheme>> inventoryItemSchemsMap = new HashMap<>();
 		for (InventoryItem inventoryItem : inventoryItems) {
 			if (itemIdSchemesMap.containsKey(inventoryItem.getItemId())) {
 				inventoryItemSchemsMap.put(inventoryItem, itemIdSchemesMap.get(inventoryItem.getItemId()));
+			}
 					fofoOrder.getCreateTimestamp(), false);
 			for (InventoryItem inventoryItem : inventoryItems) {
 				float itemCashback = 0;
 				Set<Integer> schemeIds = new HashSet<>(
-						schemeItemRepository.selectSchemeIdByItemId(inventoryItem.getItemId()));
+						schemeItemRepository.selectSchemeIdByCatalogId(inventoryItem.getItem().getCatalogItemId()));
 				List<Scheme> itemActiveSchemes = allActiveSchemes.stream().filter(x -> schemeIds.contains(x.getId()))
 						.collect(Collectors.toList());
 				for (Scheme scheme : itemActiveSchemes) {
 					LOGGER.info("Scheme ==== {}", scheme);
 					itemCashback += this.createSchemeInOut(scheme, inventoryItem);
+	}
 	@Override
 	@Cacheable(value = "itemSchemeCashback", cacheManager = "timeoutCacheManager")
-	public Map<Integer, Float> getItemSchemeCashBack() {
+	public Map<Integer, Float> getCatalogSchemeCashBack() {
 		Map<Integer, Float> itemCashbackMap = new HashMap<>();
 		Map<Integer, Scheme> cashbackSchemesMap = schemeRepository
 				.selectActiveAll(Arrays.asList(SchemeType.ACTIVATION), PartnerType.ALL, LocalDateTime.now(), false)
 				.stream().filter(x -> x.getAmountType().equals(AmountType.FIXED))
 				.collect(Collectors.toMap(x -> x.getId(), x -> x));
 		if (cashbackSchemesMap.size() > 0) {
 			List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(cashbackSchemesMap.keySet());
 			schemeItems.stream().forEach(x -> {
 				float cashbackAmount = cashbackSchemesMap.get(x.getSchemeId()).getAmount();
-				if (!itemCashbackMap.containsKey(x.getItemId())) {
+				if (!itemCashbackMap.containsKey(x.getCatalogId())) {
-					itemCashbackMap.put(x.getItemId(), cashbackAmount);
+					itemCashbackMap.put(x.getCatalogId(), cashbackAmount);
 				} else {
-					itemCashbackMap.put(x.getItemId(), itemCashbackMap.get(x.getItemId()) + cashbackAmount);
+					itemCashbackMap.put(x.getCatalogId(), itemCashbackMap.get(x.getCatalogId()) + cashbackAmount);
+				}
 			});
+		}
 		// A107FD Model needs to removed
 		itemCashbackMap.remove(30211);
+	 *
 	 * }
 	 */
 	@Override
-	public List<Scheme> selectSchemeByPartnerType(PartnerType partnerType, LocalDate onDate, int itemId,
+	public List<Scheme> selectSchemeByPartnerType(PartnerType partnerType, LocalDate onDate, int catalogId,
 												  boolean isAdmin, int offset, int limit) throws ProfitMandiBusinessException {
 		Session session = sessionFactory.getCurrentSession();
 		CriteriaBuilder cb = session.getCriteriaBuilder();
 		CriteriaQuery<Scheme> query = cb.createQuery(Scheme.class);
 		Root<Scheme> scheme = query.from(Scheme.class);
+		Predicate finalPredicate = cb.and();
+		if (partnerType.equals(PartnerType.ALL)) {
-		List<PartnerType> pt = new ArrayList<>();
+			List<PartnerType> pt = new ArrayList<>();
-		pt.add(PartnerType.ALL);
+			pt.add(PartnerType.ALL);
-		pt.add(partnerType);
+			pt.add(partnerType);
-		Predicate p1 = cb.in(scheme.get("partnerType")).value(pt);
+			Predicate p1 = cb.in(scheme.get("partnerType")).value(pt);
+			finalPredicate = cb.and(p1);
+		}
 		Predicate p2 = cb.isNotNull(scheme.get("activeTimestamp"));
 		cb.desc(cb.isNull(scheme.get("expireTimestamp")));
-		Predicate p3 = null;
-		Predicate finalPredicate = null;
-		if (itemId != 0) {
+		if (catalogId > 0) {
-			List<Integer> schemeIds = schemeItemRepository.selectSchemeIdByItemId(itemId);
+			List<Integer> schemeIds = schemeItemRepository.selectSchemeIdByCatalogId(catalogId);
 			LOGGER.info("schemeId" + schemeIds);
 			if (schemeIds.isEmpty()) {
 				return new ArrayList<>();
+			}
-			p3 = cb.in(scheme.get("id")).value(schemeIds);
+			Predicate p3 = cb.in(scheme.get("id")).value(schemeIds);
-			if (!isAdmin) {
+			if (onDate != null) {
-				finalPredicate = cb.and(p1, p2, p3, cb.greaterThan(scheme.get("endDateTime"), onDate.atStartOfDay()),
+				finalPredicate = cb.and(p2, p3, cb.greaterThan(scheme.get("endDateTime"), onDate.atStartOfDay()),
 						cb.lessThanOrEqualTo(scheme.get("startDateTime"), onDate.atStartOfDay()));
-				query.where(finalPredicate);
 			} else {
-				finalPredicate = cb.and(p1, p3);
+				finalPredicate = cb.and(p3);
-				query.where(finalPredicate);
+			}
 		} else {
 			if (!isAdmin) {
-				finalPredicate = cb.and(p1, p2);
+				finalPredicate = cb.and(p2);
-				query.where(finalPredicate);
-			} else {
-				query.where(p1);
+			}
+		}
+		query.where(finalPredicate);
 		query.orderBy(cb.desc(cb.function("isnull", Boolean.class, scheme.get("expireTimestamp"))));
 		return session.createQuery(query).setFirstResult(offset).setMaxResults(limit).getResultList();
+	}
 	@Override
-	public long selectSchemeCount(PartnerType partnerType, LocalDate onDate, int itemId, boolean isAdmin) {
-		Session session = sessionFactory.getCurrentSession();
-		CriteriaBuilder cb = session.getCriteriaBuilder();
-		CriteriaQuery<Long> query = cb.createQuery(Long.class);
-		Root<Scheme> scheme = query.from(Scheme.class);
-		List<PartnerType> pt = new ArrayList<>();
-		pt.add(PartnerType.ALL);
-		pt.add(partnerType);
-		Predicate p1 = cb.in(scheme.get("partnerType")).value(pt);
-		Predicate p2 = cb.isNotNull(scheme.get("activeTimestamp"));
-		Predicate finalPredicate = null;
-		if (itemId != 0) {
-			List<Integer> schemeIds = schemeItemRepository.selectSchemeIdByItemId(itemId);
-			Predicate p3 = cb.in(scheme.get("id")).value(schemeIds);
-			if (!isAdmin) {
-				finalPredicate = cb.and(p1, p2, p3, cb.greaterThan(scheme.get("endDateTime"), onDate.atStartOfDay()),
-						cb.lessThanOrEqualTo(scheme.get("startDateTime"), onDate.atStartOfDay()));
-				query.select(cb.count(scheme)).where(finalPredicate);
-			} else {
-				finalPredicate = cb.and(p1, p3);
-				query.select(cb.count(scheme)).where(finalPredicate);
-			}
-		} else {
-			if (!isAdmin) {
-				finalPredicate = cb.and(p1, p2);
-				query.select(cb.count(scheme)).where(finalPredicate);
-			} else {
-				query.select(cb.count(scheme)).where(p1);
-			}
-		}
-		return session.createQuery(query).getSingleResult();
-	}
-	@Override
 	public void processActivation() throws ProfitMandiBusinessException {
 		List<SchemeInOut> pendingPayouts = schemeInOutRepository.selectAllPending();
 		List<Integer> schemeIds = new ArrayList<>();
 		Set<Integer> inventoryIds = new HashSet<>();
 		for (SchemeInOut pendingPayout : pendingPayouts) {

Subversion Repositories SmartDukaan

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