Subversion Repositories SmartDukaan

        if (amount >= 100000L) {

            return String.format("%.2f L", amount / 100000.0);

        return String.format("%,d", amount);

    private static String ordinalDay(int day) {

        if (day >= 11 && day <= 13) return day + "th";

        switch (day % 10) {

            case 1:

                return day + "st";

            case 2:

                return day + "nd";

            case 3:

                return day + "rd";

            default:

                return day + "th";

        }

    }

    private static String formatSchemePeriodDisplay(LocalDateTime start, LocalDateTime end) {

        if (start == null || end == null) return "";

        String startPart = ordinalDay(start.getDayOfMonth()) + " " +

                start.getMonth().getDisplayName(java.time.format.TextStyle.FULL, Locale.ENGLISH);

        String endPart = ordinalDay(end.getDayOfMonth()) + " " +

                end.getMonth().getDisplayName(java.time.format.TextStyle.FULL, Locale.ENGLISH) + " " + end.getYear();

        long months = java.time.temporal.ChronoUnit.MONTHS.between(

                start.toLocalDate().withDayOfMonth(1),

                end.toLocalDate().withDayOfMonth(1)) + 1;

        return startPart + " – " + endPart + " (" + months + " Months)";

    }

    @RequestMapping(value = "/dashboard", method = RequestMethod.GET)

    public String dashboard(HttpServletRequest request, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();

        int fofoId = loginDetails.getFofoId();

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        model.addAttribute("isAdmin", isAdmin);

        model.addAttribute("webApiHost", webApiHost);

        model.addAttribute("webApiPort", webApiPort);

        model.addAttribute("webApiScheme", webApiScheme);

        model.addAttribute("webApiRoot", webApiRoot);

        model.addAttribute("googleApiKey", googleApiKey);

        if (isAdmin) {

            return adminUser.adminPanel(loginDetails.getFofoId(), email, model);

        } else {

            FofoStore fofoStore;

            List<PartnerRegion> partnerRegion = partnerRegionRepository.selectByfofoId(fofoId);

            LocalDateTime currentDate = LocalDateTime.now();

            List<PrintResource> printResources = printResourceRepository.selectPrintResourcesByFofoRegion(partnerRegion.get(0).getRegionId(), currentDate);

            LOGGER.info("printresourcesList {}", printResources);

            model.addAttribute("printResources", printResources);

            try {

                fofoStore = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

                if (!fofoStore.isActive()) {

                    return "redirect:/login";

                }

                LocalDateTime startDate = LocalDate.now().withDayOfYear(1).atStartOfDay();

                LocalDateTime endtDate = LocalDateTime.now();

                OnlineDeliveredOrderSum onlineDeliveredOrderSum = pendingOrderItemRepository.selectSumSellingPriceOnlineOrder(fofoId, startDate, endtDate);

                LOGGER.info("onlineDeliveredOrderSum" + onlineDeliveredOrderSum.getSellingPrice());

                long countOrder = pendingOrderRepository.pendingOrderCount(fofoId, OrderStatus.PROCESSING);

                LOGGER.info("countOrder" + countOrder);

                ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();

                orderStatus.add(SUBMITTED_FOR_PROCESSING);

                orderStatus.add(BILLED);

                orderStatus.add(SHIPPED_FROM_WH);

                orderStatus.add(DELIVERY_SUCCESS);

                List<Order> openOrders = orderRepository.selectGrnTimestampNull(fofoId, orderStatus);

                List<LineItem> submittedLineItemIds = openOrders.stream().filter(x -> x.getStatus().equals(SUBMITTED_FOR_PROCESSING)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> billedOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(BILLED)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> shippedOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(SHIPPED_FROM_WH)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> grnPendingLineItemIds = openOrders.stream().filter(x -> x.getStatus().equals(DELIVERY_SUCCESS)).map(x -> x.getLineItem()).collect(Collectors.toList());

                long imeiActivationPendingCount = 0;

                long imeiActivationPendingValue = 0;

                //Only delivered orders should be visible

                List<Integer> grnPendingOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(DELIVERY_SUCCESS)).map(x -> x.getId()).collect(Collectors.toList());

                if (grnPendingOrderIds.size() > 0) {

                    List<ImeiActivationTimestampModel> imeiActivationTimestampModels = activatedImeiRepository.selectActivatedImeisByOrders(grnPendingOrderIds);

                    imeiActivationPendingCount = imeiActivationTimestampModels.size();

                    imeiActivationPendingValue = imeiActivationTimestampModels.stream().collect(Collectors.summingDouble(x -> x.getSellingPrice())).longValue();

                }

                long grnPendingCount = grnPendingLineItemIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long grnPendingValue = grnPendingLineItemIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("grnPendingCount", grnPendingCount);

                model.addAttribute("grnPendingValue", grnPendingValue);

                long submittedCount = submittedLineItemIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long submittedValue = submittedLineItemIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("submittedCount", submittedCount);

                model.addAttribute("submittedValue", submittedValue);

                long billedCount = billedOrderIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long billedValue = billedOrderIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("billedValue", billedValue);

                model.addAttribute("billedCount", billedCount);

                LOGGER.info("billedCount {}", billedCount);

                long shippedCount = shippedOrderIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                model.addAttribute("shippedCount", shippedCount);

                LOGGER.info("shippedCount {}", shippedCount);

                long shippedValue = shippedOrderIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("shippedValue", shippedValue);

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

                LocalDateTime currentMonthStart = curDate.withDayOfMonth(1);

                LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

                LocalDateTime currentMonthEnd = currentMonthStart.withDayOfMonth(1);

                LOGGER.info("lastMonthStart" + lastMonthStart);

                LOGGER.info("currentMonthEnd" + currentMonthEnd);

                Scheme staticScheme = schemeService.getStaticScheme(fofoId);

                double schemeAchievement = 0;

                double mobileLedAchievement = 0;

                double accessoriesAchievement = 0;

                long mobileLedTarget = 0;

                long accessoriesTarget = 0;

                long totalTarget = 0;

                int achievementPercent = 0;

                String aimingTier = null;

                if (staticScheme != null) {

                    // Mobile (10006) + LED (14202) are the primary target; accessories is everything else.

                    Set<Integer> mobileLedCategoryIds = new HashSet<>(Arrays.asList(10006, 14202));

                    Map<Integer, Double> mobileLedMap = fofoOrderRepository.selectSumSaleGroupByFofoIdForCategories(

                            fofoId, staticScheme.getStartDateTime(), staticScheme.getEndDateTime(), mobileLedCategoryIds, true);

                    Map<Integer, Double> accessoriesMap = fofoOrderRepository.selectSumSaleGroupByFofoIdForCategories(

                            fofoId, staticScheme.getStartDateTime(), staticScheme.getEndDateTime(), mobileLedCategoryIds, false);

                    mobileLedAchievement = mobileLedMap.getOrDefault(fofoId, 0.0);

                    accessoriesAchievement = accessoriesMap.getOrDefault(fofoId, 0.0);

                    schemeAchievement = mobileLedAchievement + accessoriesAchievement;

                    mobileLedTarget = staticScheme.getTarget();

                    // Accessories target is fixed at 1% of the assigned mobile+LED target.

                    accessoriesTarget = Math.round(mobileLedTarget * 0.01);

                    totalTarget = mobileLedTarget + accessoriesTarget;

                    achievementPercent = totalTarget > 0 ? (int) Math.round(schemeAchievement * 100.0 / totalTarget) : 0;

                    // "Currently aiming for" — dynamic tier based on total achievement (not assigned target).

                    // Same SRC5 thresholds; the tier advances as achievement crosses each ceiling.

                    if (schemeAchievement < 4000000) {

                        aimingTier = "Shuruaat";       // up to 40 Lacs

                    } else if (schemeAchievement < 7000000) {

                        aimingTier = "Udaan";          // 40 – 70 Lacs

                    } else if (schemeAchievement < 9000000) {

                        aimingTier = "Raftaar";        // 70 – 90 Lacs

                    } else if (schemeAchievement < 12000000) {

                        aimingTier = "Tarakki";        // 90 Lacs – 1.20 Cr

                    } else if (schemeAchievement < 24000000) {

                        aimingTier = "Vijeta";         // 1.20 – 2.40 Cr

                    } else {

                        aimingTier = "Maharaja";       // 2.40 Cr and above

                    }

                }

                model.addAttribute("countOrder", countOrder);

                model.addAttribute("onlineDeliveredOrderSum", onlineDeliveredOrderSum.getSellingPrice());

                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoStore.getId(), LocalDate.now());

                model.addAttribute("partnerType", partnerType);

                model.addAttribute("partnerTypeImage", PartnerType.imageMap.get(partnerType));

                model.addAttribute("fofoStore", fofoStore);

                model.addAttribute("partnerType", partnerType);

                model.addAttribute("hasGift", fofoUser.hasGift(loginDetails.getFofoId()));

                model.addAttribute("giftItemId", ProfitMandiConstants.GIFT_ID);

                model.addAttribute("retailers", new JSONObject().append("code", fofoStore.getCode()).append("partnerId", fofoStore.getId()).toString());

                model.addAttribute("activatedImeis", inventoryItemRepository.selectCountByActivatedNotSold(loginDetails.getFofoId()));

                model.addAttribute("imeiActivationPendingCount", imeiActivationPendingCount);

                model.addAttribute("imeiActivationPendingValue", imeiActivationPendingValue);

                Map<Integer, Double> accesoriesmtdsale = fofoOrderRepository.selectSumSaleGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(), curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), Optional.of(false));

                Double accesoriesStock = currentInventorySnapshotRepository.selectSumStockGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(), Optional.of(false)).get(loginDetails.getFofoId());

                model.addAttribute("accesoriesStock", String.format("%.0f", accesoriesStock));

                model.addAttribute("staticScheme", staticScheme);

                model.addAttribute("schemeAchievement", schemeAchievement);

                model.addAttribute("mobileLedAchievement", mobileLedAchievement);

                model.addAttribute("accessoriesAchievement", accessoriesAchievement);

                model.addAttribute("mobileLedTarget", mobileLedTarget);

                model.addAttribute("accessoriesTarget", accessoriesTarget);

                model.addAttribute("totalTarget", totalTarget);

                model.addAttribute("totalTargetDisplay", formatIndianCurrency(totalTarget));

                model.addAttribute("schemeAchievementDisplay", formatIndianCurrency((long) schemeAchievement));

                model.addAttribute("mobileLedAchievementDisplay", formatIndianCurrency((long) mobileLedAchievement));

                model.addAttribute("accessoriesAchievementDisplay", formatIndianCurrency((long) accessoriesAchievement));

                model.addAttribute("achievementPercent", achievementPercent);

                model.addAttribute("aimingTier", aimingTier);

                if (staticScheme != null) {

                    model.addAttribute("schemePeriodDisplay",

                            formatSchemePeriodDisplay(staticScheme.getStartDateTime(), staticScheme.getEndDateTime()));

                }

                model.addAttribute("brandStockPrices", fofoUser.getBrandStockPrices(loginDetails.getFofoId(), false));

                model.addAttribute("salesMap", fofoUser.getSales(loginDetails.getFofoId()));

                ChartModel cm = fofoUser.getBrandChart(loginDetails.getFofoId(),null,null,false);

                LOGGER.info("chartMap" + gson.toJson(cm));

                model.addAttribute("chartMap", gson.toJson(cm));

                List<CreateOfferRequest> createOffers = offerService.getPublishedOffers(loginDetails.getFofoId(), YearMonth.from(LocalDateTime.now()));

                // Batch fetch all catalog IDs to avoid N+1 queries

                Set<Integer> allCatalogIds = createOffers.stream()

                        .flatMap(offer -> offer.getTargetSlabs().stream())

                        .flatMap(slab -> slab.getItemCriteriaPayouts().stream())

                        .map(ItemCriteriaPayout::getItemCriteria)

                        .flatMap(criteria -> criteria.getCatalogIds().stream())

                        .collect(Collectors.toSet());

                final Map<Integer, String> catalogBrandMap = new HashMap<>();

                if (!allCatalogIds.isEmpty()) {

                    try {

                        catalogBrandMap.putAll(catalogRepository.selectAllByIds(new ArrayList<>(allCatalogIds)).stream()

                                .collect(Collectors.toMap(c -> c.getId(), c -> c.getBrand())));

                    } catch (ProfitMandiBusinessException e) {

                        LOGGER.error("Error fetching catalogs by IDs", e);

                    }

                }

                List<CreateOfferRequest> publishedOffers = createOffers.stream()

                        .filter(createOffer -> createOffer.getTargetSlabs().stream()

                                .flatMap(slab -> slab.getItemCriteriaPayouts().stream())

                                .map(ItemCriteriaPayout::getItemCriteria)

                                .flatMap(criteria -> criteria.getCatalogIds().stream())

                                .noneMatch(catalogId -> "Live Demo".equals(catalogBrandMap.get(catalogId))))

                        .collect(Collectors.toList());

                model.addAttribute("publishedOffers", publishedOffers);

                model.addAttribute("investments", fofoUser.getInvestments(loginDetails.getFofoId()));

                model.addAttribute("isInvestmentOk", partnerInvestmentService.isInvestmentOk(loginDetails.getFofoId(), ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));

                double currentMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(currentMonthStart, currentMonthEnd)) / 2;

                double lastMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(lastMonthStart, currentMonthStart)) / 2;

                double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.withEndDate(currentMonthEnd)) / 2;

                model.addAttribute("currentMonthRating", (float) Math.round(currentMonthRating * 10) / 10);

                model.addAttribute("lastMonthRating", (float) Math.round(lastMonthRating * 10) / 10);

                model.addAttribute("ratingTillDate", (float) Math.round(ratingTillDate * 10) / 10);

                long hygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), true, currentMonthStart, currentMonthEnd);

                long invalidHygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), false, currentMonthStart, currentMonthEnd);

                if (hygieneCount == 0 && invalidHygieneCount == 0) {

                    invalidHygieneCount = 1;

                }

                Map<Integer, String> monthValueMap = new HashMap<>();

                for (int i = 0; i <= 12; i++) {

                    LocalDateTime startOfMonth = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

                    monthValueMap.put(i, startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

                }

                MonthlyTarget monthlyTarget = monthlyTargetRepository.selectByDateAndFofoId(YearMonth.now(), fofoId);

                model.addAttribute("monthlyTarget", monthlyTarget);

                Set<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toSet());

                model.addAttribute("brands", brands);

                model.addAttribute("monthValueMap", monthValueMap);

                model.addAttribute("month", 0);

                model.addAttribute("hygienePercentage", (hygieneCount * 100) / (invalidHygieneCount + hygieneCount));

                model.addAttribute("monthDays", LocalDate.now().minusDays(1).lengthOfMonth());

                model.addAttribute("dayOfMonth", LocalDate.now().minusDays(1).getDayOfMonth());

                Map<String, Object> rewardsMap = saleRewardService.findByFofoAndRegionId(fofoId, partnerRegion.get(0).getRegionId());

                StoreSalesTarget targetData = saleRewardService.findTargetsByFofoId(fofoId);

                model.addAttribute("rewardsMap", rewardsMap);

                model.addAttribute("targetData", targetData);

                model.addAttribute("regionId", partnerRegion.get(0).getRegionId());

            } catch (

                    ProfitMandiBusinessException e) {

                LOGGER.error("FofoStore Code not found of fofoId {}", loginDetails.getFofoId());

            }

            return "dashboard1";

        }

    }