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