Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import com.google.common.collect.Lists;

import com.google.gson.Gson;

import com.razorpay.Payment;

import com.smartdukaan.cron.itelImeiActivation.ItelImeiActivationNewService;

import com.smartdukaan.cron.itelImeiActivation.ItelImeiActivationService;

import com.smartdukaan.cron.itelImeiActivation.TecnoImeiActivation;

import com.smartdukaan.cron.scheduled.runnables.PurchaseMigration;

import com.spice.profitmandi.common.enumuration.*;

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

import com.spice.profitmandi.common.model.*;

import com.spice.profitmandi.common.services.ReporticoService;

import com.spice.profitmandi.common.services.mandii.AccountStatusResponseOut;

import com.spice.profitmandi.common.services.mandii.EligibilityStatusEnum;

import com.spice.profitmandi.common.services.mandii.MandiiService;

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

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

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

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

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

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.dao.Interface.Campaign;

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

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.auth.PartnerCollectionRemark;

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

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

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

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

import com.spice.profitmandi.dao.entity.cs.Position;

import com.spice.profitmandi.dao.entity.cs.Ticket;

import com.spice.profitmandi.dao.entity.dtr.User;

import com.spice.profitmandi.dao.entity.dtr.*;

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

import com.spice.profitmandi.dao.entity.inventory.*;

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

import com.spice.profitmandi.dao.entity.user.*;

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

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

import com.spice.profitmandi.dao.enumuration.auth.CollectionRemark;

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

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.dtr.RefferalStatus;

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

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

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

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

import com.spice.profitmandi.dao.enumuration.inventory.VendorCatalogPricingStatus;

import com.spice.profitmandi.dao.enumuration.transaction.CreditRisk;

import com.spice.profitmandi.dao.enumuration.transaction.LoanReferenceType;

import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;

import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;

import com.spice.profitmandi.dao.model.*;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.auth.PartnerCollectionRemarkRepository;

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

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

import com.spice.profitmandi.dao.repository.cs.TicketRepository;

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

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

import com.spice.profitmandi.dao.repository.inventory.*;

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

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

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

import com.spice.profitmandi.dao.service.biuedart.BluedartAuthService;

import com.spice.profitmandi.dao.service.biuedart.BluedartService;

import com.spice.profitmandi.dao.service.solr.FofoSolr;

import com.spice.profitmandi.service.*;

import com.spice.profitmandi.service.integrations.CCAvenuePaymentService;

import com.spice.profitmandi.service.integrations.RazorpayPaymentService;

import com.spice.profitmandi.service.integrations.bharti.model.BAGInsuranceModel;

import com.spice.profitmandi.service.integrations.psismart.PsiSmartService;

import com.spice.profitmandi.service.integrations.smartping.SmartPingService;

import com.spice.profitmandi.service.integrations.toffee.ToffeeService;

import com.spice.profitmandi.service.inventory.*;

import com.spice.profitmandi.service.offers.OfferService;

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

import com.spice.profitmandi.service.pricing.PriceDropService;

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.serviceConfig.ServiceConfigService;

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

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

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

import com.spice.profitmandi.service.transaction.invoicing.InvoiceService;

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

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

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

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

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

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

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

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

import org.apache.commons.lang.StringUtils;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.conn.HttpHostConnectException;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.query.NativeQuery;

import org.json.JSONObject;

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.core.io.InputStreamSource;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

import javax.mail.MessagingException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import java.io.*;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.sql.Timestamp;

import java.text.DecimalFormat;

import java.time.*;

import java.time.format.DateTimeFormatter;

import java.time.temporal.ChronoField;

import java.time.temporal.ChronoUnit;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;

import static java.util.stream.Collectors.mapping;

@Component

@Transactional(rollbackFor = Throwable.class)

public class ScheduledTasks {

    @Value("${oxigen.recharge.enquiry.url}")

    private String oxigenRechargeEnquiryUrl;

    @Autowired

    PurchaseMigration purchaseMigration;

    @Autowired

    SmartPingService smartPingService;

    @Autowired

    private ServiceConfigService serviceConfigService;

    @Autowired

    private TecnoImeiActivation tecnoImeiActivation;

    private static final DateTimeFormatter leadTimeFormatter = DateTimeFormatter.ofPattern("d LLL, hh:mm a");

    @Autowired

    private PartnerRegionRepository partnerRegionRepository;

    @Autowired

    private EmployeeAttendanceRepository employeeAttendanceRepository;

    @Autowired

    VivoImeiActivationService vivoImeiActivationService;

    @Autowired

    ItelImeiActivationService itelImeiActivationService;

    @Autowired

    private PartnerTypeChangeService partnerTypeChangeService;

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private PriceDropService priceDropService;

    @Autowired

    private FranchiseeVisitRepository franchiseeVisitRepository;

    @Autowired

    private FranchiseeActivityRepository franchiseeActivityRepository;

    @Autowired

    private HdfcPaymentRepository hdfcPaymentRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Autowired

    private InsurancePolicyRepository insurancePolicyRepository;

    @Autowired

    private ToffeeService toffeeService;

    @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 PriceDropIMEIRepository priceDropIMEIRepository;

    @Autowired

    PriceDropRepository priceDropRepository;

    @Autowired

    private PartnerTypeChangeRepository partnerTypeChangeRepository;

    @Autowired

    private SchemeService schemeService;

    @Autowired

    private ServiceConfigRepository serviceConfigRepository;

    @Autowired

    private RetailerBlockBrandsRepository retailerBlockBrandsRepository;

    private static final String[] STOCK_AGEING_MAIL_LIST = new String[]{"uday.singh@smartudkaan.com", "mohinder.mutreja@smartdukaan.com", "ankit.bhatia@smartdukaan.com", "tarun.verma@smartdukaan.com", "kuldeep.kumar@smartdukaan.com", "manish.gupta@smartdukaan.com"};

    private static final String[] ITEMWISE_PENDING_INDENT_MAIL_LIST = new String[]{"kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com", "niranjan.kala@smartdukaan.com"};

    private static final String[] INDENT_TERTIARY_MAIL_LIST = new String[]{"uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com", "nishant.ohri@smartdukaan.com"};

    private static final String[] EMPLOYEE_ATTENDANCE_MAIL_LIST = new String[]{"sm@smartdukaan.com", "sm@smartdukaan.com"};

    private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING);

    @Autowired

    private ReporticoService reporticoService;

    @Autowired

    private PartnerInvestmentService partnerInvestmentService;

    @Autowired

    private PositionRepository positionRepository;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private SchemeInOutRepository schemeInOutRepository;

    @Autowired

    private RechargeTransactionRepository rechargeTransactionRepository;

    @Autowired

    private CustomerAddressRepository customerAddressRepository;

    @Autowired

    private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;

    @Autowired

    private FofoLineItemRepository fofoLineItemRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private UserWalletHistoryRepository userWalletHistoryRepository;

    @Autowired

    private UserWalletRepository userWalletRepository;

    @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;

    @Value("${prod}")

    private boolean prod;

    @Autowired

    private StateGstRateRepository stateGstRateRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private TransactionService transactionService;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private OrderService orderService;

    @Autowired

    private SchemeRepository schemeRepository;

    @Autowired

    private SchemeItemRepository schemeItemRepository;

    @Autowired

    private JavaMailSender mailSender;

    @Autowired

    private PartnerTargetRepository partnerTargetRepository;

    @Autowired

    @Qualifier(value = "googleMailSender")

    private JavaMailSender googleMailSender;

    @Autowired

    private InventoryService inventoryService;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private DeviceRepository deviceRepository;

    @Autowired

    private PushNotificationRepository pushNotificationRepository;

    @Autowired

    private NotificationCampaignRepository notificationCampaignRepository;

    @Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    private FocusedModelRepository focusedModelRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private UserRepository userUserRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;

    @Autowired

    private UserCampaignRepository userCampaignRepository;

    @Autowired

    private Gson gson;

    @Autowired

    private TicketRepository ticketRepository;

    @Autowired

    private RefferalRepository refferalRepository;

    @Autowired

    private PartnerProblemRepository partnerProblemRepository;

    @Autowired

    private PendingOrderRepository pendingOrderRepository;

    @Autowired

    private PendingOrderItemRepository pendingOrderItemRepository;

    @Value("${razorpay.account.keyId}")

    private String keyId;

    @Value("${razorpay.account.keySecret}")

    private String keySecret;

    @Autowired

    private RazorpayPaymentService razorPaymentService;

    @Autowired

    private RazorPayRepository razorPayRepository;

    @Autowired

    private PendingOrderService pendingOrderService;

    @Autowired

    private CustomerRepository customerRepository;

    @Autowired

    private RestClient restClient;

    @Autowired

    private MandiiService mandiiService;

    @Autowired

    CreditAccountRepository creditAccountRepository;

    @Autowired

    CustomerOfferRepository customerOfferRepository;

    @Autowired

    CustomerOfferItemRepository customerOfferItemRepository;

    @Autowired

    private FofoSolr fofoSolr;

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

    private String FCM_URL = "https://fcm.googleapis.com/fcm/send";

    private String FCM_API_KEY = "AAAASAjNcn4:APA91bG6fWRIgYJI0L9gCjP5ynaXz2hJHYKtD9dfH7Depdv31Nd9APJwhx-OPkAJ1WSz4BGNYG8lHThLFSjDGFxIwUZv241YcAJEGDLgt86mxq9FXJe-yBRu-S0_ZwHqmX-QaVKl5F_A";

    @Autowired

    private TagListingRepository tagListingRepository;

    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(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");

    }

    public void processActivation() throws Exception {

        schemeService.processActivation();

    }

    // TemporaryMethod

    public void migrateInvoice() {

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));

        Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();

        partnerOrdersMap = fofoOrders.stream().collect(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);

                }

            }

        }

    }

    @Autowired

    private ReporticoCacheTableRepository reporticoCacheTableRepository;

    public void processScheme(int offset, boolean dryRun) throws Exception {

        LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

        LocalDateTime endDate = startDate.plusDays(30);

        processScheme(startDate, endDate, dryRun);

    }

    public void processSchemeOut(List<String> invoiceNumbers) throws Exception {

        for (String invoiceNumber : invoiceNumbers) {

            System.out.println("Invoice Number - " + invoiceNumber);

            FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

            //orderService.reverseScheme(fofoOrder);

            schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());

        }

    }

    public void processSchemeIn(List<String> invoiceNumbers) throws Exception {

        for (String invoiceNumber : invoiceNumbers) {

            System.out.println("Invoice Number - " + invoiceNumber);

            Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);

            schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());

        }

    }

    public void processScheme(int offset, int durationDays, boolean dryRun) throws Exception {

        LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

        LocalDateTime endDate = startDate.plusDays(durationDays);

        processScheme(startDate, endDate, dryRun);

    }

    public void processScheme(boolean dryRun) throws Exception {

        LocalDateTime fromDate = LocalDateTime.now().minusDays(30);

        processScheme(fromDate, LocalDateTime.now(), dryRun);

    }

    public void processScheme(LocalDateTime startDate, LocalDateTime endDate, boolean dryRun) throws Exception {

        LOGGER.info("Started execution at {}", LocalDateTime.now());

        System.out.println(

                "InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tDP\tTaxable\tScheme Amount\tAmount Paid");

        try {

            List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);

            for (Purchase purchase : purchases) {

                schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());

            }

            List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);

            for (FofoOrder fofoOrder : fofoOrders) {

                schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());

            }

        } catch (Exception e) {

            e.printStackTrace();

            throw e;

        }

        List<UserWalletHistory> uwhs = userWalletHistoryRepository.selectAllByDateType(LocalDate.now().atStartOfDay(), endDate, Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));

        System.out.println("Amount\tReference\tReferenceType\tTimestamp\tDescription");

        for (UserWalletHistory uwh : uwhs) {

            System.out.println(String.format("%d\t%d\t%s\t%s\t%s", uwh.getAmount(), uwh.getReference(), uwh.getReferenceType(), uwh.getTimestamp().toString(), uwh.getDescription()));

        }

        LOGGER.info("Schemes processed successfully.");

        if (dryRun) {

            throw new Exception();

        }

    }

    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(

                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), LocalDateTime.now());

            }

        }

        for (RechargeTransaction rt : pendingTransactions) {

            rt.setCashbackTimestamp(cashbackTime);

            rt.setCashbackReference(referenceId);

            rechargeTransactionRepository.persist(rt);

        }

        LOGGER.info("Cashbacks for Recharge processed Successfully");

    }

    public void rollOutUpgardedMarginsNextMonth() throws Exception {

        LocalDate startOfPreviousMonth = LocalDate.now().with(ChronoField.DAY_OF_MONTH, 1).minusMonths(1);

        List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

        for (FofoStore store : stores) {

            this.rolloutMarginForStoreOnMonth(store, startOfPreviousMonth);

        }

    }

    public void rolloutMarginForStoreOnMonth(FofoStore store, LocalDate startOfMonth) throws ProfitMandiBusinessException {

        int fofoId = store.getId();

        PartnerType startOfPreviousMonthPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, startOfMonth);

        PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnMonth(fofoId, YearMonth.from(startOfMonth.atStartOfDay()));

        if (!startOfPreviousMonthPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

            return;

        }

        if (!startOfPreviousMonthPartnerType.equals(todayPartnerType)) {

            LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(), startOfPreviousMonthPartnerType, todayPartnerType);

            List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startOfMonth.atStartOfDay(), startOfMonth.plusMonths(1).atStartOfDay(), 0, 0);

            for (FofoOrder fofoOrder : fofoOrders) {

                schemeService.processSchemeOut(fofoOrder.getId(), fofoId);

            }

        }

    }

    public void rollOutUpgardedMargins() throws Exception {

        LocalDate today = LocalDate.now();

        LocalDate yesterday = today.minusDays(1);

        int upgradedCount = 0;

        List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

        StringBuilder sb = new StringBuilder();

        for (FofoStore store : stores) {

            int fofoId = store.getId();

            PartnerType yesterdayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, yesterday);

            PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, today);

            if (!yesterdayPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

                continue;

            }

            if (!yesterdayPartnerType.equals(todayPartnerType)) {

                upgradedCount++;

                sb.append(String.format("Partner Type has been changed for code %s from %s to %s", store.getCode(), yesterdayPartnerType.toString(), todayPartnerType.toString()));

                sb.append("<br>");

                LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(), yesterdayPartnerType, todayPartnerType);

                List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, yesterday.withDayOfMonth(1).atStartOfDay(), yesterday.atStartOfDay(), 0, 0);

                for (FofoOrder fofoOrder : fofoOrders) {

                    schemeService.processSchemeOut(fofoOrder.getId(), fofoId);

                }

            }

        }

        if (upgradedCount > 0) {

            sendMailOfHtmlFormat(googleMailSender, new String[]{"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com"}, sb.toString(), null, "Few Partners Category have been Upgraded");

        } else {

            sendMailOfHtmlFormat(googleMailSender, new String[]{"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com"}, sb.toString(), null, "No partners Category have been upgraded today");

        }

    }

    @Autowired

    private PartnerStatsService partnerStatsService;

    // Temporary Method

    public void evaluateExcessSchemeOut() throws Exception {

        Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();

        Map<Integer, Float> userAmountMap = new HashMap<>();

        List<List<?>> 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"}, null, "Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));

    }

    public void fetchParnterStats() throws Exception {

        Map<Integer, PartnerDetailModel> partnerStats = partnerStatsService.getAllPartnerStats();

        ObjectOutputStream oos = null;

        FileOutputStream fout = null;

        try {

            fout = new FileOutputStream("/tmp/partnerStat.tmp", false);

            oos = new ObjectOutputStream(fout);

            oos.writeObject(partnerStats);

        } catch (Exception ex) {

            ex.printStackTrace();

        } finally {

            if (oos != null) {

                oos.close();

            }

        }

        ReporticoCacheTable reporticoCacheTable = reporticoCacheTableRepository.selectByTableName("partnerStat");

        if (reporticoCacheTable == null) {

            reporticoCacheTable = new ReporticoCacheTable();

            reporticoCacheTable.setTableName("partnerStat");

            reporticoCacheTable.setLastCreatedTimestamp(LocalDateTime.now());

            reporticoCacheTableRepository.persist(reporticoCacheTable);

        } else {

            reporticoCacheTable.setLastCreatedTimestamp(LocalDateTime.now());

        }

    }

    public void processPriceDrop() throws Exception {

        List<PriceDrop> priceDrops = priceDropRepository.selectAllByDatesBetween(LocalDateTime.now(), LocalDateTime.now().minusYears(1));

        for (PriceDrop priceDrop : priceDrops) {

            if (priceDrop.getDropAmount() > 0) {

                priceDropService.processPriceDrop(priceDrop.getId(), true);

            }

        }

    }

    @Autowired

    CreditNoteService creditNoteService;

    public void sendCreditNote(YearMonth yearMonth) throws Exception {

        creditNoteService.issueMonthlyMarginsCN(yearMonth);

    }

    @Autowired

    BrandAgeingLimitRepository brandAgeingLimitRepository;

    @Autowired

    AgeingService ageingService;

    public void sendMailForAgeingAlert() throws Exception {

        //brandAgeingLimitRepository.selectAll();

        Map<String, AgeingModel> ageingModelMap = ageingService.getAllAgeingForSecondary();

        System.out.println(ageingModelMap.size());

        List<PartnerAgeingModel> partnerAgeingModels = ageingService.getAllAgeingForTertiary();

        org.apache.commons.io.output.ByteArrayOutputStream byteArrayOutputStream = FileUtil.getCSVByteStream(Arrays.asList("InventoryItemId", "Serial Number", "Item Id", "Brand", "Model Name", "ModelNumber", "Color", "Exceed Days", "Last ScanType", "Supplier Name", "Current Warehouse", "First Warehouse", "Invoice Number", "Invoice Date"), ageingModelMap.values().stream().map(x -> Arrays.asList(x.getInventoryItemId(), x.getSerialNumber(), x.getItemId(), x.getBrand(), x.getModelName(), x.getModelNumber(), x.getColor(), x.getExceedDays(), x.getLastScanType(), x.getSupplierName(), x.getCurrentWarehouse(), x.getFirstWarehouse(), x.getInvoiceNumber(), FormattingUtils.formatDate(x.getInvoiceDate()))).collect(Collectors.toList()));

        org.apache.commons.io.output.ByteArrayOutputStream byteArrayOutputStream2 = FileUtil.getCSVByteStream(Arrays.asList("InventoryItemId", "Serial Number", "Item Id", "Brand", "Model Name", "ModelNumber", "Color", "Partner Id", "Partner Code", "Partner Name", "Activation Type", "City", "State", "Billing Date", "Exceed Days", "Max Ageing", "Activation Date"), partnerAgeingModels.stream().map(x -> Arrays.asList(x.getInventoryItemId(), x.getSerialNumber(), x.getItemId(), x.getBrand(), x.getModelName(), x.getModelNumber(), x.getColor(), x.getFofoId(), x.getFofoCode(), x.getFofoName(), x.getActivationType(), x.getFofoCity(), x.getFofoState(), FormattingUtils.formatDate(x.getBillingDate()), x.getExceedDays(), x.getMaxAgeingDays(), x.getActivationDate())).collect(Collectors.toList()));

        Utils.Attachment attachment1 = new Utils.Attachment("secondary-alert.csv", new ByteArrayResource(byteArrayOutputStream.toByteArray()));

        Utils.Attachment attachment2 = new Utils.Attachment("tertiary-alert.csv", new ByteArrayResource(byteArrayOutputStream2.toByteArray()));

        String mailSubject = "Stock ageing Alert";

        Utils.sendMailWithAttachments(mailSender, new String[]{"deena.nath@smartdukaan.com"}, null, mailSubject, "PFA", attachment1, attachment2);

    }

    public void rejectPriceDropsOfApprovedImeis() throws ProfitMandiBusinessException {

        priceDropService.rejectPriceDropsOfApprovedImeis();

    }

    private class SaleRoles {

        private List<String> l1;

        private List<String> l2;

        public SaleRoles() {

            l1 = new ArrayList<>();

            l2 = new ArrayList<>();

        }

        public List<String> getL1() {

            return l1;

        }

        public List<String> getL2() {

            return l2;

        }

    }

    private class FofoReportingModel {

        private String code;

        private int fofoId;

        private String businessName;

        private String territoryManager;

        private String regionalManager;

        private String businessManager;

        public String getCode() {

            return code;

        }

        public void setCode(String code) {

            this.code = code;

        }

        public String getBusinessName() {

            return businessName;

        }

        public void setBusinessName(String businessName) {

            this.businessName = businessName;

        }

        public String getTerritoryManager() {

            return territoryManager;

        }

        public void setTerritoryManager(String territoryManager) {

            this.territoryManager = territoryManager;

        }

        public String getRegionalManager() {

            return regionalManager;

        }

        public void setRegionalManager(String regionalManager) {

            this.regionalManager = regionalManager;

        }

        private ScheduledTasks getOuterType() {

            return ScheduledTasks.this;

        }

        @Override

        public String toString() {

            return "FofoReportingModel{" + "code='" + code + '\'' + ", fofoId=" + fofoId + ", businessName='" + businessName + '\'' + ", territoryManager='" + territoryManager + '\'' + ", regionalManager='" + regionalManager + '\'' + ", businessManager='" + businessManager + '\'' + '}';

        }

        @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (o == null || getClass() != o.getClass()) return false;

            FofoReportingModel that = (FofoReportingModel) o;

            return fofoId == that.fofoId && Objects.equals(code, that.code) && Objects.equals(businessName, that.businessName) && Objects.equals(territoryManager, that.territoryManager) && Objects.equals(regionalManager, that.regionalManager) && Objects.equals(businessManager, that.businessManager);

        }

        @Override

        public int hashCode() {