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



public class OrderServiceImpl implements OrderService {
 
	private static final Logger LOGGER = LogManager.getLogger(OrderServiceImpl.class);
 
	private static Map<String, Integer> serialNumberOrderIdMap = new HashMap<>();
 
	static {
		serialNumberOrderIdMap.put("862897055749275", 67228);
	}
 
	@Autowired
	@Qualifier("fofoInventoryItemRepository")
	private InventoryItemRepository inventoryItemRepository;
 
	@Autowired

 
		this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);
 
		Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();
		Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity
		// used for scan records insertion
 
		LOGGER.info("itemMap keys {}", itemMap.keySet());
		// Lets reduce quantity and decide what inventory items to use.
		for (Item item : items) {
			if (item.getType().equals(ItemType.SERIALIZED)) {
				// TODO:handle null
				if (serializedInventoryItemMap.get(item.getId()) == null
						|| itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails()
						.size() != serializedInventoryItemMap.get(item.getId()).size()) {
 
					List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId())
							.getSerialNumberDetails().stream().map(x -> x.getSerialNumber())
							.collect(Collectors.toList());
					throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");

		}
	}
 
	@Override
	public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue,
											  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, null,

		}
		return map;
	}
 
	public ResponseEntity<?> downloadReportInCsv(org.apache.commons.io.output.ByteArrayOutputStream baos,
												 List<List<?>> rows, String fileName) {
		final HttpHeaders headers = new HttpHeaders();
		headers.set("Content-Type", "text/csv");
 
		headers.set("Content-disposition", "inline; filename=" + fileName + ".csv");
		headers.setContentLength(baos.toByteArray().length);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
	}
 
	@Override
	public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String searchValue,
													   LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
		List<FofoOrder> fofoOrders = new ArrayList<>();
 
		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDate,
					endDate, offset, limit);

		}
		return serialNumbers;
	}
 
	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();
			LOGGER.info("CustomFofoOrderItem -- {}", customFofoOrderItem);
			PriceModel priceModel = itemIdMopPriceMap.get(itemId);
			Item item = itemRepository.selectById(itemId);
			if (!item.getBrand().equals("Live Demo")
					&& (item.getCategoryId() == ProfitMandiConstants.MOBILE_CATEGORY_ID
					|| item.getCategoryId() == ProfitMandiConstants.TABLET_CATEGORY_ID || item.getCategoryId() == ProfitMandiConstants.LED_CATEGORY_ID)
					&& customFofoOrderItem.getSerialNumberDetails().stream()
					.filter(x -> org.apache.commons.lang.StringUtils.isNotEmpty(x.getSerialNumber()))
					.collect(Collectors.toList()).size() > 0) {
				if (Utils.compareFloat(priceModel.getPrice(),
						customFofoOrderItem.getSellingPrice() + customFofoOrderItem.getDiscountAmount()) > 0) {
					throw new ProfitMandiBusinessException("Selling Price for ", item.getItemDescription(),
							"FFORDR_1010");
				}

			}
		}
	}
 
	private void validateMopPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
								  Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
		for (Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()) {
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoLineItemMap.get(entry.getKey());
			Item item = itemRepository.selectById(customFofoOrderItem.getItemId());
			if (!(item.getBrand().equals("Live Demo") || item.getCategoryId() != ProfitMandiConstants.MOBILE_CATEGORY_ID
					|| item.getCategoryId() != ProfitMandiConstants.TABLET_CATEGORY_ID)
					&& customFofoOrderItem.getSellingPrice() + customFofoOrderItem.getDiscountAmount() < entry
					.getValue().getPrice()) {
				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoOrderItem.getSellingPrice());
			}
		}
 
		if (!invalidMopItemIdPriceMap.isEmpty()) {

		}
 
	}
 
	private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId,
												   Map<Integer, Integer> inventoryItemQuantityUsed, int fofoOrderId) {
		for (InventoryItem inventoryItem : inventoryItems) {
			inventoryItem.setLastScanType(ScanType.SALE);
			ScanRecord scanRecord = new ScanRecord();
			scanRecord.setInventoryItemId(inventoryItem.getId());
			scanRecord.setFofoId(fofoId);

 
		}
	}
 
	private void createFofoLineItem(int fofoOrderItemId, Set<InventoryItem> inventoryItems,
									Map<Integer, Integer> inventoryItemIdQuantityUsed) {
		for (InventoryItem inventoryItem : inventoryItems) {
			FofoLineItem fofoLineItem = new FofoLineItem();
			fofoLineItem.setFofoOrderItemId(fofoOrderItemId);
			fofoLineItem.setSerialNumber(inventoryItem.getSerialNumber());
			fofoLineItem.setInventoryItemId(inventoryItem.getId());

			fofoLineItemRepository.persist(fofoLineItem);
		}
	}
 
	private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId,
													Map<Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId)
			throws ProfitMandiBusinessException {
		FofoOrderItem fofoOrderItem = new FofoOrderItem();
		fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
		fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
		fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());

 
		return fofoOrderItem;
	}
 
	private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots, int fofoId,
												int itemId, int quantity) throws ProfitMandiBusinessException {
		for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
			if (currentInventorySnapshot.getItemId() == itemId && currentInventorySnapshot.getFofoId() == fofoId) {
				currentInventorySnapshotRepository.updateAvailabilityByItemIdAndFofoId(itemId, fofoId,
						currentInventorySnapshot.getAvailability() - quantity);
			}

			}
		}
	}
 
	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, String documentNumber,
											float totalAmount, int customerAddressId) {
		FofoOrder fofoOrder = new FofoOrder();
		fofoOrder.setCustomerGstNumber(customerGstNumber);
		fofoOrder.setCustomerId(customerId);
		fofoOrder.setFofoId(fofoId);
		fofoOrder.setInvoiceNumber(documentNumber);

		fofoOrderRepository.persist(fofoOrder);
		return fofoOrder;
	}
 
	private void validateItemsSerializedNonSerialized(List<Item> items,
													  Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws ProfitMandiBusinessException {
		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
		List<Integer> itemIdNonSerializedSerialNumbers = new ArrayList<Integer>();
		for (Item i : items) {
			CustomFofoOrderItem customFofoOrderItem = customFofoOrderItemMap.get(i.getId());
			if (i.getType().equals(ItemType.SERIALIZED)) {

					"FFORDR_1014");
		}
	}
 
	private void validateCurrentInventorySnapshotQuantities(List<CurrentInventorySnapshot> currentInventorySnapshots,
															Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws ProfitMandiBusinessException {
		if (itemIdCustomFofoOrderItemMap.keySet().size() != currentInventorySnapshots.size()) {
			throw new ProfitMandiBusinessException("quantiiesSize", currentInventorySnapshots.size(), "");
		}
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); // this is for error
		LOGGER.info("currentInventorySnapshots " + currentInventorySnapshots);

					"FFORDR_1015");
		}
	}
 
	private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap,
										  String serialNumber) {
		int itemId = 0;
		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoOrderItemMap.entrySet()) {
			Set<SerialNumberDetail> serialNumberDetails = entry.getValue().getSerialNumberDetails();
			for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
				if (serialNumberDetail.getSerialNumber().equals(serialNumber)) {

				Arrays.asList(SchemeType.SPECIAL_SUPPORT));
 
	}
 
	@Override
	public void reverseActivationScheme(List<Integer> inventoryItemIds) throws ProfitMandiBusinessException {
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectAllByIds(inventoryItemIds);
		for (InventoryItem inventoryItem : inventoryItems) {
			List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByInventoryItemId(inventoryItem.getId());
			FofoLineItem fofoLineItem = fofoLineItems.get(0);
			FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(fofoLineItem.getFofoOrderItemId());
			FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(fofoOrderItem.getOrderId());
			String reversalReason = "Scheme rolled back as activation date is invalid for imei " + inventoryItem.getSerialNumber();
			schemeService.reverseSchemes(Arrays.asList(inventoryItem), fofoOrder.getId(), reversalReason,
					Arrays.asList(SchemeType.ACTIVATION));
			schemeService.reverseSchemes(inventoryItems, fofoOrder.getId(), reversalReason,
					Arrays.asList(SchemeType.SPECIAL_SUPPORT));
 
		}
 
	}
 
	@Override
	public float getSales(int fofoId, LocalDateTime startDate, LocalDateTime endDate) {
		Float sales = fofoOrderRepository.selectSaleSumGroupByFofoIds(startDate, endDate).get(fofoId);
		return sales == null ? 0f : sales;
	}
 

Subversion Repositories SmartDukaan

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

Rev 30993		Rev 31030
Line 78...		Line 78...
78	`public class OrderServiceImpl implements OrderService {`	78	`public class OrderServiceImpl implements OrderService {`
79		79
80	`private static final Logger LOGGER = LogManager.getLogger(OrderServiceImpl.class);`	80	`private static final Logger LOGGER = LogManager.getLogger(OrderServiceImpl.class);`
81		81
82	`private static Map<String, Integer> serialNumberOrderIdMap = new HashMap<>();`	82	`private static Map<String, Integer> serialNumberOrderIdMap = new HashMap<>();`
-		83
83	`static {`	84	`static {`
84	`serialNumberOrderIdMap.put("862897055749275", 67228);`	85	`serialNumberOrderIdMap.put("862897055749275", 67228);`
85	`}`	86	`}`
-		87
86	`@Autowired`	88	`@Autowired`
87	`@Qualifier("fofoInventoryItemRepository")`	89	`@Qualifier("fofoInventoryItemRepository")`
88	`private InventoryItemRepository inventoryItemRepository;`	90	`private InventoryItemRepository inventoryItemRepository;`
89		91
90	`@Autowired`	92	`@Autowired`
Line 378...		Line 380...
378		380
379	`this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);`	381	`this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);`
380		382
381	`Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();`	383	`Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();`
382	`Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity`	384	`Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity`
383	`// used for scan records insertion`	385	`// used for scan records insertion`
384		386
385	`LOGGER.info("itemMap keys {}", itemMap.keySet());`	387	`LOGGER.info("itemMap keys {}", itemMap.keySet());`
386	`// Lets reduce quantity and decide what inventory items to use.`	388	`// Lets reduce quantity and decide what inventory items to use.`
387	`for (Item item : items) {`	389	`for (Item item : items) {`
388	`if (item.getType().equals(ItemType.SERIALIZED)) {`	390	`if (item.getType().equals(ItemType.SERIALIZED)) {`
389	`// TODO:handle null`	391	`// TODO:handle null`
390	`if (serializedInventoryItemMap.get(item.getId()) == null`	392	`if (serializedInventoryItemMap.get(item.getId()) == null`
391	`\|\| itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails()`	393	`\|\| itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails()`
392	`.size() != serializedInventoryItemMap.get(item.getId()).size()) {`	394	`.size() != serializedInventoryItemMap.get(item.getId()).size()) {`
393		395
394	`List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId())`	396	`List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId())`
395	`.getSerialNumberDetails().stream().map(x -> x.getSerialNumber())`	397	`.getSerialNumberDetails().stream().map(x -> x.getSerialNumber())`
396	`.collect(Collectors.toList());`	398	`.collect(Collectors.toList());`
397	`throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");`	399	`throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");`
Line 1152...		Line 1154...
1152	`}`	1154	`}`
1153	`}`	1155	`}`