Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import com.jcraft.jsch.Logger;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;
import com.spice.profitmandi.dao.entity.fofo.SchemeInOut;
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;
import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;
import com.spice.profitmandi.service.user.RetailerService;;

@Component
@Transactional(rollbackFor = Throwable.class)
public class InvestmentRelatedTasks {
        @Autowired
        RetailerService retailerService;
        @Autowired
        SchemeInOutRepository schemeInOutRepository;

        @Autowired
        InventoryItemRepository inventoryItemRepository;
        
        @Autowired
        PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;
        
        void payMonthlyInvestment() {
                LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();
                LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);
                LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);
                List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository.selectAll(startOfPreviousMonth, lastOfPreviousMonth);
                Map<Integer, Long> investmentShortDaysMap = partnerDailyInvestments.stream().filter(x->x.getShortPercentage() > 10).collect(Collectors.groupingBy(x->x.getFofoId(), Collectors.counting()));
                List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectAllPending(SchemeType.INVESTMENT, startOfPreviousMonth.atStartOfDay(), firstDateOfCurrentMonth.atStartOfDay());
                Map<Integer, List<SchemeInOut>> inventoryItemIdSchemeMap = schemeInOuts.stream().collect(Collectors.groupingBy(x->x.getInventoryItemId()));
                List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdSchemeMap.keySet());
                Map<Integer, List<Integer>> retailerInventoryItemIdMap = inventoryItems.stream()
                                .collect(Collectors.groupingBy(x->x.getFofoId(), Collectors.mapping(x->x.getId(), Collectors.toList())));
                for(Map.Entry<Integer, List<Integer>> retailerEntry : retailerInventoryItemIdMap.entrySet()) {
                        int fofoId = retailerEntry.getKey();
                        System.out.print("fofoId\tInvestment Short Days\tEligible payout");
                        List<SchemeInOut> schemeInouts = retailerEntry.getValue().stream().map(x->inventoryItemIdSchemeMap.get(x)).flatMap(List::stream).collect(Collectors.toList());
                        double totalAmount = schemeInouts.stream().filter(x->x.getRolledBackTimestamp()!=null).collect(Collectors.summingDouble(x->x.getAmount()));
                        long daysShort = investmentShortDaysMap.get(fofoId);
                        if(daysShort >= 12) {
                                //do nothing
                        } else if(daysShort >= 8) {
                                totalAmount = totalAmount/2;
                        } else {
                                totalAmount = 0;
                        }
                        System.out.printf("%d\t%d\t%f%n", fofoId, daysShort, totalAmount);
                }
        }
}