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

 import com.spice.profitmandi.common.util.StringUtils;
 import com.spice.profitmandi.common.web.util.ResponseSender;
 import com.spice.profitmandi.dao.entity.auth.AuthUser;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.TagListing;
+import com.spice.profitmandi.dao.entity.cs.Position;
 import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
 import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;
 import com.spice.profitmandi.dao.entity.dtr.PaymentOptionTransaction;
 import com.spice.profitmandi.dao.entity.fofo.*;
 import com.spice.profitmandi.dao.entity.transaction.TransactionApproval;
 import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;
 import com.spice.profitmandi.dao.entity.user.Address;
+import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
 import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
 import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;
 import com.spice.profitmandi.dao.enumuration.transaction.TransactionApprovalStatus;
 import com.spice.profitmandi.dao.repository.auth.AuthRepository;
 import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
 import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
+import com.spice.profitmandi.dao.repository.cs.PositionRepository;
 import com.spice.profitmandi.dao.repository.dtr.*;
 import com.spice.profitmandi.dao.repository.fofo.*;
 import com.spice.profitmandi.dao.repository.inventory.StateRepository;
 import com.spice.profitmandi.dao.repository.transaction.*;
 import com.spice.profitmandi.dao.repository.user.AddressRepository;
     CartRepository cartRepository;
     @Autowired
     UserWalletRepository userWalletRepository;
-    @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());
-            }
+    @Autowired
-        }
-        PendingOrder po = null;
-        Customer customer = null;
+    PositionRepository positionRepository;
-        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));
-        List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();
-        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";
-    }
     @RequestMapping(value = "/checkplans", method = RequestMethod.GET)
     public String getInsurancePrices(HttpServletRequest request, @RequestParam float price, Model model,
                                      @RequestParam int itemId) throws ProfitMandiBusinessException {
         LOGGER.info("Request received at url : {}", request.getRequestURI());
                     paymentOptionTransaction);
+        }
         return paymentOptionIdPaymentOptionTransactionMap;
+    }
-    @RequestMapping(value = "/create-order", method = RequestMethod.POST)
+    @RequestMapping(value = "/order")
-    public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
+    public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model)
-                              Model model) throws ProfitMandiBusinessException {
+            throws ProfitMandiBusinessException {
-        // throw new ProfitMandiBusinessException("Billing is on hold temporarily",
-        // "Billing is on hold temporarily", "Billing is on hold temporarily");
-        LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
-        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
+        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
-        int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);
+        int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(loginDetails.getFofoId());
+        Address address = addressRepository.selectById(addressId);
-        LOGGER.info("Order has been created successfully...");
+        List<CartFofo> cartItems = orderService.cartCheckout(cartData);
+        Set<Integer> itemIds = new HashSet<>();
+        List<Integer> poIds = new ArrayList<>();
+        List<Integer> poItemIds = new ArrayList<>();
-        try {
+        for (CartFofo cartFofo : cartItems) {
-            this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(fofoOrderId));
+            itemIds.add(cartFofo.getItemId());
-        } catch (Exception e) {
+            if (cartFofo.getPoId() != 0) {
-            LOGGER.info("Could not send whatsapp message");
+                poIds.add(cartFofo.getPoId());
-            e.printStackTrace();
+                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));
+        List<PaymentOption> paymentOptions = paymentOptionRepository.selectActiveOption();
+        LOGGER.info("pendingOrder" + po);
+        LOGGER.info("pendingOrderItem" + poi);
+        int onlineSellingPrice = 0;
+        Map<Integer, PendingOrderItem> itemIdAndPoiMap = new HashMap<>();
+        if (po != null) {
+            List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(po.getId());
-        return "redirect:/get-order/?orderId=" + fofoOrderId;
+            for (PendingOrderItem poItem : pendingOrderItems) {
+                onlineSellingPrice += poItem.getSellingPrice();
+            }
+            itemIdAndPoiMap = pendingOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> pendingOrderItemRepository.selectById(x.getId())));
+        }
+        LOGGER.info("itemIdAndPoiMap {}", itemIdAndPoiMap);
+        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("itemIdAndPoiMap", itemIdAndPoiMap);
+        model.addAttribute("onlineSellingPrice", onlineSellingPrice);
+        model.addAttribute("mopPriceMap", mopPriceMap);
+        model.addAttribute("paymentOptions", paymentOptions);
+        model.addAttribute("accessoriesDeals", accessoriesDeals);
+        return "order-index";
+    }
     private void sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {
         Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
         CustomRetailer retailer = retailerService.getFofoRetailer(fofoOrder.getFofoId());
         model.addAttribute("isAdmin", isAdmin);
         return "pending_fofo_order";
+    }
+    @RequestMapping(value = "/create-order", method = RequestMethod.POST)
+    public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
+                              Model model) throws ProfitMandiBusinessException {
+        // throw new ProfitMandiBusinessException("Billing is on hold temporarily",
+        // "Billing is on hold temporarily", "Billing is on hold temporarily");
+        LOGGER.info("request at uri {}", request.getRequestURI());
+        LOGGER.info("request body {}", createOrderRequest);
+        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
+        int fofoOrderId = orderService.createOrder(createOrderRequest, fofoDetails.getFofoId(), accessoriesDeals);
+        LOGGER.info("Order has been created successfully...");
+        try {
+            this.sendWhatsappInvoice(fofoOrderRepository.selectByOrderId(fofoOrderId));
+        } catch (Exception e) {
+            LOGGER.info("Could not send whatsapp message");
+            e.printStackTrace();
+        }
+        return "redirect:/get-order/?orderId=" + fofoOrderId;
+    }
     @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;
+        List<PendingOrderItem> pendingOrderItems;
         if (isAdmin) {
-            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);
+            pendingOrderItems = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.BILLED);
         } else {
-            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
+            pendingOrderItems = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.BILLED,
                     loginDetails.getFofoId());
+        }
-        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItems, loginDetails.getFofoId());
+        model.addAttribute("pendingOrderItems", (List<PendingOrderItem>) map.get("pendingOrderItems"));
-        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
         model.addAttribute("isAdmin", isAdmin);
         return "billed_order_item";
+    }
     @GetMapping("/settledOrders")
                     loginDetails.getFofoId());
+        }
         Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
-        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+        model.addAttribute("pendingOrderItems", (List<PendingOrderItem>) map.get("pendingOrderItems"));
         model.addAttribute("isAdmin", isAdmin);
         return "settled_order_item";
+    }
     @GetMapping("/unsettledOrders")
                     loginDetails.getFofoId());
+        }
         Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
-        model.addAttribute("pendingOrderItem", map.get("pendingOrderItem"));
+        model.addAttribute("pendingOrderItems", (List<PendingOrderItem>) map.get("pendingOrderItems"));
         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> customRetailerMap = retailerService.getAllFofoRetailers();
-            Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
-                    .filter(x -> x != null).collect(Collectors.toList()).stream()
-                    .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
-            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("isAdmin", isAdmin);
-        return "claim_raised_order_item";
-    }
     @GetMapping("/getPendingOrderItem")
     public String getPendingOrderItem(HttpServletRequest request, @RequestParam int orderId, Model model)
             throws ProfitMandiBusinessException {
         LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
         Map<Integer, Item> itemMap = new HashMap<>();
         model.addAttribute("response1", mvcResponseSender.createResponseString(true));
         return "response";
+    }
-    @RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
+    @GetMapping("/claimedOrders")
-    public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam int id, Model model)
+    public String getclaimedOrders(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
-            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());
+        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
-        } else {
-            pendingOrderItem.setStatus(OrderStatus.SETTLED);
-            pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
-        }
-        List<OrderStatus> status = pendingOrderItemRepository.selectByOrderId(pendingOrderItem.getOrderId()).stream()
+        List<Integer> fofoIds = fofoStoreRepository.selectActiveStores().stream().map(x -> x.getId())
-                .map(x -> x.getStatus()).collect(Collectors.toList());
+                .collect(Collectors.toList());
-        List<Integer> catalogIds = new ArrayList<>();
+        List<PendingOrderItem> pendingOrderItem = null;
-        Item item = itemRepository.selectById(pendingOrderItem.getItemId());
-        pendingOrderItem.setItemName(item.getItemDescription());
-        catalogIds.add(item.getCatalogItemId());
+        if (isAdmin) {
-        Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
-        JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
-        pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
-        pendingOrder.setPendingOrderItems(Arrays.asList(pendingOrderItem));
+            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatus(OrderStatus.CLAIMED);
-        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());
+            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
-        String[] customerEmail = null;
-        if (customer.getEmailId() != null && !customer.getEmailId().isEmpty()) {
-            customerEmail = new String[]{customer.getEmailId()};
-            List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
-            emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
+            Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
+                    .filter(x -> x != null).collect(Collectors.toList()).stream()
-                    customerEmail, null, bccTo.toArray(new String[0]));
+                    .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
+            model.addAttribute("customRetailersMap", customRetailersMap);
+        } else {
+            pendingOrderItem = pendingOrderItemRepository.selectOrderItemByStatusAndFofoId(OrderStatus.CLAIMED,
+                    loginDetails.getFofoId());
+        }
-        if (!status.contains(OrderStatus.PENDING) && !status.contains(OrderStatus.PROCESSING)
-                && !status.contains(OrderStatus.BILLED) && !status.contains(OrderStatus.UNSETTLED)
-                && !status.contains(OrderStatus.CLAIMED)) {
-            pendingOrder.setStatus(OrderStatus.CLOSED);
-        }
-        pendingOrderItemRepository.persist(pendingOrderItem);
-        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        Map<String, Object> map = pendingOrderService.getItemOrders(pendingOrderItem, loginDetails.getFofoId());
+        model.addAttribute("pendingOrderItems", map.get("pendingOrderItems"));
+        model.addAttribute("isAdmin", isAdmin);
-        return "response";
+        return "claim_raised_order_item";
+    }
     @RequestMapping(value = "/raiseClaimOrderItem", method = RequestMethod.POST)
     public String raiseClaimOrderItem(HttpServletRequest request, @RequestParam int id, Model model) throws Exception {
     @RequestMapping(value = "/getOnlineOrder", method = RequestMethod.GET)
     public String cancelOrder(HttpServletRequest request, Model model) throws Exception {
         return "online-order";
+    }
+    @RequestMapping(value = "/deliveredPendingOrderItem", method = RequestMethod.POST)
+    public String deliveredPendingOrderItem(HttpServletRequest request, @RequestParam(name = "id") int pendingOrderItemId, Model model)
+            throws Exception {
+        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(pendingOrderItemId);
+        PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
+        //Prepaid payment successful
+        if (pendingOrder.getTotalAmount() == pendingOrder.getPaidAmount()) {
+            //pendingOrderItem.setStatus(OrderStatus.UNSETTLED);
+//            pendingOrderItem.setSettled(false);
+            pendingOrderItem.setStatus(OrderStatus.CLAIMED);
+            pendingOrderItem.setClaimedTimestamp(LocalDateTime.now());
+        } else {
+            pendingOrderItem.setStatus(OrderStatus.SETTLED);
+        }
+        pendingOrderItem.setDeliveredTimestamp(LocalDateTime.now());
+        List<OrderStatus> pendingOrderItemStatusList = 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 && !customer.getEmailId().isEmpty()) {
+            customerEmail = new String[]{customer.getEmailId()};
+            List<String> bccTo = Arrays.asList("tejbeer.kaur@smartdukaan.com");
+            emailService.sendMailWithAttachments("Order Delivered with SmartDukaan", "order-delivered.vm", emailModel,
+                    customerEmail, null, bccTo.toArray(new String[0]));
+        }
+        if (!pendingOrderItemStatusList.contains(OrderStatus.PENDING) && !pendingOrderItemStatusList.contains(OrderStatus.PROCESSING)
+                && !pendingOrderItemStatusList.contains(OrderStatus.BILLED) && !pendingOrderItemStatusList.contains(OrderStatus.UNSETTLED)
+                && !pendingOrderItemStatusList.contains(OrderStatus.CLAIMED)) {
+            pendingOrder.setStatus(OrderStatus.CLOSED);
+        }
+        pendingOrderItemRepository.persist(pendingOrderItem);
+        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        return "response";
+    }
     @GetMapping("/getAllOrdersByStatus")
     public String getAllOrdersByStatus(HttpServletRequest request, @RequestParam OrderStatus status,
                                        @RequestParam(required = false) LocalDateTime startTime,
                                        @RequestParam(required = false) LocalDateTime endTime, Model model) throws ProfitMandiBusinessException {
         LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
         boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
+        boolean isAccountsL2 = false;
+        if (isAdmin) {
+            AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
+            List<Position> positions = positionRepository.selectPositionByAuthId(authUser.getId());
+            for (Position position : positions) {
+                if ((position.getEscalationType().equals(EscalationType.L2)
+                        && position.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS)) {
+                    isAccountsL2 = true;
+                    break;
+                }
+            }
+            LOGGER.info("positions {}", positions);
+        }
         LOGGER.info("startTime {}", startTime);
         LOGGER.info("endTime {}", endTime);
         List<PendingOrderItem> pendingOrderItems;
         model.addAttribute("pendingOrderItems", (List<PendingOrderItem>) map.get("pendingOrderItems"));
         model.addAttribute("partnerInventoryMap", map.get("partnerInventoryMap"));
         model.addAttribute("isAdmin", isAdmin);
+        model.addAttribute("isAccountsL2", isAccountsL2);
         return "online-order-item";
+    }
+    @RequestMapping(value = "/onlinePaymentAddToPartnerWallet", method = RequestMethod.POST)
+    public String onlinePaymentAddToPartnerWallet(HttpServletRequest request, @RequestParam int id,
+                                                  Model model) throws Exception {
+        PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(id);
+        PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderItem.getOrderId());
+        int fofoId = pendingOrder.getFofoId();
+        double deductionPayment = (pendingOrderItem.getSellingPrice() * 2.36) / 100;
+        walletService.addAmountToWallet(fofoId, id, WalletReferenceType.ONLINE_ORDER_PAYMENT, "Online Order Payment", pendingOrderItem.getSellingPrice(), LocalDateTime.now());
+        walletService.consumeAmountFromWallet(fofoId, id,
+                WalletReferenceType.ONLINE_GATEWAY_FEE, "Payment Gatewayfee", (float) deductionPayment, LocalDateTime.now());
+        pendingOrderItem.setStatus(OrderStatus.CLOSED);
+        pendingOrder.setStatus(OrderStatus.CLOSED);
+        model.addAttribute("response1", mvcResponseSender.createResponseString(true));
+        return "response";
+    }
     //TODO Tejus
     @RequestMapping(value = "/getBulkOrder")
     public String getBulkOrder(HttpServletRequest request, Model model) throws ProfitMandiBusinessException, MessagingException, IOException {
         return "bulk-order";
+    }

Subversion Repositories SmartDukaan

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