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

 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Random;
 import java.util.Set;
+import java.util.AbstractMap.SimpleEntry;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
 import org.json.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
+import com.mongodb.MongoClient;
 import com.spice.profitmandi.common.enumuration.ItemType;
 import com.spice.profitmandi.common.enumuration.SearchType;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
 import com.spice.profitmandi.common.model.BadReturnRequest;
 import com.spice.profitmandi.common.model.CartFofo;
 import com.spice.profitmandi.dao.repository.catalog.StateGstRateRepository;
 import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
 import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
 import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
+import com.spice.profitmandi.dao.repository.dtr.Mongo;
 import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;
 import com.spice.profitmandi.dao.repository.dtr.PolicyNumberGenerationSequenceRepository;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
 import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
 import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
 import com.spice.profitmandi.service.integrations.zest.InsuranceService;
 import com.spice.profitmandi.service.inventory.InventoryService;
 import com.spice.profitmandi.service.inventory.PurchaseReturnService;
 import com.spice.profitmandi.service.inventory.SaholicInventoryService;
+import com.spice.profitmandi.service.offers.ItemCriteria;
+import com.spice.profitmandi.service.offers.PartnerCriteria;
 import com.spice.profitmandi.service.pricing.PricingService;
 import com.spice.profitmandi.service.scheme.SchemeService;
 import com.spice.profitmandi.service.user.RetailerService;
 import com.spice.profitmandi.service.wallet.WalletService;
 	@Autowired
 	private SchemeService schemeService;
 	private static final List<Integer> orderIdsConsumed = new ArrayList<>();
 	@Autowired
 	@Qualifier("fofoInventoryService")
 	private InventoryService inventoryService;
 	@Autowired
 	private OrderRepository orderRepository;
 	@Autowired
 	private HygieneDataRepository hygieneDataRepository;
+	@Autowired
+	private SessionFactory sessionFactory;
+	@Autowired
+	private Mongo mongoClient;
 	@Override
 	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals)
 			throws ProfitMandiBusinessException {
 		LOGGER.info("fofoId -- {} Order Request -- {}", fofoId, createOrderRequest);
 		CustomCustomer customCustomer = createOrderRequest.getCustomer();
 					int itemId = warehouseInventoryItem.getItemId();
 					LocalDateTime grnDate = warehouseInventoryItem.getCreated();
 					Random random = new Random();
 					int randomDays = random.ints(2, 15).findFirst().getAsInt();
 					LocalDateTime saleDate = grnDate.plusDays(randomDays);
-					if(saleDate.isAfter(LocalDate.now().atStartOfDay())) {
+					if (saleDate.isAfter(LocalDate.now().atStartOfDay())) {
 						saleDate = LocalDateTime.now().minusDays(2);
+					}
 					Random offsetRandom = new Random();
 					int offset = offsetRandom.ints(2, 100).findFirst().getAsInt();
 					FofoOrder fofoOrder = fofoOrderRepository.selectFirstOrderAfterDate(saleDate, offset);
 					while (orderIdsConsumed.contains(fofoOrder.getId())) {
 						Random offsetRandom2 = new Random();
 						int offset2 = offsetRandom2.ints(2, 100).findFirst().getAsInt();
 						FofoOrder fofoOrder2 = fofoOrderRepository.selectFirstOrderAfterDate(saleDate, offset2);
-						if(fofoOrder2 != null) {
+						if (fofoOrder2 != null) {
 							fofoOrder = fofoOrder2;
+						}
+					}
 					PdfModel pdfModel = this.getInvoicePdfModel(fofoOrder.getId());
 					orderIdsConsumed.add(fofoOrder.getId());
 			throw new ProfitMandiBusinessException("Serial Number", serialNumber,
 					"Serial Number does not exist in our warehouse");
+		}
+	}
-	void modifyDummyModel(FofoOrder fofoOrder, PdfModel pdfModel, int itemId, String serialNumber) throws ProfitMandiBusinessException {
+	void modifyDummyModel(FofoOrder fofoOrder, PdfModel pdfModel, int itemId, String serialNumber)
+			throws ProfitMandiBusinessException {
 		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoOrder.getFofoId());
 		Address retailerAddress = addressRepository.selectById(retailerAddressId);
 		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
 		CustomerAddress customerAddress = customer.getCustomerAddress().stream()
 				.filter(x -> x.getId() == fofoOrder.getCustomerAddressId()).findFirst().get();
 		Integer stateId = null;
 		if (customerAddress.getState().equals(retailerAddress.getState())) {
 			try {
 				stateId = Long.valueOf(Utils.getStateInfo(customerAddress.getState()).getId()).intValue();
 			} catch (Exception e) {
 				LOGGER.error("Unable to get state rates");
+			}
+		}
 		CustomOrderItem cli = pdfModel.getOrderItems().stream().findFirst().get();
+		List<FofoOrderItem> fofoOrderItems = Arrays
-		List<FofoOrderItem> fofoOrderItems = Arrays.asList(this.getDummyFofoOrderItem(itemId, fofoOrder.getId(), serialNumber, stateId));
+				.asList(this.getDummyFofoOrderItem(itemId, fofoOrder.getId(), serialNumber, stateId));
 		pdfModel.setPaymentOptions(pdfModel.getPaymentOptions().stream().limit(1).collect(Collectors.toList()));
 		CustomPaymentOption paymentOption = pdfModel.getPaymentOptions().get(0);
 		paymentOption.setAmount(fofoOrderItems.get(0).getMop());
 		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
 		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
 			customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
 			customerFofoOrderItems.add(customFofoOrderItem);
+		}
 		pdfModel.setTotalAmount(paymentOption.getAmount());
 		pdfModel.setOrderItems(customerFofoOrderItems);
+	}
 	private PdfModel getInvoicePdfModel(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
 		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
 		fofoOrderItem.setColor(item.getColor());
 		fofoOrderItemRepository.persist(fofoOrderItem);
 		return fofoOrderItem;
+	}
-	private FofoOrderItem getDummyFofoOrderItem(int itemId, int fofoOrderId,
+	private FofoOrderItem getDummyFofoOrderItem(int itemId, int fofoOrderId, String serialNumber, Integer stateId)
-			String serialNumber, Integer stateId) throws ProfitMandiBusinessException {
+			throws ProfitMandiBusinessException {
 		Item item = itemRepository.selectById(itemId);
 		TagListing tl = tagListingRepository.selectByItemId(itemId);
 		FofoOrderItem fofoOrderItem = new FofoOrderItem();
 		fofoOrderItem.setItemId(itemId);
 		fofoOrderItem.setQuantity(1);
 	// This will remove the order and maintain order record and reverse inventory
 	// and scheme
 	@Override
 	public void cancelOrder(List<String> invoiceNumbers) throws Exception {
 		for (String invoiceNumber : invoiceNumbers) {
-			//Cancel only when not cancelled
+			// Cancel only when not cancelled
 			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
-			if(fofoOrder.getCancelledTimestamp()==null) {
+			if (fofoOrder.getCancelledTimestamp() == null) {
 				fofoOrder.setCancelledTimestamp(LocalDateTime.now());
 				fofoOrderRepository.persist(fofoOrder);
 				List<PaymentOptionTransaction> paymentTransactions = paymentOptionTransactionRepository
 						.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
 				for (PaymentOptionTransaction paymentOptionTransaction : paymentTransactions) {
+				}
 				List<FofoOrderItem> fois = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 				List<InventoryItem> inventoryItems = new ArrayList<>();
 				fois.stream().forEach(x -> {
 					x.getFofoLineItems().stream().forEach(y -> {
-						inventoryService.rollbackInventory(y.getInventoryItemId(), y.getQuantity(), fofoOrder.getFofoId());
+						inventoryService.rollbackInventory(y.getInventoryItemId(), y.getQuantity(),
+								fofoOrder.getFofoId());
 						inventoryItems.add(inventoryItemRepository.selectById(y.getInventoryItemId()));
 					});
 				});
 				String reversalReason = "Order Rolledback/Cancelled for Invoice Number " + invoiceNumber;
 				schemeService.reverseSchemes(inventoryItems, fofoOrder.getId(), reversalReason, SchemeType.OUT);
 				schemeService.reverseSchemes(inventoryItems, fofoOrder.getId(), reversalReason, SchemeType.ACTIVATION);
-				//If insured that no cancellation happens on next month
+				// If insured that no cancellation happens on next month
 				schemeService.reverseSchemes(inventoryItems, fofoOrder.getId(), reversalReason, SchemeType.INVESTMENT);
+			}
+		}
+	}
 			return fofoOrder;
 		} else {
 			throw new Exception(String.format("Could not find inventoryItemId - %s", inventoryItemId));
+		}
+	}
+	@Override
+	public Map<Integer, Long> carryBagCreditCount(int fofoId) throws ProfitMandiBusinessException {
+		FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);
+		LocalDateTime lastCredit = fs.getBagsLastCredited();
+		/*
+		 * long carryBagCount = 0; List<FofoOrder> fofoOrders =
+		 * fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(fofoId,
+		 * lastCredit.atStartOfDay(), LocalDate.now().plusDays(1).atStartOfDay()); for
+		 * (FofoOrder fo : fofoOrders) { carryBagCount +=
+		 * fofoOrderItemRepository.selectByOrderId(fo.getId()).stream() .filter(x ->
+		 * x.getSellingPrice() >= 12000).count();
+		 *
+		 * }
+		 */
+		Session session = sessionFactory.getCurrentSession();
+		CriteriaBuilder cb = session.getCriteriaBuilder();
+		CriteriaQuery<SimpleEntry> query = cb.createQuery(SimpleEntry.class);
+		Root<FofoOrder> fofoOrder = query.from(FofoOrder.class);
+		Root<FofoOrderItem> fofoOrderItem = query.from(FofoOrderItem.class);
+		Predicate p2 = cb.between(fofoOrder.get(ProfitMandiConstants.CREATE_TIMESTAMP), lastCredit,
+				LocalDate.now().atStartOfDay());
+		Predicate p3 = cb.isNull(fofoOrder.get("cancelledTimestamp"));
+		Predicate p4 = cb.equal(fofoOrder.get(ProfitMandiConstants.ID),
+				fofoOrderItem.get(ProfitMandiConstants.ORDER_ID));
+		Predicate p5 = cb.equal(fofoOrder.get(ProfitMandiConstants.FOFO_ID), fofoId);
+		ItemCriteria itemCriteria = new ItemCriteria();
+		itemCriteria.setBrands(mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
+				.collect(Collectors.toList()));
+		float startValue = 12000;
+		itemCriteria.setStartPrice(startValue);
+		itemCriteria.setEndPrice(0);
+		itemCriteria.setFeaturedPhone(false);
+		itemCriteria.setSmartPhone(true);
+		itemCriteria.setCatalogIds(new ArrayList<>());
+		itemCriteria.setExcludeCatalogIds(new ArrayList<>());
+		Predicate itemPredicate = itemRepository.getItemPredicate(itemCriteria, query, cb, fofoOrderItem, "dp");
+		Predicate finalPredicate = cb.and(itemPredicate, p2, p3, p4, p5);
+		query = query.multiselect(fofoOrder.get(ProfitMandiConstants.FOFO_ID), cb.count(fofoOrder))
+				.where(finalPredicate).groupBy(fofoOrder.get(ProfitMandiConstants.FOFO_ID));
+		List<SimpleEntry> simpleEntries = session.createQuery(query).getResultList();
+		Map<Integer, Long> returnMap = new HashMap<>();
+		for (SimpleEntry simpleEntry : simpleEntries) {
+			returnMap.put((Integer) simpleEntry.getKey(), (Long) simpleEntry.getValue());
+		}
+		return returnMap;
+	}
+}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java – Rev 28093 → 28166