Subversion Repositories SmartDukaan

Rev

Rev 24337 | Rev 24461 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package com.smartdukaan.cron.scheduled;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Timestamp;
import java.text.MessageFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import javax.mail.MessagingException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import org.apache.commons.codec.CharEncoding;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import com.spice.profitmandi.common.enumuration.RechargeStatus;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.model.RechargeCredential;
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.dtr.DailyRecharge;
import com.spice.profitmandi.dao.entity.dtr.RechargeProvider;
import com.spice.profitmandi.dao.entity.dtr.RechargeProviderCreditWalletHistory;
import com.spice.profitmandi.dao.entity.dtr.RechargeTransaction;
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;
import com.spice.profitmandi.dao.entity.fofo.PartnerTargetDetails;
import com.spice.profitmandi.dao.entity.fofo.Purchase;
import com.spice.profitmandi.dao.entity.fofo.SaleHeadDetails;
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;
import com.spice.profitmandi.dao.repository.dtr.DailyRechargeRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderCreditWalletHistoryRepository;
import com.spice.profitmandi.dao.repository.dtr.RechargeProviderRepository;
import com.spice.profitmandi.dao.repository.dtr.RechargeTransactionRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerTargetRepository;
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.service.PartnerInvestmentService;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.order.OrderService;
import com.spice.profitmandi.service.recharge.provider.OxigenRechargeProviderService;
import com.spice.profitmandi.service.recharge.provider.ThinkWalnutDigitalRechargeProviderService;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.service.slab.TargetSlabService;
import com.spice.profitmandi.service.transaction.TransactionService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.wallet.WalletService;

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

@Component
@Transactional(rollbackFor = Throwable.class)
public class ScheduledTasks {

        @Value("${oxigen.recharge.transaction.url}")
        private String oxigenRechargeTransactionUrl;

        @Value("${oxigen.recharge.enquiry.url}")
        private String oxigenRechargeEnquiryUrl;

        @Value("${oxigen.recharge.auth.key}")
        private String oxigenRechargeAuthKey;

        @Value("${oxigen.recharge.validation.url}")
        private String oxigenRechargeValidationUrl;

        @Value("${oxigen.recharge.validation.auth.key}")
        private String oxigenRechargeValidationAuthKey;

        @Value("${think.walnut.digital.recharge.transaction.mobile.url}")
        private String thinkWalnutDigitalRechargeTransactionMobileUrl;

        @Value("${think.walnut.digital.recharge.transaction.dth.url}")
        private String thinkWalnutDigitalRechargeTransactionDthUrl;

        @Value("${think.walnut.digital.recharge.enquiry.url}")
        private String thinkWalnutDigitalRechargeEnquiryUrl;

        @Value("${think.walnut.digital.recharge.balance.url}")
        private String thinkWalnutDigitalRechargeBalanceUrl;

        @Value("${think.walnut.digital.recharge.username}")
        private String thinkWalnutDigitalRechargeUserName;

        @Value("${think.walnut.digital.recharge.password}")
        private String thinkWalnutDigitalRechargePassword;

        @Value("${think.walnut.digital.recharge.auth.key}")
        private String thinkWalnutDigitalRechargeAuthKey;

        @Autowired
        private PurchaseRepository purchaseRepository;

        @Autowired
        private SchemeService schemeService;

        @Autowired
        private OrderService orderService;

        @Autowired
        private PartnerInvestmentService partnerInvestmentService;

        @Autowired
        private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

        @Autowired
        private SchemeInOutRepository schemeInOutRepository;

        @Autowired
        private RechargeTransactionRepository rechargeTransactionRepository;

        @Autowired
        private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;

        @Autowired
        private FofoOrderRepository fofoOrderRepository;

        @Autowired
        private InventoryItemRepository inventoryItemRepository;

        @Autowired
        private WalletService walletService;

        @Autowired
        private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;

        @Autowired
        private OxigenRechargeProviderService oxigenRechargeProviderService;

        @Autowired
        private RechargeProviderRepository rechargeProviderRepository;

        @Autowired
        private ScanRecordRepository scanRecordRepository;

        @Autowired
        private DailyRechargeRepository dailyRechargeRepository;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private TargetSlabService targetService;

        @Value("${prod}")
        private boolean prod;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private TransactionService transactionService;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private OrderRepository orderRepository;

        @Autowired
        private SchemeRepository schemeRepository;

        @Autowired
        private JavaMailSender mailSender;

        @Autowired
        private PartnerTargetRepository partnerTargetRepository;

        @Autowired
        @Qualifier(value = "googleMailSender")
        private JavaMailSender googleMailSender;

        @Autowired
        private InventoryService inventoryService;

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

        public void generateDailyRecharge() {
                List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository
                                .selectAll(0, 2000);
                List<RechargeProvider> rechargeProviders = rechargeProviderRepository.selectAll();
                rechargeProviders.stream().forEach(x -> x.setAmount(0));

                rechargeProviders.stream().forEach(x -> {
                        Map<LocalDate, List<RechargeProviderCreditWalletHistory>> dateWiseProviderCreditsMap = allCreditHistory
                                        .stream().filter(z -> z.getProviderId() == x.getId())
                                        .collect(Collectors.groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));

                        LOGGER.info("dateWiseProviderCreditsMap -- {}", dateWiseProviderCreditsMap);
                        LocalDate endDate = LocalDate.now().plusDays(1);
                        float previousDayClosing = 0;
                        LocalDate date = LocalDate.of(2018, 4, 6);
                        while (date.isBefore(endDate)) {
                                List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository
                                                .selectAllBetweenTimestamp(Arrays.asList(RechargeStatus.values()), date.atStartOfDay(),
                                                                date.plusDays(1).atStartOfDay());

                                List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()
                                                .filter(y -> y.getStatus().equals(RechargeStatus.SUCCESS)).collect(Collectors.toList());

                                float dailyAmount = 0;
                                float totalCommission = 0;
                                for (RechargeTransaction rechargeTransaction : successfulTransactions) {
                                        if (rechargeTransaction.getProviderId() == x.getId()) {
                                                dailyAmount += rechargeTransaction.getAmount();
                                                totalCommission += rechargeTransaction.getCommission();
                                        }
                                }

                                List<RechargeProviderCreditWalletHistory> rechargeHistoryList = dateWiseProviderCreditsMap.get(date);
                                float dailyWalletRecharge = 0;
                                if (rechargeHistoryList != null) {
                                        for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {
                                                if (rechargeProviderCreditWalletHistory.getProviderId() == x.getId()) {
                                                        dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();
                                                }
                                        }
                                }
                                if (dailyAmount > 0 || dailyWalletRecharge > 0) {
                                        DailyRecharge dailyRecharge = null;
                                        try {
                                                dailyRecharge = dailyRechargeRepository.selectByProviderIdAndCreateDate(x.getId(), date);
                                        } catch (Exception e) {
                                                LOGGER.info("Could not find Recharge entry");
                                        }
                                        if (dailyRecharge == null) {
                                                dailyRecharge = new DailyRecharge();
                                                dailyRecharge.setCreateDate(date);
                                        }
                                        dailyRecharge.setOpeningBalance(previousDayClosing);
                                        dailyRecharge.setProviderId(x.getId());
                                        dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);
                                        dailyRecharge.setTotalAmount(dailyAmount);
                                        dailyRecharge.setTotalCommission(totalCommission);
                                        float closingBalance = dailyRecharge.getOpeningBalance() + dailyWalletRecharge - dailyAmount;
                                        dailyRecharge.setClosingBalance(closingBalance);
                                        dailyRechargeRepository.persist(dailyRecharge);
                                        x.setAmount(x.getAmount() + dailyRecharge.getClosingBalance() - dailyRecharge.getOpeningBalance());
                                        previousDayClosing = dailyRecharge.getClosingBalance();
                                }
                                date = date.plusDays(1);
                        }
                        rechargeProviderRepository.persist(x);
                });
                LOGGER.info("finished generating daily recharge");
        }

        public void reconcileRecharge() throws Exception {
                LocalDateTime fromDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS).minusDays(30);
                LocalDateTime toDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);
                List<RechargeStatus> nonSuccessRechargeStatuses = new ArrayList<>(Arrays.asList(RechargeStatus.values()));
                LOGGER.info("nonSuccessRechargeStatuses {} ", nonSuccessRechargeStatuses);
                nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);
                nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);
                RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();
                thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);
                thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);
                thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);
                thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);
                Map<String, RechargeStatus> requestRechargeStatusChanged = new HashMap<>();
                List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository
                                .selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);
                for (RechargeTransaction rechargeTransaction : rechargeTransactions) {
                        try {
                                int providerId = rechargeTransaction.getProviderId();
                                if (providerId == 1) {
                                        oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,
                                                        rechargeTransaction);
                                } else if (providerId == 2) {
                                        thinkWalnutDigitalRechargeProviderService
                                                        .doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);
                                }
                                if (rechargeTransaction.getStatus().equals(RechargeStatus.SUCCESS)
                                                || rechargeTransaction.getStatus().equals(RechargeStatus.FAILED)) {
                                        requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),
                                                        rechargeTransaction.getStatus());
                                }
                        } catch (Exception e) {
                                LOGGER.info("Could not check status for Request {}", rechargeTransaction.getRequestId());
                        }
                }
                LOGGER.info("Reconcile recharge ran successfully");
        }

        // TemporaryMethod
        public void migrateInvoice() {
                List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));
                Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();
                partnerOrdersMap = fofoOrders.stream()
                                .collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));
                for (List<FofoOrder> orderList : partnerOrdersMap.values()) {
                        int sequence = 0;
                        String prefix = "";
                        List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())
                                        .collect(Collectors.toList());
                        for (FofoOrder order : sortedList) {

                                LOGGER.info("Order Id is {}, partner Id is {}", order.getId(), order.getFofoId());
                                if (!order.getInvoiceNumber().contains("SEC")) {
                                        sequence = Integer.parseInt(order.getInvoiceNumber().split("/")[1]);
                                        prefix = order.getInvoiceNumber().split("/")[0];
                                } else {
                                        sequence += 1;
                                        String invoiceNumber = prefix + "/" + sequence;
                                        order.setInvoiceNumber(invoiceNumber);
                                        fofoOrderRepository.persist(order);
                                }
                        }

                }
        }

        // Temporary Method
        public void evaluateExcessSchemeOut() throws Exception {
                Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();
                Map<Integer, Float> userAmountMap = new HashMap<>();

                List<List<Object>> rows = new ArrayList<>();
                List<String> headers = Arrays.asList("Scheme", "Item", "Partner", "Amount", "Credited On", "Invoice Number",
                                "Sale On", "Scheme Start", "Scheme End", "Active On", "Expired On");
                schemeRepository.selectAll().stream().forEach(x -> {
                        if (x.getType().equals(SchemeType.OUT)) {
                                List<SchemeInOut> sioList = schemeInOutRepository
                                                .selectBySchemeIds(new HashSet<>(Arrays.asList(x.getId())));
                                if (x.getActiveTimestamp() != null) {
                                        LocalDateTime endDateTime = x.getEndDateTime();
                                        if (x.getExpireTimestamp() != null && x.getExpireTimestamp().isBefore(x.getEndDateTime())) {
                                                endDateTime = x.getExpireTimestamp();
                                        }
                                        for (SchemeInOut sio : sioList) {
                                                InventoryItem inventoryItem = null;
                                                inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());
                                                FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndSerialNumber(
                                                                inventoryItem.getFofoId(), inventoryItem.getSerialNumber(), null, null, 0, 1).get(0);
                                                Optional<ScanRecord> record = scanRecordRepository
                                                                .selectByInventoryItemId(sio.getInventoryItemId()).stream()
                                                                .filter(y -> y.getType().equals(ScanType.SALE)).findFirst();
                                                if (record.isPresent()) {
                                                        int fofoId = record.get().getFofoId();
                                                        if (record.get().getCreateTimestamp().isAfter(endDateTime)
                                                                        || record.get().getCreateTimestamp().isBefore(x.getStartDateTime())) {
                                                                if (!userAmountMap.containsKey(fofoId)) {
                                                                        userAmountMap.put(fofoId, 0f);
                                                                }
                                                                userAmountMap.put(fofoId, sio.getAmount() + userAmountMap.get(fofoId));
                                                                try {
                                                                        rows.add(Arrays.asList(x.getDescription(),
                                                                                        itemRepository.selectById(inventoryItem.getItemId()).getItemDescription(),
                                                                                        userNameMap.get(fofoId), sio.getAmount(),
                                                                                        FormattingUtils.formatDate(sio.getCreateTimestamp()),
                                                                                        fofoOrder.getInvoiceNumber(),
                                                                                        FormattingUtils.formatDate(record.get().getCreateTimestamp()),
                                                                                        FormattingUtils.formatDate(x.getStartDateTime()),
                                                                                        FormattingUtils.formatDate(x.getEndDateTime()),
                                                                                        FormattingUtils.formatDate(x.getActiveTimestamp()),
                                                                                        FormattingUtils.formatDate(x.getExpireTimestamp())));
                                                                } catch (Exception e) {
                                                                        e.printStackTrace();
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                });
                userAmountMap.entrySet().stream()
                                .forEach(x -> LOGGER.info("{} to be deducted from {}({}) for wrongly disbursed due to technical error.",
                                                x.getValue(), userNameMap.get(x.getKey())));

                ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
                Utils.sendMailWithAttachment(googleMailSender,
                                new String[] { "amit.gupta@shop2020.in", "adeel.yazdani@smartdukaan.com" }, null,
                                "Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));

        }

        public void processScheme(int offset) throws Exception {
                LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(30 * offset);
                LocalDateTime endDate = startDate.plusDays(30);
                processScheme(startDate, endDate);
        }

        public void processScheme() throws Exception {
                LocalDateTime fromDate = LocalDateTime.now().minusDays(30);
                processScheme(fromDate, LocalDateTime.now());
        }

        public void processScheme(LocalDateTime startDate, LocalDateTime endDate) throws Exception {
                LOGGER.info("Started execution at {}", LocalDateTime.now());
                List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);
                for (Purchase purchase : purchases) {
                        try {
                                schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
                        } catch (Exception e) {
                                LOGGER.error("Error while processing purchase {} for scheme In ", purchase.getId());
                                e.printStackTrace();

                        }
                }
                List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);
                for (FofoOrder fofoOrder : fofoOrders) {
                        try {
                                schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
                        } catch (Exception e) {
                                LOGGER.error("Error while processing sale order {} for scheme Out", fofoOrder.getId());
                        }
                }
                LOGGER.info("Schemes process successfully.");
        }

        public void processRechargeCashback() throws Throwable {
                LocalDateTime cashbackTime = LocalDateTime.now();
                int referenceId = (int) Timestamp.valueOf(cashbackTime).getTime() / 1000;
                List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository
                                .getPendingCashBackRehargeTransactions();
                Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(
                                Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));
                for (Map.Entry<Object, Double> totalRetailerCashback : totalRetailerCashbacks.entrySet()) {
                        int retailerId = (Integer) totalRetailerCashback.getKey();
                        float amount = totalRetailerCashback.getValue().floatValue();
                        if (Math.round(amount) > 0) {
                                walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,
                                                "Recharge Cashback", Math.round(amount));
                        }
                }
                for (RechargeTransaction rt : pendingTransactions) {
                        rt.setCashbackTimestamp(cashbackTime);
                        rt.setCashbackReference(referenceId);
                        rechargeTransactionRepository.persist(rt);
                }
                LOGGER.info("Cashbacks for Recharge processed Successfully");
        }

        public void sendPartnerInvestmentDetails(List<String> sendTo) throws Exception {
                LocalDate yesterDay = LocalDate.now().minusDays(1);
                List<FofoStore> fofoStores = fofoStoreRepository.selectAll();
                Map<Integer, CustomRetailer> customRetailerMap = retailerService
                                .getFofoRetailers(fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList()));

                List<String> headers = Arrays.asList("Code", "StoreName", "Email", "Mobile", "Wallet Amount",
                                "Yesterday's Sale", "In Stock Amount", "Return In Transit Stock", "Unbilled Amount",
                                "Grn Pending Amount", "Min Investment", "Investment Amount", "Investment Short");
                List<List<Object>> rows = new ArrayList<>();
                for (FofoStore fofoStore : fofoStores) {
                        CustomRetailer retailer = customRetailerMap.get(fofoStore.getId());
                        if (retailer == null) {
                                LOGGER.info("Could not find retailer with retailer Id {}", fofoStore.getId());
                                continue;
                        }
                        PartnerDailyInvestment partnerDailyInvestment = partnerInvestmentService
                                        .getInvestment(fofoStore.getId(), 1);
                        partnerDailyInvestment.setDate(yesterDay);
                        partnerDailyInvestmentRepository.persist(partnerDailyInvestment);
                        
                        List<Object> row = Arrays.asList(fofoStore.getCode(), retailer.getBusinessName(), retailer.getEmail(),
                                        retailer.getMobileNumber(), partnerDailyInvestment.getWalletAmount(),
                                        partnerDailyInvestment.getSalesAmount(), partnerDailyInvestment.getInStockAmount(), 0,
                                        partnerDailyInvestment.getUnbilledAmount(), partnerDailyInvestment.getGrnPendingAmount(),
                                        partnerDailyInvestment.getMinInvestment(), partnerDailyInvestment.getTotalInvestment(), partnerDailyInvestment.getShortInvestment());
                        rows.add(row);

                }
                String fileName = "InvestmentSummary-" + FormattingUtils.formatDate(LocalDateTime.now()) + ".csv";
                ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);
                String[] sendToArray = sendTo.toArray(new String[sendTo.size()]);

                Utils.sendMailWithAttachment(googleMailSender, sendToArray, null, "Partner Investment Summary", "PFA", fileName,
                                new ByteArrayResource(baos.toByteArray()));

        }

        public void sendPartnerInvestmentDetails() throws Exception {
                List<String> sendTo = Arrays.asList("adeel.yazdani@smartdukaan.com", "amandeep.singh@smartdukaan.com",
                                "tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com", "dhruv.kathpal@smartdukaan.com",
                                "neeraj.gupta@smartdukaan.com");
                this.sendPartnerInvestmentDetails(sendTo);

        }

        private void sendMailWithAttachments(String[] email, String[] ccEmails, String body, String subject,
                        Map<String, InputStream> inputStreams)
                        throws MessagingException, ProfitMandiBusinessException, IOException {
                MimeMessage message = mailSender.createMimeMessage();
                MimeMessageHelper helper = new MimeMessageHelper(message, true, CharEncoding.UTF_8);
                helper.setSubject(subject);
                helper.setText(body);
                if (ccEmails != null) {
                        helper.setCc(ccEmails);
                }
                for (String attachment : inputStreams.keySet()) {
                        helper.addAttachment(attachment + "_" + LocalDate.now() + ".xls",
                                        new ByteArrayResource(IOUtils.toByteArray(inputStreams.get(attachment))));
                }
                helper.setTo(email);
                InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
                helper.setFrom(senderAddress);
                mailSender.send(message);
        }

        private void sendMailWithAttachmentsForPartners(String email, String body, String subject, InputStream is)
                        throws MessagingException, ProfitMandiBusinessException, IOException {
                MimeMessage message = mailSender.createMimeMessage();
                MimeMessageHelper helper = new MimeMessageHelper(message, true, CharEncoding.UTF_8);
                helper.setSubject(subject);
                helper.setText(body);
                helper.addAttachment("DailySaleTargetReports_" + LocalDate.now() + ".xls",
                                new ByteArrayResource(IOUtils.toByteArray(is)));
                helper.setTo(email);
                InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smart Dukaan");
                helper.setFrom(senderAddress);
                mailSender.send(message);
        }

        public void sendMailToSalesHeadAboutTargetAndSales(SaleHeadDetails salesHeadDetail)
                        throws MessagingException, ProfitMandiBusinessException, IOException {
                List<PartnerTargetDetails> partnerTargetDetails = partnerTargetRepository
                                .selectAllGeEqAndLeEqStartDateAndEndDate(LocalDateTime.now());
                Map<String, InputStream> inputStreams = new HashMap<>();
                for (PartnerTargetDetails partnerTargetDetail : partnerTargetDetails) {
                        InputStream is = targetService.getDailySaleReportVsTargetForSaleHead(partnerTargetDetail,
                                        salesHeadDetail.getName());

                        inputStreams.put(partnerTargetDetail.getTargetName(), is);

                }
                // String[] ccEmails = null;
                if (partnerTargetDetails.size() > 0) {
                        String[] ccEmails = { "Tarun.verma@smartdukaan.com", "Kamini.sharma@smartdukaan.com",
                                        "chaitnaya.vats@smartdukaan.com", "dhruv.kathpal@smartdukaan.com" };
                        String subject = "Daily Sales Report ";
                        String message = MessageFormat.format("Sale Target summary for {0}", LocalDate.now());
                        LOGGER.info("message" + message);
                        if (salesHeadDetail.getName().equals("Kamal")) {
                                LOGGER.info("salesHeadDetail.getName()" + salesHeadDetail.getName());
                                String[] to = { salesHeadDetail.getEmail(), "mohinder.mutreja@smartdukaan.com" };

                                this.sendMailWithAttachments(to, ccEmails, message, subject, inputStreams);

                        } else {
                                LOGGER.info("salesHeadDetail.getName()" + salesHeadDetail.getName());
                                String[] to = { salesHeadDetail.getEmail() };
                                this.sendMailWithAttachments(to, ccEmails, message, subject, inputStreams);
                        }
                }
        }

        public void sendMailToPartnerAboutTargetAndSales() throws ProfitMandiBusinessException, MessagingException,
                        IOException, EncryptedDocumentException, InvalidFormatException {
                List<Integer> fofoIds = targetService.getfofoIdsFromfofoStore();
                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = retailerService
                                .getFofoRetailers(new ArrayList<>(fofoIds));
                List<InputStream> input = new ArrayList<>();
                List<PartnerTargetDetails> partnerTargetDetails = partnerTargetRepository
                                .selectAllGeEqAndLeEqStartDateAndEndDate(LocalDateTime.now());
                for (Integer fofoId : fofoIds) {
                        InputStream is = targetService.getDailySaleReportVsTargetForPartner(fofoId, partnerTargetDetails);
                        LOGGER.info("is" + is);
                        if (is == null) {
                                continue;
                        }
                        LOGGER.info("fofoId" + fofoId);

                        LOGGER.info(fofoIdsAndCustomRetailer.get(fofoId).getEmail());
                        String subject = "Daily Sales Report";
                        String message = MessageFormat.format("Sale Target summary for {0}", LocalDate.now());
                        LOGGER.info(message);
                        this.sendMailWithAttachmentsForPartners(fofoIdsAndCustomRetailer.get(fofoId).getEmail(), message, subject,
                                        is);

                }
        }

}