Subversion Repositories SmartDukaan

import java.time.LocalDate;

import java.time.LocalTime;

import java.util.LinkedHashMap;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.PartnerInvestmentService;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private LeadRepository leadRepository;

	@Autowired

	private HygieneDataRepository hygieneDataRepository;

	@Autowired

	private PartnerInvestmentService partnerInvestmentService;

	@Autowired

	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Override

	public Map<Integer, Object> getL2AuthUserPartnerDetail() throws Exception {

		List<Position> pos = positionRepository.selectPositionbyCategoryIdAndEscalationType(

				ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L2);

		LocalDateTime curDate = LocalDate.now().atStartOfDay();

		Map<Integer, Double> lmtdSale = fofoOrderItemRepository.selectSumAmountGroupByRetailer(

				curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), 0, false);

		Map<Integer, Double> mtdSale = fofoOrderItemRepository.selectSumAmountGroupByRetailer(curDate.withDayOfMonth(1),

				curDate.with(LocalTime.MAX), 0, false);

		Map<Integer, List<Integer>> pp = this.getAuthUserIdPartnerIdMapping();

		Map<Integer, Long> ticketMap = ticketRepository.selectAllNotClosedTicketsGroupByRetailer();

		Map<Integer, Integer> authIdAndleadsCountMap = new HashMap<>();

		Map<Integer, List<Integer>> L2L1Mapping = this.getL1L2Mapping();

		for (Entry<Integer, List<Integer>> l2l1 : L2L1Mapping.entrySet()) {

			List<Integer> authIds = l2l1.getValue();

			authIds.add(l2l1.getKey());

			List<Lead> leads = leadRepository.selectByAssignAuthIdsAndStatus(authIds, LeadStatus.followUp);

			AuthUser auth = authRepository.selectById(l2l1.getKey());

			authIdAndleadsCountMap.put(auth.getId(), leads.size());

		}

		Map<Integer, Object> authIdAndallValues = new LinkedHashMap<>();

		for (Position po : pos) {

			double totallmtdAmount = 0;

			double totalmtdAmount = 0;

			int totalTicketCount = 0;

			float totalTodayInvestment = 0;

			float totalStockInInvestment = 0;

			double currentMonthRatingAllPartners = 0;

			AuthUser auth = authRepository.selectById(po.getAuthUserId());

			List<Integer> fofoIds = pp.get(po.getAuthUserId());

			for (Integer fId : fofoIds) {

				Map<String, Object> investmentMap = this.getInvestments(fId);

				double currentMonthRating = hygieneDataRepository.selectRatingAvg(fId,

						curDate.withDayOfMonth(1).minusMonths(1), curDate.plusMonths(1).withDayOfMonth(1));

				currentMonthRatingAllPartners += currentMonthRating;

				fofoIds.size();

				Double lmtdAmount = lmtdSale.get(fId);

				Double mtdAmount = mtdSale.get(fId);

				Long ticketCount = ticketMap.get(fId);

				if (!investmentMap.isEmpty()) {

					totalTodayInvestment += (float) investmentMap.get("today");

					totalStockInInvestment += (float) investmentMap.get("inStock");

				}

				LOGGER.info("totalTodayInvestment" + totalTodayInvestment);

				LOGGER.info("totalStockInInvestment" + totalStockInInvestment);

				if (ticketCount != null) {

					totalTicketCount += ticketCount;

				}

				if (lmtdAmount != null) {

					totallmtdAmount += lmtdAmount;

				}

				if (mtdAmount != null) {

					totalmtdAmount += mtdAmount;

				}

			}

			LOGGER.info("currentMonthRatingAllPartners" + currentMonthRatingAllPartners);

			LOGGER.info("size" + fofoIds.size());

			double totalHygieneRating = currentMonthRatingAllPartners / fofoIds.size();

			LOGGER.info("totalHygieneRating" + totalHygieneRating);

			PartnerDetailModel pm = new PartnerDetailModel();

			pm.setLmtd(totallmtdAmount);

			pm.setMtd(totalmtdAmount);

			pm.setLeads(authIdAndleadsCountMap.get(po.getAuthUserId()));

			pm.setInvestment(totalTodayInvestment);

			pm.setStockInInvestment(totalStockInInvestment);

			pm.setTicket(totalTicketCount);

			pm.setHygiene((double) Math.round(totalHygieneRating));

			authIdAndallValues.put(auth.getId(), pm);

		}

		return authIdAndallValues;

	}

	private Map<String, Object> getInvestments(int fofoId) throws Exception {

		Map<String, Object> investments = new LinkedHashMap<>();

		PartnerDailyInvestment investment = partnerInvestmentService.getInvestment(fofoId, 0);

		LocalDate currentMonthStart = LocalDate.now().withDayOfMonth(1);

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

		PartnerDailyInvestment yesterdayInvestment = partnerDailyInvestmentRepository.select(fofoId, yesterDate);

		if (yesterdayInvestment == null) {

			yesterdayInvestment = new PartnerDailyInvestment();

		}

		List<PartnerDailyInvestment> currentMonthInvestments = partnerDailyInvestmentRepository.selectAll(fofoId,

				currentMonthStart, currentMonthStart.withDayOfMonth(currentMonthStart.lengthOfMonth()));

		long okInvestmentDays = currentMonthInvestments.stream().filter(x -> x.getShortPercentage() <= 10)

				.collect(Collectors.counting());

		investments.put("today", investment.getTotalInvestment());

		investments.put("investment", investment);

		investments.put("inStock", investment.getInStockAmount());

		investments.put("minimum", investment.getMinInvestmentString());

		investments.put("short", investment.getShortPercentage());

		investments.put("activated_stock", investment.getActivatedStockAmount());

		investments.put("okDays", okInvestmentDays);

		return investments;

	}