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

 	@Qualifier("fofoInventoryItemRepository")
 	private InventoryItemRepository inventoryItemRepository;
 	@Autowired
 	private ActivatedImeiRepository activatedImeiRepository;
 	@Autowired
 	private PartnerTypeChangeService partnerTypeChangeService;
 	@Autowired
 	private PurchaseService purchaseService;
 	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);
 		PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,
 				purchase.getCreateTimestamp().toLocalDate());
-		LOGGER.info("purchase is completed = {}", (purchase.getCompleteTimestamp() != null));
-		if (purchase.getCompleteTimestamp() != null) {
-			List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, partnerType,
+		List<Scheme> schemes = schemeRepository.selectActiveAll(SchemeType.IN, partnerType,
-					purchase.getCompleteTimestamp(), false);
+				purchase.getCreateTimestamp(), false);
-			float totalCashback = 0;
+		float totalCashback = 0;
-			if (schemes.isEmpty()) {
+		if (schemes.isEmpty()) {
-				return;
+			return;
-			}
+		}
-			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
+		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);
-			Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
-			LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);
-			Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
-					.filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())
-					.collect(Collectors.toSet());
-			// Only consider inventory items that were not returned
-			inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))
-					.filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))
-					.filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());
-			LOGGER.info(inventoryItems);
-			if (inventoryItems.size() == 0)
-				return;
-			Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,
-					inventoryItems);
-			if (inventoryItemSchemesMap.isEmpty()) {
-				return;
-			}
-			Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
-			for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
-				Set<Scheme> allSchemes = new HashSet<>();
-				for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
-					allSchemes.add(scheme);
-				}
-				allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
-			}
+		Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
+		LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);
+		Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()
+				.filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())
+				.collect(Collectors.toSet());
+		// Only consider inventory items that were not returned
+		inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))
+				.filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))
+				.filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());
+		LOGGER.info(inventoryItems);
+		if (inventoryItems.size() == 0)
-			//
+			return;
+		Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,
+				inventoryItems);
-			int itemsCount = 0;
+		if (inventoryItemSchemesMap.isEmpty()) {
-			for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
-					.entrySet()) {
+			return;
-				float inventoryItemCashback = 0;
-				for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
-					InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
-					float cashback = this.createSchemeInOut(scheme, inventoryItem);
-					inventoryItemCashback += cashback;
-				}
+		}
-				if (inventoryItemCashback > 0) {
-					totalCashback += inventoryItemCashback;
+		Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();
-					itemsCount++;
-				}
-			}
+		for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {
+			Set<Scheme> allSchemes = new HashSet<>();
+			for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {
+				allSchemes.add(scheme);
+			}
-			LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
+			allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);
+		}
+		//
-			if (itemsCount > 0) {
+		int itemsCount = 0;
+		for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap
+				.entrySet()) {
-				walletService.addAmountToWallet(
+			float inventoryItemCashback = 0;
-						retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "
+			for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {
-								+ purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",
+				InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();
-						totalCashback, purchase.getCreateTimestamp());
+				float cashback = this.createSchemeInOut(scheme, inventoryItem);
-				LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
+				inventoryItemCashback += cashback;
+			}
-						purchase.getPurchaseReference(), itemsCount);
+			if (inventoryItemCashback > 0) {
-				purchase.setCashback(purchase.getCashback() + totalCashback);
+				totalCashback += inventoryItemCashback;
-				purchaseRepository.persist(purchase);
+				itemsCount++;
+			}
+		}
+		LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);
+		if (itemsCount > 0) {
+			walletService.addAmountToWallet(
+					retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "
+							+ purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",
+					totalCashback, purchase.getCreateTimestamp());
+			LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,
+					purchase.getPurchaseReference(), itemsCount);
+			purchase.setCashback(purchase.getCashback() + totalCashback);
+			purchaseRepository.persist(purchase);
+		}
+	}
 	private float createSchemeInOut(Scheme scheme, InventoryItem inventoryItem) {
 		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());
 		float amountToCredit = 0;
 			amountToCredit = this.getAmount(inventoryItem, scheme);
 			schemeInOut.setSchemeId(scheme.getId());
 			schemeInOut.setInventoryItemId(inventoryItem.getId());
 			schemeInOut.setAmount(amountToCredit);
 			schemeInOutRepository.persist(schemeInOut);
-			if(scheme.getType().equals(SchemeType.ACTIVATION)) {
+			if (scheme.getType().equals(SchemeType.ACTIVATION)) {
 				schemeInOut.setStatus(SchemePayoutStatus.PENDING);
 				schemeInOut.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());
 				return 0;
-			} else if(scheme.getType().equals(SchemeType.INVESTMENT)) {
+			} else if (scheme.getType().equals(SchemeType.INVESTMENT)) {
-					schemeInOut.setStatus(SchemePayoutStatus.PENDING);
+				schemeInOut.setStatus(SchemePayoutStatus.PENDING);
-					schemeInOut.setStatusDescription("Subject to investment days maintained");
+				schemeInOut.setStatusDescription("Subject to investment days maintained");
-					return 0;
+				return 0;
 			} else {
 				schemeInOut.setStatus(SchemePayoutStatus.CREDITED);
-				if(scheme.getType().equals(SchemeType.IN)) {
+				if (scheme.getType().equals(SchemeType.IN)) {
 					schemeInOut.setStatusDescription("Credited for GRN of IMEI#" + inventoryItem.getSerialNumber());
+				}
 				schemeInOut.setStatusDescription("Credited for sale of IMEI#" + inventoryItem.getSerialNumber());
 				schemeInOut.setCreditTimestamp(LocalDateTime.now());
+			}
+		}
 		float totalCashback = 0;
 		int count = 0;
-		List<Scheme> allActiveSchemes = schemeRepository
+		List<Scheme> allActiveSchemes = schemeRepository.selectActiveAll(SchemeType.OUT, partnerType,
-				.selectActiveAll(SchemeType.OUT, partnerType, fofoOrder.getCreateTimestamp(), false);
+				fofoOrder.getCreateTimestamp(), false);
-		allActiveSchemes.addAll(schemeRepository.selectActiveAll(SchemeType.ACTIVATION, partnerType, fofoOrder.getCreateTimestamp(), false));
+		allActiveSchemes.addAll(schemeRepository.selectActiveAll(SchemeType.ACTIVATION, partnerType,
+				fofoOrder.getCreateTimestamp(), false));
-		allActiveSchemes.addAll(schemeRepository.selectActiveAll(SchemeType.INVESTMENT, partnerType, fofoOrder.getCreateTimestamp(), false));
+		allActiveSchemes.addAll(schemeRepository.selectActiveAll(SchemeType.INVESTMENT, partnerType,
+				fofoOrder.getCreateTimestamp(), false));
 		for (InventoryItem inventoryItem : inventoryItems) {
 			float itemCashback = 0;
-			Purchase purchase = purchaseRepository.selectByIdAndFofoId(inventoryItem.getPurchaseId(), retailerId);
 			Set<Integer> schemeIds = new HashSet<>(
 					schemeItemRepository.selectSchemeIdByItemId(inventoryItem.getItemId()));
-			if (purchase.getCompleteTimestamp() == null) {
-				continue;
-			}
-			allActiveSchemes = allActiveSchemes.stream().filter(x -> schemeIds.contains(x.getId())).collect(Collectors.toList());
+			allActiveSchemes = allActiveSchemes.stream().filter(x -> schemeIds.contains(x.getId()))
+					.collect(Collectors.toList());
 			for (Scheme scheme : allActiveSchemes) {
 				itemCashback += this.createSchemeInOut(scheme, inventoryItem);
+			}
 			if (itemCashback > 0) {
 				count++;
 		float amountToRollback = 0;
 		List<SchemeInOut> schemes = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIdSet);
 		for (SchemeInOut schemeInOut : schemes) {
 			if (schemeInOut.getRolledBackTimestamp() == null) {
 				schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
-				if(schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
+				if (schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
 					amountToRollback += schemeInOut.getAmount();
+				}
 				schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
 				schemeInOut.setStatusDescription(rollbackReason);
+			}
+		}
 		if (amountToRollback > 0) {
 			int inventoryItemId = inventoryItemIds.get(0);
 			InventoryItem ii = inventoryItemRepository.selectById(inventoryItemId);
 			Integer fofoId = ii.getFofoId();
-			//Purchase p = purchaseRepository.selectById(ii.getPurchaseId());
+			// Purchase p = purchaseRepository.selectById(ii.getPurchaseId());
 			// TODO//
 			walletService.rollbackAmountFromWallet(fofoId, amountToRollback, ii.getPurchaseId(),
 					WalletReferenceType.SCHEME_IN, rollbackReason, LocalDateTime.now());
+		}
+	}
+		}
 		return schemes;
+	}
 	@Override
-	//This is being called to reverse schemes while processing price Drop
+	// This is being called to reverse schemes while processing price Drop
 	public void reverseSchemes(List<InventoryItem> inventoryItems, int priceDropId, String reversalReason)
 			throws ProfitMandiBusinessException {
 		PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);
 		Map<Integer, List<InventoryItem>> purchaseInventoryListMap = inventoryItems.stream()
 				.collect(Collectors.groupingBy(InventoryItem::getPurchaseId, Collectors.toList()));
 			Map<Integer, InventoryItem> inventoryItemsMap = purchaseInventoryItemList.stream()
 					.collect(Collectors.toMap(x -> x.getId(), x -> x));
 			List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
 			LOGGER.info("Scheme InOuts , {}", schemeInOuts);
-			if(schemeInOuts.size() == 0) {
+			if (schemeInOuts.size() == 0) {
 				continue;
+			}
 			List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());
 			Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())
 					.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+				}
 				if (scheme.getType().equals(SchemeType.IN) && schemeInOut.getRolledBackTimestamp() == null) {
 					float newAmount = getAmount(ii, scheme);
 					if (schemeInOut.getAmount() - newAmount >= 0.01f) {
 						schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
 						SchemeInOut sioNew = new SchemeInOut();
 						sioNew.setAmount(newAmount);
 						sioNew.setStatus(schemeInOut.getStatus());
 						sioNew.setStatusDescription(schemeInOut.getStatusDescription());
 						sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());
 						sioNew.setSchemeId(schemeInOut.getSchemeId());
 						schemeInOutRepository.persist(sioNew);
 						schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
 						schemeInOut.setStatusDescription("Pricedrop processed, new entries added");
-						//IF not credited then dont consider any credit/debit for that sio entry
+						// IF not credited then dont consider any credit/debit for that sio entry
-						if(schemeInOut.getCreditTimestamp()!=null) {
+						if (schemeInOut.getCreditTimestamp() != null) {
 							amountToCredit += sioNew.getAmount();
 							amountToDebit += schemeInOut.getAmount();
+						}
+					}
+			}
+		}
+	}
 	@Override
-	//Always being called from cancel order means no SCHEME IN is considered
+	// Always being called from cancel order means no SCHEME IN is considered
 	public void reverseSchemes(List<InventoryItem> inventoryItems, int reversalReference, String reversalReason,
 			SchemeType schemeType) throws ProfitMandiBusinessException {
 		Map<Integer, InventoryItem> inventoryItemsMap = inventoryItems.stream()
 				.collect(Collectors.toMap(x -> x.getId(), x -> x));
 		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());
 		for (SchemeInOut schemeInOut : schemeInOuts) {
 			Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());
 			if (scheme.getType().equals(schemeType)) {
 				if (schemeInOut.getRolledBackTimestamp() == null) {
 					schemeInOut.setRolledBackTimestamp(LocalDateTime.now());
-					if(schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
+					if (schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {
 						amountToRollback += schemeInOut.getAmount();
+					}
 					schemeInOut.setStatus(SchemePayoutStatus.REJECTED);
 					schemeInOut.setStatusDescription(reversalReason);
+				}
+			}
+		}
 		int fofoId = inventoryItems.get(0).getFofoId();
 		WalletReferenceType walletReferenceType = schemeType.equals(SchemeType.OUT) ? WalletReferenceType.SCHEME_OUT
-				: schemeType.equals(SchemeType.INVESTMENT) ? WalletReferenceType.INVESTMENT_PAYOUT : WalletReferenceType.ACTIVATION_SCHEME;
+				: schemeType.equals(SchemeType.INVESTMENT) ? WalletReferenceType.INVESTMENT_PAYOUT
+						: WalletReferenceType.ACTIVATION_SCHEME;
 		if (amountToRollback > 0) {
 			// TODO//
 			walletService.rollbackAmountFromWallet(fofoId, amountToRollback, reversalReference, walletReferenceType,
 					reversalReason, LocalDateTime.now());
+		}
+	 *
 	 * }
 	 */
 	@Override
-	public List<Scheme> selectSchemeByPartnerType(PartnerType partnerType, LocalDate onDate, int itemId, boolean isAdmin, int offset,
+	public List<Scheme> selectSchemeByPartnerType(PartnerType partnerType, LocalDate onDate, int itemId,
-			int limit) throws ProfitMandiBusinessException {
+			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);
 		List<PartnerType> pt = new ArrayList<>();
 		cb.desc(cb.isNull(scheme.get("expireTimestamp")));
 		Predicate p3 = null;
 		Predicate finalPredicate = null;
 		if (itemId != 0) {
 			List<Integer> schemeIds = schemeItemRepository.selectSchemeIdByItemId(itemId);
 			LOGGER.info("schemeId" + schemeIds);
-			if(schemeIds.isEmpty()) {
+			if (schemeIds.isEmpty()) {
 				return new ArrayList<>();
+			}
 			p3 = cb.in(scheme.get("id")).value(schemeIds);
 			if (!isAdmin) {
+		}
 		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) {
+		for (SchemeInOut pendingPayout : pendingPayouts) {
 			schemeIds.add(pendingPayout.getSchemeId());
+		}
 		Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, 0).stream()
-				.filter(x->x.getType().equals(SchemeType.ACTIVATION)).collect(Collectors.toMap(x->x.getId(), x->x));
+				.filter(x -> x.getType().equals(SchemeType.ACTIVATION))
+				.collect(Collectors.toMap(x -> x.getId(), x -> x));
-		pendingPayouts = pendingPayouts.stream().filter(x->schemesMap.get(x.getSchemeId())!=null).collect(Collectors.toList());
+		pendingPayouts = pendingPayouts.stream().filter(x -> schemesMap.get(x.getSchemeId()) != null)
+				.collect(Collectors.toList());
-		for (SchemeInOut pendingPayout: pendingPayouts) {
+		for (SchemeInOut pendingPayout : pendingPayouts) {
 			inventoryIds.add(pendingPayout.getInventoryItemId());
+		}
-		Map<Integer, InventoryItem> inventoryItemMap = inventoryItemRepository.selectByIds(inventoryIds).stream().collect(Collectors.toMap(x->x.getId(), x->x));
+		Map<Integer, InventoryItem> inventoryItemMap = inventoryItemRepository.selectByIds(inventoryIds).stream()
+				.collect(Collectors.toMap(x -> x.getId(), x -> x));
-		Map<String, InventoryItem> serialNumberMap = inventoryItemMap.values().stream(). collect(Collectors.toMap(x->x.getSerialNumber(), x->x));
+		Map<String, InventoryItem> serialNumberMap = inventoryItemMap.values().stream()
+				.collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x));
+		List<ActivatedImei> activatedImeis = activatedImeiRepository
-		List<ActivatedImei> activatedImeis = activatedImeiRepository.selectBySerialNumbers(new ArrayList<>(serialNumberMap.keySet()));
+				.selectBySerialNumbers(new ArrayList<>(serialNumberMap.keySet()));
-		Map<String, ActivatedImei> activatedImeiMap = activatedImeis.stream().collect(Collectors.toMap(x->x.getSerialNumber(), x->x));
+		Map<String, ActivatedImei> activatedImeiMap = activatedImeis.stream()
+				.collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x));
-		for(SchemeInOut pendingPayout : pendingPayouts) {
+		for (SchemeInOut pendingPayout : pendingPayouts) {
 			InventoryItem ii = inventoryItemMap.get(pendingPayout.getInventoryItemId());
 			String serialNumber = ii.getSerialNumber();
 			ActivatedImei activatedImei = activatedImeiMap.get(serialNumber);
-			if(activatedImei == null) {
+			if (activatedImei == null) {
 				continue;
+			}
 			Scheme scheme = schemesMap.get(pendingPayout.getSchemeId());
-			if(activatedImei.getActivationTimestamp().isBefore(scheme.getEndDateTime())
+			if (activatedImei.getActivationTimestamp().isBefore(scheme.getEndDateTime())
-				&& activatedImei.getActivationTimestamp().isAfter(scheme.getStartDateTime())) {
+					&& activatedImei.getActivationTimestamp().isAfter(scheme.getStartDateTime())) {
 				int fofoId = ii.getFofoId();
-				//Get latest order Id
+				// Get latest order Id
-				int orderId = scanRecordRepository.selectByInventoryItemId(ii.getId()).stream().filter(x->x.getOrderId() > 0).
+				int orderId = scanRecordRepository.selectByInventoryItemId(ii.getId()).stream()
+						.filter(x -> x.getOrderId() > 0)
-				sorted(Comparator.comparing(ScanRecord::getCreateTimestamp).reversed()).findFirst().get().getOrderId();
+						.sorted(Comparator.comparing(ScanRecord::getCreateTimestamp).reversed()).findFirst().get()
+						.getOrderId();
 				FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
-				walletService.addAmountToWallet(fofoId, orderId, WalletReferenceType.ACTIVATION_SCHEME, "Activation margin for Imei#" + serialNumber,
+				walletService.addAmountToWallet(fofoId, orderId, WalletReferenceType.ACTIVATION_SCHEME,
+						"Activation margin for Imei#" + serialNumber, pendingPayout.getAmount(),
-						pendingPayout.getAmount(), fofoOrder.getCreateTimestamp());
+						fofoOrder.getCreateTimestamp());
 				pendingPayout.setCreditTimestamp(LocalDateTime.now());
 				pendingPayout.setStatus(SchemePayoutStatus.CREDITED);
 				pendingPayout.setStatusDescription("Activation margin credited");
 			} else {
 				pendingPayout.setStatus(SchemePayoutStatus.REJECTED);
-				pendingPayout.setRolledBackTimestamp(LocalDateTime.now());;
+				pendingPayout.setRolledBackTimestamp(LocalDateTime.now());
+				;
+				pendingPayout.setStatusDescription(
-				pendingPayout.setStatusDescription("Rejected, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
+						"Rejected, activated on " + FormattingUtils.formatDate(activatedImei.getActivationTimestamp()));
+			}
+		}
+	}
+}

Subversion Repositories SmartDukaan

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