Subversion Repositories SmartDukaan

import com.spice.profitmandi.dao.cart.CartService;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;

import com.spice.profitmandi.dao.enumuration.fofo.ReturnType;

import com.spice.profitmandi.service.wallet.CommonPaymentService;

import com.spice.profitmandi.service.warehouse.WarehouseInventoryService;

import in.shop2020.payments.PaymentService;

    @Autowired

    PurchaseReturnService purchaseReturnService;

        //Create return

        Map<Integer, Set<String>> fofoIdImeiReturnMap = new HashMap<>();

        //fofoIdImeiReturnMap.put(175139463, new HashSet<>(Arrays.asList("869916067368297", "350923626635949", "350923626636269", "350923626690902", "866807064687750", "864848068046108", "864848068051546", "861784060309637", "862027063792071", "867158060967690", "866132064917630", "864288065020691", "861025062454157", "860398063432170", "863653063902490", "863653063902938", "863653065416358", "866726067460694", "866726067914955", "862628065654159", "864647062834471")));

        fofoIdImeiReturnMap.put(175138674, new HashSet<>(Arrays.asList("866807064015176","861831062447822","869916067520632","869916067520178","865753069672200","865753067320703","864920066684790","868905064555858")));

        for (Entry<Integer, Set<String>> fofoIdImeiReturnEntry : fofoIdImeiReturnMap.entrySet()) {

            int fofoId = fofoIdImeiReturnEntry.getKey();

            Set<String> imeis = fofoIdImeiReturnEntry.getValue();

            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, imeis, true);

            for (InventoryItem inventoryItem : inventoryItems) {

                //inventoryItem.getId();

                purchaseReturnService.returnInventoryItem(fofoId, true, inventoryItem.getId(), ReturnType.GOOD);

                //Approve return

                PurchaseReturnItem purchaseReturnItem = purchaseReturnItemRepository.selectByInventoryItemId(inventoryItem.getId());

                purchaseReturnItem.setStatus(PurchaseReturnStatus.APPROVED);

                purchaseReturnItem.setApproveTimestamp(LocalDateTime.now());

            }

            Map<Purchase, List<InventoryItem>> purchaseInventoryItemsMap = purchaseReturnService.getPurchaseMapForApprovedReturns(fofoId);

            int walletAmount = walletService.getWalletAmount(fofoId);

            List<DebitNote> debitNotes = purchaseReturnService.generateDebitNotes(purchaseInventoryItemsMap);

            int walletDiff = walletAmount - walletService.getWalletAmount(fofoId);

            if (walletDiff > 0) {

                int reference = walletService.getManualReference(WalletReferenceType.OTHERS);

                walletService.addAmountToWallet(fofoId, reference, WalletReferenceType.ADVANCE_AMOUNT, "Sytematically added for internal PO", (float) walletDiff, LocalDateTime.now());

            }

            for (DebitNote debitNote : debitNotes) {

                debitNote.setCreateTimestamp(LocalDate.of(2023, Month.SEPTEMBER, 30).atStartOfDay());

                //Try to refund amount per debit note

                this.refundDnAmount(debitNote);

            }

            //List<DebitNotePdfModel> debitNotePdfModels = purchaseReturnService.generateDebitNotes(purchaseInventoryMap, warehouseId);

        }

        //transactionService.billOrder(Arrays.asList(1800765), )

    CartService cartService;

    @Autowired

    UserRepository userRepository;

    @Autowired

    WarehouseScanRepository warehouseScanRepository;

    @Autowired

    WarehouseInventoryService warehouseInventoryService;

    @Autowired

    CommonPaymentService commonPaymentService;

    //Also create order

    private void refundDnAmount(DebitNote debitNote) throws ProfitMandiBusinessException {

        List<Integer> inventoryItemIds = purchaseReturnItemRepository.selectAllByDebitNoteId(debitNote.getId()).stream().map(x -> x.getInventoryItemId()).collect(Collectors.toList());

        Map<Integer, Long> inventoryItemCountMap = inventoryItemIds.stream().collect(Collectors.groupingBy(x -> x, Collectors.counting()));

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectAllByIds(new ArrayList<>(inventoryItemCountMap.keySet()));

        Purchase purchase = purchaseRepository.selectById(inventoryItems.get(0).getPurchaseId());

        String invoice = purchase.getPurchaseReference();

        List<Order> orders = orderRepository.selectByInvoiceNumber(invoice);

        Set<Integer> orderIds = orders.stream().map(x -> x.getId()).collect(Collectors.toSet());

        Order order = orders.get(0);

        float totalAmount = 0;

        float walletTotalAmount = 0;

        int totalQty = 0;

        Map<Integer, CartItem> itemIdCartItemMap = new HashMap<>();

        List<CartItem> cartItems = new ArrayList<>();

        for (InventoryItem inventoryItem : inventoryItems) {

            TagListing tagListing = tagListingRepository.selectByItemId(inventoryItem.getItemId());

            long quantity = inventoryItemCountMap.get(inventoryItem.getId());

            totalAmount += inventoryItem.getUnitPrice() * quantity;

            walletTotalAmount += tagListing.getSellingPrice() * quantity;

            totalQty += quantity;

            if (!itemIdCartItemMap.containsKey(inventoryItem.getItemId())) {

                CartItem cartItem = new CartItem();

                cartItem.setItemId(inventoryItem.getItemId());

                cartItem.setSellingPrice(tagListing.getSellingPrice());

                cartItems.add(cartItem);

                itemIdCartItemMap.put(inventoryItem.getItemId(), cartItem);

            }

            CartItem cartItem = itemIdCartItemMap.get(inventoryItem.getItemId());

            cartItem.setQuantity((int) quantity + cartItem.getQuantity());

        }

        String rollbackDescription = String.format("Refunded against DN %s, %d pc(s)", debitNote.getDebitNoteNumber(), totalQty);

        walletService.addAmountToWallet(debitNote.getFofoId(), order.getTransactionId(), WalletReferenceType.PURCHASE, rollbackDescription, totalAmount, LocalDateTime.now());

        //Before creating order lets try to in the stock

        //All scans pertaining to specific Invoices

        List<WarehouseScan> warehouseScans = warehouseScanRepository.selectAllByOrderIds(new ArrayList<>(orderIds));

        Map<Integer, Integer> inventoryItemIdOrderIdMap = warehouseScans.stream().collect(Collectors.toMap(x -> x.getInventoryItemId(), x -> x.getQuantity()));

        List<Integer> warehouseInventoryItemIds = warehouseScans.stream().filter(x -> !(x.getType().equals(in.shop2020.warehouse.ScanType.SALE_RET) || x.getType().equals(in.shop2020.warehouse.ScanType.SALE_RET_UNUSABLE)))

                .map(x -> x.getInventoryItemId()).collect(Collectors.toList());

        List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository.selectAllByIds(warehouseInventoryItemIds);

        Map<String, WarehouseInventoryItem> serialNumberWarehouseInventoryItemMap = warehouseInventoryItems.stream().filter(x -> StringUtils.isNotBlank(x.getSerialNumber())).collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x));

        Map<Integer, List<WarehouseInventoryItem>> itemIdWarehouseInventoryItemsMap = warehouseInventoryItems.stream().filter(x -> StringUtils.isBlank(x.getSerialNumber())).collect(Collectors.groupingBy(x -> x.getItemId(), Collectors.toList()));

        for (InventoryItem inventoryItem : inventoryItems) {

            if (StringUtils.isBlank(inventoryItem.getSerialNumber())) {

                //As of now this should be happening as  dn are specifically for serialized devices

                /*int returnQty = inventoryItemCountMap.get(inventoryItem.getId()).intValue();

                List<WarehouseInventoryItem> warehouseInventoryItemList = itemIdWarehouseInventoryItemsMap.get(inventoryItem.getItemId());

                warehouseInventoryService.returnNonSerializedQty(warehouseInventoryItem)*/

            } else if (StringUtils.isNotBlank(inventoryItem.getSerialNumber())) {

                String serialNumber = inventoryItem.getSerialNumber();

                WarehouseInventoryItem warehouseInventoryItem = serialNumberWarehouseInventoryItemMap.get(serialNumber);

                warehouseInventoryItem.setLastScanType(in.shop2020.warehouse.ScanType.SALE_RET);

                warehouseInventoryService.addQuantity(warehouseInventoryItem.getId(), 1);

                WarehouseScan warehouseScan = new WarehouseScan();

                warehouseScan.setInventoryItemId(warehouseInventoryItem.getId());

                warehouseScan.setQuantity(1);

                warehouseScan.setOrderId(inventoryItemIdOrderIdMap.get(warehouseInventoryItem.getItemId()));

                warehouseScan.setScannedAt(LocalDateTime.now());

                warehouseScan.setType(in.shop2020.warehouse.ScanType.SALE_RET);

                warehouseScanRepository.persist(warehouseScan);

            }

        }

        //Create Order as well

        com.spice.profitmandi.dao.entity.user.User user = userRepository.selectById(debitNote.getFofoId());

        cartService.clearCart(user.getActiveCartId());

        cartService.addItemsToCart(user.getActiveCartId(), cartItems);

        UserCart userCart = new UserCart();

        userCart.setCartId(user.getActiveCartId());

        userCart.setUserId(user.getId());

        int transactionId = transactionService.createTransactionInternally(userCart, walletTotalAmount, order.getWarehouseId());

        commonPaymentService.payThroughWallet(transactionId);

        transactionService.processTransaction(transactionId);

    }

    @Autowired