Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import java.io.Serializable;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

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

import com.spice.profitmandi.dao.enumuration.catalog.StockTransactionType;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.core.io.ByteArrayResource;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

import com.google.common.collect.Sets;

import com.smartdukaan.cron.Application;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.util.Utils;

import com.spice.profitmandi.dao.entity.catalog.Scheme;

import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;

import com.spice.profitmandi.dao.entity.fofo.FofoOrder;

import com.spice.profitmandi.dao.entity.fofo.InventoryItem;

import com.spice.profitmandi.dao.entity.fofo.Purchase;

import com.spice.profitmandi.dao.entity.fofo.ScanRecord;

import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;

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

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

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

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

import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;

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

import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;

import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;

import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;

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

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

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

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

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.service.user.RetailerService;

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

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

@Component

@Transactional(rollbackFor = Throwable.class)

public class Reconciliation {

    private static final Logger LOGGER = LogManager.getLogger(Application.class);

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    private static final List<WalletReferenceType> reconciliationReferenceTypes = Arrays

            .asList(WalletReferenceType.PURCHASE, WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT);

    @Autowired

    private PurchaseRepository purchaseRepository;

    @Autowired

    private OrderService orderService;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private FofoLineItemRepository fofoLineItemRepository;

    @Autowired

    private UserWalletRepository userWalletRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private ScanRecordRepository scanRecordRepository;

    @Autowired

    private UserWalletHistoryRepository userWalletHistoryRepository;

    @Autowired

    private SchemeInOutRepository schemeInOutRepository;

    @Autowired

    private SchemeRepository schemeRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private ReturnOrderRepository returnOrderRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private JavaMailSender mailSender;

    public void dailyReconciliation() throws Exception {

        LocalDate date = LocalDate.now().minusDays(1);

        dailyReconciliation(date);

    }

    public void dailyReconciliation(LocalDate localDate) throws Exception {

        Map<SchemeType, Set<Integer>> schemeTypeMap = schemeRepository.selectAll().stream()

                .collect(Collectors.groupingBy(Scheme::getType, Collectors.mapping(Scheme::getId, Collectors.toSet())));

        boolean reconciled = true;

        Map<Integer, String> stores = fofoStoreRepository.getStoresMap();

        List<List<?>> rows = new ArrayList<>();

        LocalDate yesterday = LocalDate.now().minusDays(1);

        Map<Integer, String> retailerNameMap = retailerService

                .getAllFofoRetailerIdNameMap(new ArrayList<>(stores.keySet()));

        for (int partnerId : stores.keySet()) {

            UserWallet uw = userWalletRepository.selectByRetailerId(partnerId);

            List<UserWalletHistory> walletHistory = userWalletHistoryRepository.selectByWalletIdAndDate(uw.getId(),

                    yesterday);

            Map<WalletReferenceType, List<UserWalletHistory>> referenceWiseWalletHistory = walletHistory.stream()

                    .collect(Collectors.groupingBy(x -> x.getReferenceType(), Collectors.toList()));

            reconciliationReferenceTypes.forEach(x -> {

                if (!referenceWiseWalletHistory.containsKey(x)) {

                    referenceWiseWalletHistory.put(x, new ArrayList<>());

                }

            });

            List<Serializable> reconciliation = new ArrayList<>();

            LocalDate dateToReconcile = yesterday;

            // "PartnerId", "Partner Name", "Reconciliation Date"

            reconciliation.addAll(Arrays.asList(partnerId, retailerNameMap.get(partnerId), dateToReconcile));

            for (WalletReferenceType walletReferenceType : reconciliationReferenceTypes) {

                List<UserWalletHistory> history = referenceWiseWalletHistory.get(walletReferenceType);

                Map<Integer, Integer> referenceWalletMap = history.stream().collect(

                        Collectors.groupingBy(x -> x.getReference(), Collectors.summingInt(x -> x.getAmount())));

                switch (walletReferenceType) {

                    case PURCHASE:

                        reconciliation.addAll(reconcileOrdersAndWallet(dateToReconcile, referenceWalletMap, history));

                        break;

                    case SCHEME_IN:

                        for (SchemeType schemeType : SchemeType.IN_TYPES) {

                            reconciliation.addAll(reconcileSchemeInAndWallet(dateToReconcile, referenceWalletMap, history,

                                    schemeTypeMap.get(schemeType)));

                        }

                        break;

                    case SCHEME_OUT:

                        for (SchemeType schemeType : SchemeType.OUT_TYPES) {

                            reconciliation.addAll(reconcileSchemeOutAndWallet(dateToReconcile, referenceWalletMap, history,

                                    schemeTypeMap.get(schemeType)));

                            break;

                        }

                    default:

                        break;

                }

            }

            reconciled = reconciled || Boolean.TRUE.equals(reconciliation.get(0));

            rows.add(reconciliation);

        }

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList("PartnerId", "Partner Name",

                "Reconciliation Date", "Purchase Reconciled", "Wallet amount consumed", "Ordered Total",

                "Cancelled Total", "Refunded Total", "Scheme In Reconciled", "Scheme In to Wallet",

                "Scheme In disbursed", "Scheme In rolledback", "SchemeOut Reconciled", "Scheme Out to Wallet",

                "Scheme Out Disbursed", "Scheme Out Rolledback"), rows);

        Utils.sendMailWithAttachment(mailSender,

                new String[]{"amit.gupta@shop2020.in", "neeraj.gupta@smartdukaan.com"}, new String[]{},

                reconciled ? "Reconciled Successfully" : "Reconciliation failed", "Report attached",

                String.format("reconciliation-%s.csv", FormattingUtils.formatDate(yesterday.atStartOfDay())),

                new ByteArrayResource(baos.toByteArray()));

    }

    private List<? extends Serializable> reconcileOrdersAndWallet(LocalDate localDate,

                                                                  Map<Integer, Integer> transactionsOnThatDate, List<UserWalletHistory> history) throws Exception {

        int totalWalletConsumed = 0;

        float cancelledAmount = 0;

        float returnedAmount = 0;

        float totalDeductedAmount = 0;

        for (int transactionId : transactionsOnThatDate.keySet()) {

            List<Order> orders = orderRepository.selectAllByTransactionId(transactionId);

            for (Order o : orders) {

                if (o.getCreateTimestamp().toLocalDate().equals(localDate)) {

                    if (Arrays.asList(OrderStatus.PAYMENT_PENDING, OrderStatus.PAYMENT_FAILED)

                            .contains(o.getStatus())) {

                        cancelledAmount += o.getWalletAmount();

                    } else if (o.getRefundTimestamp() != null

                            && o.getRefundTimestamp().toLocalDate().equals(localDate)) {

                        ReturnOrder returnedOrder = returnOrderRepository.selectByOrderId(o.getId());

                        if (returnedOrder == null) {

                            cancelledAmount += o.getWalletAmount();

                        } else {

                            returnedAmount += returnedOrder.getTotalPrice();

                        }

                    }

                    totalDeductedAmount += o.getWalletAmount();

                } else if (o.getRefundTimestamp() != null && o.getRefundTimestamp().toLocalDate().equals(localDate)) {

                    ReturnOrder returnedOrder = returnOrderRepository.selectByOrderId(o.getId());

                    if (returnedOrder == null) {

                        cancelledAmount += o.getWalletAmount();

                    } else {

                        returnedAmount += returnedOrder.getTotalPrice();

                    }

                }

            }

            totalWalletConsumed -= transactionsOnThatDate.get(transactionId);

        }

        boolean reconciled = Math

                .abs(totalWalletConsumed - (totalDeductedAmount - cancelledAmount - returnedAmount)) < 2;

        return Arrays.asList(reconciled, totalWalletConsumed, totalDeductedAmount, cancelledAmount, returnedAmount, "");

    }

    private List<? extends Serializable> reconcileSchemeInAndWallet(LocalDate localDate,

                                                                    Map<Integer, Integer> transactionsOnThatDate, List<UserWalletHistory> history, Set<Integer> schemeIds) throws ProfitMandiBusinessException {

        int totalSchemeInWalletCredited = 0;

        float schemeInAmountAdded = 0;

        float schemeInAmountRolledBack = 0;

        for (int transactionId : transactionsOnThatDate.keySet()) {

            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(transactionId).stream()

                    .filter(x -> x.getSerialNumber() != null).collect(Collectors.toList());

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

            if (inventoryItemIds.size() == 0) {

                continue;

            }

            List<SchemeInOut> sios = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(inventoryItemIds))

                    .stream().filter(x -> schemeIds.contains(x.getSchemeId())).collect(Collectors.toList());

            totalSchemeInWalletCredited += transactionsOnThatDate.get(transactionId);

            for (SchemeInOut sio : sios) {

                if (sio.getCreateTimestamp().toLocalDate().equals(localDate)) {

                    schemeInAmountAdded += sio.getAmount();

                }

                if (sio.getRolledBackTimestamp() != null

                        && sio.getRolledBackTimestamp().toLocalDate().equals(localDate)) {

                    schemeInAmountRolledBack += sio.getAmount();

                }

            }

        }

        boolean reconciled = Math

                .abs(totalSchemeInWalletCredited - (schemeInAmountAdded - schemeInAmountRolledBack)) < 5;

        return Arrays.asList(reconciled, totalSchemeInWalletCredited, schemeInAmountAdded, schemeInAmountRolledBack,

                "");

    }

    private List<? extends Serializable> reconcileSchemeOutAndWallet(LocalDate localDate,

                                                                     Map<Integer, Integer> transactionsOnThatDate, List<UserWalletHistory> history, Set<Integer> schemeIds) throws ProfitMandiBusinessException {

        int totalSchemeOutWalletCredited = 0;

        float schemeOutAmountAdded = 0;

        float schemeOutAmountRolledBack = 0;

        for (int fofoOrderId : transactionsOnThatDate.keySet()) {

            Set<Integer> fofoOrderItemIds = fofoOrderItemRepository.selectByOrderId(fofoOrderId).stream()

                    .map(x -> x.getId()).collect(Collectors.toSet());

            List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);

            Set<Integer> inventoryItemIds = fofoLineItems.stream().map(x -> x.getInventoryItemId())

                    .collect(Collectors.toSet());

            List<SchemeInOut> sios = schemeInOutRepository.selectByInventoryItemIds(new HashSet<>(inventoryItemIds))

                    .stream().filter(x -> schemeIds.contains(x.getSchemeId())).collect(Collectors.toList());

            totalSchemeOutWalletCredited += transactionsOnThatDate.get(fofoOrderId);

            for (SchemeInOut sio : sios) {

                if (sio.getCreateTimestamp().toLocalDate().equals(localDate)) {

                    schemeOutAmountAdded += sio.getAmount();

                }

                if (sio.getRolledBackTimestamp() != null

                        && sio.getRolledBackTimestamp().toLocalDate().equals(localDate)) {

                    schemeOutAmountRolledBack += sio.getAmount();

                }

            }

        }

        boolean reconciled = Math

                .abs(totalSchemeOutWalletCredited - (schemeOutAmountAdded - schemeOutAmountRolledBack)) < 5;

        return Arrays.asList(reconciled, totalSchemeOutWalletCredited, schemeOutAmountAdded, schemeOutAmountRolledBack,

                "");

    }

    public void reconcileExpiredFixedSchemes() throws Exception {

        List<Scheme> allSchemes = schemeRepository.selectAll();

        // .stream().filter(x ->

        // x.getAmountType().equals(AmountType.FIXED)).collect(Collectors.toList());

        allSchemes = allSchemes.stream()

                .filter(x -> x.getEndDateTime().isAfter(LocalDate.of(2019, 3, 31).atStartOfDay()))

                .collect(Collectors.toList());

        System.out.println(

                "InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tScheme Amount\tAmount Paid\tReference\tTransaction Time\tScheme Start\tScheme End\tScheme Expiry");

        for (Scheme scheme : allSchemes) {

            if (scheme.getExpireTimestamp() != null) {

                if (scheme.getExpireTimestamp().isBefore(scheme.getEndDateTime())) {

                    List<SchemeInOut> inOuts = schemeInOutRepository.selectBySchemeIds(Sets.newHashSet(scheme.getId()));

                    if (scheme.getType().getTransactionType().equals(StockTransactionType.IN)) {

                        for (SchemeInOut schemeInOut : inOuts) {

                            ScanRecord inRecord = scanRecordRepository

                                    .selectByInventoryItemId(schemeInOut.getInventoryItemId()).stream()

                                    .filter(x -> x.getType().equals(ScanType.PURCHASE)).collect(Collectors.toList())

                                    .get(0);

                            if (inRecord.getCreateTimestamp().isAfter(scheme.getExpireTimestamp())) {

                                InventoryItem ii = inventoryItemRepository.selectById(inRecord.getInventoryItemId());

                                Purchase purchase = purchaseRepository.selectByIdAndFofoId(ii.getPurchaseId(),

                                        ii.getFofoId());

                                System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%f\t%f\t%d\t%s\t%s\t%s\t%s",

                                        ii.getId(), ii.getSerialNumber(), ii.getItemId(), schemeInOut.getSchemeId(),

                                        scheme.getName(), scheme.getType(), scheme.getAmount(), schemeInOut.getAmount(),

                                        purchase.getId(), inRecord.getCreateTimestamp(), scheme.getStartDateTime(),

                                        scheme.getEndDateTime(), scheme.getExpireTimestamp()));

                            }

                        }

                    }

                    if (scheme.getType().getTransactionType().equals(StockTransactionType.OUT)) {

                        for (SchemeInOut schemeInOut : inOuts) {

                            ScanRecord outRecord = scanRecordRepository

                                    .selectByInventoryItemId(schemeInOut.getInventoryItemId()).stream()

                                    .filter(x -> x.getType().equals(ScanType.SALE))

                                    .sorted((x1, x2) -> x1.getId() - x2.getId()).collect(Collectors.toList()).get(0);

                            if (outRecord.getCreateTimestamp().isAfter(scheme.getExpireTimestamp())) {

                                InventoryItem ii = inventoryItemRepository.selectById(outRecord.getInventoryItemId());

                                FofoOrder fofoOrder;

                                if (outRecord.getOrderId() == 0) {

                                    fofoOrder = orderService.getOrderByInventoryItemId(ii.getId());

                                } else {

                                    fofoOrder = fofoOrderRepository.selectByOrderId(outRecord.getOrderId());

                                    if (fofoOrder == null) {

                                        LOGGER.info("Order id does not exits - {}", outRecord.getOrderId());

                                        continue;

                                    }

                                }

                                System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%f\t%f\t%d\t%s\t%s\t%s\t%s",

                                        ii.getId(), ii.getSerialNumber(), ii.getItemId(), schemeInOut.getSchemeId(),

                                        scheme.getName(), scheme.getType(), scheme.getAmount(), schemeInOut.getAmount(),

                                        fofoOrder.getId(), outRecord.getCreateTimestamp(), scheme.getStartDateTime(),

                                        scheme.getEndDateTime(), scheme.getExpireTimestamp()));

                            }

                        }

                    }

                }

            }

        }

    }

    private void checkForDblClickIssues() {

        // For all schmes from April onwards

    }

    private void dbClickPurchase() {

        List<Purchase> purchases = purchaseRepository

                .selectAllBetweenPurchaseDate(LocalDate.of(2019, 4, 1).atStartOfDay(), LocalDateTime.now());

    }

    private void dbClickSale() {

        List<FofoOrder> sales = fofoOrderRepository.selectBetweenSaleDate(LocalDate.of(2019, 4, 1).atStartOfDay(),

                LocalDateTime.now());

    }

}