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

 	@Autowired
 	private CustomerCreditNoteRepository customerCreditNoteRepository;
 	@Override
-	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals) throws ProfitMandiBusinessException {
+	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals)
+			throws ProfitMandiBusinessException {
 		CustomCustomer customCustomer = createOrderRequest.getCustomer();
 		if (!StringUtils.isValidEmailAddress(customCustomer.getEmailId())) {
 			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());
 		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); // this is for error
 		Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();
 		Map<Integer, Float> lineItemPrice = new HashMap<>(); // this is for pricing error
 		float totalAmount = 0;
 		boolean noGST = false;
 		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
 			// itemIds.add(customFofoOrderItem.getItemId());
 			Set<String> serialNumbers = this
 			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
 			throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");
 			// return "error";
+		}
-		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(),
+		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);
-				totalAmount);
 		if (!lineItemPrice.isEmpty()) {
 			// given fofo line item price must be greater than zero
 			LOGGER.error("requested itemId's selling price must greater than 0");
 			throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");
 		Map<String, Float> insuranceSerialNumberSaleAmount = new HashMap<>();
 		Map<String, String> serialNumberModelName = new HashMap<>();
 		Map<String, String> serialNumberBrand = new HashMap<>();
 		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
 			Item item = itemMap.get(customFofoOrderItem.getItemId());
 			noGST = item.getHsnCode().equals("NOGST");
 			if (item.getType().equals(ItemType.SERIALIZED)) {
 				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {
 					serialNumbers.add(serialNumberDetail.getSerialNumber());
 					if (serialNumberDetail.isInsurance()) {
 						insuranceSerialNumberItemPrice.put(serialNumberDetail.getSerialNumber(),
+			}
+		}
 		Map<Integer, PriceModel> itemIdMopPriceMap = pricingService
 				.getPurchasePriceMopPriceNotFound(itemIdCustomFofoOrderItemMap.keySet(), fofoId);
-		if(accessoriesDeals) {
+		if (accessoriesDeals) {
 			this.validateDpPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);
 		} else {
 			this.validateMopPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);
+		}
 		String fofoStoreCode = this.getFofoStoreCode(fofoId);
 		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
 		String documentNumber = null;
-		if(noGST) {
+		if (noGST) {
 			documentNumber = this.getSecurityDepositNumber(fofoId, fofoStoreCode);
 		} else {
 			documentNumber = this.getInvoiceNumber(fofoId, fofoStoreCode);
+		}
 		Customer customer = this.createAndGetCustomer(customCustomer);
 		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress(), customer.getId());
 			this.createFofoLineItem(fofoOrderItem.getId(), inventoryItems, inventoryItemIdQuantityUsed);
 			this.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(),
 					customFofoOrderItem.getQuantity());
-			this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed, fofoOrder.getId());
+			this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed,
+					fofoOrder.getId());
+		}
 		// insurance calculation is insurance flag is enabled
 		if (!insuranceSerialNumberItemPrice.isEmpty()) {
 			LOGGER.info("Processing for insurence for serialNumbers");
 		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
 		return fofoOrder.getId();
+	}
-	private String getInvoiceNumber(int fofoId,
+	private String getInvoiceNumber(int fofoId, String fofoStoreCode) {
-			String fofoStoreCode) {
 		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
 		try {
 			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
 			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
 		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
 			invoiceNumberGenerationSequence.setSequence(1);
+		}
 		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
 		return invoiceNumberGenerationSequence.getPrefix() + "/" + invoiceNumberGenerationSequence.getSequence();
+	}
-	private String getSecurityDepositNumber(int fofoId,
+	private String getSecurityDepositNumber(int fofoId, String fofoStoreCode) {
-			String fofoStoreCode) {
 		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
 		try {
 			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
+			invoiceNumberGenerationSequence
-			invoiceNumberGenerationSequence.setChallanNumberSequence(invoiceNumberGenerationSequence.getChallanNumberSequence()+ 1);
+					.setChallanNumberSequence(invoiceNumberGenerationSequence.getChallanNumberSequence() + 1);
 		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
 			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
 			invoiceNumberGenerationSequence.setFofoId(fofoId);
 			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);
 			invoiceNumberGenerationSequence.setChallanNumberSequence(1);
+		}
 		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
+		return invoiceNumberGenerationSequence.getPrefix() + "/SEC"
-		return invoiceNumberGenerationSequence.getPrefix() + "/SEC" + invoiceNumberGenerationSequence.getChallanNumberSequence();
+				+ invoiceNumberGenerationSequence.getChallanNumberSequence();
+	}
 	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails) {
 		Set<String> serialNumbers = new HashSet<>();
 		for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
 					paymentOptionRepository.selectById(paymentOptionTransaction.getPaymentOptionId()).getName());
 			paymentOptions.add(cpi);
+		}
 		List<FofoOrderItem> fofoOrderItems = this.getByOrderId(fofoOrder.getId());
 		pdfModel.setTitle("Retailer Invoice");
-		if(fofoOrderItems.stream().findAny().get().getHsnCode().equals("NOGST")) {
+		if (fofoOrderItems.stream().findAny().get().getHsnCode().equals("NOGST")) {
 			pdfModel.setTitle("Security Deposit Receipt");
+		}
 		pdfModel.setPaymentOptions(paymentOptions);
 		pdfModel.setAuther("SmartDukaan");
 		pdfModel.setInvoiceDate(fofoOrder.getFormattedDate());
 		tncs.add("Warranty for the goods received by me is the responsibility of the manufacturer only.");
 		if (pdfModel.getInsurancePolicies() != null && pdfModel.getInsurancePolicies().size() > 0) {
 			tncs.add("Damage protection provided is the responisibility of Protection Provider only");
+		}
 		pdfModel.setTncs(tncs);
 		pdfModel.setCustomer(getCustomCustomer(fofoOrder));
 		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
 		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
 		Retailer retailer = retailerRepository.selectById(fofoOrder.getFofoId());
 			LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
 		long countItems = 0;
 		List<FofoOrder> fofoOrders = new ArrayList<>();
 		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, null,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, null, null,
-					null, offset, limit);
+					offset, limit);
-			countItems = fofoOrderRepository.selectCountByCustomerMobileNumber(fofoId, searchValue, null,
+			countItems = fofoOrderRepository.selectCountByCustomerMobileNumber(fofoId, searchValue, null, null);
-					null);
 		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, null,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, null, null, offset,
-					null, offset, limit);
+					limit);
 			countItems = fofoOrderRepository.selectCountByCustomerName(fofoId, searchValue, null, null);
 		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, null,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, null, null, offset,
-					null, offset, limit);
+					limit);
 			countItems = fofoOrderRepository.selectCountBySerialNumber(fofoId, searchValue, null, null);
 		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, null, null,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, null, null, offset, limit);
-					offset, limit);
-			countItems=fofoOrderRepository.selectCountByItemName(fofoId, searchValue, null, null);
+			countItems = fofoOrderRepository.selectCountByItemName(fofoId, searchValue, null, null);
 		} else if (searchType == SearchType.INVOICE_NUMBER && !searchValue.isEmpty()) {
 			fofoOrders = Arrays.asList(fofoOrderRepository.selectByFofoIdAndInvoiceNumber(fofoId, searchValue));
 			countItems = fofoOrders.size();
-		}  else if(searchType == SearchType.DATE_RANGE){
+		} else if (searchType == SearchType.DATE_RANGE) {
 			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
 			countItems = fofoOrderRepository.selectCountByFofoId(fofoId, startDate, endDate);
+		}
 		Map<String, Object> map = new HashMap<>();
 		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
 			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDate,
 					endDate, offset, limit);
 		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDate,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDate, endDate,
-					endDate, offset, limit);
+					offset, limit);
 		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDate,
-					endDate, offset, limit);
-		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
-			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDate, endDate,
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDate, endDate,
 					offset, limit);
+		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
+			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDate, endDate, offset,
+					limit);
-		}  else if (searchType == SearchType.DATE_RANGE){
+		} else if (searchType == SearchType.DATE_RANGE) {
 			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
+		}
 		Map<String, Object> map = new HashMap<>();
 		map.put("saleHistories", fofoOrders);
 		map.put("searchType", searchType);
 					invalidInsuranceSalePurchaseAmount);
 			throw new ProfitMandiBusinessException("invalidInsuranceSalePurchaseAmount",
 					invalidInsuranceSalePurchaseAmount, "FFORDR_1009");
+		}
+	}
 	private void validateDpPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
 			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
 		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoLineItemMap.entrySet()) {
 			int itemId = entry.getKey();
 			CustomFofoOrderItem customFofoOrderItem = entry.getValue();
 			PriceModel priceModel = itemIdMopPriceMap.get(itemId);
-			if(customFofoOrderItem.getSerialNumberDetails().size() > 0) {
+			if (customFofoOrderItem.getSerialNumberDetails().size() > 0) {
-				if(priceModel.getPrice() > customFofoOrderItem.getSellingPrice()) {
+				if (priceModel.getPrice() > customFofoOrderItem.getSellingPrice()) {
+					throw new ProfitMandiBusinessException("Selling Price",
-					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "FFORDR_1010");
+							itemRepository.selectById(itemId).getItemDescription(), "FFORDR_1010");
+				}
 			} else {
-				if(priceModel.getPurchasePrice() > customFofoOrderItem.getSellingPrice()) {
+				if (priceModel.getPurchasePrice() > customFofoOrderItem.getSellingPrice()) {
+					throw new ProfitMandiBusinessException("Selling Price",
-					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "Selling Price should not be less than DP");
+							itemRepository.selectById(itemId).getItemDescription(),
+							"Selling Price should not be less than DP");
+				}
+			}
+		}
+	}
 	private void validateMopPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
 			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
 		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
 		Map<Integer, Float> invalidDiscountAmountMap = new HashMap<>();
 		for (Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()) {
 				paymentOptionTransactionRepository.persist(paymentOptionTransaction);
+			}
+		}
+	}
-	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId,
+	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, String documentNumber,
-			String documentNumber, float totalAmount, int customerAddressId) {
+			float totalAmount, int customerAddressId) {
 		FofoOrder fofoOrder = new FofoOrder();
 		fofoOrder.setCustomerGstNumber(customerGstNumber);
 		fofoOrder.setCustomerId(customerId);
 		fofoOrder.setFofoId(fofoId);
 		fofoOrder.setInvoiceNumber(documentNumber);
 		customerAddressRepository.persist(customerAddress);
 		fofoOrder.setCustomerGstNumber(customCustomer.getGstNumber());
+	}
 	@Override
-	public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest) throws ProfitMandiBusinessException {
+	public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest)
+			throws ProfitMandiBusinessException {
 		FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
 		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(foi.getOrderId());
 		if (fofoOrder.getFofoId() != fofoId) {
 			throw new ProfitMandiBusinessException("Partner Auth", "", "Invalid Order");
+		}
 		int billedQty = foi.getQuantity() - customerReturnItemRepository.selectAllByOrderItemId(foi.getId()).size();
-		if(foiBadReturnRequest.getMarkedBadArr().size() > billedQty ) {
+		if (foiBadReturnRequest.getMarkedBadArr().size() > billedQty) {
 			throw new ProfitMandiBusinessException("Cant bad return more than what is billed", "", "Invalid Quantity");
+		}
 		List<CustomerReturnItem> customerReturnItems = new ArrayList<>();
 		for (BadReturnRequest badReturnRequest : foiBadReturnRequest.getMarkedBadArr()) {
 			CustomerReturnItem customerReturnItem = new CustomerReturnItem();
 			customerReturnItem.setFofoOrderId(fofoOrder.getId());
 			customerReturnItem.setRemarks(badReturnRequest.getRemarks());
 			customerReturnItem.setInventoryItemId(badReturnRequest.getInventoryItemId());
 			customerReturnItem.setQuantity(1);
 			customerReturnItem.setType(ReturnType.BAD);
-			//customerReturnItemRepository.persist(customerReturnItem);
+			// customerReturnItemRepository.persist(customerReturnItem);
 			inventoryService.saleReturnInventoryItem(customerReturnItem);
 			customerReturnItems.add(customerReturnItem);
+		}
 		CustomerCreditNote creditNote = generateCreditNote(fofoOrder, customerReturnItems);
-		for (CustomerReturnItem customerReturnItem: customerReturnItems) {
+		for (CustomerReturnItem customerReturnItem : customerReturnItems) {
-			purchaseReturnService.returnInventoryItem(fofoId, false, customerReturnItem.getInventoryItemId(), ReturnType.BAD);
+			purchaseReturnService.returnInventoryItem(fofoId, false, customerReturnItem.getInventoryItemId(),
+					ReturnType.BAD);
+		}
-        return creditNote;
+		return creditNote;
+	}
-	private CustomerCreditNote generateCreditNote(FofoOrder fofoOrder, List<CustomerReturnItem> customerReturnItems) throws ProfitMandiBusinessException {
+	private CustomerCreditNote generateCreditNote(FofoOrder fofoOrder, List<CustomerReturnItem> customerReturnItems)
+			throws ProfitMandiBusinessException {
 		InvoiceNumberGenerationSequence sequence = invoiceNumberGenerationSequenceRepository
 				.selectByFofoId(fofoOrder.getFofoId());
 		sequence.setCreditNoteSequence(sequence.getCreditNoteSequence() + 1);
 		invoiceNumberGenerationSequenceRepository.persist(sequence);
 		String creditNoteNumber = sequence.getPrefix() + "/" + sequence.getCreditNoteSequence();
 		CustomerCreditNote creditNote = new CustomerCreditNote();
 		creditNote.setCreditNoteNumber(creditNoteNumber);
 		creditNote.setFofoId(fofoOrder.getFofoId());
 		creditNote.setFofoOrderId(fofoOrder.getId());
 		creditNote.setFofoOrderItemId(customerReturnItems.get(0).getFofoOrderItemId());
 		creditNote.setSettlementType(SettlementType.UNSETTLED);
 		customerCreditNoteRepository.persist(creditNote);
 		for (CustomerReturnItem customerReturnItem : customerReturnItems) {
 			customerReturnItem.setCreditNoteId(creditNote.getId());
 			customerReturnItemRepository.persist(customerReturnItem);
+		}
-		//this.returnInventoryItems(inventoryItems, debitNote);
+		// this.returnInventoryItems(inventoryItems, debitNote);
 		return creditNote;
+	}
 	@Override
 	public CreditNotePdfModel getCreditNotePdfModel(int customerCreditNoteId) throws ProfitMandiBusinessException {
 		CustomerCreditNote creditNote = customerCreditNoteRepository.selectById(customerCreditNoteId);
 		return getCreditNotePdfModel(creditNote);
+	}
-	private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote) throws ProfitMandiBusinessException {
+	private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote)
+			throws ProfitMandiBusinessException {
 		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(creditNote.getFofoOrderId());
-		List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository.selectAllByCreditNoteId(creditNote.getId());
+		List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository
+				.selectAllByCreditNoteId(creditNote.getId());
 		CustomCustomer customCustomer = getCustomCustomer(fofoOrder);
 		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
-		CustomRetailer customRetailer = retailerService.getFofoRetailers(Arrays.asList(fofoOrder.getFofoId())).get(fofoOrder.getFofoId());
+		CustomRetailer customRetailer = retailerService.getFofoRetailers(Arrays.asList(fofoOrder.getFofoId()))
+				.get(fofoOrder.getFofoId());
 		FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(creditNote.getFofoOrderItemId());
 		float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
 		float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
 		float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
 		CustomOrderItem customFofoOrderItem = new CustomOrderItem();
 		customFofoOrderItem.setAmount(customerReturnItems.size() * (taxableSellingPrice - taxableDiscountPrice));
 		customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "
 				+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
-		if(ItemType.SERIALIZED.equals(itemRepository.selectById(fofoOrderItem.getItemId()).getType())){
+		if (ItemType.SERIALIZED.equals(itemRepository.selectById(fofoOrderItem.getItemId()).getType())) {
 			Set<Integer> inventoryItemIds = customerReturnItems.stream().map(x -> x.getInventoryItemId())
 					.collect(Collectors.toSet());
 			List<String> serialNumbers = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
 					.map(x -> x.getSerialNumber()).collect(Collectors.toList());
 			customFofoOrderItem.setDescription(
 					customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
+		}
 		customFofoOrderItem.setRate(taxableSellingPrice);
 		customFofoOrderItem.setDiscount(taxableDiscountPrice);
 		customFofoOrderItem.setQuantity(customerReturnItems.size());
+		customFofoOrderItem.setNetAmount(
-		customFofoOrderItem.setNetAmount((fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * customFofoOrderItem.getQuantity());
+				(fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * customFofoOrderItem.getQuantity());
 		float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
 		float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
 		float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
 		LOGGER.info("fofoOrderItem - {}", fofoOrderItem);
 		customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
 		customFofoOrderItem.setSgstAmount(sgstAmount);
 		customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
 		customFofoOrderItem.setOrderId(1);
 		customerFofoOrderItems.add(customFofoOrderItem);
 		PdfModel pdfModel = new PdfModel();
 		pdfModel.setAuther("NSSPL");
 		pdfModel.setCustomer(customCustomer);
 		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
 		pdfModel.setInvoiceDate(FormattingUtils.formatDate(fofoOrder.getCreateTimestamp()));
 		pdfModel.setTitle("Credit Note");
 		pdfModel.setRetailer(customRetailer);
 		pdfModel.setTotalAmount(customFofoOrderItem.getNetAmount());
 		pdfModel.setOrderItems(customerFofoOrderItems);
 		CreditNotePdfModel creditNotePdfModel = new CreditNotePdfModel();
 		creditNotePdfModel.setCreditNoteDate(FormattingUtils.formatDate(creditNote.getCreateTimestamp()));
 		creditNotePdfModel.setCreditNoteNumber(creditNote.getCreditNoteNumber());
 		creditNotePdfModel.setPdfModel(pdfModel);
 		return creditNotePdfModel;
+	}
-	//This will remove the order and maintain order record and reverse inventory and scheme
+	// 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) {
+		for (String invoiceNumber : invoiceNumbers) {
 			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
 			fofoOrder.setCancelledTimestamp(LocalDateTime.now());
 			fofoOrderRepository.persist(fofoOrder);
-			List<PaymentOptionTransaction> paymentTransactions = paymentOptionTransactionRepository.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
+			List<PaymentOptionTransaction> paymentTransactions = paymentOptionTransactionRepository
+					.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
 			for (PaymentOptionTransaction paymentOptionTransaction : paymentTransactions) {
 				paymentOptionTransactionRepository.delete(paymentOptionTransaction);
+			}
 			List<FofoOrderItem> fois = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 			List<InventoryItem> inventoryItems = new ArrayList<>();
-			fois.stream().forEach(x->{
+			fois.stream().forEach(x -> {
-				x.getFofoLineItems().stream().forEach(y->{
+				x.getFofoLineItems().stream().forEach(y -> {
 					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);
+		}
+	}
 	@Override
 	public float getSales(int fofoId, LocalDateTime startDate, LocalDateTime endDate) {
 		// TODO Auto-generated method stub
 		return 0;
+	}
 	@Override
 	public float getSales(int fofoId, LocalDate onDate) {
-		return fofoOrderRepository.selectSaleSumGroupByFofoIds(LocalDateTime.of(onDate, LocalTime.MIDNIGHT),
+		LocalDateTime startTime = LocalDateTime.of(onDate, LocalTime.MIDNIGHT).minusDays(1);
-				LocalDateTime.of(onDate.plusDays(1), LocalTime.MIDNIGHT)).get(fofoId);
+		LocalDateTime endTime = LocalDateTime.of(onDate, LocalTime.MIDNIGHT);
+		Float sales = fofoOrderRepository.selectSaleSumGroupByFofoIds(startTime, endTime).get(fofoId);
+		return sales == null ? 0f : sales;
+	}
 	@Override
 	public float getSales(LocalDateTime onDate) {
 		// TODO Auto-generated method stub
 		return 0;
+	}
 	@Override
 	public float getSales(LocalDateTime startDate, LocalDateTime endDate) {
 		// TODO Auto-generated method stub
 		return 0;
+	}

Subversion Repositories SmartDukaan

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