Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.dao.entity.transaction.Order;

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

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

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;

import com.spice.profitmandi.service.transaction.ReturnService;

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

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

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.model.v1.order.WalletReferenceType;

import in.shop2020.warehouse.Scan;

import in.shop2020.warehouse.ScanType;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Component

public class TransactionRelatedTasks {

    @Autowired

    private ReturnService returnService;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    WarehouseScanRepository warehouseScanRepository;

    @Autowired

    WarehouseInventoryService warehouseInventoryService;

    @Autowired

    WalletService walletService;

    public void reverseRTO(List<String> invoiceNumbers) throws ProfitMandiBusinessException {

        // Fetch with pessimistic lock to prevent concurrent modifications

        List<Order> lockedOrders = orderRepository.selectByInvoiceNumbersForUpdate(invoiceNumbers);

        Map<String, List<Order>> invoiceOrderMap = lockedOrders.stream().collect(Collectors.groupingBy(x -> x.getInvoiceNumber()));

        List<Integer> rtoOrderIds = lockedOrders.stream().map(x -> x.getId()).collect(Collectors.toList());

        Map<Integer, List<WarehouseScan>> orderIdWarehouseScanMap = warehouseScanRepository.selectAllByOrderIds(rtoOrderIds).stream().filter(x -> x.getType().equals(ScanType.SALE_RET)).collect(Collectors.groupingBy(x -> x.getOrderId()));

        for (Map.Entry<String, List<Order>> invoiceOrdersEntry : invoiceOrderMap.entrySet()) {

            String invoiceNumber = invoiceOrdersEntry.getKey();

            List<Order> orders = invoiceOrdersEntry.getValue();

            int transactionId = orders.get(0).getTransactionId();

            int fofoId = orders.get(0).getRetailerId();

            Float walletAmount = 0f;

            for (Order order : orders) {

                order.setRefundBy(null);

                order.setRefundTimestamp(null);

                order.setRefundReason(null);

                order.setStatusDescription("");

                order.setReceiverReturnTimestamp(null);

                order.getWalletAmount();

                if (order.getShippingTimestamp() != null) {

                    order.setStatus(OrderStatus.SHIPPED_FROM_WH);

                } else {

                    order.setStatus(OrderStatus.BILLED);

                }

                walletAmount += order.getWalletAmount();

                List<WarehouseScan> warehouseScans = orderIdWarehouseScanMap.get(order.getId());

                for (WarehouseScan warehouseScan : warehouseScans) {

                    warehouseInventoryService.addQuantity(warehouseScan.getInventoryItemId(), warehouseScan.getQuantity());

                    warehouseScanRepository.delete(warehouseScan);

                }

                //Find inventory items and remove return entries

            }

            walletService.rollbackAmountFromWallet(fofoId, walletAmount, transactionId, WalletReferenceType.PURCHASE, "RTO reversed for invoice - " + invoiceNumber, LocalDateTime.now());

        }

    }

}

//RTOs should also come in curtomer return report