from datetime import timedelta from decimal import Decimal from django.db.models import Count, Min, Q, Sum from django.db.models.functions import TruncDate from django.utils import timezone from rest_framework import permissions, status from rest_framework.response import Response from rest_framework.views import APIView from apps.accounts.models import User from apps.business.distributor.models import DistributorID from apps.business.lucky_dip.models import LuckyDip, LuckyDipEntry from apps.business.orders.models import Order from apps.business.power_stream.models import PowerStreamBonusRecord from apps.business.rewards.services.bonus_metrics_service import get_user_bonus_metrics from apps.business.schema_compat import defer_missing_product_part_payment_fields from apps.business.distributor.services.sponsor_income_service import get_sponsor_income_summary from apps.business.schemes.models import Rank from apps.business.wallet.models import Wallet, WalletLedger from apps.business.withdrawals.models import BankAccount, WithdrawalRequest from apps.notifications.models import Notification from apps.support.models import SupportTicket class UserDashboardSummaryView(APIView): permission_classes = [permissions.IsAuthenticated] def get(self, request): def _chunked(values, size=500): for i in range(0, len(values), size): yield values[i:i + size] def _to_decimal(value): try: return Decimal(str(value or "0")) except Exception: return Decimal("0.00") def _fmt_amount(value): return str(_to_decimal(value).quantize(Decimal("0.01"))) def _bucket_from_opportunity_bundle_amount(value): amount = _to_decimal(value) if amount == Decimal("1180") or amount == Decimal("1180.00"): return "silver" if amount == Decimal("11800") or amount == Decimal("11800.00"): return "gold" return "other" def _sum_ledger_by_scheme(ledger_qs): rows = list(ledger_qs.values("reference_id", "amount")) refs = [row["reference_id"] for row in rows if row.get("reference_id")] order_map = {} if refs: for ref_chunk in _chunked(refs, size=500): for ref, amt in Order.objects.filter(reference_id__in=ref_chunk).values_list( "reference_id", "product__opportunity_bundle__opportunity_bundle_amount" ): order_map[ref] = amt totals = { "silver": Decimal("0.00"), "gold": Decimal("0.00"), "other": Decimal("0.00"), "all": Decimal("0.00"), } for row in rows: amount = _to_decimal(row.get("amount")) totals["all"] += amount bucket = _bucket_from_opportunity_bundle_amount(order_map.get(row.get("reference_id"))) totals[bucket] += amount return totals def _sum_power_stream_by_scheme(record_qs): rows = list( record_qs.values("opportunity_bundle__opportunity_bundle_amount") .annotate(total=Sum("net_amount")) ) totals = { "silver": Decimal("0.00"), "gold": Decimal("0.00"), "other": Decimal("0.00"), "all": Decimal("0.00"), } for row in rows: amount = _to_decimal(row.get("total")) bucket = _bucket_from_opportunity_bundle_amount(row.get("opportunity_bundle__opportunity_bundle_amount")) totals[bucket] += amount totals["all"] += amount return totals user = request.user profile_image_url = None if getattr(user, "profile_image", None) and getattr(user.profile_image, "name", None): try: image_url = user.profile_image.url profile_image_url = request.build_absolute_uri(image_url) if request else image_url except Exception: try: profile_image_url = user.profile_image.url except Exception: profile_image_url = None if not profile_image_url: profile_image_url = getattr(user, "google_avatar_url", None) pincode_obj = getattr(user, "pincode", None) now = timezone.now() today = timezone.localdate() last_7_days_start = today - timedelta(days=6) month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0) start_of_today = now.replace(hour=0, minute=0, second=0, microsecond=0) wallet = Wallet.objects.filter(user=user).first() main_balance = wallet.main_balance if wallet else Decimal("0.00") repurchase_balance = wallet.repurchase_balance if wallet else Decimal("0.00") voucher_balance = wallet.voucher_balance if wallet else Decimal("0.00") locked_amount = wallet.locked_amount if wallet else Decimal("0.00") orders_qs = Order.objects.filter(user=user) completed_orders_qs = orders_qs.filter(status="COMPLETED") user_distributor_qs = defer_missing_product_part_payment_fields( DistributorID.objects.filter(user=user).select_related("product__opportunity_bundle"), relation_prefix='product', ) distributor_ids_count = user_distributor_qs.count() first_distributor = user_distributor_qs.order_by("created_at", "id").first() direct_ref_dist_qs = defer_missing_product_part_payment_fields( DistributorID.objects.filter(sponsor_distributor__in=user_distributor_qs).select_related("product__opportunity_bundle", "user"), relation_prefix='product', ) direct_ref_user_ids = list(direct_ref_dist_qs.values_list("user_id", flat=True).distinct()) completed_revenue = completed_orders_qs.aggregate(total=Sum("amount"))["total"] or Decimal("0.00") total_spent = orders_qs.aggregate(total=Sum("amount"))["total"] or Decimal("0.00") unread_notifications = Notification.objects.filter(user=user, channel="in_app", is_read=False).count() support_qs = SupportTicket.objects.filter(user=user, is_active=True) referrals_count = User.objects.filter(referred_by=user).count() lucky_entries = LuckyDipEntry.objects.filter(user=user).count() active_dips = LuckyDip.objects.filter(is_active=True, is_drawn=False).count() earning_credits = ( WalletLedger.objects.filter( user=user, transaction_type=WalletLedger.TransactionType.CREDIT, ).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) latest_ledger = list( WalletLedger.objects.filter(user=user) .order_by("-created_at")[:6] .values("id", "transaction_type", "wallet_type", "source_type", "amount", "reference_id", "created_at") ) latest_orders = list( orders_qs.order_by("-created_at")[:6].values( "id", "status", "amount", "reference_id", "payment_method", "product__name", "created_at", ) ) latest_tickets = list( support_qs.order_by("-updated_at")[:5].values( "id", "ticket_number", "subject", "priority", "status", "updated_at", "created_at", ) ) order_trend_qs = ( orders_qs.filter(created_at__date__gte=last_7_days_start) .annotate(day=TruncDate("created_at")) .values("day") .annotate(count=Count("id")) ) completed_trend_qs = ( completed_orders_qs.filter(created_at__date__gte=last_7_days_start) .annotate(day=TruncDate("created_at")) .values("day") .annotate(count=Count("id"), revenue=Sum("amount")) ) order_map = {row["day"]: int(row.get("count") or 0) for row in order_trend_qs} completed_map = {row["day"]: int(row.get("count") or 0) for row in completed_trend_qs} revenue_map = {row["day"]: str(row.get("revenue") or Decimal("0.00")) for row in completed_trend_qs} trend = [] for offset in reversed(range(7)): day = today - timedelta(days=offset) trend.append( { "date": day.isoformat(), "orders": order_map.get(day, 0), "completed_orders": completed_map.get(day, 0), "revenue": revenue_map.get(day, "0.00"), } ) # -------------------------- # Extended metrics contract # -------------------------- current_rank_name = "Not Qualified" first_distributor_activation = None brand_ambassador_position_number = None first_distributor_referrals = 0 if first_distributor: first_distributor_activation = first_distributor.created_at.isoformat() if first_distributor.created_at else None brand_ambassador_position_number = first_distributor.global_position first_distributor_referrals = first_distributor.direct_referrals.count() rank_qs = Rank.objects.filter( Q(opportunity_bundle=first_distributor.product.opportunity_bundle) | Q(opportunity_bundle__isnull=True) ).order_by("level_number", "opportunity_bundle_id") for rank in rank_qs: if rank.level_number <= first_distributor_referrals: current_rank_name = rank.name else: break power_stream_active_count = max(distributor_ids_count - 2, 0) power_stream_inactive_count = min(distributor_ids_count, 2) qualifying_rows = list( DistributorID.objects.annotate(ref_cnt=Count("direct_referrals")) .filter(ref_cnt__gte=100) .values("user_id") .annotate(qualified_at=Min("created_at")) .order_by("qualified_at", "user_id")[:48] ) club_user_ids = [row["user_id"] for row in qualifying_rows] is_director_club_member = user.id in club_user_ids director_club_position = (club_user_ids.index(user.id) + 1) if is_director_club_member else None active_scheme_rows = list( user_distributor_qs.filter(is_active=True) .values("product__opportunity_bundle_id", "product__opportunity_bundle__name", "product__opportunity_bundle__opportunity_bundle_amount") .annotate(active_count=Count("id")) .order_by("product__opportunity_bundle__opportunity_bundle_amount", "product__opportunity_bundle__name") ) package_active_schemes = [ { "opportunity_bundle_id": str(row["product__opportunity_bundle_id"]) if row["product__opportunity_bundle_id"] else None, "opportunity_bundle_name": row["product__opportunity_bundle__name"] or "opportunity_bundle", "opportunity_bundle_amount": _fmt_amount(row["product__opportunity_bundle__opportunity_bundle_amount"]), "active_distributor_ids": int(row["active_count"] or 0), } for row in active_scheme_rows ] direct_ref_rows = list( direct_ref_dist_qs.values("is_active", "product__opportunity_bundle__opportunity_bundle_amount").annotate(cnt=Count("id")) ) direct_ref_breakdown = { "active_silver": 0, "active_gold": 0, "inactive_silver": 0, "inactive_gold": 0, "total_silver": 0, "total_gold": 0, } for row in direct_ref_rows: bucket = _bucket_from_opportunity_bundle_amount(row.get("product__opportunity_bundle__opportunity_bundle_amount")) cnt = int(row.get("cnt") or 0) if bucket not in ("silver", "gold"): continue direct_ref_breakdown[f"total_{bucket}"] += cnt prefix = "active" if row.get("is_active") else "inactive" direct_ref_breakdown[f"{prefix}_{bucket}"] += cnt # Downline tree (all descendants under user's distributor ids) root_ids = list(user_distributor_qs.values_list("id", flat=True)) seen = set(root_ids) frontier = list(root_ids) descendant_ids = [] while frontier: child_ids = [] for id_chunk in _chunked(frontier): child_ids.extend( DistributorID.objects.filter(sponsor_distributor_id__in=id_chunk).values_list("id", flat=True) ) new_ids = [item for item in child_ids if item not in seen] if not new_ids: break seen.update(new_ids) descendant_ids.extend(new_ids) frontier = new_ids # Chunk queries against potentially large ID lists to avoid SQLite parameter limits downline_rows = [] if descendant_ids: for chunk in _chunked(descendant_ids, size=500): rows = list( DistributorID.objects.filter(id__in=chunk) .values("product__opportunity_bundle__opportunity_bundle_amount") .annotate(cnt=Count("id")) ) # merge counts by opportunity_bundle_amount for row in rows: key = row.get("product__opportunity_bundle__opportunity_bundle_amount") existing = next((r for r in downline_rows if r.get("product__opportunity_bundle__opportunity_bundle_amount") == key), None) if existing: existing["cnt"] = int(existing.get("cnt", 0)) + int(row.get("cnt", 0)) else: downline_rows.append({ "product__opportunity_bundle__opportunity_bundle_amount": key, "cnt": int(row.get("cnt", 0)), }) downline_scheme_counts = {"silver": 0, "gold": 0, "other": 0} for row in downline_rows: bucket = _bucket_from_opportunity_bundle_amount(row.get("product__opportunity_bundle__opportunity_bundle_amount")) downline_scheme_counts[bucket] += int(row.get("cnt") or 0) today_direct_sales_rows = [] if direct_ref_user_ids: for chunk in _chunked(direct_ref_user_ids, size=500): rows = list( Order.objects.filter( user_id__in=chunk, status="COMPLETED", created_at__date=today, ).values("product__opportunity_bundle__opportunity_bundle_amount").annotate(cnt=Count("id"), amount=Sum("amount")) ) today_direct_sales_rows.extend(rows) today_direct_sales = { "silver_count": 0, "silver_amount": Decimal("0.00"), "gold_count": 0, "gold_amount": Decimal("0.00"), } for row in today_direct_sales_rows: bucket = _bucket_from_opportunity_bundle_amount(row.get("product__opportunity_bundle__opportunity_bundle_amount")) if bucket not in ("silver", "gold"): continue today_direct_sales[f"{bucket}_count"] += int(row.get("cnt") or 0) today_direct_sales[f"{bucket}_amount"] += _to_decimal(row.get("amount")) direct_bonus_qs = WalletLedger.objects.filter( user=user, transaction_type=WalletLedger.TransactionType.CREDIT, source_type=WalletLedger.SourceType.DIRECT_INCENTIVE, ) level_reward_qs = WalletLedger.objects.filter( user=user, transaction_type=WalletLedger.TransactionType.CREDIT, source_type=WalletLedger.SourceType.LEVEL_REWARD, ) direct_bonus_split = _sum_ledger_by_scheme(direct_bonus_qs) royalty_split = _sum_ledger_by_scheme(level_reward_qs) earnings_today = ( WalletLedger.objects.filter( user=user, transaction_type=WalletLedger.TransactionType.CREDIT, created_at__date=today, ).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) earnings_month = ( WalletLedger.objects.filter( user=user, transaction_type=WalletLedger.TransactionType.CREDIT, created_at__gte=month_start, ).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) team_monthly_sales_rows = [] if direct_ref_user_ids: for chunk in _chunked(direct_ref_user_ids, size=500): rows = list( Order.objects.filter( user_id__in=chunk, status="COMPLETED", created_at__gte=month_start, ).values("product__opportunity_bundle__opportunity_bundle_amount").annotate(total=Sum("amount")) ) team_monthly_sales_rows.extend(rows) team_monthly_sales = {"silver": Decimal("0.00"), "gold": Decimal("0.00")} for row in team_monthly_sales_rows: bucket = _bucket_from_opportunity_bundle_amount(row.get("product__opportunity_bundle__opportunity_bundle_amount")) if bucket in team_monthly_sales: team_monthly_sales[bucket] += _to_decimal(row.get("total")) primary_bank_account = BankAccount.objects.filter(user=user, is_primary=True).first() any_bank_account = BankAccount.objects.filter(user=user).exists() withdrawable_balance = max(_to_decimal(main_balance) - _to_decimal(locked_amount), Decimal("0.00")) withdrawal_qs = WithdrawalRequest.objects.filter(user=user) pending_payout_total = ( withdrawal_qs.filter(status__in=[WithdrawalRequest.Status.PENDING, WithdrawalRequest.Status.APPROVED]) .aggregate(total=Sum("amount_requested"))["total"] or Decimal("0.00") ) received_payout_total = ( withdrawal_qs.filter(status=WithdrawalRequest.Status.PAID) .aggregate(total=Sum("net_amount"))["total"] or Decimal("0.00") ) power_stream_records_today = PowerStreamBonusRecord.objects.filter(earner=user, earned_at__gte=start_of_today) power_stream_records_month = PowerStreamBonusRecord.objects.filter(earner=user, earned_at__gte=month_start) power_stream_today_split = _sum_power_stream_by_scheme(power_stream_records_today) power_stream_month_split = _sum_power_stream_by_scheme(power_stream_records_month) direct_bonus_today_total = ( direct_bonus_qs.filter(created_at__gte=start_of_today).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) direct_bonus_month_total = ( direct_bonus_qs.filter(created_at__gte=month_start).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) level_reward_month_total = ( level_reward_qs.filter(created_at__gte=month_start).aggregate(total=Sum("amount"))["total"] or Decimal("0.00") ) director_monthly_bonus = level_reward_month_total if is_director_club_member else Decimal("0.00") bonus_metrics = get_user_bonus_metrics(user=user, month_start=month_start.date()) sponsor_income_summary = get_sponsor_income_summary(user) advanced_dashboard = { "my_details": { "user_id": str(user.id), "user_name": f"{(user.first_name or '').strip()} {(user.last_name or '').strip()}".strip() or user.mobile or user.email, "mobile": user.mobile, "email": user.email, "date_joined": user.date_joined.isoformat() if user.date_joined else None, "profile_image_url": profile_image_url, "referral_id": user.referral_code, "current_level_rank_name": current_rank_name, "activation_date_time": first_distributor_activation, "brand_ambassador_position_number": brand_ambassador_position_number, "power_stream_bonus_active_count": power_stream_active_count, "power_stream_bonus_inactive_count": power_stream_inactive_count, "director_club_member": is_director_club_member, "director_club_position": director_club_position, "bank_account_linked": any_bank_account, "bank_name": primary_bank_account.bank_name if primary_bank_account else None, "pincode_code": getattr(pincode_obj, "code", None), "pincode_location": getattr(pincode_obj, "location", None) or user.location, "pincode_mandal": user.location or getattr(pincode_obj, "location", None), "pincode_district": getattr(getattr(pincode_obj, "district", None), "name", None) or user.city, "pincode_state": getattr(getattr(pincode_obj, "state", None), "name", None) or user.state, "pincode_country": getattr(getattr(pincode_obj, "country", None), "name", None) or user.country, }, "package_active_schemes": package_active_schemes, "total_earnings": { "all_time": _fmt_amount(earning_credits), "today": _fmt_amount(earnings_today), "this_month": _fmt_amount(earnings_month), }, "direct_referrals": { "active_silver_1180": direct_ref_breakdown["active_silver"], "active_gold_11800": direct_ref_breakdown["active_gold"], "inactive_silver_1180": direct_ref_breakdown["inactive_silver"], "inactive_gold_11800": direct_ref_breakdown["inactive_gold"], "total_silver_1180": direct_ref_breakdown["total_silver"], "total_gold_11800": direct_ref_breakdown["total_gold"], }, "sponsor_income": { "total_sponsor_income": _fmt_amount(sponsor_income_summary.get("total_earned")), "this_month_sponsor_income": _fmt_amount(sponsor_income_summary.get("this_month_earned")), "total_sponsor_direct_referrals": int(sponsor_income_summary.get("total_direct_referrals") or 0), "total_sponsor_distributor_ids": int(sponsor_income_summary.get("total_distributor_ids") or 0), "active_sponsor_distributor_ids": int(sponsor_income_summary.get("active_distributor_ids") or 0), }, "downline_team": { "scheme_1_1180": downline_scheme_counts["silver"], "scheme_2_11800": downline_scheme_counts["gold"], "other_schemes": downline_scheme_counts["other"], }, "today_direct_sales": { "today_scheme_1_1180_count": today_direct_sales["silver_count"], "today_scheme_1_1180_amount": _fmt_amount(today_direct_sales["silver_amount"]), "today_scheme_2_11800_count": today_direct_sales["gold_count"], "today_scheme_2_11800_amount": _fmt_amount(today_direct_sales["gold_amount"]), }, "power_stream_bonus": { "today_scheme_1_products_sales_bonus": _fmt_amount(power_stream_today_split["silver"]), "today_scheme_2_products_sales_bonus": _fmt_amount(power_stream_today_split["gold"]), "this_month_scheme_1_products_bonus": _fmt_amount(power_stream_month_split["silver"]), "this_month_scheme_2_products_sales_bonus": _fmt_amount(power_stream_month_split["gold"]), }, "director_club_monthly_bonus": _fmt_amount(director_monthly_bonus), "wallets": { "e_wallet": _fmt_amount(main_balance), "bank_wallet": _fmt_amount(withdrawable_balance), "repurchase_wallet": _fmt_amount(repurchase_balance), "voucher_wallet": _fmt_amount(voucher_balance), }, "direct_sales_bonus": { "direct_silver_scheme_1_products_sales_bonus": _fmt_amount(direct_bonus_split["silver"]), "direct_gold_scheme_2_products_sales_bonus": _fmt_amount(direct_bonus_split["gold"]), }, "brand_ambassador_bonuses": { "silver_products_royalty_bonus": _fmt_amount(royalty_split["silver"]), "gold_products_royalty_bonus": _fmt_amount(royalty_split["gold"]), "level_rank_status": current_rank_name, }, "bonanzas": { "lucky_dip_bonanza": max(lucky_entries, int(bonus_metrics.get("lucky_dip_bonanza", 0))), "products_bonanzas": max(completed_orders_qs.count(), int(bonus_metrics.get("products_bonanzas", 0))), "domestic_travel_bonanzas": int(bonus_metrics.get("domestic_travel_bonanzas", 0)), "international_travel_bonanzas": int(bonus_metrics.get("international_travel_bonanzas", 0)), "two_wheeler_bonanzas": int(bonus_metrics.get("two_wheeler_bonanzas", 0)), "alkaline_water_device_bonanzas": int(bonus_metrics.get("alkaline_water_device_bonanzas", 0)), "gold_bonanzas": int(bonus_metrics.get("gold_bonanzas", 0)), "car_fund_bonanzas": int(bonus_metrics.get("car_fund_bonanzas", 0)), }, "sales_bonuses": { "daily_top_sales_bonus": _fmt_amount(direct_bonus_today_total), "monthly_direct_top_sales_bonus": _fmt_amount(direct_bonus_month_total), "team_silver_products_monthly_sales_bonus": _fmt_amount(team_monthly_sales["silver"]), "team_gold_products_monthly_sales_bonus": _fmt_amount(team_monthly_sales["gold"]), "director_team_sales_bonus": _fmt_amount(director_monthly_bonus), }, "glyminoh_rice_revenue_franchise_development_officer": { "monthly_sales_incentives": _fmt_amount(bonus_metrics.get("glyminoh_monthly_sales_incentives", Decimal("0.00"))), }, "payouts": { "pending_payout": _fmt_amount(pending_payout_total), "received_payout": _fmt_amount(received_payout_total), "direct_referrals_silver_products_received_payout": _fmt_amount(direct_bonus_split["silver"]), "direct_referrals_gold_products_received_payout": _fmt_amount(direct_bonus_split["gold"]), "silver_products_brand_ambassadors_royalty_bonus": _fmt_amount(royalty_split["silver"]), "gold_products_brand_ambassadors_royalty_bonus": _fmt_amount(royalty_split["gold"]), }, "implementation_metadata": { "computed_with_real_models": True, "unimplemented_metrics": [], }, } return Response( { "generated_at": now.isoformat(), "wallet": { "main_balance": str(main_balance), "repurchase_balance": str(repurchase_balance), "locked_amount": str(locked_amount), "total_earning_credits": str(earning_credits), }, "orders": { "total": orders_qs.count(), "completed": completed_orders_qs.count(), "pending": orders_qs.filter(status="PENDING").count(), "failed": orders_qs.filter(status="FAILED").count(), "total_spent": str(total_spent), "completed_revenue": str(completed_revenue), }, "network": { "referrals": referrals_count, "distributor_ids": distributor_ids_count, }, "lucky_dip": { "my_entries": lucky_entries, "active_dips": active_dips, }, "notifications": { "unread": unread_notifications, }, "support": { "total": support_qs.count(), "open": support_qs.filter(status="open").count(), "in_progress": support_qs.filter(status="in_progress").count(), "resolved": support_qs.filter(status="resolved").count(), "closed": support_qs.filter(status="closed").count(), }, "trend_7d": trend, "recent_wallet_transactions": [ { "id": str(row["id"]), "transaction_type": row["transaction_type"], "wallet_type": row["wallet_type"], "source_type": row["source_type"], "amount": str(row["amount"]), "reference_id": row["reference_id"], "created_at": row["created_at"], } for row in latest_ledger ], "recent_orders": [ { "id": str(row["id"]), "status": row["status"], "amount": str(row["amount"]), "reference_id": row["reference_id"], "payment_method": row["payment_method"], "product_name": row.get("product__name") or "Product", "created_at": row["created_at"], } for row in latest_orders ], "recent_support_tickets": [ { "id": str(row["id"]), "ticket_number": row["ticket_number"], "subject": row["subject"], "priority": row["priority"], "status": row["status"], "updated_at": row["updated_at"], "created_at": row["created_at"], } for row in latest_tickets ], "advanced_dashboard": advanced_dashboard, }, status=status.HTTP_200_OK, )