WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.json.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.io.InputStreamResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import com.spice.profitmandi.common.model.PartnerOptionsAndItemAmountModel;
 import com.spice.profitmandi.common.model.PaymentOptionTransactionModel;
 import com.spice.profitmandi.common.model.PdfModel;
 import com.spice.profitmandi.common.model.PriceModel;
 import com.spice.profitmandi.common.model.ProfitMandiConstants;
+import com.spice.profitmandi.common.solr.SolrService;
 import com.spice.profitmandi.common.util.PdfUtils;
 import com.spice.profitmandi.common.util.StringUtils;
 import com.spice.profitmandi.common.web.util.ResponseSender;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.TagListing;
 import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
 import com.spice.profitmandi.dao.repository.fofo.FofoPartnerPaymentOptionRepository;
 import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
 import com.spice.profitmandi.dao.repository.fofo.PendingOrderItemRepository;
 import com.spice.profitmandi.dao.repository.fofo.PendingOrderRepository;
+import com.spice.profitmandi.dao.repository.fofo.PendingOrderService;
 import com.spice.profitmandi.dao.repository.inventory.StateRepository;
 import com.spice.profitmandi.dao.repository.user.AddressRepository;
 import com.spice.profitmandi.service.authentication.RoleManager;
 import com.spice.profitmandi.service.integrations.zest.InsuranceService;
 import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;
 import com.spice.profitmandi.service.order.OrderService;
 import com.spice.profitmandi.service.pricing.PricingService;
 import com.spice.profitmandi.service.user.RetailerService;
 import com.spice.profitmandi.web.model.LoginDetails;
+import com.spice.profitmandi.web.services.EmailService;
 import com.spice.profitmandi.web.util.CookiesProcessor;
 import com.spice.profitmandi.web.util.MVCResponseSender;
 @Controller
 @Transactional(rollbackFor = Throwable.class)
 public class OrderController {
 	private static final Logger LOGGER = LogManager.getLogger(OrderController.class);
+	private static final List<String> offlineOrders = Arrays.asList("EMIOD", "POD");
 	@Autowired
 	private CustomerRepository customerRepository;
 	private boolean accessoriesDeals = true;
 	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
 	@Autowired
 	private TagListingRepository tagListingRepository;
+	@Autowired
+	private PendingOrderService pendingOrderService;
+	@Autowired
+	private EmailService emailService;
+	@Autowired
+	private SolrService commonSolrService;
 	@RequestMapping(value = "/order")
 	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)
 			throws ProfitMandiBusinessException {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
-		;
 		int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
 		Address address = addressRepository.selectById(addressId);
 		List<CartFofo> cartItems = orderService.cartCheckout(cartData);
 		Set<Integer> itemIds = new HashSet<>();
+		List<Integer> poIds = new ArrayList<>();
+		List<Integer> poItemIds = new ArrayList<>();
 		for (CartFofo cartFofo : cartItems) {
 			itemIds.add(cartFofo.getItemId());
+			if (cartFofo.getPoId() != 0) {
+				poIds.add(cartFofo.getPoId());
+				poItemIds.add(cartFofo.getPoItemId());
+			}
+		}
+		PendingOrder po = null;
+		Customer customer = null;
+		PendingOrderItem poi = null;
 		Map<Integer, PriceModel> mopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds,
 				loginDetails.getFofoId());
 		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository
 				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());
+		if (!poIds.isEmpty()) {
+			po = pendingOrderRepository.selectById(poIds.get(0));
+			customer = customerRepository.selectById(po.getCustomerId());
+			if (!offlineOrders.contains(po.getPayMethod())) {
+				paymentOptionIds.add(23);
+			}
+		}
+		if (!poItemIds.isEmpty()) {
+			poi = pendingOrderItemRepository.selectById(poItemIds.get(0));
+		}
 		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new HashSet<>(paymentOptionIds));
+		LOGGER.info("pendingOrder" + po);
+		LOGGER.info("pendingOrderItem" + poi);
 		LOGGER.info("mopPriceMap {}", mopPriceMap);
 		model.addAttribute("stateNames",
 				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
 		model.addAttribute("retailerStateName", address.getState());
+		model.addAttribute("pendingPOCustomer", gson.toJson(customer));
+		model.addAttribute("pendingPO", gson.toJson(po));
 		model.addAttribute("cartItems", cartItems);
+		model.addAttribute("pendingOrder", po);
+		model.addAttribute("pendingOrderItem", poi);
 		model.addAttribute("mopPriceMap", mopPriceMap);
 		model.addAttribute("paymentOptions", paymentOptions);
 		model.addAttribute("accessoriesDeals", accessoriesDeals);
 		return "order-index";
+	}
 	private void markDoa(FofoOrder fofoOrder, FofoOrderItem foi, boolean isAdmin) {
 		if (isAdmin) {
 			foi.setDoa(true);
 			return;
+		}
-		boolean isImei = foi.getFofoLineItems().stream().anyMatch(x->x.getSerialNumber().equals("863903054378477"));
+		boolean isImei = foi.getFofoLineItems().stream().anyMatch(x -> x.getSerialNumber().equals("863903054378477"));
 		LocalDateTime buyDate = fofoOrder.getCreateTimestamp().truncatedTo(ChronoUnit.DAYS);
 		LocalDateTime curDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
 		if (buyDate.isAfter(curDate.minusDays(45)) || isImei) {
 			foi.setDoa(true);
 		} else
 		// "Billing is on hold temporarily", "Billing is on hold temporarily");
 		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
 		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 		int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);
 		LOGGER.info("Order has been created successfully...");
 		return "redirect:/get-order/?orderId=" + fofoOrderId;
+	}
 	@RequestMapping(value = "/order/bad_return", method = RequestMethod.POST)
 		if (isAdmin) {
 			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
 			model.addAttribute("customRetailersMap", customRetailersMap);
+		}
-		List<PendingOrder> pendingOrders = null;
+		List<PendingOrderItem> pendingOrderItem = null;
+		if (isAdmin) {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.PENDING);
+		} else {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.PENDING,
+					loginDetails.getFofoId());
+		}
+		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+		if (!isAdmin) {
+			model.addAttribute("inventoryMap", map.get("inventoryMap"));
+		}
+		model.addAttribute("isAdmin", isAdmin);
+		return "pending_fofo_order";
+	}
+	@GetMapping("/billedOrders")
+	public String getBilledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
+		List<PendingOrderItem> pendingOrderItem = null;
 		if (isAdmin) {
-			pendingOrders = pendingOrderRepository.selectAllByStatus(OrderStatus.PENDING);
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);
 		} else {
-			pendingOrders = pendingOrderRepository.selectByFofoId(loginDetails.getFofoId(), OrderStatus.PENDING);
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
+					loginDetails.getFofoId());
+		}
+		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+		model.addAttribute("inventoryMap", map.get("inventoryMap"));
+		model.addAttribute("isAdmin", isAdmin);
+		return "billed_order_item";
+	}
-		if (!pendingOrders.isEmpty()) {
+	@GetMapping("/settledOrders")
+	public String getSettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
-			List<Integer> customerIds = pendingOrders.stream().map(x -> x.getCustomerId()).collect(Collectors.toList());
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
+		List<PendingOrderItem> pendingOrderItem = null;
+		if (isAdmin) {
-			Map<Integer, Customer> customersMap = customerRepository.selectAllByIds(customerIds).stream()
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.SETTLED);
-					.collect(Collectors.toMap(x -> x.getId(), x -> x));
-			pendingOrders.stream().forEach(x -> {
-				x.setCustomer(customersMap.get(x.getCustomerId()));
-			});
+		} else {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.SETTLED,
+					loginDetails.getFofoId());
+		}
+		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
-		model.addAttribute("pendingOrder", pendingOrders);
+		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+		model.addAttribute("inventoryMap", map.get("inventoryMap"));
 		model.addAttribute("isAdmin", isAdmin);
-		return "pending_fofo_order";
+		return "settled_order_item";
+	}
+	@GetMapping("/unsettledOrders")
+	public String getunsettledOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
+		List<PendingOrderItem> pendingOrderItem = null;
+		if (isAdmin) {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.UNSETTLED);
+		} else {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.UNSETTLED,
+					loginDetails.getFofoId());
+		}
+		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+		model.addAttribute("inventoryMap", map.get("inventoryMap"));
+		model.addAttribute("isAdmin", isAdmin);
+		return "unsettled_order_item";
+	}
+	@GetMapping("/claimedOrders")
+	public String getclaimedOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
+		List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
+				.collect(Collectors.toList());
+		List<PendingOrderItem> pendingOrderItem = null;
+		if (isAdmin) {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.CLAIMED);
+			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
+			model.addAttribute("customRetailersMap", customRetailersMap);
+		} else {
+			pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.CLAIMED,
+					loginDetails.getFofoId());
+		}
+		Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+		model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+		model.addAttribute("inventoryMap", map.get("inventoryMap"));
+		model.addAttribute("isAdmin", isAdmin);
+		return "claim_raised_order_item";
+	}
 	@GetMapping("/getPendingOrderItem")
 	public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)
 			throws ProfitMandiBusinessException {
 		Customer customer = customerRepository.selectById(pendingPO.getCustomerId());
 		List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(orderId);
 		for (PendingOrderItem pendingOrderItem : pendingOrderItems) {
 			Item item = itemRepository.selectById(pendingOrderItem.getItemId());
 			CurrentInventorySnapshot cis = currentInventorySnapshotRepository
-					.selectByItemAndFofoId(pendingOrderItem.getItemId(), loginDetails.getFofoId());
+					.selectByItemAndFofoId(pendingOrderItem.getItemId(), pendingPO.getFofoId());
 			itemMap.put(pendingOrderItem.getItemId(), item);
 			LOGGER.info("cis" + cis);
 			inventoryMap.put(pendingOrderItem.getItemId(), cis);
+		}
 		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
 		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
 				.map(x -> x.getStatus()).collect(Collectors.toList());
-		if (!status.contains(OrderStatus.PENDING)) {
+		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.BILLED)
+				&& !status.contains(OrderStatus.UNSETTLED) && !status.contains(OrderStatus.CLAIMED)) {
 			pendingOrder.setStatus(OrderStatus.CLOSED);
+		}
 		pendingOrderItemRepository.persist(pendingOrderItem);
 		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
+	}
+	@RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
+	public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)
+			throws Exception {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
+		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
+		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
+			pendingOrderItem.setStatus(OrderStatus.UNSETTLED);
+			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
+		} else {
+			pendingOrderItem.setStatus(OrderStatus.SETTLED);
+			pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
+		}
+		List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
+				.map(x -> x.getStatus()).collect(Collectors.toList());
+		List<Integer> catalogIds = new ArrayList<>();
+		Item item = itemRepository.selectById(pendingOrderItem.getItemId());
+		pendingOrderItem.setItemName(item.getItemDescription());
+		catalogIds.add(item.getCatalogItemId());
+		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
+		JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
+		pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
+		pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
+		CustomerAddress customerAddress = customerAddressRepository.selectById(pendingOrder.getCustomerAddressId());
+		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy h:mm a");
+		Map<String, Object> emailModel = new HashMap<>();
+		emailModel.put("customer", customerAddress);
+		emailModel.put("pendingOrder", pendingOrder);
+		emailModel.put("date", dateTimeFormatter);
+		Customer customer = customerRepository.selectById(pendingOrder.getCustomerId());
+		String[] customerEmail = null;
+		if (customer.getEmailId() != null) {
+			customerEmail = new String[] { customer.getEmailId(), "tejbeer.kaur@smartdukaan.com" };
+			emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
+					customerEmail, null, null);
+		}
+		if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.BILLED)
+				&& !status.contains(OrderStatus.UNSETTLED) && !status.contains(OrderStatus.CLAIMED))
+		{
+			pendingOrder.setStatus(OrderStatus.CLOSED);
+		}
+		pendingOrderItemRepository.persist(pendingOrderItem);
+		model.addAttribute("response", mvcResponseSender.createResponseString(true));
+		return "response";
+	}
+	@RequestMapping(value = "/raiseClaimOrderItem", method = RequestMethod.POST)
+	public String raiseClaimOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
+		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
+		if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
+			pendingOrderItem.setStatus(OrderStatus.CLAIMED);
+			pendingOrderItem.setClaimedTimestamp(LocalDateTime.now());
+		}
+		pendingOrderItemRepository.persist(pendingOrderItem);
+		model.addAttribute("response", mvcResponseSender.createResponseString(true));
+		return "response";
+	}
 	@RequestMapping(value = "/cancelOrderByInvoice", method = RequestMethod.POST)
 	public String cancelOrder(HttpServletRequest request, @RequestParam List<String> invoiceNumbers, Model model)
 			throws Exception {

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java – Rev 28263 → 28339