feat(network): enrich network tree with package leg scores and update Protobuf definitions

- Added logic to enrich the network tree with the latest left/right leg totals for gold and silver packages in GetNetworkTreeQueryHandler.
- Introduced new properties in NetworkTreeDto for GoldLeftLegTotal, GoldRightLegTotal, SilverLeftLegTotal, and SilverRightLegTotal.
- Updated Protobuf definitions to include new fields for leg scores in NetworkTreeNodeModel.
- Enhanced mapping in NetworkMembershipProfile and NetworkMembershipService to accommodate new leg score properties.
- Bumped Protobuf project version to reflect the addition of new features.

.gitea/workflows/kub-deploy.yml

@@ -95,6 +95,7 @@ jobs:
           sshpass -e ssh -o StrictHostKeyChecking=no root@${{ env.K8S_SERVER }} "
             kubectl apply -f /tmp/cms-config.yaml &&
             kubectl apply -f /tmp/cms-deployment.yaml &&
+            crictl rmi ${REGISTRY}/${IMAGE_NAME}:latest 2>/dev/null || true &&
             kubectl rollout restart deployment/cms &&
             kubectl rollout status deployment/cms --timeout=180s &&
             rm -f /tmp/cms-config.yaml /tmp/cms-deployment.yaml

README.md

@@ -1,3 +1,4 @@
 # CMS Microservice
 
 Documentation moved to [totalDoc/INDEX.md](../totalDoc/INDEX.md).
+   

k8s/staging/cms-config.yaml

@@ -24,6 +24,8 @@ stringData:
         "MerchantId": "4225d555-5fa9-4df0-9b61-1ce152cbbba8",
         "UseSandbox": true
       },
+      "CmsBaseUrl": "https://cms.se.kbs1.ir",
+      "FrontOfficeBaseUrl": "https://frontoffice.se.kbs1.ir",
       "FMS": {
         "Address": "https://dl.afrino.co"
       },
@@ -62,7 +64,7 @@ stringData:
       "Sms": {
         "Enabled": true,
         "Provider": "Kavenegar",
-        "KavenegarApiKey": "497263626F32626A48685A6137524C4F78575A766E4C74694A556B79317648424964655030682B554545413D",
+        "KavenegarApiKey": "43676A4E786A6C50452F2F6252507939346A5145764B33566B456454374E657A614468706658656D6534593D",
         "Sender": "1000001110100"
       },
       "DayaPayment": {

k8s/staging/cms-deployment.yaml

@@ -101,6 +101,8 @@ spec:
 
 ---
 # CMS Ingress
+# If clients report TLS PartialChain, the tls secret (cms-tls) tls.crt must include the full chain
+# (leaf + intermediates). cert-manager ACME usually provides this; manual certs need fullchain.pem in tls.crt.
 apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:

src/CMSMicroservice.Application/BlogPostCQ/Commands/CreateBlogPost/CreateBlogPostCommandHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.FileManager;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Entities.Blog;
@@ -32,12 +33,13 @@ public class CreateBlogPostCommandHandler : IRequestHandler<CreateBlogPostComman
         if (string.IsNullOrEmpty(currentUserId) || !long.TryParse(currentUserId, out var authorUserId))
             throw new UnauthorizedAccessException("کاربر احراز هویت نشده است");
 
+        var slug = BlogSlugHelper.ResolveForCreate(request.Slug, request.Title.Trim());
+        slug = await BlogSlugHelper.EnsureUniquePostSlugAsync(_context, slug, cancellationToken: cancellationToken);
+
         var post = new BlogPost
         {
             Title = request.Title.Trim(),
-            Slug = string.IsNullOrWhiteSpace(request.Slug)
-                ? $"post-{Guid.NewGuid():N}".Substring(0, 20)
-                : request.Slug.Trim().ToLower(),
+            Slug = slug,
             Summary = request.Summary?.Trim(),
             HtmlContent = request.HtmlContent,
             FeaturedImagePath = request.FeaturedImagePath,

src/CMSMicroservice.Application/BlogPostCQ/Commands/CreateBlogPost/CreateBlogPostCommandValidator.cs

@@ -11,9 +11,9 @@ public class CreateBlogPostCommandValidator : AbstractValidator<CreateBlogPostCo
             .MaximumLength(200).WithMessage("عنوان نمی‌تواند بیشتر از 200 کاراکتر باشد");
 
         RuleFor(x => x.Slug)
-            .NotEmpty().WithMessage("نشانی یکتا (slug) الزامی است")
             .MaximumLength(200).WithMessage("نشانی نمی‌تواند بیشتر از 200 کاراکتر باشد")
-            .Matches(@"^[a-z0-9\-]+$").WithMessage("نشانی فقط می‌تواند شامل حروف کوچک انگلیسی، اعداد و خط تیره باشد");
+            .Matches(@"^[a-z0-9\-]+$").WithMessage("نشانی فقط می‌تواند شامل حروف کوچک انگلیسی، اعداد و خط تیره باشد")
+            .When(x => !string.IsNullOrWhiteSpace(x.Slug));
 
         RuleFor(x => x.Summary)
             .MaximumLength(500).WithMessage("خلاصه نمی‌تواند بیشتر از 500 کاراکتر باشد")

src/CMSMicroservice.Application/BlogPostCQ/Commands/UpdateBlogPost/UpdateBlogPostCommandHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.FileManager;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Entities.Blog;
@@ -29,9 +30,21 @@ public class UpdateBlogPostCommandHandler : IRequestHandler<UpdateBlogPostComman
             ?? throw new KeyNotFoundException($"مقاله با شناسه {request.Id} یافت نشد");
 
         post.Title = request.Title.Trim();
-        // حفظ slug قبلی اگر مقدار جدید خالی باشد
+
         if (!string.IsNullOrWhiteSpace(request.Slug))
-            post.Slug = request.Slug.Trim().ToLower();
+        {
+            post.Slug = await BlogSlugHelper.EnsureUniquePostSlugAsync(
+                _context,
+                BlogSlugHelper.NormalizeOptional(request.Slug)!,
+                post.Id,
+                cancellationToken);
+        }
+        else if (string.IsNullOrWhiteSpace(post.Slug))
+        {
+            var slug = BlogSlugHelper.ResolveForCreate(null, post.Title);
+            post.Slug = await BlogSlugHelper.EnsureUniquePostSlugAsync(
+                _context, slug, post.Id, cancellationToken);
+        }
         post.Summary = request.Summary?.Trim();
         post.HtmlContent = request.HtmlContent;
         post.FeaturedImagePath = request.FeaturedImagePath;

src/CMSMicroservice.Application/BlogPostCQ/Commands/UpdateBlogPost/UpdateBlogPostCommandValidator.cs

@@ -13,9 +13,9 @@ public class UpdateBlogPostCommandValidator : AbstractValidator<UpdateBlogPostCo
             .MaximumLength(200).WithMessage("عنوان نمی‌تواند بیشتر از 200 کاراکتر باشد");
 
         RuleFor(x => x.Slug)
-            .NotEmpty().WithMessage("نشانی یکتا (slug) الزامی است")
             .MaximumLength(200).WithMessage("نشانی نمی‌تواند بیشتر از 200 کاراکتر باشد")
-            .Matches(@"^[a-z0-9\-]+$").WithMessage("نشانی فقط می‌تواند شامل حروف کوچک انگلیسی، اعداد و خط تیره باشد");
+            .Matches(@"^[a-z0-9\-]+$").WithMessage("نشانی فقط می‌تواند شامل حروف کوچک انگلیسی، اعداد و خط تیره باشد")
+            .When(x => !string.IsNullOrWhiteSpace(x.Slug));
 
         RuleFor(x => x.HtmlContent)
             .NotEmpty().WithMessage("محتوای مقاله الزامی است");

src/CMSMicroservice.Application/ClubMembershipCQ/Commands/AcceptClubMembershipContract/AcceptClubMembershipContractCommandHandler.cs

@@ -135,15 +135,65 @@ public class AcceptClubMembershipContractCommandHandler
         };
         await _context.UserContracts.AddAsync(userContract, cancellationToken);
 
-        // 6. بارگذاری پکیج از آخرین خرید کاربر یا پکیج پایه
+        // 6. بارگذاری پکیج موثر برای امضای قرارداد
+        // اولویت:
+        //   1) پکیج Cycle جاری (مسیر صحیح برای پرداخت دستی)
+        //   2) آخرین خرید پکیج
+        //   3) پکیج پایه
+        var currentCyclePackageId = await _context.ClubMembershipCycles
+            .Where(c => c.UserId == userId && c.IsCurrentCycle)
+            .OrderByDescending(c => c.CycleNumber)
+            .Select(c => (long?)c.PackageId)
+            .FirstOrDefaultAsync(cancellationToken);
+
         var latestPurchase = await _context.UserPackagePurchases
             .Where(p => p.UserId == userId)
             .OrderByDescending(p => p.PurchasedAt)
             .FirstOrDefaultAsync(cancellationToken);
 
-        var package = latestPurchase != null
-            ? await _context.Packages.FirstOrDefaultAsync(p => p.Id == latestPurchase.PackageId && !p.IsDeleted, cancellationToken)
-            : await _context.Packages.FirstOrDefaultAsync(p => p.IsBasePackage && !p.IsDeleted, cancellationToken);
+        Package? package = null;
+
+        if (currentCyclePackageId.HasValue && currentCyclePackageId.Value > 0)
+        {
+            package = await _context.Packages
+                .FirstOrDefaultAsync(p => p.Id == currentCyclePackageId.Value && !p.IsDeleted, cancellationToken);
+
+            if (package != null)
+            {
+                _logger.LogInformation(
+                    "AcceptContract package source: CurrentCycle (UserId={UserId}, PackageId={PackageId})",
+                    userId,
+                    package.Id);
+            }
+        }
+
+        if (package == null && latestPurchase != null)
+        {
+            package = await _context.Packages
+                .FirstOrDefaultAsync(p => p.Id == latestPurchase.PackageId && !p.IsDeleted, cancellationToken);
+
+            if (package != null)
+            {
+                _logger.LogInformation(
+                    "AcceptContract package source: LatestPurchase (UserId={UserId}, PackageId={PackageId})",
+                    userId,
+                    package.Id);
+            }
+        }
+
+        if (package == null)
+        {
+            package = await _context.Packages
+                .FirstOrDefaultAsync(p => p.IsBasePackage && !p.IsDeleted, cancellationToken);
+
+            if (package != null)
+            {
+                _logger.LogInformation(
+                    "AcceptContract package source: BasePackage (UserId={UserId}, PackageId={PackageId})",
+                    userId,
+                    package.Id);
+            }
+        }
 
         if (package == null)
             throw new NotFoundException("پکیج یافت نشد");
@@ -221,7 +271,54 @@ public class AcceptClubMembershipContractCommandHandler
         _context.ClubMembershipHistories.Add(history);
         await _context.SaveChangesAsync(cancellationToken);
 
-        // 9. اضافه کردن مبلغ به Pool هفته جاری
+        // 8.5. آپدیت PackagePurchasedAt سایکل جاری به زمان امضای قرارداد
+        // دلیل: Pool در همین لحظه شارژ می‌شود — Validation باید به همین هفته اشاره کند
+        // سناریوی cross-week: کاربر هفته ۱۸ پکیج خریده، هفته ۱۹ قرارداد امضا کرده
+        //   بدون این Fix: Cycle.PackagePurchasedAt = هفته ۱۸ ولی Pool هفته ۱۹ → اختلاف
+        //   با این Fix: Cycle.PackagePurchasedAt = هفته ۱۹ = Pool هفته ۱۹ → درست
+        var currentCycle = await _context.ClubMembershipCycles
+            .FirstOrDefaultAsync(c => c.UserId == userId && c.IsCurrentCycle, cancellationToken);
+
+        if (currentCycle != null)
+        {
+            currentCycle.PackagePurchasedAt = activationDate;
+            _context.ClubMembershipCycles.Update(currentCycle);
+            await _context.SaveChangesAsync(cancellationToken);
+
+            _logger.LogInformation(
+                "Updated Cycle #{CycleNumber} PackagePurchasedAt to contract-signing time for UserId {UserId}",
+                currentCycle.CycleNumber,
+                userId
+            );
+        }
+        else
+        {
+            // در صورتی که Cycle وجود ندارد (legacy یا مسیر مستقیم AcceptContract)
+            // Cycle را همین‌جا بساز تا Validation درست کار کند
+            _logger.LogWarning(
+                "No IsCurrentCycle found for UserId {UserId} at AcceptContract — creating Cycle now",
+                userId
+            );
+
+            var maxCycleNumber = await _context.ClubMembershipCycles
+                .Where(c => c.ClubMembershipId == clubMembership.Id)
+                .MaxAsync(c => (int?)c.CycleNumber, cancellationToken) ?? 0;
+
+            var newCycle = new ClubMembershipCycle
+            {
+                UserId = userId,
+                ClubMembershipId = clubMembership.Id,
+                CycleNumber = maxCycleNumber + 1,
+                PackagePurchasedAt = activationDate,
+                PurchaseMethod = user.PackagePurchaseMethod,
+                PackageAmount = package.Price,
+                PackageId = package.Id,
+                IsCurrentCycle = true
+            };
+
+            _context.ClubMembershipCycles.Add(newCycle);
+            await _context.SaveChangesAsync(cancellationToken);
+        }
         var currentWeekDefinitionId = GetCurrentWeekDefinitionId();
         var weeklyPool = await _context.WeeklyCommissionPools
             .FirstOrDefaultAsync(p => p.WeekDefinitionId == currentWeekDefinitionId && p.PackageId == package.Id, cancellationToken);

src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommand.cs

@@ -17,4 +17,10 @@ public record ActivateClubMembershipCommand : IRequest<bool>
     /// فعال‌سازی اجباری توسط ادمین — بدون بررسی سفارش و کیف‌پول
     /// </summary>
     public bool ForceActivation { get; init; }
+
+    /// <summary>
+    /// شناسه پکیج — فقط در ForceActivation استفاده می‌شود.
+    /// اگر 0 باشد، پکیج پایه (IsBasePackage) استفاده می‌شود.
+    /// </summary>
+    public long PackageId { get; init; }
 }

src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommandHandler.cs

@@ -1,4 +1,5 @@
 using CMSMicroservice.Application.Common.Exceptions;
+using CMSMicroservice.Application.Common.Helpers;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
 using CMSMicroservice.Domain.Common;
@@ -162,18 +163,27 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
                     request.UserId
                 );
 
-                // در فعال‌سازی اجباری، اگر PackagePurchaseMethod تنظیم نشده، مقدار DirectPurchase بگذار
+                // در فعال‌سازی اجباری ادمین، اگر روش خرید تنظیم نشده، دستی در نظر بگیر
                 if (user.PackagePurchaseMethod == PackagePurchaseMethod.None)
                 {
-                    user.PackagePurchaseMethod = PackagePurchaseMethod.DirectPurchase;
+                    user.PackagePurchaseMethod = PackagePurchaseMethod.Manual;
                     _context.Users.Update(user);
                     await _context.SaveChangesAsync(cancellationToken);
                 }
 
-                // بارگذاری پکیج پایه برای فعال‌سازی اجباری
-                package = await _context.Packages
-                    .FirstOrDefaultAsync(p => p.IsBasePackage && !p.IsDeleted, cancellationToken)
-                    ?? throw new NotFoundException("پکیج پایه یافت نشد");
+                // بارگذاری پکیج — اگر PackageId مشخص شده همان را لود کن، وگرنه پکیج پایه
+                if (request.PackageId > 0)
+                {
+                    package = await _context.Packages
+                        .FirstOrDefaultAsync(p => p.Id == request.PackageId && !p.IsDeleted, cancellationToken)
+                        ?? throw new NotFoundException($"پکیج {request.PackageId} یافت نشد");
+                }
+                else
+                {
+                    package = await _context.Packages
+                        .FirstOrDefaultAsync(p => p.IsBasePackage && !p.IsDeleted, cancellationToken)
+                        ?? throw new NotFoundException("پکیج پایه یافت نشد");
+                }
             }
 
             // 6. بررسی عضویت فعلی
@@ -226,10 +236,12 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
                 var hasCurrentCycle = await _context.ClubMembershipCycles
                     .AnyAsync(c => c.UserId == user.Id && c.IsCurrentCycle, cancellationToken);
 
-                if (existingMembership.IsActive && hasCurrentCycle)
+                // اگر چرخه فعال دارد و درخواست Force نیست — احتمال اجرای تکراری همان خرید
+                // در حالت ForceActivation (مثل پرداخت دستی)، باید چرخه جدید ساخته شود تا پکیج جدید ثبت شود.
+                if (hasCurrentCycle && !request.ForceActivation)
                 {
                     _logger.LogInformation(
-                        "User {UserId} is already an active club member with a running cycle",
+                        "User {UserId} already has a running cycle — skipping duplicate activation",
                         user.Id
                     );
                     return true;
@@ -261,6 +273,7 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
             foreach (var prevCycle in previousCycles)
             {
                 prevCycle.IsCurrentCycle = false;
+                ClubMembershipCycleHistoryWriter.WriteCycleClosed(_context, prevCycle, reason: "شروع دوره جدید");
             }
 
             var maxCycleNumber = await _context.ClubMembershipCycles
@@ -282,6 +295,9 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
             _context.ClubMembershipCycles.Add(newCycle);
             await _context.SaveChangesAsync(cancellationToken);
 
+            ClubMembershipCycleHistoryWriter.WriteCycleStarted(_context, newCycle, reason: "فعال‌سازی عضویت باشگاه");
+            await _context.SaveChangesAsync(cancellationToken);
+
             _logger.LogInformation(
                 "Created ClubMembershipCycle #{CycleNumber} for UserId {UserId}, MembershipId {MembershipId}",
                 newCycle.CycleNumber,
@@ -307,48 +323,60 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
             await _context.SaveChangesAsync(cancellationToken);
 
             // ⭐ 8. اضافه کردن مبلغ به Pool هفته جاری
-            var currentWeekDefinitionId = GetCurrentWeekDefinitionId();
-            var weeklyPool = await _context.WeeklyCommissionPools
-                .FirstOrDefaultAsync(p => p.WeekDefinitionId == currentWeekDefinitionId && p.PackageId == package.Id, cancellationToken);
-
-            if (weeklyPool == null)
+            // عضو جدید (isNewMembership=true): Pool توسط AcceptClubMembershipContract شارژ می‌شود
+            //   چون کاربر قبل از امضای قرارداد IsActive=false است و قرارداد فقط یک‌بار امضا می‌شود.
+            // خرید مجدد (isNewMembership=false): قرارداد مجدد امضا نمی‌شود — Pool همین‌جا شارژ می‌شود.
+            if (!isNewMembership)
             {
-                // ایجاد Pool جدید برای این هفته × این پکیج
-                weeklyPool = new WeeklyCommissionPool
-                {
-                    WeekDefinitionId = currentWeekDefinitionId,
-                    PackageId = package.Id,
-                    TotalPoolAmount = activationFeeValue,
-                    TotalBalances = 0, // در CalculateWeeklyBalances محاسبه میشه
-                    ValuePerBalance = 0, // در CalculateWeeklyCommissionPool محاسبه میشه
-                    IsCalculated = false,
-                    CalculatedAt = null
-                };
+                var currentWeekDefinitionId = GetCurrentWeekDefinitionId();
+                var weeklyPool = await _context.WeeklyCommissionPools
+                    .FirstOrDefaultAsync(p => p.WeekDefinitionId == currentWeekDefinitionId && p.PackageId == package.Id, cancellationToken);
 
-                await _context.WeeklyCommissionPools.AddAsync(weeklyPool, cancellationToken);
-                
-                _logger.LogInformation(
-                    "Created new WeeklyCommissionPool for WeekDefinitionId={WeekDefinitionId} with initial amount: {Amount}",
-                    currentWeekDefinitionId,
-                    giftValue
-                );
+                if (weeklyPool == null)
+                {
+                    // ایجاد Pool جدید برای این هفته × این پکیج
+                    weeklyPool = new WeeklyCommissionPool
+                    {
+                        WeekDefinitionId = currentWeekDefinitionId,
+                        PackageId = package.Id,
+                        TotalPoolAmount = activationFeeValue,
+                        TotalBalances = 0,
+                        ValuePerBalance = 0,
+                        IsCalculated = false,
+                        CalculatedAt = null
+                    };
+
+                    await _context.WeeklyCommissionPools.AddAsync(weeklyPool, cancellationToken);
+
+                    _logger.LogInformation(
+                        "Created new WeeklyCommissionPool for WeekDefinitionId={WeekDefinitionId} with initial amount: {Amount}",
+                        currentWeekDefinitionId,
+                        activationFeeValue
+                    );
+                }
+                else
+                {
+                    weeklyPool.TotalPoolAmount += activationFeeValue;
+                    _context.WeeklyCommissionPools.Update(weeklyPool);
+
+                    _logger.LogInformation(
+                        "Added {Amount} to existing WeeklyCommissionPool for WeekDefinitionId={WeekDefinitionId}. New total: {NewTotal}",
+                        activationFeeValue,
+                        currentWeekDefinitionId,
+                        weeklyPool.TotalPoolAmount
+                    );
+                }
+
+                await _context.SaveChangesAsync(cancellationToken);
             }
             else
             {
-                // اضافه کردن به Pool موجود
-                weeklyPool.TotalPoolAmount += activationFeeValue;
-                _context.WeeklyCommissionPools.Update(weeklyPool);
-                
                 _logger.LogInformation(
-                    "Added {Amount} to existing WeeklyCommissionPool for WeekDefinitionId={WeekDefinitionId}. New total: {NewTotal}",
-                    activationFeeValue,
-                    currentWeekDefinitionId,
-                    weeklyPool.TotalPoolAmount
+                    "New member — Pool charge deferred to AcceptClubMembershipContract for UserId {UserId}",
+                    user.Id
                 );
             }
 
-            await _context.SaveChangesAsync(cancellationToken);
-
             // 9. اعمال ویژگی‌های پکیج — DIFF/تفاضل (Q20)
             await ApplyFeatureDiffAsync(user.Id, entity.Id, package.Id, isNewMembership, activationDate, cancellationToken);
 

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetAllClubMemberships/GetAllClubMembershipsQueryHandler.cs

@@ -13,6 +13,7 @@ public class GetAllClubMembershipsQueryHandler : IRequestHandler<GetAllClubMembe
     {
         var query = _context.ClubMemberships
             .Include(x => x.User)
+            .Include(x => x.LastPackage)
             .ApplyOrder(sortBy: request.SortBy)
             .AsNoTracking()
             .AsQueryable();
@@ -35,8 +36,10 @@ public class GetAllClubMembershipsQueryHandler : IRequestHandler<GetAllClubMembe
                 Id = x.Id,
                 UserId = x.UserId,
                 UserName = x.User != null ? $"{x.User.FirstName} {x.User.LastName}" : string.Empty,
+                PackageId = x.LastPackageId ?? 0,
+                PackageName = x.LastPackage != null ? x.LastPackage.Title : string.Empty,
                 IsActive = x.IsActive,
-                ActivatedAt = x.ActivatedAt,
+                ActivatedAt = x.LastActivationDate ?? x.ActivatedAt,
                 InitialContribution = x.InitialContribution,
                 TotalEarned = x.TotalEarned,
                 Created = x.Created,

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetAllClubMemberships/GetAllClubMembershipsResponseDto.cs

@@ -11,6 +11,8 @@ public class GetAllClubMembershipsResponseModel
     public long Id { get; set; }
     public long UserId { get; set; }
     public string UserName { get; set; } = string.Empty;
+    public long PackageId { get; set; }
+    public string PackageName { get; set; } = string.Empty;
     public bool IsActive { get; set; }
     public DateTime? ActivatedAt { get; set; }
     public long InitialContribution { get; set; }

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubMembershipHistory/GetClubMembershipHistoryQuery.cs

@@ -1,27 +1,17 @@
 namespace CMSMicroservice.Application.ClubMembershipCQ.Queries.GetClubMembershipHistory;
 
-/// <summary>
-/// Query برای دریافت تاریخچه تغییرات عضویت باشگاه
-/// </summary>
 public record GetClubMembershipHistoryQuery : IRequest<GetClubMembershipHistoryResponseDto>
 {
-    /// <summary>
-    /// شناسه عضویت (اختیاری)
-    /// </summary>
-    public long? MembershipId { get; init; }
-
-    /// <summary>
-    /// شناسه کاربر (اختیاری)
-    /// </summary>
-    public long? UserId { get; init; }
-
-    /// <summary>
-    /// موقعیت صفحه‌بندی
-    /// </summary>
     public PaginationState? PaginationState { get; init; }
-
-    /// <summary>
-    /// مرتب‌سازی بر اساس
-    /// </summary>
     public string? SortBy { get; init; }
+    public GetClubMembershipHistoryFilter? Filter { get; init; }
+}
+
+public class GetClubMembershipHistoryFilter
+{
+    public long? UserId { get; set; }
+    public long? ClubMembershipId { get; set; }
+    public ClubMembershipAction? Action { get; set; }
+    public DateTime? CreatedFrom { get; set; }
+    public DateTime? CreatedTo { get; set; }
 }

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubMembershipHistory/GetClubMembershipHistoryQueryHandler.cs

@@ -12,20 +12,30 @@ public class GetClubMembershipHistoryQueryHandler : IRequestHandler<GetClubMembe
     public async Task<GetClubMembershipHistoryResponseDto> Handle(GetClubMembershipHistoryQuery request, CancellationToken cancellationToken)
     {
         var query = _context.ClubMembershipHistories
+            .Include(x => x.ClubMembership)
+                .ThenInclude(m => m!.User)
             .AsNoTracking()
             .AsQueryable();
 
-        if (request.MembershipId.HasValue)
+        if (request.Filter != null)
         {
-            query = query.Where(x => x.ClubMembershipId == request.MembershipId.Value);
+            if (request.Filter.ClubMembershipId.HasValue)
+                query = query.Where(x => x.ClubMembershipId == request.Filter.ClubMembershipId.Value);
+
+            if (request.Filter.UserId.HasValue)
+                query = query.Where(x => x.UserId == request.Filter.UserId.Value);
+
+            if (request.Filter.Action.HasValue)
+                query = query.Where(x => x.Action == request.Filter.Action.Value);
+
+            if (request.Filter.CreatedFrom.HasValue)
+                query = query.Where(x => x.Created >= request.Filter.CreatedFrom.Value);
+
+            if (request.Filter.CreatedTo.HasValue)
+                query = query.Where(x => x.Created <= request.Filter.CreatedTo.Value);
         }
 
-        if (request.UserId.HasValue)
-        {
-            query = query.Where(x => x.UserId == request.UserId.Value);
-        }
-
-        query = query.ApplyOrder(sortBy: request.SortBy ?? "Created"); // پیش‌فرض: جدیدترین اول
+        query = query.ApplyOrder(sortBy: request.SortBy ?? "-Created");
 
         var meta = await query.GetMetaData(request.PaginationState, cancellationToken);
 
@@ -36,6 +46,9 @@ public class GetClubMembershipHistoryQueryHandler : IRequestHandler<GetClubMembe
                 Id = x.Id,
                 ClubMembershipId = x.ClubMembershipId,
                 UserId = x.UserId,
+                UserName = x.ClubMembership != null && x.ClubMembership.User != null
+                    ? $"{x.ClubMembership.User.FirstName} {x.ClubMembership.User.LastName}"
+                    : string.Empty,
                 OldIsActive = x.OldIsActive,
                 NewIsActive = x.NewIsActive,
                 OldInitialContribution = x.OldInitialContribution,

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubMembershipHistory/GetClubMembershipHistoryQueryValidator.cs

@@ -4,31 +4,6 @@ public class GetClubMembershipHistoryQueryValidator : AbstractValidator<GetClubM
 {
     public GetClubMembershipHistoryQueryValidator()
     {
-        RuleFor(x => x.MembershipId)
-            .GreaterThan(0)
-            .WithMessage("شناسه عضویت معتبر نیست")
-            .When(x => x.MembershipId.HasValue);
-
-        RuleFor(x => x.UserId)
-            .GreaterThan(0)
-            .WithMessage("شناسه کاربر معتبر نیست")
-            .When(x => x.UserId.HasValue);
-
-        RuleFor(x => x)
-            .Must(x => x.MembershipId.HasValue || x.UserId.HasValue)
-            .WithMessage("حداقل یکی از MembershipId یا UserId باید مقداردهی شود");
+        // Admin report: filters are all optional
     }
-
-    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
-    {
-        var result = await ValidateAsync(
-            ValidationContext<GetClubMembershipHistoryQuery>.CreateWithOptions(
-                (GetClubMembershipHistoryQuery)model, 
-                x => x.IncludeProperties(propertyName)));
-        
-        if (result.IsValid)
-            return Array.Empty<string>();
-        
-        return result.Errors.Select(e => e.ErrorMessage);
-    };
 }

src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubMembershipHistory/GetClubMembershipHistoryResponseDto.cs

@@ -11,6 +11,7 @@ public class GetClubMembershipHistoryResponseModel
     public long Id { get; set; }
     public long ClubMembershipId { get; set; }
     public long UserId { get; set; }
+    public string UserName { get; set; } = string.Empty;
     public bool OldIsActive { get; set; }
     public bool NewIsActive { get; set; }
     public long? OldInitialContribution { get; set; }

src/CMSMicroservice.Application/ClubMembershipCycleCQ/Queries/GetAllClubMembershipCycleByFilter/ClubMembershipCycleFilterExtensions.cs

@@ -0,0 +1,46 @@
+using CMSMicroservice.Domain.Entities.Club;
+
+namespace CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetAllClubMembershipCycleByFilter;
+
+public static class ClubMembershipCycleFilterExtensions
+{
+    public static IQueryable<ClubMembershipCycle> ApplyClubMembershipCycleFilter(
+        this IQueryable<ClubMembershipCycle> query,
+        GetAllClubMembershipCycleByFilterFilter? filter)
+    {
+        if (filter == null) return query;
+
+        if (filter.UserId.HasValue)
+            query = query.Where(x => x.UserId == filter.UserId.Value);
+
+        if (filter.IsCurrentCycle.HasValue)
+            query = query.Where(x => x.IsCurrentCycle == filter.IsCurrentCycle.Value);
+
+        if (filter.PackageId.HasValue)
+            query = query.Where(x => x.PackageId == filter.PackageId.Value);
+
+        if (filter.CycleNumber.HasValue)
+            query = query.Where(x => x.CycleNumber == filter.CycleNumber.Value);
+
+        if (filter.PurchaseMethod.HasValue)
+            query = query.Where(x => x.PurchaseMethod == filter.PurchaseMethod.Value);
+
+        if (filter.MagicState.HasValue)
+        {
+            query = filter.MagicState.Value switch
+            {
+                1 => query.Where(x => x.MagicStartedAt != null && x.MagicCompletedAt == null),
+                2 => query.Where(x => x.MagicCompletedAt != null),
+                _ => query.Where(x => x.MagicStartedAt == null && x.MagicCompletedAt == null)
+            };
+        }
+
+        if (filter.PackagePurchasedFrom.HasValue)
+            query = query.Where(x => x.PackagePurchasedAt >= filter.PackagePurchasedFrom.Value);
+
+        if (filter.PackagePurchasedTo.HasValue)
+            query = query.Where(x => x.PackagePurchasedAt <= filter.PackagePurchasedTo.Value);
+
+        return query;
+    }
+}

src/CMSMicroservice.Application/ClubMembershipCycleCQ/Queries/GetAllClubMembershipCycleByFilter/GetAllClubMembershipCycleByFilterQuery.cs

@@ -0,0 +1,47 @@
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetAllClubMembershipCycleByFilter;
+
+public record GetAllClubMembershipCycleByFilterQuery : IRequest<GetAllClubMembershipCycleByFilterResponseDto>
+{
+    public PaginationState? PaginationState { get; init; }
+    public string? SortBy { get; init; }
+    public GetAllClubMembershipCycleByFilterFilter? Filter { get; init; }
+}
+
+public class GetAllClubMembershipCycleByFilterFilter
+{
+    public long? UserId { get; set; }
+    public bool? IsCurrentCycle { get; set; }
+    public long? PackageId { get; set; }
+    public int? CycleNumber { get; set; }
+    public PackagePurchaseMethod? PurchaseMethod { get; set; }
+    /// <summary>0=none, 1=active magic, 2=completed magic</summary>
+    public int? MagicState { get; set; }
+    public DateTime? PackagePurchasedFrom { get; set; }
+    public DateTime? PackagePurchasedTo { get; set; }
+}
+
+public class GetAllClubMembershipCycleByFilterResponseDto
+{
+    public MetaData MetaData { get; set; }
+    public List<GetAllClubMembershipCycleByFilterResponseModel>? Models { get; set; }
+}
+
+public class GetAllClubMembershipCycleByFilterResponseModel
+{
+    public long Id { get; set; }
+    public long UserId { get; set; }
+    public string UserName { get; set; } = string.Empty;
+    public long ClubMembershipId { get; set; }
+    public int CycleNumber { get; set; }
+    public long PackageId { get; set; }
+    public string PackageName { get; set; } = string.Empty;
+    public long PackageAmount { get; set; }
+    public PackagePurchaseMethod PurchaseMethod { get; set; }
+    public DateTime PackagePurchasedAt { get; set; }
+    public DateTime? MagicStartedAt { get; set; }
+    public DateTime? MagicCompletedAt { get; set; }
+    public bool IsCurrentCycle { get; set; }
+    public DateTimeOffset Created { get; set; }
+}

src/CMSMicroservice.Application/ClubMembershipCycleCQ/Queries/GetAllClubMembershipCycleByFilter/GetAllClubMembershipCycleByFilterQueryHandler.cs

@@ -0,0 +1,49 @@
+namespace CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetAllClubMembershipCycleByFilter;
+
+public class GetAllClubMembershipCycleByFilterQueryHandler
+    : IRequestHandler<GetAllClubMembershipCycleByFilterQuery, GetAllClubMembershipCycleByFilterResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetAllClubMembershipCycleByFilterQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetAllClubMembershipCycleByFilterResponseDto> Handle(
+        GetAllClubMembershipCycleByFilterQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.ClubMembershipCycles
+            .Include(x => x.User)
+            .Include(x => x.Package)
+            .AsNoTracking()
+            .ApplyClubMembershipCycleFilter(request.Filter)
+            .ApplyOrder(sortBy: request.SortBy ?? "-PackagePurchasedAt");
+
+        return new GetAllClubMembershipCycleByFilterResponseDto
+        {
+            MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
+            Models = await query
+                .PaginatedListAsync(paginationState: request.PaginationState)
+                .Select(x => new GetAllClubMembershipCycleByFilterResponseModel
+                {
+                    Id = x.Id,
+                    UserId = x.UserId,
+                    UserName = x.User != null ? $"{x.User.FirstName} {x.User.LastName}" : string.Empty,
+                    ClubMembershipId = x.ClubMembershipId,
+                    CycleNumber = x.CycleNumber,
+                    PackageId = x.PackageId,
+                    PackageName = x.Package != null ? x.Package.Title : string.Empty,
+                    PackageAmount = x.PackageAmount,
+                    PurchaseMethod = x.PurchaseMethod,
+                    PackagePurchasedAt = x.PackagePurchasedAt,
+                    MagicStartedAt = x.MagicStartedAt,
+                    MagicCompletedAt = x.MagicCompletedAt,
+                    IsCurrentCycle = x.IsCurrentCycle,
+                    Created = x.Created
+                })
+                .ToListAsync(cancellationToken)
+        };
+    }
+}

src/CMSMicroservice.Application/ClubMembershipCycleCQ/Queries/GetClubMembershipCycleSummary/GetClubMembershipCycleSummaryQuery.cs

@@ -0,0 +1,13 @@
+namespace CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetClubMembershipCycleSummary;
+
+public record GetClubMembershipCycleSummaryQuery : IRequest<GetClubMembershipCycleSummaryResponseDto>
+{
+    public GetAllClubMembershipCycleByFilter.GetAllClubMembershipCycleByFilterFilter? Filter { get; init; }
+}
+
+public class GetClubMembershipCycleSummaryResponseDto
+{
+    public long TotalCount { get; set; }
+    public long CurrentCycleCount { get; set; }
+    public long MagicActiveCount { get; set; }
+}

src/CMSMicroservice.Application/ClubMembershipCycleCQ/Queries/GetClubMembershipCycleSummary/GetClubMembershipCycleSummaryQueryHandler.cs

@@ -0,0 +1,36 @@
+using CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetAllClubMembershipCycleByFilter;
+
+namespace CMSMicroservice.Application.ClubMembershipCycleCQ.Queries.GetClubMembershipCycleSummary;
+
+public class GetClubMembershipCycleSummaryQueryHandler
+    : IRequestHandler<GetClubMembershipCycleSummaryQuery, GetClubMembershipCycleSummaryResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetClubMembershipCycleSummaryQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetClubMembershipCycleSummaryResponseDto> Handle(
+        GetClubMembershipCycleSummaryQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.ClubMembershipCycles
+            .AsNoTracking()
+            .ApplyClubMembershipCycleFilter(request.Filter);
+
+        var totalCount = await query.LongCountAsync(cancellationToken);
+        var currentCycleCount = await query.LongCountAsync(x => x.IsCurrentCycle, cancellationToken);
+        var magicActiveCount = await query.LongCountAsync(
+            x => x.MagicStartedAt != null && x.MagicCompletedAt == null,
+            cancellationToken);
+
+        return new GetClubMembershipCycleSummaryResponseDto
+        {
+            TotalCount = totalCount,
+            CurrentCycleCount = currentCycleCount,
+            MagicActiveCount = magicActiveCount
+        };
+    }
+}

src/CMSMicroservice.Application/ClubMembershipCycleHistoryCQ/Queries/GetAllClubMembershipCycleHistoryByFilter/ClubMembershipCycleHistoryFilterExtensions.cs

@@ -0,0 +1,33 @@
+using CMSMicroservice.Domain.Entities.History;
+
+namespace CMSMicroservice.Application.ClubMembershipCycleHistoryCQ.Queries.GetAllClubMembershipCycleHistoryByFilter;
+
+public static class ClubMembershipCycleHistoryFilterExtensions
+{
+    public static IQueryable<ClubMembershipCycleHistory> ApplyClubMembershipCycleHistoryFilter(
+        this IQueryable<ClubMembershipCycleHistory> query,
+        GetAllClubMembershipCycleHistoryByFilterFilter? filter)
+    {
+        if (filter == null) return query;
+
+        if (filter.UserId.HasValue)
+            query = query.Where(x => x.UserId == filter.UserId.Value);
+
+        if (filter.ClubMembershipCycleId.HasValue)
+            query = query.Where(x => x.ClubMembershipCycleId == filter.ClubMembershipCycleId.Value);
+
+        if (filter.CycleNumber.HasValue)
+            query = query.Where(x => x.CycleNumber == filter.CycleNumber.Value);
+
+        if (filter.Action.HasValue)
+            query = query.Where(x => x.Action == filter.Action.Value);
+
+        if (filter.CreatedFrom.HasValue)
+            query = query.Where(x => x.Created >= filter.CreatedFrom.Value);
+
+        if (filter.CreatedTo.HasValue)
+            query = query.Where(x => x.Created <= filter.CreatedTo.Value);
+
+        return query;
+    }
+}

src/CMSMicroservice.Application/ClubMembershipCycleHistoryCQ/Queries/GetAllClubMembershipCycleHistoryByFilter/GetAllClubMembershipCycleHistoryByFilterQuery.cs

@@ -0,0 +1,45 @@
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.ClubMembershipCycleHistoryCQ.Queries.GetAllClubMembershipCycleHistoryByFilter;
+
+public record GetAllClubMembershipCycleHistoryByFilterQuery : IRequest<GetAllClubMembershipCycleHistoryByFilterResponseDto>
+{
+    public PaginationState? PaginationState { get; init; }
+    public string? SortBy { get; init; }
+    public GetAllClubMembershipCycleHistoryByFilterFilter? Filter { get; init; }
+}
+
+public class GetAllClubMembershipCycleHistoryByFilterFilter
+{
+    public long? UserId { get; set; }
+    public long? ClubMembershipCycleId { get; set; }
+    public int? CycleNumber { get; set; }
+    public ClubMembershipCycleAction? Action { get; set; }
+    public DateTime? CreatedFrom { get; set; }
+    public DateTime? CreatedTo { get; set; }
+}
+
+public class GetAllClubMembershipCycleHistoryByFilterResponseDto
+{
+    public MetaData MetaData { get; set; }
+    public List<GetAllClubMembershipCycleHistoryByFilterResponseModel>? Models { get; set; }
+}
+
+public class GetAllClubMembershipCycleHistoryByFilterResponseModel
+{
+    public long Id { get; set; }
+    public long ClubMembershipCycleId { get; set; }
+    public long UserId { get; set; }
+    public string UserName { get; set; } = string.Empty;
+    public int CycleNumber { get; set; }
+    public bool OldIsCurrentCycle { get; set; }
+    public bool NewIsCurrentCycle { get; set; }
+    public DateTime? OldMagicStartedAt { get; set; }
+    public DateTime? NewMagicStartedAt { get; set; }
+    public DateTime? OldMagicCompletedAt { get; set; }
+    public DateTime? NewMagicCompletedAt { get; set; }
+    public ClubMembershipCycleAction Action { get; set; }
+    public string? PerformedBy { get; set; }
+    public string? Reason { get; set; }
+    public DateTimeOffset Created { get; set; }
+}

src/CMSMicroservice.Application/ClubMembershipCycleHistoryCQ/Queries/GetAllClubMembershipCycleHistoryByFilter/GetAllClubMembershipCycleHistoryByFilterQueryHandler.cs

@@ -0,0 +1,52 @@
+namespace CMSMicroservice.Application.ClubMembershipCycleHistoryCQ.Queries.GetAllClubMembershipCycleHistoryByFilter;
+
+public class GetAllClubMembershipCycleHistoryByFilterQueryHandler
+    : IRequestHandler<GetAllClubMembershipCycleHistoryByFilterQuery, GetAllClubMembershipCycleHistoryByFilterResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetAllClubMembershipCycleHistoryByFilterQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetAllClubMembershipCycleHistoryByFilterResponseDto> Handle(
+        GetAllClubMembershipCycleHistoryByFilterQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.ClubMembershipCycleHistories
+            .Include(x => x.ClubMembershipCycle)
+                .ThenInclude(c => c!.User)
+            .AsNoTracking()
+            .ApplyClubMembershipCycleHistoryFilter(request.Filter)
+            .ApplyOrder(sortBy: request.SortBy ?? "-Created");
+
+        return new GetAllClubMembershipCycleHistoryByFilterResponseDto
+        {
+            MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
+            Models = await query
+                .PaginatedListAsync(paginationState: request.PaginationState)
+                .Select(x => new GetAllClubMembershipCycleHistoryByFilterResponseModel
+                {
+                    Id = x.Id,
+                    ClubMembershipCycleId = x.ClubMembershipCycleId,
+                    UserId = x.UserId,
+                    UserName = x.ClubMembershipCycle != null && x.ClubMembershipCycle.User != null
+                        ? $"{x.ClubMembershipCycle.User.FirstName} {x.ClubMembershipCycle.User.LastName}"
+                        : string.Empty,
+                    CycleNumber = x.CycleNumber,
+                    OldIsCurrentCycle = x.OldIsCurrentCycle,
+                    NewIsCurrentCycle = x.NewIsCurrentCycle,
+                    OldMagicStartedAt = x.OldMagicStartedAt,
+                    NewMagicStartedAt = x.NewMagicStartedAt,
+                    OldMagicCompletedAt = x.OldMagicCompletedAt,
+                    NewMagicCompletedAt = x.NewMagicCompletedAt,
+                    Action = x.Action,
+                    PerformedBy = x.PerformedBy,
+                    Reason = x.Reason,
+                    Created = x.Created
+                })
+                .ToListAsync(cancellationToken)
+        };
+    }
+}

src/CMSMicroservice.Application/CommissionCQ/Commands/BulkCreditPayouts/BulkCreditPayoutsCommand.cs

@@ -0,0 +1,12 @@
+namespace CMSMicroservice.Application.CommissionCQ.Commands.BulkCreditPayouts;
+
+public class BulkCreditPayoutsCommand : IRequest<BulkCreditPayoutsResult>
+{
+    public long WeekDefinitionId { get; set; }
+}
+
+public class BulkCreditPayoutsResult
+{
+    public int CreditedCount { get; set; }
+    public long TotalCredited { get; set; }
+}

src/CMSMicroservice.Application/CommissionCQ/Commands/BulkCreditPayouts/BulkCreditPayoutsCommandHandler.cs

@@ -0,0 +1,82 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Domain.Entities.Commission;
+using CMSMicroservice.Domain.Entities.History;
+using CMSMicroservice.Domain.Enums;
+using Microsoft.Extensions.Logging;
+
+namespace CMSMicroservice.Application.CommissionCQ.Commands.BulkCreditPayouts;
+
+public class BulkCreditPayoutsCommandHandler : IRequestHandler<BulkCreditPayoutsCommand, BulkCreditPayoutsResult>
+{
+    private readonly IApplicationDbContext _context;
+    private readonly ICurrentUserService _currentUser;
+    private readonly ILogger<BulkCreditPayoutsCommandHandler> _logger;
+
+    public BulkCreditPayoutsCommandHandler(
+        IApplicationDbContext context,
+        ICurrentUserService currentUser,
+        ILogger<BulkCreditPayoutsCommandHandler> logger)
+    {
+        _context = context;
+        _currentUser = currentUser;
+        _logger = logger;
+    }
+
+    public async Task<BulkCreditPayoutsResult> Handle(BulkCreditPayoutsCommand request, CancellationToken cancellationToken)
+    {
+        var pendingPayouts = await _context.UserCommissionPayouts
+            .Where(p => p.WeekDefinitionId == request.WeekDefinitionId
+                     && p.Status == CommissionPayoutStatus.Pending
+                     && !p.IsDeleted)
+            .ToListAsync(cancellationToken);
+
+        if (!pendingPayouts.Any())
+        {
+            return new BulkCreditPayoutsResult { CreditedCount = 0, TotalCredited = 0 };
+        }
+
+        var performedBy = _currentUser.GetPerformedBy() ?? "System";
+        var now = DateTime.UtcNow;
+
+        var payoutHistories = new List<CommissionPayoutHistory>();
+        var creditedCount = 0;
+        long totalCredited = 0;
+
+        foreach (var payout in pendingPayouts)
+        {
+            payout.Status = CommissionPayoutStatus.Paid;
+            payout.PaidAt = now;
+            payout.LastModified = now;
+
+            payoutHistories.Add(new CommissionPayoutHistory
+            {
+                UserCommissionPayoutId = payout.Id, 
+                UserId = payout.UserId,
+                WeekDefinitionId = payout.WeekDefinitionId,
+                AmountBefore = payout.TotalAmount,
+                AmountAfter = payout.TotalAmount,
+                OldStatus = CommissionPayoutStatus.Pending,
+                NewStatus = CommissionPayoutStatus.Paid,
+                Action = CommissionPayoutAction.Paid,
+                PerformedBy = performedBy,
+                Reason = $"تایید پرداخت دسته‌جمعی کمیسیون هفته {payout.WeekDefinitionId} توسط {performedBy}"
+            });
+
+            creditedCount++;
+            totalCredited += payout.TotalAmount;
+        }
+
+        await _context.CommissionPayoutHistories.AddRangeAsync(payoutHistories, cancellationToken);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "BulkCreditPayouts completed: Week={WeekId}, Credited={Count}, TotalAmount={Total}, By={By}",
+            request.WeekDefinitionId, creditedCount, totalCredited, performedBy);
+
+        return new BulkCreditPayoutsResult
+        {
+            CreditedCount = creditedCount,
+            TotalCredited = totalCredited
+        };
+    }
+}

src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyBalances/CalculateWeeklyBalancesCommandHandler.cs

@@ -266,12 +266,16 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
 
         var count = 0;
 
-        // اگر فرزند در این هفته پکیج خریده (Cycle جدید ساخته شده)، 1 امتیاز
-        // ⚠️ از ClubMembershipCycle.PackagePurchasedAt استفاده میکنیم (نه ActivatedAt که overwrite میشد)
-        var currentCycle = await _context.ClubMembershipCycles
-            .FirstOrDefaultAsync(x => x.UserId == child.Id && x.IsCurrentCycle, cancellationToken);
+        // ⭐ بر اساس بازه تاریخی هفته، نه IsCurrentCycle
+        // IsCurrentCycle فقط آخرین خرید را نشان می‌دهد — برای تاریخچه‌ای (هفته‌های گذشته)
+        // باید از PackagePurchasedAt استفاده کرد که تاریخ دقیق خرید را نگه می‌دارد
+        var hadCycleInWeek = await _context.ClubMembershipCycles
+            .AnyAsync(x => x.UserId == child.Id
+                && x.PackagePurchasedAt >= startDate
+                && x.PackagePurchasedAt <= endDate,
+                cancellationToken);
 
-        if (currentCycle?.PackagePurchasedAt >= startDate && currentCycle?.PackagePurchasedAt <= endDate)
+        if (hadCycleInWeek)
         {
             count = 1;
         }

src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommand.cs

@@ -10,6 +10,11 @@ public record CalculateWeeklyCommissionPoolCommand : IRequest<long>
     /// </summary>
     public long WeekDefinitionId { get; init; } 
 
+    /// <summary>
+    /// شناسه پکیج — اگر مقدار داشته باشد فقط همین پکیج محاسبه می‌شود.
+    /// </summary>
+    public long? PackageId { get; init; }
+
     /// <summary>
     /// آیا محاسبه مجدد انجام شود؟
     /// </summary>

src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommandHandler.cs

@@ -23,8 +23,17 @@ public class CalculateWeeklyCommissionPoolCommandHandler : IRequestHandler<Calcu
         }
         
         // بررسی وجود استخر
-        var existingPool = await _context.WeeklyCommissionPools
-            .FirstOrDefaultAsync(x => x.WeekDefinitionId == request.WeekDefinitionId, cancellationToken);
+        var existingPoolQuery = _context.WeeklyCommissionPools
+            .Where(x => x.WeekDefinitionId == request.WeekDefinitionId);
+
+        if (request.PackageId.HasValue)
+        {
+            existingPoolQuery = existingPoolQuery.Where(x => x.PackageId == request.PackageId.Value);
+        }
+
+        var existingPool = await existingPoolQuery
+            .OrderBy(x => x.Id)
+            .FirstOrDefaultAsync(cancellationToken);
 
         if (existingPool == null)
         {
@@ -40,9 +49,15 @@ public class CalculateWeeklyCommissionPoolCommandHandler : IRequestHandler<Calcu
         }
 
         // بررسی وجود تعادل‌های هفتگی
-        var weeklyBalances = await _context.NetworkWeeklyBalances
-            .Where(x => x.WeekDefinitionId == request.WeekDefinitionId)
-            .ToListAsync(cancellationToken);
+        var weeklyBalancesQuery = _context.NetworkWeeklyBalances
+            .Where(x => x.WeekDefinitionId == request.WeekDefinitionId);
+
+        if (request.PackageId.HasValue)
+        {
+            weeklyBalancesQuery = weeklyBalancesQuery.Where(x => x.PackageId == request.PackageId.Value);
+        }
+
+        var weeklyBalances = await weeklyBalancesQuery.ToListAsync(cancellationToken);
 
         if (!weeklyBalances.Any())
         {
@@ -76,9 +91,15 @@ public class CalculateWeeklyCommissionPoolCommandHandler : IRequestHandler<Calcu
         // حذف پرداخت‌های قبلی در صورت ForceRecalculate
         if (request.ForceRecalculate)
         {
-            var oldPayouts = await _context.UserCommissionPayouts
-                .Where(p => p.WeekDefinitionId == request.WeekDefinitionId)
-                .ToListAsync(cancellationToken);
+            var oldPayoutsQuery = _context.UserCommissionPayouts
+                .Where(p => p.WeekDefinitionId == request.WeekDefinitionId);
+
+            if (request.PackageId.HasValue)
+            {
+                oldPayoutsQuery = oldPayoutsQuery.Where(p => p.PackageId == request.PackageId.Value);
+            }
+
+            var oldPayouts = await oldPayoutsQuery.ToListAsync(cancellationToken);
             
             if (oldPayouts.Any())
             {

src/CMSMicroservice.Application/CommissionCQ/Commands/RequestWithdrawal/RequestWithdrawalCommandHandler.cs

@@ -1,3 +1,5 @@
+using CMSMicroservice.Application.Common;
+
 namespace CMSMicroservice.Application.CommissionCQ.Commands.RequestWithdrawal;
 
 public class RequestWithdrawalCommandHandler : IRequestHandler<RequestWithdrawalCommand, Unit>
@@ -37,7 +39,10 @@ public class RequestWithdrawalCommandHandler : IRequestHandler<RequestWithdrawal
 
         if (request.Method == WithdrawalMethod.Cash)
         {
-            payout.IbanNumber = request.IbanNumber;
+            var normalizedIban = IbanNormalizer.TryNormalize(request.IbanNumber);
+            if (normalizedIban is null)
+                throw new InvalidOperationException("فرمت شماره شبا معتبر نیست. باید IR و ۲۴ رقم باشد.");
+            payout.IbanNumber = normalizedIban;
         }
 
         _context.UserCommissionPayouts.Update(payout);

src/CMSMicroservice.Application/CommissionCQ/Queries/GetUserWeeklyBalances/GetUserWeeklyBalancesQueryHandler.cs

@@ -15,75 +15,49 @@ public class GetUserWeeklyBalancesQueryHandler : IRequestHandler<GetUserWeeklyBa
 
     public async Task<GetUserWeeklyBalancesResponseDto> Handle(GetUserWeeklyBalancesQuery request, CancellationToken cancellationToken)
     {
-        var query = _context.NetworkWeeklyBalances
-            .Include(x => x.WeekDefinition)
-            .Include(x => x.User)
-            .Include(x => x.Package)
-            .AsNoTracking()
-            .AsQueryable();
+        var pageSize   = request.PaginationState?.PageSize   > 0 ? request.PaginationState.PageSize   : PaginationDefaults.PageSize;
+        var pageNumber = request.PaginationState?.PageNumber > 0 ? request.PaginationState.PageNumber : PaginationDefaults.PageNumber;
 
-        // UserId > 0 → filter by that user
-        // UserId == 0 or null → show ALL users (admin mode)
-        // Customer endpoints resolve UserId from JWT before calling this handler
-        long? userId = request.UserId;
+        // تشخیص جهت مرتب‌سازی از SortBy (پیش‌فرض: نزولی)
+        var sortBy         = request.SortBy ?? "-WeekDefinitionId";
+        int sortDescending = sortBy.StartsWith("-") ? 1 : 0;
 
-        if (userId.HasValue && userId.Value > 0)
-        {
-            query = query.Where(x => x.UserId == userId.Value);
-        }
+        long? userId          = request.UserId.HasValue && request.UserId.Value > 0 ? request.UserId : null;
+        long? weekDefinitionId = request.WeekDefinitionId.HasValue ? request.WeekDefinitionId : null;
+        long? packageId       = request.PackageId.HasValue && request.PackageId.Value > 0 ? request.PackageId : null;
+        int   onlyActive      = request.OnlyActive.HasValue && request.OnlyActive.Value ? 1 : 0;
 
-        // فیلتر بر اساس WeekDefinitionId (روش ترجیحی)
-        if (request.WeekDefinitionId.HasValue)
-        {
-            query = query.Where(x => x.WeekDefinitionId == request.WeekDefinitionId.Value);
-        }
-    
-
-        if (request.OnlyActive.HasValue && request.OnlyActive.Value)
-        {
-            query = query.Where(x => !x.IsExpired);
-        }
-
-        // فیلتر بر اساس پکیج
-        if (request.PackageId.HasValue && request.PackageId.Value > 0)
-        {
-            query = query.Where(x => x.PackageId == request.PackageId.Value);
-        }
-
-        // مرتب‌سازی بر اساس WeekDefinitionId (نزولی = جدیدترین اول)
-        query = query.ApplyOrder(sortBy: request.SortBy ?? "-WeekDefinitionId");
-
-        var meta = await query.GetMetaData(request.PaginationState, cancellationToken);
-
-        var models = await query
-            .PaginatedListAsync(paginationState: request.PaginationState)
-            .Select(x => new GetUserWeeklyBalancesResponseModel
-            {
-                Id = x.Id,
-                UserId = x.UserId,
-                UserFullName = x.User != null ? $"{x.User.FirstName} {x.User.LastName}".Trim() : "",
-                WeekDefinitionId = x.WeekDefinitionId,
-                WeekDisplayName = x.WeekDefinition != null ? x.WeekDefinition.DisplayName : "",
-                LeftLegNewMembers = x.LeftLegNewMembers,
-                LeftLegCarryover = x.LeftLegCarryover,
-                LeftLegTotal = x.LeftLegTotal,
-                RightLegNewMembers = x.RightLegNewMembers,
-                RightLegCarryover = x.RightLegCarryover,
-                RightLegTotal = x.RightLegTotal,
-                TotalBalances = x.TotalBalances,
-                WeeklyPoolContribution = x.WeeklyPoolContribution,
-                CalculatedAt = x.CalculatedAt,
-                IsExpired = x.IsExpired,
-                Created = x.Created,
-                PackageId = x.PackageId,
-                PackageTitle = x.Package != null ? x.Package.Title : ""
-            })
+        var rows = await _context.Database
+            .SqlQuery<GetUserWeeklyBalancesResponseModel>(
+                $"""
+                EXEC [CMS].[sp_GetUserWeeklyBalances]
+                    @UserId           = {userId},
+                    @WeekDefinitionId = {weekDefinitionId},
+                    @PackageId        = {packageId},
+                    @OnlyActive       = {onlyActive},
+                    @SortDescending   = {sortDescending},
+                    @PageNumber       = {pageNumber},
+                    @PageSize         = {pageSize}
+                """)
             .ToListAsync(cancellationToken);
 
+        var totalCount     = rows.Count > 0 ? rows[0].TotalCount : 0;
+        var totalPageCount = (int)Math.Ceiling(totalCount / (double)pageSize);
+
+        var meta = new MetaData
+        {
+            CurrentPage  = pageNumber,
+            PageSize     = pageSize,
+            TotalCount   = totalCount,
+            TotalPage    = totalPageCount,
+            HasNext      = pageNumber < totalPageCount,
+            HasPrevious  = pageNumber > 1
+        };
+
         return new GetUserWeeklyBalancesResponseDto
         {
             MetaData = meta,
-            Models = models
+            Models   = rows
         };
     }
 }

src/CMSMicroservice.Application/CommissionCQ/Queries/GetUserWeeklyBalances/GetUserWeeklyBalancesResponseDto.cs

@@ -33,4 +33,7 @@ public class GetUserWeeklyBalancesResponseModel
     // Package info
     public long PackageId { get; set; }
     public string PackageTitle { get; set; } = string.Empty;
+
+    // نتیجه COUNT(*) OVER() از SP — فقط در خواندن از SP پر می‌شود
+    public int TotalCount { get; set; }
 }

src/CMSMicroservice.Application/CommissionCQ/Queries/GetWeeklyCommissionPool/GetWeeklyCommissionPoolQueryHandler.cs

@@ -41,6 +41,61 @@ public class GetWeeklyCommissionPoolQueryHandler : IRequestHandler<GetWeeklyComm
             })
             .FirstOrDefaultAsync(cancellationToken);
 
-        return pool ?? new WeeklyCommissionPoolDto();
+        pool ??= new WeeklyCommissionPoolDto();
+
+        // ── Q29: اعتبارسنجی TotalPoolAmount در برابر فعال‌سازی‌های واقعی ──
+        await ValidatePoolAmountAsync(pool, request, cancellationToken);
+
+        return pool;
+    }
+
+    /// <summary>
+    /// TotalPoolAmount استخر را با تعداد فعال‌سازی‌های ثبت‌شده (AcceptContract + ActivateClubMembership) مقایسه می‌کند.
+    /// نتیجه در فیلدهای Validation... ذخیره می‌شود.
+    /// </summary>
+    private async Task ValidatePoolAmountAsync(WeeklyCommissionPoolDto pool, GetWeeklyCommissionPoolQuery request, CancellationToken cancellationToken)
+    {
+        var packageId = pool.PackageId > 0 ? pool.PackageId : request.PackageId;
+        if (packageId is null or 0)
+            return;
+
+        var weekDef = _weekDefinitionRepository.GetWeekById(request.WeekDefinitionId);
+        if (weekDef is null)
+            return;
+
+        var activationFee = await _context.Packages
+            .AsNoTracking()
+            .Where(p => p.Id == packageId.Value)
+            .Select(p => p.ActivationFee)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (activationFee <= 0)
+            return;
+
+        // شمارش Cycle‌هایی که Pool آن‌ها واقعاً شارژ شده:
+        //   - عضو جدید: Pool توسط AcceptContract شارژ می‌شود → UserContract وجود دارد
+        //   - خرید مجدد: Pool در ActivateClubMembership شارژ می‌شود → IsCurrentCycle نبوده (قبلاً active بوده)
+        //   - نباید از IsActive استفاده شود: وضعیت تاریخی نیست (عضو ممکن است بعداً غیرفعال شده باشد)
+        //
+        // قانون: Cycle شارژ شده = یا قرارداد دارد (عضو جدید) یا IsActive قبلاً true بوده (خرید مجدد)
+        // ساده‌ترین معادل: Cycle هایی که ClubMembership.ActivatedAt در بازه هفته است (زمان واقعی شارژ Pool)
+        var totalActivations = await _context.ClubMembershipCycles
+            .AsNoTracking()
+            .Where(c => c.PackageId == packageId.Value
+                && c.PackagePurchasedAt >= weekDef.StartDate
+                && c.PackagePurchasedAt < weekDef.EndDate
+                && _context.UserContracts.Any(uc =>
+                    uc.UserId == c.UserId
+                    && _context.Contracts.Any(con =>
+                        con.Id == uc.ContractId
+                        && con.Type == ContractType.ClubMembership)))
+            .CountAsync(cancellationToken);
+
+        var expectedAmount = (long)totalActivations * activationFee;
+
+        pool.ValidationActivationCount = totalActivations;
+        pool.ValidationExpectedAmount = expectedAmount;
+        pool.ValidationDiscrepancy = pool.TotalPoolAmount - expectedAmount;
+        pool.ValidationIsValid = pool.TotalPoolAmount == expectedAmount;
     }
 }

src/CMSMicroservice.Application/CommissionCQ/Queries/GetWeeklyCommissionPool/WeeklyCommissionPoolDto.cs

@@ -16,4 +16,14 @@ public class WeeklyCommissionPoolDto
     public DateTimeOffset Created { get; set; }
     public long PackageId { get; set; }
     public string PackageTitle { get; set; } = string.Empty;
+
+    // ── Validation Fields (Q29) ──
+    /// <summary>آیا TotalPoolAmount با تعداد فعال‌سازی‌های ثبت‌شده در دیتابیس مطابقت دارد؟</summary>
+    public bool ValidationIsValid { get; set; } = true;
+    /// <summary>مبلغ مورد انتظار بر اساس شمارش فعال‌سازی‌ها × ActivationFee</summary>
+    public long ValidationExpectedAmount { get; set; }
+    /// <summary>اختلاف: TotalPoolAmount - ValidationExpectedAmount</summary>
+    public long ValidationDiscrepancy { get; set; }
+    /// <summary>تعداد فعال‌سازی‌های شناسایی‌شده برای این هفته و پکیج</summary>
+    public int ValidationActivationCount { get; set; }
 }

src/CMSMicroservice.Application/Common/BlogSlugHelper.cs

@@ -0,0 +1,85 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace CMSMicroservice.Application.Common;
+
+public static class BlogSlugHelper
+{
+    private const int MaxSlugLength = 200;
+
+    public static string? NormalizeOptional(string? slug)
+    {
+        if (string.IsNullOrWhiteSpace(slug))
+            return null;
+
+        return slug.Trim().ToLowerInvariant();
+    }
+
+    /// <summary>
+    /// Builds a URL slug from title (ASCII letters/digits). Persian-only titles yield empty string.
+    /// </summary>
+    public static string GenerateFromTitle(string title)
+    {
+        if (string.IsNullOrWhiteSpace(title))
+            return string.Empty;
+
+        var sb = new System.Text.StringBuilder();
+        var lastWasHyphen = false;
+
+        foreach (var c in title.Trim().ToLowerInvariant())
+        {
+            if (c is >= 'a' and <= 'z' or >= '0' and <= '9')
+            {
+                sb.Append(c);
+                lastWasHyphen = false;
+            }
+            else if (c is ' ' or '_' or '-')
+            {
+                if (sb.Length > 0 && !lastWasHyphen)
+                {
+                    sb.Append('-');
+                    lastWasHyphen = true;
+                }
+            }
+        }
+
+        var result = sb.ToString().Trim('-');
+        return result.Length > MaxSlugLength ? result[..MaxSlugLength].TrimEnd('-') : result;
+    }
+
+    public static string CreateFallbackSlug() =>
+        $"post-{Guid.NewGuid():N}"[..Math.Min(20, MaxSlugLength)];
+
+    public static string ResolveForCreate(string? requestedSlug, string title)
+    {
+        var normalized = NormalizeOptional(requestedSlug);
+        if (!string.IsNullOrEmpty(normalized))
+            return normalized;
+
+        var fromTitle = GenerateFromTitle(title);
+        return !string.IsNullOrEmpty(fromTitle) ? fromTitle : CreateFallbackSlug();
+    }
+
+    public static async Task<string> EnsureUniquePostSlugAsync(
+        IApplicationDbContext context,
+        string slug,
+        long? excludePostId = null,
+        CancellationToken cancellationToken = default)
+    {
+        var candidate = slug;
+        var suffix = 2;
+
+        while (await context.BlogPosts.AnyAsync(
+            p => p.Slug == candidate && !p.IsDeleted && (excludePostId == null || p.Id != excludePostId.Value),
+            cancellationToken))
+        {
+            var suffixStr = $"-{suffix}";
+            var maxBase = MaxSlugLength - suffixStr.Length;
+            var basePart = slug.Length > maxBase ? slug[..maxBase].TrimEnd('-') : slug;
+            candidate = basePart + suffixStr;
+            suffix++;
+        }
+
+        return candidate;
+    }
+}

src/CMSMicroservice.Application/Common/Exceptions/PaymentInProgressException.cs

@@ -0,0 +1,22 @@
+namespace CMSMicroservice.Application.Common.Exceptions;
+
+/// <summary>
+/// Thrown when a concurrent payment operation is already in progress for the same scope.
+/// </summary>
+public class PaymentInProgressException : Exception
+{
+    public PaymentInProgressException()
+        : base("یک عملیات پرداخت دیگر در حال پردازش است. لطفاً چند لحظه صبر کنید.")
+    {
+    }
+
+    public PaymentInProgressException(string message)
+        : base(message)
+    {
+    }
+
+    public PaymentInProgressException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

src/CMSMicroservice.Application/Common/Extensions/SortByExtensions.cs

@@ -1,3 +1,4 @@
+using System.Linq.Expressions;
 using System.Linq.Dynamic.Core;
 using CMSMicroservice.Domain.Common;
 
@@ -8,16 +9,46 @@ public static class SortByExtensions
     public static IQueryable<TSource> ApplyOrder<TSource>(this IQueryable<TSource> source,
         string? sortBy) where TSource : BaseAuditableEntity
     {
-        // default sort approach
         if (sortBy is null or "")
         {
-            source = source.OrderByDescending(p => p.Created);
-            return source;
+            return source.OrderByDescending(p => p.Created);
         }
 
-        // sort using dynamic linq
-        source = source.OrderBy(sortBy);
+        return source.OrderBy(NormalizeSortBy(sortBy));
+    }
 
-        return source;
+    /// <summary>
+    /// موجودی‌دارها اول، سپس سورت درخواستی کاربر (یا Created desc اگر SortBy خالی باشد).
+    /// </summary>
+    public static IQueryable<TSource> ApplyOrderWithInStockPriority<TSource>(
+        this IQueryable<TSource> source,
+        string? sortBy,
+        Expression<Func<TSource, bool>> isInStock) where TSource : BaseAuditableEntity
+    {
+        var ordered = source.OrderByDescending(isInStock);
+        if (string.IsNullOrWhiteSpace(sortBy))
+            return ordered.ThenByDescending(p => p.Created);
+
+        return ordered.ThenBy(NormalizeSortBy(sortBy));
+    }
+
+    /// <summary>
+    /// Dynamic LINQ treats "-Created" as unary minus on DateTime (invalid).
+    /// Project convention: leading '-' means descending sort.
+    /// </summary>
+    private static string NormalizeSortBy(string sortBy)
+    {
+        sortBy = sortBy.Trim();
+        if (sortBy.StartsWith('-') && sortBy.Length > 1)
+        {
+            return $"{sortBy[1..]} descending";
+        }
+
+        if (sortBy.StartsWith('+') && sortBy.Length > 1)
+        {
+            return $"{sortBy[1..]} ascending";
+        }
+
+        return sortBy;
     }
 }

src/CMSMicroservice.Application/Common/Helpers/ClubMembershipCycleHistoryWriter.cs

@@ -0,0 +1,54 @@
+using CMSMicroservice.Domain.Entities.Club;
+using CMSMicroservice.Domain.Entities.History;
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.Common.Helpers;
+
+public static class ClubMembershipCycleHistoryWriter
+{
+    public static void WriteCycleStarted(
+        IApplicationDbContext context,
+        ClubMembershipCycle cycle,
+        string? performedBy = "System",
+        string? reason = null)
+    {
+        context.ClubMembershipCycleHistories.Add(new ClubMembershipCycleHistory
+        {
+            ClubMembershipCycleId = cycle.Id,
+            UserId = cycle.UserId,
+            CycleNumber = cycle.CycleNumber,
+            OldIsCurrentCycle = false,
+            NewIsCurrentCycle = cycle.IsCurrentCycle,
+            OldMagicStartedAt = null,
+            NewMagicStartedAt = cycle.MagicStartedAt,
+            OldMagicCompletedAt = null,
+            NewMagicCompletedAt = cycle.MagicCompletedAt,
+            Action = ClubMembershipCycleAction.Started,
+            PerformedBy = performedBy,
+            Reason = reason
+        });
+    }
+
+    public static void WriteCycleClosed(
+        IApplicationDbContext context,
+        ClubMembershipCycle cycle,
+        string? performedBy = "System",
+        string? reason = null)
+    {
+        context.ClubMembershipCycleHistories.Add(new ClubMembershipCycleHistory
+        {
+            ClubMembershipCycleId = cycle.Id,
+            UserId = cycle.UserId,
+            CycleNumber = cycle.CycleNumber,
+            OldIsCurrentCycle = true,
+            NewIsCurrentCycle = false,
+            OldMagicStartedAt = cycle.MagicStartedAt,
+            NewMagicStartedAt = cycle.MagicStartedAt,
+            OldMagicCompletedAt = cycle.MagicCompletedAt,
+            NewMagicCompletedAt = cycle.MagicCompletedAt,
+            Action = ClubMembershipCycleAction.Completed,
+            PerformedBy = performedBy,
+            Reason = reason ?? "دوره جدید جایگزین شد"
+        });
+    }
+}

src/CMSMicroservice.Application/Common/IbanNormalizer.cs

@@ -0,0 +1,34 @@
+using System.Text.RegularExpressions;
+
+namespace CMSMicroservice.Application.Common;
+
+/// <summary>
+/// نرمال‌سازی و اعتبارسنجی شماره شبا ایران (IR + 24 رقم).
+/// </summary>
+public static class IbanNormalizer
+{
+    private static readonly Regex IranianIbanRegex = new(@"^IR\d{24}$", RegexOptions.Compiled);
+
+    /// <summary>
+    /// فاصله و خط تیره را حذف می‌کند، به حروف بزرگ تبدیل می‌کند و یک پیشوند IR می‌گذارد.
+    /// در صورت نامعتبر بودن، null برمی‌گرداند.
+    /// </summary>
+    public static string? TryNormalize(string? iban)
+    {
+        if (string.IsNullOrWhiteSpace(iban))
+            return null;
+
+        var normalized = iban.Trim().ToUpperInvariant()
+            .Replace(" ", "", StringComparison.Ordinal)
+            .Replace("-", "", StringComparison.Ordinal);
+
+        if (normalized.StartsWith("IR", StringComparison.Ordinal))
+            normalized = normalized[2..];
+
+        normalized = "IR" + normalized;
+
+        return IranianIbanRegex.IsMatch(normalized) ? normalized : null;
+    }
+
+    public static bool IsValid(string? iban) => TryNormalize(iban) is not null;
+}

src/CMSMicroservice.Application/Common/Interfaces/IPaymentGatewayService.cs

@@ -47,6 +47,17 @@ public interface IPaymentGatewayService
             "درگاه پرداخت باید متد VerifyPaymentAsync با مبلغ را پیاده‌سازی کند");
     }
     
+    /// <summary>
+    /// فهرست Authority‌هایی که کاربر پرداخت کرده ولی سیستم هنوز Verify نکرده
+    /// این متد برای Reconciliation در background job استفاده می‌شود.
+    /// پیاده‌سازی پیش‌فرض لیست خالی برمی‌گرداند (درگاه‌هایی که این API را ندارند).
+    /// </summary>
+    Task<IReadOnlyList<string>> GetUnverifiedAuthoritiesAsync(
+        CancellationToken cancellationToken = default)
+    {
+        return Task.FromResult<IReadOnlyList<string>>(Array.Empty<string>());
+    }
+
     /// <summary>
     /// واریز مبلغ به حساب کاربر (برداشت از کیف پول)
     /// </summary>

src/CMSMicroservice.Application/Common/Interfaces/IUserPaymentLock.cs

@@ -0,0 +1,32 @@
+namespace CMSMicroservice.Application.Common.Interfaces;
+
+/// <summary>
+/// Per-scope in-process mutex for payment flows (initiate / verify).
+/// Prevents the same user from running duplicate gateway operations concurrently.
+/// </summary>
+public interface IUserPaymentLock
+{
+    Task<T> ExecuteAsync<T>(
+        string scope,
+        PaymentLockStrategy strategy,
+        Func<CancellationToken, Task<T>> action,
+        CancellationToken cancellationToken = default);
+
+    Task ExecuteAsync(
+        string scope,
+        PaymentLockStrategy strategy,
+        Func<CancellationToken, Task> action,
+        CancellationToken cancellationToken = default);
+}
+
+/// <summary>
+/// How to behave when the payment lock is already held.
+/// </summary>
+public enum PaymentLockStrategy
+{
+    /// <summary>Wait up to the configured timeout (callback / verify paths).</summary>
+    WaitForRelease,
+
+    /// <summary>Reject immediately (initiate / double-click paths).</summary>
+    FailFast
+}

src/CMSMicroservice.Application/Common/PaymentLockScopes.cs

@@ -0,0 +1,19 @@
+namespace CMSMicroservice.Application.Common;
+
+/// <summary>
+/// Canonical scope keys for <see cref="Interfaces.IUserPaymentLock"/>.
+/// </summary>
+public static class PaymentLockScopes
+{
+    /// <summary>One active payment initiation per user (package, wallet charge, order, IPG deposit).</summary>
+    public static string Initiate(long userId) => $"payment:initiate:user:{userId}";
+
+    /// <summary>One active verify per user + authority/order (duplicate callback protection).</summary>
+    public static string Verify(long userId, string resourceKey)
+    {
+        if (string.IsNullOrWhiteSpace(resourceKey))
+            throw new ArgumentException("Payment verify resource key is required.", nameof(resourceKey));
+
+        return $"payment:verify:user:{userId}:{resourceKey.Trim()}";
+    }
+}

src/CMSMicroservice.Application/Common/UserDisplayName.cs

@@ -0,0 +1,29 @@
+namespace CMSMicroservice.Application.Common;
+
+/// <summary>
+/// نام نمایشی کاربر برای گزارش‌ها؛ اگر نام خالی باشد موبایل یا شناسه.
+/// </summary>
+public static class UserDisplayName
+{
+    public static string From(string? firstName, string? lastName, string? mobile, long userId)
+    {
+        var name = string.Join(" ",
+            new[] { firstName, lastName }.Where(s => !string.IsNullOrWhiteSpace(s)));
+
+        if (!string.IsNullOrWhiteSpace(name))
+            return name;
+
+        if (!string.IsNullOrWhiteSpace(mobile))
+            return mobile.Trim();
+
+        return userId > 0 ? $"کاربر {userId}" : "—";
+    }
+
+    public static string From(Domain.Entities.User? user)
+    {
+        if (user is null)
+            return string.Empty;
+
+        return From(user.FirstName, user.LastName, user.Mobile, user.Id);
+    }
+}

src/CMSMicroservice.Application/DiscountShopCQ/Commands/PlaceOrder/PlaceOrderCommandHandler.cs

@@ -1,3 +1,5 @@
+using CMSMicroservice.Application.Common;
+using CMSMicroservice.Application.Common.Exceptions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Services;
 using CMSMicroservice.Domain.Entities.DiscountShop;
@@ -17,22 +19,32 @@ public class PlaceOrderCommandHandler : IRequestHandler<PlaceOrderCommand, Place
     private readonly IPaymentGatewayService _paymentGateway;
     private readonly IConfiguration _configuration;
     private readonly ILogger<PlaceOrderCommandHandler> _logger;
+    private readonly IUserPaymentLock _paymentLock;
 
     public PlaceOrderCommandHandler(
         IApplicationDbContext context,
         IInventoryService inventoryService,
         IPaymentGatewayService paymentGateway,
         IConfiguration configuration,
-        ILogger<PlaceOrderCommandHandler> logger)
+        ILogger<PlaceOrderCommandHandler> logger,
+        IUserPaymentLock paymentLock)
     {
         _context = context;
         _inventoryService = inventoryService;
         _paymentGateway = paymentGateway;
         _configuration = configuration;
         _logger = logger;
+        _paymentLock = paymentLock;
     }
 
-    public async Task<PlaceOrderResponseDto> Handle(PlaceOrderCommand request, CancellationToken cancellationToken)
+    public Task<PlaceOrderResponseDto> Handle(PlaceOrderCommand request, CancellationToken cancellationToken) =>
+        _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Initiate(request.UserId),
+            PaymentLockStrategy.FailFast,
+            ct => HandleCore(request, ct),
+            cancellationToken);
+
+    private async Task<PlaceOrderResponseDto> HandleCore(PlaceOrderCommand request, CancellationToken cancellationToken)
     {
         // Get user wallet
         var userWallet = await _context.UserWallets

src/CMSMicroservice.Application/DiscountShopCQ/Commands/UpdateOrderStatus/UpdateOrderStatusCommandHandler.cs

@@ -35,6 +35,11 @@ public class UpdateOrderStatusCommandHandler : IRequestHandler<UpdateOrderStatus
             order.TrackingCode = request.TrackingCode;
         }
 
+        if (!string.IsNullOrEmpty(request.AdminNotes))
+        {
+            order.DeliveryDescription = request.AdminNotes;
+        }
+
         await _context.SaveChangesAsync(cancellationToken);
 
         return new UpdateOrderStatusResponseDto

src/CMSMicroservice.Application/DiscountShopCQ/Queries/GetAllDiscountOrders/GetAllDiscountOrdersQueryHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
 using MediatR;
@@ -80,35 +81,58 @@ public class GetAllDiscountOrdersQueryHandler : IRequestHandler<GetAllDiscountOr
         // Apply pagination
         var pagination = request.PaginationQuery ?? new PaginationState { PageNumber = 1, PageSize = 20 };
 
-        var orders = await query
+        var rows = await query
             .OrderByDescending(o => o.Created)
             .Skip((pagination.PageNumber - 1) * pagination.PageSize)
             .Take(pagination.PageSize)
-            .Select(o => new AdminOrderDto
+            .Select(o => new
             {
-                Id = o.Id,
-                UserId = o.UserId,
-                UserFullName = (o.User.FirstName ?? "") + " " + (o.User.LastName ?? ""),
-                UserMobile = o.User.Mobile,
-                TotalAmount = o.TotalAmount,
-                DiscountBalanceUsed = o.DiscountBalanceUsed,
-                GatewayAmountPaid = o.GatewayAmountPaid,
-                VatAmount = o.VatAmount,
-                PaymentStatus = o.PaymentStatus,
-                PaymentDate = o.PaymentDate,
-                DeliveryStatus = o.DeliveryStatus,
-                DeliveryDate = null, // TODO: Add DeliveryDate to DiscountOrder if needed
+                o.Id,
+                o.UserId,
+                FirstName = o.User.FirstName,
+                LastName = o.User.LastName,
+                Mobile = o.User.Mobile,
+                o.TotalAmount,
+                o.DiscountBalanceUsed,
+                o.GatewayAmountPaid,
+                o.VatAmount,
+                o.PaymentStatus,
+                o.PaymentDate,
+                o.DeliveryStatus,
                 ShippingAddress = o.UserAddress.Address,
                 ReceiverName = o.UserAddress.Title,
-                ReceiverMobile = o.User.Mobile,
-                TrackingCode = o.TrackingCode,
+                o.TrackingCode,
                 AdminNote = o.DeliveryDescription,
-                Created = o.Created,
-                LastModified = o.LastModified,
+                o.Created,
+                o.LastModified,
                 ItemsCount = o.OrderDetails.Count
             })
             .ToListAsync(cancellationToken);
 
+        var orders = rows.Select(o => new AdminOrderDto
+        {
+            Id = o.Id,
+            UserId = o.UserId,
+            UserFullName = UserDisplayName.From(o.FirstName, o.LastName, o.Mobile, o.UserId),
+            UserMobile = o.Mobile,
+            TotalAmount = o.TotalAmount,
+            DiscountBalanceUsed = o.DiscountBalanceUsed,
+            GatewayAmountPaid = o.GatewayAmountPaid,
+            VatAmount = o.VatAmount,
+            PaymentStatus = o.PaymentStatus,
+            PaymentDate = o.PaymentDate,
+            DeliveryStatus = o.DeliveryStatus,
+            DeliveryDate = null,
+            ShippingAddress = o.ShippingAddress,
+            ReceiverName = o.ReceiverName,
+            ReceiverMobile = o.Mobile,
+            TrackingCode = o.TrackingCode,
+            AdminNote = o.AdminNote,
+            Created = o.Created,
+            LastModified = o.LastModified,
+            ItemsCount = o.ItemsCount
+        }).ToList();
+
         return new GetAllDiscountOrdersResponseDto
         {
             MetaData = new MetaData

src/CMSMicroservice.Application/DiscountShopCQ/Queries/GetDiscountProducts/GetDiscountProductsQuery.cs

@@ -8,9 +8,14 @@ public class GetDiscountProductsQuery : IRequest<GetDiscountProductsResponseDto>
     public PaginationState? PaginationQuery { get; set; }
     public long? CategoryId { get; set; }
     public string? SearchTerm { get; set; }
+    /// <summary>
+    /// true = فقط موجود (RemainingCount &gt; 0)، false = فقط ناموجود
+    /// </summary>
+    public bool? InStock { get; set; }
     public bool? IsActive { get; set; }
     public int? MinPrice { get; set; }
     public int? MaxPrice { get; set; }
+    public string? SortBy { get; set; }
 }
 
 public class GetDiscountProductsResponseDto

src/CMSMicroservice.Application/DiscountShopCQ/Queries/GetDiscountProducts/GetDiscountProductsQueryHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common.Extensions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
 using MediatR;
@@ -41,6 +42,11 @@ public class GetDiscountProductsQueryHandler : IRequestHandler<GetDiscountProduc
             query = query.Where(p => p.IsActive == request.IsActive.Value);
         }
 
+        if (request.InStock == true)
+            query = query.Where(p => p.RemainingCount > 0);
+        else if (request.InStock == false)
+            query = query.Where(p => p.RemainingCount <= 0);
+
         if (request.MinPrice.HasValue)
         {
             query = query.Where(p => p.Price >= request.MinPrice.Value);
@@ -51,13 +57,14 @@ public class GetDiscountProductsQueryHandler : IRequestHandler<GetDiscountProduc
             query = query.Where(p => p.Price <= request.MaxPrice.Value);
         }
 
+        // موجودی‌دارها اول، سپس سورت درخواستی
+        query = query.ApplyOrderWithInStockPriority(request.SortBy, p => p.RemainingCount > 0);
+
         var totalCount = await query.CountAsync(cancellationToken);
 
-        // Apply pagination
         var pagination = request.PaginationQuery ?? new PaginationState { PageNumber = 1, PageSize = 10 };
-        
+
         var products = await query
-            .OrderByDescending(p => p.Created)
             .Skip((pagination.PageNumber - 1) * pagination.PageSize)
             .Take(pagination.PageSize)
             .Select(p => new DiscountProductDto

src/CMSMicroservice.Application/DiscountShopCQ/Queries/GetOrderById/GetOrderByIdQuery.cs

@@ -6,7 +6,7 @@ namespace CMSMicroservice.Application.DiscountShopCQ.Queries.GetOrderById;
 public class GetOrderByIdQuery : IRequest<OrderDetailDto?>
 {
     public long OrderId { get; set; }
-    public long UserId { get; set; }
+    public long? UserId { get; set; }
 }
 
 public class OrderDetailDto
@@ -32,6 +32,8 @@ public class UserAddressDto
     public string Title { get; set; }
     public string Address { get; set; }
     public string PostalCode { get; set; }
+    /// <summary>شماره تماس سفارش‌دهنده (موبایل کاربر) برای برچسب پست</summary>
+    public string? Phone { get; set; }
 }
 
 public class OrderItemDto

src/CMSMicroservice.Application/DiscountShopCQ/Queries/GetOrderById/GetOrderByIdQueryHandler.cs

@@ -15,9 +15,17 @@ public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, Order
 
     public async Task<OrderDetailDto?> Handle(GetOrderByIdQuery request, CancellationToken cancellationToken)
     {
-        var order = await _context.DiscountOrders
-            .Where(o => o.Id == request.OrderId && o.UserId == request.UserId)
+        var query = _context.DiscountOrders
+            .Where(o => o.Id == request.OrderId);
+
+        if (request.UserId.HasValue && request.UserId.Value > 0)
+        {
+            query = query.Where(o => o.UserId == request.UserId.Value);
+        }
+
+        var order = await query
             .Include(o => o.UserAddress)
+            .Include(o => o.User)
             .Include(o => o.OrderDetails)
                 .ThenInclude(od => od.Product)
             .FirstOrDefaultAsync(cancellationToken);
@@ -43,7 +51,8 @@ public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, Order
             {
                 Title = order.UserAddress.Title,
                 Address = order.UserAddress.Address,
-                PostalCode = order.UserAddress.PostalCode
+                PostalCode = order.UserAddress.PostalCode,
+                Phone = order.User?.Mobile
             },
             Items = order.OrderDetails.Select(od => new OrderItemDto
             {

src/CMSMicroservice.Application/ManualPaymentCQ/Commands/CreateManualPayment/CreateManualPaymentCommandHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.ClubMembershipCQ.Commands.ActivateClubMembership;
 using CMSMicroservice.Application.Common.Exceptions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Common;
@@ -14,15 +15,18 @@ public class CreateManualPaymentCommandHandler : IRequestHandler<CreateManualPay
 {
     private readonly IApplicationDbContext _context;
     private readonly ICurrentUserService _currentUser;
+    private readonly ISender _sender;
     private readonly ILogger<CreateManualPaymentCommandHandler> _logger;
 
     public CreateManualPaymentCommandHandler(
         IApplicationDbContext context,
         ICurrentUserService currentUser,
+        ISender sender,
         ILogger<CreateManualPaymentCommandHandler> logger)
     {
         _context = context;
         _currentUser = currentUser;
+        _sender = sender;
         _logger = logger;
     }
 
@@ -146,12 +150,45 @@ public class CreateManualPaymentCommandHandler : IRequestHandler<CreateManualPay
 
             await _context.UserWalletHistories.AddAsync(walletLog, cancellationToken);
 
-            // 9. تنظیم روش خرید پکیج
-            user.PackagePurchaseMethod = PackagePurchaseMethod.DirectPurchase;
+            // 9. تنظیم روش خرید پکیج + ثبت ledger خرید دستی
+            user.PackagePurchaseMethod = PackagePurchaseMethod.Manual;
+
+            _context.UserPackagePurchases.Add(new UserPackagePurchase
+            {
+                UserId = request.UserId,
+                PackageId = package.Id,
+                PurchaseMethod = PackagePurchaseMethod.Manual,
+                PurchasedAt = DateTime.Now,
+                Amount = balanceAmount,
+                TransactionId = transaction.Id
+            });
 
             // 10. ذخیره همه تغییرات
             await _context.SaveChangesAsync(cancellationToken);
 
+            // 11. فعال‌سازی باشگاه مشتریان — ساخت Cycle و آماده‌سازی برای AcceptContract
+            // این مرحله تضمین می‌کند که:
+            //   الف) ClubMembershipCycle ساخته شود تا والدین امتیاز «عضو جدید» بگیرند
+            //   ب) Pool توسط AcceptContract (که کاربر در FO امضا می‌کند) شارژ شود
+            try
+            {
+                await _sender.Send(new ActivateClubMembershipCommand
+                {
+                    UserId = request.UserId,
+                    ForceActivation = true,
+                    PackageId = package.Id
+                }, cancellationToken);
+            }
+            catch (Exception activateEx)
+            {
+                // عضویت باشگاه اختیاری است — خطا نباید پرداخت دستی را برگرداند
+                _logger.LogWarning(
+                    activateEx,
+                    "Club membership activation failed after manual payment for UserId {UserId} — payment recorded successfully",
+                    request.UserId
+                );
+            }
+
             _logger.LogInformation(
                 "Manual membership payment created successfully. " +
                 "ManualPaymentId: {Id}, UserId: {UserId}, TransactionId: {TransactionId}, " +

src/CMSMicroservice.Application/ManualPaymentCQ/Commands/ProcessManualMembershipPayment/ProcessManualMembershipPaymentCommandHandler.cs

@@ -118,7 +118,7 @@ public class ProcessManualMembershipPaymentCommandHandler : IRequestHandler<Proc
             };
             await _context.UserWalletHistories.AddAsync(balanceLog, cancellationToken);
 
-            user.PackagePurchaseMethod = PackagePurchaseMethod.DirectPurchase;
+            user.PackagePurchaseMethod = PackagePurchaseMethod.Manual;
             // 10. به‌روزرسانی ManualPayment با TransactionId
             manualPayment.TransactionId = transaction.Id;
             await _context.SaveChangesAsync(cancellationToken);

src/CMSMicroservice.Application/ManualPaymentCQ/Queries/GetAllManualPayments/GetAllManualPaymentsQueryHandler.cs

@@ -70,7 +70,7 @@ public class GetAllManualPaymentsQueryHandler
         // Pagination
         var skip = (request.PageNumber - 1) * request.PageSize;
         
-        // دریافت PackageName از آخرین خرید پکیج کاربر
+        // دریافت PackageName پیش‌فرض از آخرین خرید پکیج کاربر (fallback برای داده‌های قدیمی)
         var userPackageNames = await _context.UserPackagePurchases
             .Include(p => p.Package)
             .GroupBy(p => p.UserId)
@@ -103,12 +103,45 @@ public class GetAllManualPaymentsQueryHandler
                 Created = m.Created
             })
             .ToListAsync(cancellationToken);
+
+        // PackageName دقیق هر پرداخت دستی از UserWalletHistories بر اساس TransactionId همان پرداخت
+        var transactionIds = data
+            .Where(x => x.TransactionId.HasValue)
+            .Select(x => x.TransactionId!.Value)
+            .Distinct()
+            .ToList();
+
+        var packageNamesByTransaction = new Dictionary<long, string>();
+        if (transactionIds.Count > 0)
+        {
+            packageNamesByTransaction = await _context.UserWalletHistories
+                .AsNoTracking()
+                .Include(h => h.Package)
+                .Where(h => h.RefrenceId.HasValue
+                    && transactionIds.Contains(h.RefrenceId.Value)
+                    && h.PackageId.HasValue)
+                .GroupBy(h => h.RefrenceId!.Value)
+                .Select(g => new
+                {
+                    TransactionId = g.Key,
+                    PackageName = g.OrderByDescending(x => x.Created)
+                        .Select(x => x.Package != null ? x.Package.Title : string.Empty)
+                        .FirstOrDefault()
+                })
+                .ToDictionaryAsync(x => x.TransactionId, x => x.PackageName ?? string.Empty, cancellationToken);
+        }
         
         // تکمیل PackageName
         foreach (var item in data)
         {
-            if (userPackageNames.TryGetValue(item.UserId, out var pkgName))
+            if (item.TransactionId.HasValue && packageNamesByTransaction.TryGetValue(item.TransactionId.Value, out var txPkgName))
+            {
+                item.PackageName = txPkgName;
+            }
+            else if (userPackageNames.TryGetValue(item.UserId, out var pkgName))
+            {
                 item.PackageName = pkgName;
+            }
         }
 
         var metaData = new MetaData

src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkTree/GetNetworkTreeQueryHandler.cs

@@ -1,5 +1,4 @@
 using System.Data;
-using System.Data.Common;
 using Microsoft.EntityFrameworkCore;
 
 namespace CMSMicroservice.Application.NetworkMembershipCQ.Queries.GetNetworkTree;
@@ -42,6 +41,11 @@ public class GetNetworkTreeQueryHandler : IRequestHandler<GetNetworkTreeQuery, N
 
             // تبدیل نتایج flat به ساختار درختی
             var tree = BuildTreeFromFlatNodes(flatNodes);
+            if (tree != null)
+            {
+                await EnrichWithPackageLegScoresAsync(tree, flatNodes, cancellationToken);
+            }
+
             return tree;
         }
         catch (Exception ex)
@@ -118,7 +122,10 @@ public class GetNetworkTreeQueryHandler : IRequestHandler<GetNetworkTreeQuery, N
                     ActivationWeekDefinitionId = reader.IsDBNull(reader.GetOrdinal("ActivationWeekDefinitionId")) ? null : reader.GetInt64(reader.GetOrdinal("ActivationWeekDefinitionId")),
                     ActivationWeekDisplayName = reader.IsDBNull(reader.GetOrdinal("ActivationWeekDisplayName")) ? null : reader.GetString(reader.GetOrdinal("ActivationWeekDisplayName")),
                     IsActivatedInTargetWeek = Convert.ToBoolean(reader.GetValue(reader.GetOrdinal("IsActivatedInTargetWeek"))),
-                    UserCreated = new DateTimeOffset(reader.GetDateTime(reader.GetOrdinal("UserCreated")))
+                    UserCreated = new DateTimeOffset(reader.GetDateTime(reader.GetOrdinal("UserCreated"))),
+                    IsNewActivation = reader.IsDBNull(reader.GetOrdinal("IsNewActivation")) ? null : (bool?)(reader.GetInt32(reader.GetOrdinal("IsNewActivation")) == 1),
+                    PackageName = reader.IsDBNull(reader.GetOrdinal("PackageName")) ? null : reader.GetString(reader.GetOrdinal("PackageName")),
+                    PackageId = reader.IsDBNull(reader.GetOrdinal("PackageId")) ? null : reader.GetInt64(reader.GetOrdinal("PackageId"))
                 };
                 
                 results.Add(node);
@@ -160,7 +167,10 @@ public class GetNetworkTreeQueryHandler : IRequestHandler<GetNetworkTreeQuery, N
                 ActivationWeekDefinitionId = flatNode.ActivationWeekDefinitionId,
                 ActivationWeekDisplayName = flatNode.ActivationWeekDisplayName,
                 IsActivatedInTargetWeek = flatNode.IsActivatedInTargetWeek,
-                UserCreated = flatNode.UserCreated
+                UserCreated = flatNode.UserCreated,
+                IsNewActivation = flatNode.IsNewActivation,
+                PackageName = flatNode.PackageName,
+                PackageId = flatNode.PackageId
             };
         }
 
@@ -188,4 +198,93 @@ public class GetNetworkTreeQueryHandler : IRequestHandler<GetNetworkTreeQuery, N
         var rootNode = flatNodes.FirstOrDefault(n => n.NetworkLevel == 0);
         return rootNode != null ? nodeDict[rootNode.UserId] : null;
     }
+
+    /// <summary>
+    /// آخرین Left/RightLegTotal طلایی و نقره‌ای برای هر نود درخت (برنامه‌ریزی پای چپ/راست).
+    /// </summary>
+    private async Task EnrichWithPackageLegScoresAsync(
+        NetworkTreeDto root,
+        List<NetworkTreeNodeDto> flatNodes,
+        CancellationToken cancellationToken)
+    {
+        var userIds = flatNodes.Select(n => n.UserId).Distinct().ToList();
+        if (userIds.Count == 0) return;
+
+        var packages = await _context.Packages
+            .AsNoTracking()
+            .Where(p => !p.IsDeleted && p.IsActive)
+            .Select(p => new { p.Id, p.Title, p.IsBasePackage, p.MaxBalancesPerLeg })
+            .ToListAsync(cancellationToken);
+
+        var goldPackageId = packages.FirstOrDefault(p => p.IsBasePackage)?.Id
+            ?? packages.FirstOrDefault(p => p.Title.Contains("طلایی") || p.Title.Contains("طلايی"))?.Id;
+
+        var silverPackageId = packages.FirstOrDefault(p =>
+                !p.IsBasePackage && (p.Title.Contains("نقره") || p.MaxBalancesPerLeg <= 30))?.Id
+            ?? packages.FirstOrDefault(p => !p.IsBasePackage)?.Id;
+
+        if (!goldPackageId.HasValue && !silverPackageId.HasValue)
+        {
+            _logger.LogWarning("GetNetworkTree: no gold/silver packages found for leg score enrichment");
+            return;
+        }
+
+        var packageIds = new List<long>();
+        if (goldPackageId.HasValue) packageIds.Add(goldPackageId.Value);
+        if (silverPackageId.HasValue && silverPackageId != goldPackageId)
+            packageIds.Add(silverPackageId.Value);
+
+        var rawBalances = await _context.NetworkWeeklyBalances
+            .AsNoTracking()
+            .Where(b => userIds.Contains(b.UserId) && packageIds.Contains(b.PackageId))
+            .Select(b => new LegScoreRow(
+                b.UserId,
+                b.PackageId,
+                b.WeekDefinitionId,
+                b.LeftLegTotal,
+                b.RightLegTotal))
+            .ToListAsync(cancellationToken);
+
+        var latestByUserPackage = rawBalances
+            .GroupBy(b => (b.UserId, b.PackageId))
+            .ToDictionary(
+                g => g.Key,
+                g => g.OrderByDescending(x => x.WeekDefinitionId).First());
+
+        ApplyLegScores(root, goldPackageId, silverPackageId, latestByUserPackage);
+    }
+
+    private static void ApplyLegScores(
+        NetworkTreeDto node,
+        long? goldPackageId,
+        long? silverPackageId,
+        Dictionary<(long UserId, long PackageId), LegScoreRow> latestByUserPackage)
+    {
+        if (goldPackageId.HasValue &&
+            latestByUserPackage.TryGetValue((node.UserId, goldPackageId.Value), out var gold))
+        {
+            node.GoldLeftLegTotal = gold.LeftLegTotal;
+            node.GoldRightLegTotal = gold.RightLegTotal;
+        }
+
+        if (silverPackageId.HasValue &&
+            latestByUserPackage.TryGetValue((node.UserId, silverPackageId.Value), out var silver))
+        {
+            node.SilverLeftLegTotal = silver.LeftLegTotal;
+            node.SilverRightLegTotal = silver.RightLegTotal;
+        }
+
+        if (node.LeftChild != null)
+            ApplyLegScores(node.LeftChild, goldPackageId, silverPackageId, latestByUserPackage);
+
+        if (node.RightChild != null)
+            ApplyLegScores(node.RightChild, goldPackageId, silverPackageId, latestByUserPackage);
+    }
+
+    private sealed record LegScoreRow(
+        long UserId,
+        long PackageId,
+        long WeekDefinitionId,
+        int LeftLegTotal,
+        int RightLegTotal);
 }

src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkTree/NetworkTreeDto.cs

@@ -47,7 +47,31 @@ public class NetworkTreeDto
     /// تاریخ ایجاد کاربر
     /// </summary>
     public DateTimeOffset UserCreated { get; set; }
-    
+
+    /// <summary>
+    /// آیا فعال‌سازی در هفته هدف اولین بار بوده؟ null = بدون Cycle
+    /// </summary>
+    public bool? IsNewActivation { get; set; }
+
+    /// <summary>
+    /// نام پکیج موثر (هفته هدف یا پکیج فعلی)
+    /// </summary>
+    public string? PackageName { get; set; }
+
+    public long? PackageId { get; set; }
+
+    /// <summary>آخرین LeftLegTotal پکیج طلایی (پایه)</summary>
+    public int GoldLeftLegTotal { get; set; }
+
+    /// <summary>آخرین RightLegTotal پکیج طلایی (پایه)</summary>
+    public int GoldRightLegTotal { get; set; }
+
+    /// <summary>آخرین LeftLegTotal پکیج نقره‌ای</summary>
+    public int SilverLeftLegTotal { get; set; }
+
+    /// <summary>آخرین RightLegTotal پکیج نقره‌ای</summary>
+    public int SilverRightLegTotal { get; set; }
+
     public NetworkTreeDto? LeftChild { get; set; }
     public NetworkTreeDto? RightChild { get; set; }
 }

src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkTree/NetworkTreeNodeDto.cs

@@ -20,6 +20,19 @@ public class NetworkTreeNodeDto
     public string? ActivationWeekDisplayName { get; set; }
     public bool IsActivatedInTargetWeek { get; set; }
     public DateTimeOffset UserCreated { get; set; }
+
+    /// <summary>
+    /// آیا فعال‌سازی در هفته هدف اولین بار بوده (true) یا خرید مجدد (false)؟
+    /// null یعنی Cycle‌ای ندارد
+    /// </summary>
+    public bool? IsNewActivation { get; set; }
+
+    /// <summary>
+    /// نام پکیج موثر (هفته هدف یا پکیج فعلی)
+    /// </summary>
+    public string? PackageName { get; set; }
+
+    public long? PackageId { get; set; }
     
     /// <summary>
     /// نام کامل کاربر

src/CMSMicroservice.Application/OrderManagementCQ/Commands/CancelOrderByAdmin/CancelOrderByAdminCommandHandler.cs

@@ -10,15 +10,18 @@ public class CancelOrderByAdminCommandHandler : IRequestHandler<CancelOrderByAdm
 {
     private readonly IApplicationDbContext _context;
     private readonly ICurrentUserService _currentUser;
+    private readonly IInventoryService _inventoryService;
     private readonly ILogger<CancelOrderByAdminCommandHandler> _logger;
 
     public CancelOrderByAdminCommandHandler(
         IApplicationDbContext context,
         ICurrentUserService currentUser,
+        IInventoryService inventoryService,
         ILogger<CancelOrderByAdminCommandHandler> logger)
     {
         _context = context;
         _currentUser = currentUser;
+        _inventoryService = inventoryService;
         _logger = logger;
     }
 
@@ -33,6 +36,7 @@ public class CancelOrderByAdminCommandHandler : IRequestHandler<CancelOrderByAdm
         var order = await _context.UserOrders
             .Include(x => x.User)
             .ThenInclude(x => x.UserWallets)
+            .Include(x => x.FactorDetails)
             .FirstOrDefaultAsync(x => x.Id == request.OrderId && !x.IsDeleted, cancellationToken);
 
         if (order == null)
@@ -87,6 +91,26 @@ public class CancelOrderByAdminCommandHandler : IRequestHandler<CancelOrderByAdm
 
         await _context.SaveChangesAsync(cancellationToken);
 
+        // Restore inventory for each item (only if order was not yet delivered)
+        if (order.FactorDetails != null && order.FactorDetails.Any())
+        {
+            foreach (var item in order.FactorDetails)
+            {
+                var restored = await _inventoryService.ProcessReturnAsync(
+                    item.ProductId, ProductType.RegularProduct,
+                    item.Count, order.Id,
+                    note: $"برگشت موجودی — لغو سفارش #{order.Id} توسط Admin",
+                    ct: cancellationToken);
+
+                if (!restored)
+                {
+                    _logger.LogWarning(
+                        "Failed to restore inventory for ProductId={ProductId} on cancel OrderId={OrderId}",
+                        item.ProductId, order.Id);
+                }
+            }
+        }
+
         _logger.LogInformation(
             "Order cancelled by admin. OrderId: {OrderId}, Reason: {Reason}, Refunded: {Refunded}, Admin: {AdminId}",
             order.Id,

src/CMSMicroservice.Application/OtpTokenCQ/Commands/VerifyOtpToken/VerifyOtpTokenCommandHandler.cs

@@ -55,6 +55,9 @@ public class VerifyOtpTokenCommandHandler : IRequestHandler<VerifyOtpTokenComman
 
         if (user is null)
         {
+            if (purpose == "login")
+                return new VerifyOtpTokenResponseDto() { Success = false, Message = "کاربری با این شماره موبایل وجود ندارد." };
+
             if (request.ParentReferralCode == null)
                 return new VerifyOtpTokenResponseDto() { Success = false, Message = "کد معرف الزامی است." };
 

src/CMSMicroservice.Application/PackageCQ/Commands/VerifyUserPackagePurchasePayment/VerifyUserPackagePurchasePaymentCommand.cs

@@ -0,0 +1,26 @@
+using MediatR;
+
+namespace CMSMicroservice.Application.PackageCQ.Commands.VerifyUserPackagePurchasePayment;
+
+/// <summary>
+/// Shared verify + wallet credit path for package IPG payments (callback UI and reconciliation job).
+/// </summary>
+public class VerifyUserPackagePurchasePaymentCommand : IRequest<VerifyUserPackagePurchasePaymentResult>
+{
+    public long PurchaseId { get; set; }
+    public string Authority { get; set; } = string.Empty;
+    public string Status { get; set; } = "OK";
+}
+
+public class VerifyUserPackagePurchasePaymentResult
+{
+    public bool Success { get; init; }
+    public bool AlreadyPaid { get; init; }
+    public string Message { get; init; } = string.Empty;
+    public long TransactionId { get; init; }
+    public string ReferenceCode { get; init; } = string.Empty;
+    public long PackageId { get; init; }
+    public string PackageName { get; init; } = string.Empty;
+    public long AmountPaid { get; init; }
+    public DateTime PurchasedAt { get; init; }
+}

src/CMSMicroservice.Application/PackageCQ/Commands/VerifyUserPackagePurchasePayment/VerifyUserPackagePurchasePaymentCommandHandler.cs

@@ -0,0 +1,303 @@
+using System.Data;
+using CMSMicroservice.Application.ClubMembershipCQ.Commands.ActivateClubMembership;
+using CMSMicroservice.Application.Common;
+using CMSMicroservice.Application.Common.Exceptions;
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Domain.Entities;
+using CMSMicroservice.Domain.Entities.Payment;
+using CMSMicroservice.Domain.Enums;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace CMSMicroservice.Application.PackageCQ.Commands.VerifyUserPackagePurchasePayment;
+
+public class VerifyUserPackagePurchasePaymentCommandHandler
+    : IRequestHandler<VerifyUserPackagePurchasePaymentCommand, VerifyUserPackagePurchasePaymentResult>
+{
+    private readonly IApplicationDbContext _context;
+    private readonly IPaymentGatewayService _paymentGateway;
+    private readonly ISender _sender;
+    private readonly IUserPaymentLock _paymentLock;
+    private readonly ILogger<VerifyUserPackagePurchasePaymentCommandHandler> _logger;
+
+    public VerifyUserPackagePurchasePaymentCommandHandler(
+        IApplicationDbContext context,
+        IPaymentGatewayService paymentGateway,
+        ISender sender,
+        IUserPaymentLock paymentLock,
+        ILogger<VerifyUserPackagePurchasePaymentCommandHandler> logger)
+    {
+        _context = context;
+        _paymentGateway = paymentGateway;
+        _sender = sender;
+        _paymentLock = paymentLock;
+        _logger = logger;
+    }
+
+    public async Task<VerifyUserPackagePurchasePaymentResult> Handle(
+        VerifyUserPackagePurchasePaymentCommand request,
+        CancellationToken cancellationToken)
+    {
+        var purchaseUserId = await _context.UserPackagePurchases
+            .Where(p => p.Id == request.PurchaseId && !p.IsDeleted)
+            .Select(p => (long?)p.UserId)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (purchaseUserId is null or 0)
+            throw new NotFoundException("سفارش یافت نشد");
+
+        var verifyKey = !string.IsNullOrEmpty(request.Authority)
+            ? request.Authority
+            : request.PurchaseId.ToString();
+
+        return await _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Verify(purchaseUserId.Value, verifyKey),
+            PaymentLockStrategy.WaitForRelease,
+            ct => HandleCoreAsync(request, ct),
+            cancellationToken);
+    }
+
+    private async Task<VerifyUserPackagePurchasePaymentResult> HandleCoreAsync(
+        VerifyUserPackagePurchasePaymentCommand request,
+        CancellationToken ct)
+    {
+        var purchase = await _context.UserPackagePurchases
+            .Include(p => p.Package)
+            .Where(p => p.Id == request.PurchaseId && !p.IsDeleted)
+            .FirstOrDefaultAsync(ct);
+
+        if (purchase == null)
+            throw new NotFoundException("سفارش یافت نشد");
+
+        var transaction = purchase.TransactionId.HasValue
+            ? await _context.Transactions
+                .FirstOrDefaultAsync(t => t.Id == purchase.TransactionId.Value, ct)
+            : null;
+
+        var paymentTx = !string.IsNullOrEmpty(request.Authority)
+            ? await _context.PaymentTransactions
+                .FirstOrDefaultAsync(pt => pt.Authority == request.Authority, ct)
+            : null;
+
+        if (IsPaymentAlreadyCompleted(transaction, paymentTx))
+        {
+            return BuildResult(purchase, transaction, paymentTx, alreadyPaid: true);
+        }
+
+        if (!string.Equals(request.Status, "OK", StringComparison.OrdinalIgnoreCase))
+        {
+            if (transaction != null && transaction.PaymentStatus != PaymentStatus.Success)
+            {
+                transaction.PaymentStatus = PaymentStatus.Reject;
+                await _context.SaveChangesAsync(ct);
+            }
+
+            return new VerifyUserPackagePurchasePaymentResult
+            {
+                Success = false,
+                Message = "پرداخت توسط کاربر لغو شد",
+                PackageId = purchase.PackageId,
+                PackageName = purchase.Package?.Title ?? string.Empty,
+                AmountPaid = purchase.Amount,
+                PurchasedAt = purchase.PurchasedAt
+            };
+        }
+
+        var amountInToman = paymentTx?.Amount ?? purchase.Amount;
+        var verifyResult = await _paymentGateway.VerifyPaymentAsync(
+            request.Authority, request.Status, (decimal)amountInToman, ct);
+
+        if (!verifyResult.IsSuccess)
+        {
+            if (paymentTx != null)
+            {
+                paymentTx.PaymentStatus = false;
+                paymentTx.VerificationStatusCode = verifyResult.VerificationCode;
+                paymentTx.VerificationStatusMessage = verifyResult.Message;
+            }
+
+            if (transaction != null)
+                transaction.PaymentStatus = PaymentStatus.Reject;
+
+            await _context.SaveChangesAsync(ct);
+
+            return new VerifyUserPackagePurchasePaymentResult
+            {
+                Success = false,
+                Message = verifyResult.Message ?? "خرید پکیج ناموفق بود",
+                TransactionId = transaction?.Id ?? 0,
+                PackageId = purchase.PackageId,
+                PackageName = purchase.Package?.Title ?? string.Empty,
+                AmountPaid = purchase.Amount,
+                PurchasedAt = purchase.PurchasedAt
+            };
+        }
+
+        await using var dbTx = await _context.Database.BeginTransactionAsync(IsolationLevel.Serializable, ct);
+        try
+        {
+            if (purchase.TransactionId.HasValue)
+            {
+                transaction = await _context.Transactions
+                    .FirstOrDefaultAsync(t => t.Id == purchase.TransactionId.Value, ct);
+            }
+
+            if (!string.IsNullOrEmpty(request.Authority))
+            {
+                paymentTx = await _context.PaymentTransactions
+                    .FirstOrDefaultAsync(pt => pt.Authority == request.Authority, ct);
+            }
+
+            if (IsPaymentAlreadyCompleted(transaction, paymentTx))
+            {
+                await dbTx.CommitAsync(ct);
+                return BuildResult(purchase, transaction, paymentTx, alreadyPaid: true);
+            }
+
+            if (transaction == null)
+                throw new InvalidOperationException("تراکنش سفارش یافت نشد");
+
+            var alreadyCredited = await _context.UserWalletHistories
+                .AnyAsync(h => h.RefrenceId == transaction.Id && !h.IsDeleted, ct);
+
+            if (alreadyCredited)
+            {
+                transaction.PaymentStatus = PaymentStatus.Success;
+                transaction.PaymentDate ??= DateTime.UtcNow;
+                UpdatePaymentTransaction(paymentTx, verifyResult, markSuccess: true);
+                await _context.SaveChangesAsync(ct);
+                await dbTx.CommitAsync(ct);
+                return BuildResult(purchase, transaction, paymentTx, alreadyPaid: true);
+            }
+
+            UpdatePaymentTransaction(paymentTx, verifyResult, markSuccess: true);
+
+            transaction.PaymentStatus = PaymentStatus.Success;
+            transaction.PaymentDate = DateTime.UtcNow;
+            transaction.RefId = verifyResult.RefId;
+
+            var wallet = await _context.UserWallets
+                .FirstOrDefaultAsync(w => w.UserId == purchase.UserId, ct);
+
+            if (wallet == null)
+            {
+                wallet = new UserWallet
+                {
+                    UserId = purchase.UserId,
+                    Balance = 0,
+                    DiscountBalance = 0,
+                    NetworkBalance = 0
+                };
+                _context.UserWallets.Add(wallet);
+                await _context.SaveChangesAsync(ct);
+            }
+
+            var discountMultiplier = purchase.Package?.DiscountMultiplier
+                ?? throw new InvalidOperationException("پکیج سفارش یافت نشد");
+            var discountAmount = (long)(purchase.Amount * (double)discountMultiplier);
+            wallet.Balance += purchase.Amount;
+            wallet.DiscountBalance += discountAmount;
+
+            _context.UserWalletHistories.Add(new UserWalletHistory
+            {
+                WalletId = wallet.Id,
+                CurrentBalance = wallet.Balance,
+                ChangeValue = purchase.Amount,
+                CurrentNetworkBalance = wallet.NetworkBalance,
+                ChangeNerworkValue = 0,
+                CurrentDiscountBalance = wallet.DiscountBalance,
+                ChangeDiscountValue = discountAmount,
+                IsIncrease = true,
+                RefrenceId = transaction.Id,
+                PackageId = purchase.PackageId
+            });
+
+            var user = await _context.Users
+                .FirstOrDefaultAsync(u => u.Id == purchase.UserId, ct);
+            if (user != null)
+                user.PackagePurchaseMethod = PackagePurchaseMethod.DirectPurchase;
+
+            await _context.SaveChangesAsync(ct);
+            await dbTx.CommitAsync(ct);
+        }
+        catch
+        {
+            await dbTx.RollbackAsync(ct);
+            throw;
+        }
+
+        try
+        {
+            await _sender.Send(new ActivateClubMembershipCommand
+            {
+                UserId = purchase.UserId,
+                ForceActivation = false
+            }, ct);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(
+                ex,
+                "Auto club activation failed after package verify. UserId={UserId}, PurchaseId={PurchaseId}",
+                purchase.UserId,
+                purchase.Id);
+        }
+
+        _logger.LogInformation(
+            "Package purchase verified. PurchaseId={PurchaseId}, UserId={UserId}, Authority={Authority}",
+            purchase.Id,
+            purchase.UserId,
+            request.Authority);
+
+        return BuildResult(
+            purchase, transaction, paymentTx, alreadyPaid: false, verifyResult.RefId);
+    }
+
+    private static bool IsPaymentAlreadyCompleted(Transaction? transaction, PaymentTransaction? paymentTx)
+    {
+        return transaction?.PaymentStatus == PaymentStatus.Success
+            || paymentTx?.PaymentStatus == true;
+    }
+
+    private static void UpdatePaymentTransaction(
+        PaymentTransaction? paymentTx,
+        PaymentVerificationResult verifyResult,
+        bool markSuccess)
+    {
+        if (paymentTx == null) return;
+
+        paymentTx.PaymentStatus = markSuccess && verifyResult.IsSuccess;
+        paymentTx.VerificationStatusCode = verifyResult.VerificationCode;
+        paymentTx.VerificationStatusMessage = verifyResult.Message;
+        paymentTx.CardPan = verifyResult.CardPan;
+        paymentTx.CardHash = verifyResult.CardHash;
+        paymentTx.RefId = verifyResult.TrackingCode;
+    }
+
+    private static VerifyUserPackagePurchasePaymentResult BuildResult(
+        UserPackagePurchase purchase,
+        Transaction? transaction,
+        PaymentTransaction? paymentTx,
+        bool alreadyPaid,
+        string? referenceCode = null)
+    {
+        var refCode = referenceCode
+            ?? paymentTx?.RefId
+            ?? transaction?.RefId
+            ?? string.Empty;
+
+        return new VerifyUserPackagePurchasePaymentResult
+        {
+            Success = true,
+            AlreadyPaid = alreadyPaid,
+            Message = alreadyPaid ? "پرداخت قبلاً تأیید شده بود" : "خرید پکیج با موفقیت تایید شد",
+            TransactionId = transaction?.Id ?? 0,
+            ReferenceCode = refCode,
+            PackageId = purchase.PackageId,
+            PackageName = purchase.Package?.Title ?? string.Empty,
+            AmountPaid = purchase.Amount,
+            PurchasedAt = purchase.PurchasedAt
+        };
+    }
+}

src/CMSMicroservice.Application/PaymentTransactionCQ/Queries/GetAllPaymentTransactionByFilter/GetAllPaymentTransactionByFilterQuery.cs

@@ -0,0 +1,46 @@
+namespace CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetAllPaymentTransactionByFilter;
+
+public record GetAllPaymentTransactionByFilterQuery : IRequest<GetAllPaymentTransactionByFilterResponseDto>
+{
+    public PaginationState? PaginationState { get; init; }
+    public string? SortBy { get; init; }
+    public GetAllPaymentTransactionByFilterFilter? Filter { get; init; }
+}
+
+public class GetAllPaymentTransactionByFilterFilter
+{
+    public long? UserId { get; set; }
+    public string? Mobile { get; set; }
+    public string? GatewayProvider { get; set; }
+    public bool? PaymentStatus { get; set; }
+    public string? Authority { get; set; }
+    public string? RefId { get; set; }
+    public string? OrderId { get; set; }
+    public DateTime? CreatedFrom { get; set; }
+    public DateTime? CreatedTo { get; set; }
+}
+
+public class GetAllPaymentTransactionByFilterResponseDto
+{
+    public MetaData MetaData { get; set; }
+    public List<GetAllPaymentTransactionByFilterResponseModel>? Models { get; set; }
+}
+
+public class GetAllPaymentTransactionByFilterResponseModel
+{
+    public long Id { get; set; }
+    public long? UserId { get; set; }
+    public string? Mobile { get; set; }
+    public string GatewayProvider { get; set; } = string.Empty;
+    public long Amount { get; set; }
+    public string? Authority { get; set; }
+    public bool PaymentStatus { get; set; }
+    public int? VerificationStatusCode { get; set; }
+    public string? VerificationStatusMessage { get; set; }
+    public string? RefId { get; set; }
+    public string? CardPan { get; set; }
+    public string? OrderId { get; set; }
+    public long? TransactionId { get; set; }
+    public string? Description { get; set; }
+    public DateTimeOffset Created { get; set; }
+}

src/CMSMicroservice.Application/PaymentTransactionCQ/Queries/GetAllPaymentTransactionByFilter/GetAllPaymentTransactionByFilterQueryHandler.cs

@@ -0,0 +1,48 @@
+namespace CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetAllPaymentTransactionByFilter;
+
+public class GetAllPaymentTransactionByFilterQueryHandler
+    : IRequestHandler<GetAllPaymentTransactionByFilterQuery, GetAllPaymentTransactionByFilterResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetAllPaymentTransactionByFilterQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetAllPaymentTransactionByFilterResponseDto> Handle(
+        GetAllPaymentTransactionByFilterQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.PaymentTransactions
+            .AsNoTracking()
+            .ApplyPaymentTransactionFilter(request.Filter)
+            .ApplyOrder(sortBy: request.SortBy ?? "-Created");
+
+        return new GetAllPaymentTransactionByFilterResponseDto
+        {
+            MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
+            Models = await query
+                .PaginatedListAsync(paginationState: request.PaginationState)
+                .Select(x => new GetAllPaymentTransactionByFilterResponseModel
+                {
+                    Id = x.Id,
+                    UserId = x.UserId,
+                    Mobile = x.Mobile,
+                    GatewayProvider = x.GatewayProvider,
+                    Amount = x.Amount,
+                    Authority = x.Authority,
+                    PaymentStatus = x.PaymentStatus,
+                    VerificationStatusCode = x.VerificationStatusCode,
+                    VerificationStatusMessage = x.VerificationStatusMessage,
+                    RefId = x.RefId,
+                    CardPan = x.CardPan,
+                    OrderId = x.OrderId,
+                    TransactionId = x.TransactionId,
+                    Description = x.Description,
+                    Created = x.Created
+                })
+                .ToListAsync(cancellationToken)
+        };
+    }
+}

src/CMSMicroservice.Application/PaymentTransactionCQ/Queries/GetAllPaymentTransactionByFilter/PaymentTransactionFilterExtensions.cs

@@ -0,0 +1,42 @@
+using CMSMicroservice.Domain.Entities.Payment;
+
+namespace CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetAllPaymentTransactionByFilter;
+
+public static class PaymentTransactionFilterExtensions
+{
+    public static IQueryable<PaymentTransaction> ApplyPaymentTransactionFilter(
+        this IQueryable<PaymentTransaction> query,
+        GetAllPaymentTransactionByFilterFilter? filter)
+    {
+        if (filter == null) return query;
+
+        if (filter.UserId.HasValue)
+            query = query.Where(x => x.UserId == filter.UserId.Value);
+
+        if (!string.IsNullOrWhiteSpace(filter.Mobile))
+            query = query.Where(x => x.Mobile != null && x.Mobile.Contains(filter.Mobile));
+
+        if (!string.IsNullOrWhiteSpace(filter.GatewayProvider))
+            query = query.Where(x => x.GatewayProvider == filter.GatewayProvider);
+
+        if (filter.PaymentStatus.HasValue)
+            query = query.Where(x => x.PaymentStatus == filter.PaymentStatus.Value);
+
+        if (!string.IsNullOrWhiteSpace(filter.Authority))
+            query = query.Where(x => x.Authority != null && x.Authority.Contains(filter.Authority));
+
+        if (!string.IsNullOrWhiteSpace(filter.RefId))
+            query = query.Where(x => x.RefId != null && x.RefId.Contains(filter.RefId));
+
+        if (!string.IsNullOrWhiteSpace(filter.OrderId))
+            query = query.Where(x => x.OrderId != null && x.OrderId.Contains(filter.OrderId));
+
+        if (filter.CreatedFrom.HasValue)
+            query = query.Where(x => x.Created >= filter.CreatedFrom.Value);
+
+        if (filter.CreatedTo.HasValue)
+            query = query.Where(x => x.Created <= filter.CreatedTo.Value);
+
+        return query;
+    }
+}

src/CMSMicroservice.Application/PaymentTransactionCQ/Queries/GetPaymentTransactionSummary/GetPaymentTransactionSummaryQuery.cs

@@ -0,0 +1,14 @@
+namespace CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetPaymentTransactionSummary;
+
+public record GetPaymentTransactionSummaryQuery : IRequest<GetPaymentTransactionSummaryResponseDto>
+{
+    public GetAllPaymentTransactionByFilter.GetAllPaymentTransactionByFilterFilter? Filter { get; init; }
+}
+
+public class GetPaymentTransactionSummaryResponseDto
+{
+    public long TotalCount { get; set; }
+    public long TotalAmount { get; set; }
+    public long SuccessfulCount { get; set; }
+    public long PendingCount { get; set; }
+}

src/CMSMicroservice.Application/PaymentTransactionCQ/Queries/GetPaymentTransactionSummary/GetPaymentTransactionSummaryQueryHandler.cs

@@ -0,0 +1,36 @@
+using CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetAllPaymentTransactionByFilter;
+
+namespace CMSMicroservice.Application.PaymentTransactionCQ.Queries.GetPaymentTransactionSummary;
+
+public class GetPaymentTransactionSummaryQueryHandler
+    : IRequestHandler<GetPaymentTransactionSummaryQuery, GetPaymentTransactionSummaryResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetPaymentTransactionSummaryQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetPaymentTransactionSummaryResponseDto> Handle(
+        GetPaymentTransactionSummaryQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.PaymentTransactions
+            .AsNoTracking()
+            .ApplyPaymentTransactionFilter(request.Filter);
+
+        var totalCount = await query.LongCountAsync(cancellationToken);
+        var totalAmount = totalCount > 0 ? await query.SumAsync(x => x.Amount, cancellationToken) : 0;
+        var successfulCount = await query.LongCountAsync(x => x.PaymentStatus, cancellationToken);
+        var pendingCount = await query.LongCountAsync(x => !x.PaymentStatus, cancellationToken);
+
+        return new GetPaymentTransactionSummaryResponseDto
+        {
+            TotalCount = totalCount,
+            TotalAmount = totalAmount,
+            SuccessfulCount = successfulCount,
+            PendingCount = pendingCount
+        };
+    }
+}

src/CMSMicroservice.Application/ProductsCQ/Queries/GetCustomerProductsByFilter/GetCustomerProductsByFilterQuery.cs

@@ -21,6 +21,10 @@ public class GetCustomerProductsByFilterQuery : IRequest<GetCustomerProductsByFi
     public int? SaleCount { get; set; }
     public int? ViewCount { get; set; }
     public int? RemainingCount { get; set; }
+    /// <summary>
+    /// true = فقط موجود (RemainingCount &gt; 0)، false = فقط ناموجود
+    /// </summary>
+    public bool? InStock { get; set; }
     public bool? IsActive { get; set; }
     public List<long>? CategoryIds { get; set; }
 }

src/CMSMicroservice.Application/ProductsCQ/Queries/GetCustomerProductsByFilter/GetCustomerProductsByFilterQueryHandler.cs

@@ -56,17 +56,19 @@ public class GetCustomerProductsByFilterQueryHandler : IRequestHandler<GetCustom
         if (request.RemainingCount.HasValue)
             query = query.Where(x => x.RemainingCount == request.RemainingCount.Value);
 
+        if (request.InStock == true)
+            query = query.Where(x => x.RemainingCount > 0);
+        else if (request.InStock == false)
+            query = query.Where(x => x.RemainingCount <= 0);
+
         if (request.CategoryIds != null && request.CategoryIds.Any())
             query = query.Where(x => x.ProductCategories.Any(pc => request.CategoryIds.Contains(pc.CategoryId)));
 
         if (request.IsActive.HasValue)
             query = query.Where(x => x.IsDeleted != request.IsActive.Value);
 
-        // Apply sorting
-        if (!string.IsNullOrEmpty(request.SortBy))
-            query = query.ApplyOrder(request.SortBy);
-        else
-            query = query.OrderByDescending(x => x.Created);
+        // موجودی‌دارها اول، سپس سورت درخواستی
+        query = query.ApplyOrderWithInStockPriority(request.SortBy, x => x.RemainingCount > 0);
 
         // Pagination
         var totalCount = await query.CountAsync(cancellationToken);

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetAllTransactionsByFilter/GetAllTransactionsByFilterQuery.cs

@@ -26,4 +26,8 @@ public record GetAllTransactionsByFilterQuery : IRequest<GetAllTransactionsByFil
     public string? RefId { get; set; }
     // 
     public TransactionType? Type { get; set; }
+    public DateTime? CreatedFrom { get; set; }
+    public DateTime? CreatedTo { get; set; }
+    public DateTime? PaymentDateFrom { get; set; }
+    public DateTime? PaymentDateTo { get; set; }
 }

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetAllTransactionsByFilter/GetAllTransactionsByFilterQueryHandler.cs

@@ -1,4 +1,5 @@
 namespace CMSMicroservice.Application.TransactionsCQ.Queries.GetAllTransactionsByFilter;
+
 public class GetAllTransactionsByFilterQueryHandler : IRequestHandler<GetAllTransactionsByFilterQuery, GetAllTransactionsByFilterResponseDto>
 {
     private readonly IApplicationDbContext _context;
@@ -11,26 +12,27 @@ public class GetAllTransactionsByFilterQueryHandler : IRequestHandler<GetAllTran
     public async Task<GetAllTransactionsByFilterResponseDto> Handle(GetAllTransactionsByFilterQuery request, CancellationToken cancellationToken)
     {
         var query = _context.Transactions
-            .ApplyOrder(sortBy: request.SortBy)
             .AsNoTracking()
-            .AsQueryable();
-        if (request.Filter is not null)
-        {
-            query = query
-                .Where(x => request.Filter.Id == null || x.Id == request.Filter.Id)
-                .Where(x => request.Filter.Amount == null || x.Amount == request.Filter.Amount)
-                .Where(x => request.Filter.Description == null || x.Description.Contains(request.Filter.Description))
-                .Where(x => request.Filter.PaymentStatus == null || x.PaymentStatus== request.Filter.PaymentStatus)
-                .Where(x => request.Filter.PaymentDate == null || x.PaymentDate == request.Filter.PaymentDate)
-                .Where(x => request.Filter.RefId == null || x.RefId.Contains(request.Filter.RefId))
-                .Where(x => request.Filter.Type == null || x.Type == request.Filter.Type)
-;
-        }
+            .ApplyTransactionFilter(request.Filter)
+            .ApplyOrder(sortBy: request.SortBy ?? "-Created");
+
         return new GetAllTransactionsByFilterResponseDto
         {
             MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
-            Models = await query.PaginatedListAsync(paginationState: request.PaginationState)
-                .ProjectToType<GetAllTransactionsByFilterResponseModel>().ToListAsync(cancellationToken)
-        };        
+            Models = await query
+                .PaginatedListAsync(paginationState: request.PaginationState)
+                .Select(x => new GetAllTransactionsByFilterResponseModel
+                {
+                    Id = x.Id,
+                    Amount = x.Amount,
+                    Description = x.Description,
+                    PaymentStatus = x.PaymentStatus,
+                    PaymentDate = x.PaymentDate,
+                    RefId = x.RefId,
+                    Type = x.Type,
+                    Created = x.Created
+                })
+                .ToListAsync(cancellationToken)
+        };
     }
 }

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetAllTransactionsByFilter/GetAllTransactionsByFilterResponseDto.cs

@@ -24,4 +24,5 @@ public class GetAllTransactionsByFilterResponseDto
     public string? RefId { get; set; }
     // 
     public TransactionType Type { get; set; }
+    public DateTime Created { get; set; }
 }

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetAllTransactionsByFilter/TransactionFilterExtensions.cs

@@ -0,0 +1,48 @@
+using CMSMicroservice.Domain.Entities;
+
+namespace CMSMicroservice.Application.TransactionsCQ.Queries.GetAllTransactionsByFilter;
+
+public static class TransactionFilterExtensions
+{
+    public static IQueryable<Transaction> ApplyTransactionFilter(
+        this IQueryable<Transaction> query,
+        GetAllTransactionsByFilterFilter? filter)
+    {
+        if (filter == null) return query;
+
+        if (filter.Id.HasValue)
+            query = query.Where(x => x.Id == filter.Id.Value);
+
+        if (filter.Amount.HasValue)
+            query = query.Where(x => x.Amount == filter.Amount.Value);
+
+        if (!string.IsNullOrWhiteSpace(filter.Description))
+            query = query.Where(x => x.Description.Contains(filter.Description));
+
+        if (filter.PaymentStatus.HasValue)
+            query = query.Where(x => x.PaymentStatus == filter.PaymentStatus.Value);
+
+        if (filter.PaymentDate.HasValue)
+            query = query.Where(x => x.PaymentDate == filter.PaymentDate.Value);
+
+        if (!string.IsNullOrWhiteSpace(filter.RefId))
+            query = query.Where(x => x.RefId != null && x.RefId.Contains(filter.RefId));
+
+        if (filter.Type.HasValue)
+            query = query.Where(x => x.Type == filter.Type.Value);
+
+        if (filter.CreatedFrom.HasValue)
+            query = query.Where(x => x.Created >= filter.CreatedFrom.Value);
+
+        if (filter.CreatedTo.HasValue)
+            query = query.Where(x => x.Created <= filter.CreatedTo.Value);
+
+        if (filter.PaymentDateFrom.HasValue)
+            query = query.Where(x => x.PaymentDate >= filter.PaymentDateFrom.Value);
+
+        if (filter.PaymentDateTo.HasValue)
+            query = query.Where(x => x.PaymentDate <= filter.PaymentDateTo.Value);
+
+        return query;
+    }
+}

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetTransactionSummary/GetTransactionSummaryQuery.cs

@@ -0,0 +1,17 @@
+using CMSMicroservice.Application.TransactionsCQ.Queries.GetAllTransactionsByFilter;
+
+namespace CMSMicroservice.Application.TransactionsCQ.Queries.GetTransactionSummary;
+
+public record GetTransactionSummaryQuery : IRequest<GetTransactionSummaryResponseDto>
+{
+    public GetAllTransactionsByFilterFilter? Filter { get; init; }
+}
+
+public class GetTransactionSummaryResponseDto
+{
+    public long TotalCount { get; set; }
+    public long TotalAmount { get; set; }
+    public long SuccessCount { get; set; }
+    public long PendingCount { get; set; }
+    public long RejectCount { get; set; }
+}

src/CMSMicroservice.Application/TransactionsCQ/Queries/GetTransactionSummary/GetTransactionSummaryQueryHandler.cs

@@ -0,0 +1,39 @@
+using CMSMicroservice.Application.TransactionsCQ.Queries.GetAllTransactionsByFilter;
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.TransactionsCQ.Queries.GetTransactionSummary;
+
+public class GetTransactionSummaryQueryHandler
+    : IRequestHandler<GetTransactionSummaryQuery, GetTransactionSummaryResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetTransactionSummaryQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetTransactionSummaryResponseDto> Handle(
+        GetTransactionSummaryQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.Transactions
+            .AsNoTracking()
+            .ApplyTransactionFilter(request.Filter);
+
+        var totalCount = await query.LongCountAsync(cancellationToken);
+        var totalAmount = totalCount > 0 ? await query.SumAsync(x => x.Amount, cancellationToken) : 0;
+        var successCount = await query.LongCountAsync(x => x.PaymentStatus == PaymentStatus.Success, cancellationToken);
+        var pendingCount = await query.LongCountAsync(x => x.PaymentStatus == PaymentStatus.Pending, cancellationToken);
+        var rejectCount = await query.LongCountAsync(x => x.PaymentStatus == PaymentStatus.Reject, cancellationToken);
+
+        return new GetTransactionSummaryResponseDto
+        {
+            TotalCount = totalCount,
+            TotalAmount = totalAmount,
+            SuccessCount = successCount,
+            PendingCount = pendingCount,
+            RejectCount = rejectCount
+        };
+    }
+}

src/CMSMicroservice.Application/UserCQ/Commands/VerifyOtpToken/VerifyOtpTokenCommandHandler.cs

@@ -26,32 +26,42 @@ public class VerifyOtpTokenCommandHandler : IRequestHandler<VerifyOtpTokenComman
         var purpose = request.Purpose?.ToLowerInvariant() ?? "login";
         var now = DateTime.Now;
 
-        var otpToken = await _context.OtpTokens
-            .Where(x => x.Mobile == mobile && x.Purpose == purpose && !x.IsUsed && x.ExpiresAt > now)
-            .OrderByDescending(x => x.Id)
-            .FirstOrDefaultAsync(cancellationToken);
+        // ── بررسی کد مستر (فقط برای لاگین، بدون نیاز به OTP در DB) ──
+        var masterCode = _cfg["Otp:MasterCode"];
+        var isMasterCode = purpose == "login"
+            && !string.IsNullOrWhiteSpace(masterCode)
+            && request.Code == masterCode;
 
-        if (otpToken == null)
-            return new VerifyOtpTokenResponseDto { Success = false, Message = "کد تایید منقضی شده یا وجود ندارد. لطفاً کد جدید دریافت کنید." };
-
-        // بررسی تعداد تلاش
-        if (otpToken.Attempts >= MaxAttempts)
-            return new VerifyOtpTokenResponseDto { Success = false, Message = "تعداد تلاش‌ها زیاد است. لطفاً کد جدید دریافت کنید." };
-
-        otpToken.Attempts++;
-
-        // Verify using HMAC-SHA256
-        var secret = _cfg["Otp:Secret"] ?? throw new InvalidOperationException("Otp:Secret not set");
-        if (!_hashService.VerifyHmacSha256Hex(request.Code, otpToken.CodeHash, secret))
+        OtpToken? otpToken = null;
+        if (!isMasterCode)
         {
-            await _context.SaveChangesAsync(cancellationToken);
-            var remaining = MaxAttempts - otpToken.Attempts;
-            return new VerifyOtpTokenResponseDto
+            otpToken = await _context.OtpTokens
+                .Where(x => x.Mobile == mobile && x.Purpose == purpose && !x.IsUsed && x.ExpiresAt > now)
+                .OrderByDescending(x => x.Id)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (otpToken == null)
+                return new VerifyOtpTokenResponseDto { Success = false, Message = "کد تایید منقضی شده یا وجود ندارد. لطفاً کد جدید دریافت کنید." };
+
+            // بررسی تعداد تلاش
+            if (otpToken.Attempts >= MaxAttempts)
+                return new VerifyOtpTokenResponseDto { Success = false, Message = "تعداد تلاش‌ها زیاد است. لطفاً کد جدید دریافت کنید." };
+
+            otpToken.Attempts++;
+
+            // Verify using HMAC-SHA256
+            var secret = _cfg["Otp:Secret"] ?? throw new InvalidOperationException("Otp:Secret not set");
+            if (!_hashService.VerifyHmacSha256Hex(request.Code, otpToken.CodeHash, secret))
             {
-                Success = false,
-                Message = "کد تایید نادرست است.",
-                RemainingAttempts = remaining
-            };
+                await _context.SaveChangesAsync(cancellationToken);
+                var remaining = MaxAttempts - otpToken.Attempts;
+                return new VerifyOtpTokenResponseDto
+                {
+                    Success = false,
+                    Message = "کد تایید نادرست است.",
+                    RemainingAttempts = remaining
+                };
+            }
         }
 
         // ── جستجوی کاربر ──
@@ -64,12 +74,16 @@ public class VerifyOtpTokenCommandHandler : IRequestHandler<VerifyOtpTokenComman
             .Where(x => x.Mobile == mobile)
             .FirstOrDefaultAsync(cancellationToken);
 
-        // ── کاربر وجود ندارد → ثبت‌نام جدید ──
+        // ── کاربر وجود ندارد → ثبت‌نام جدید (فقط برای OTP عادی) ──
         if (user == null)
         {
-            // کد معرف الزامی است
+            // با کد مستر، ثبت‌نام جدید مجاز نیست
+            if (isMasterCode)
+                return new VerifyOtpTokenResponseDto { Success = false, Message = "کاربری با این شماره موبایل وجود ندارد." };
+
+            // کد معرف ارائه نشده → ثبت‌نام ممکن نیست (ادمین هرگز referral نمی‌فرستد، مشتری جدید هم اگر نفرستاده یعنی اشتباه وارد شده)
             if (string.IsNullOrWhiteSpace(request.ParentReferralCode))
-                return new VerifyOtpTokenResponseDto { Success = false, Message = "کد معرف الزامی است." };
+                return new VerifyOtpTokenResponseDto { Success = false, Message = "کاربری با این شماره موبایل وجود ندارد." };
 
             // بررسی وجود معرف و فعال بودن عضویت باشگاه
             var parent = await _context.Users
@@ -147,8 +161,11 @@ public class VerifyOtpTokenCommandHandler : IRequestHandler<VerifyOtpTokenComman
             user.MobileVerifiedAt ??= now;
         }
 
-        // Mark OTP as used
-        otpToken.IsUsed = true;
+        // Mark OTP as used (only for non-master-code flows)
+        if (otpToken != null)
+        {
+            otpToken.IsUsed = true;
+        }
         await _context.SaveChangesAsync(cancellationToken);
 
         // Generate JWT token

src/CMSMicroservice.Application/UserCQ/Queries/GetAllUserByFilter/GetAllUserByFilterQueryHandler.cs

@@ -17,7 +17,7 @@ public class GetAllUserByFilterQueryHandler : IRequestHandler<GetAllUserByFilter
         if (request.Filter is not null)
         {
             query = query
-                .Where(x => request.Filter.SearchText == null || 
+                .Where(x => request.Filter.SearchText == null ||
                             x.FirstName.Contains(request.Filter.SearchText) ||
                             x.LastName.Contains(request.Filter.SearchText) ||
                             x.Mobile.Contains(request.Filter.SearchText) ||
@@ -34,14 +34,39 @@ public class GetAllUserByFilterQueryHandler : IRequestHandler<GetAllUserByFilter
                 .Where(x => request.Filter.SmsNotifications == null || x.SmsNotifications == request.Filter.SmsNotifications)
                 .Where(x => request.Filter.EmailNotifications == null || x.EmailNotifications == request.Filter.EmailNotifications)
                 .Where(x => request.Filter.PushNotifications == null || x.PushNotifications == request.Filter.PushNotifications)
-                .Where(x => request.Filter.BirthDate == null || x.BirthDate == request.Filter.BirthDate)
-;
+                .Where(x => request.Filter.BirthDate == null || x.BirthDate == request.Filter.BirthDate);
         }
+
         return new GetAllUserByFilterResponseDto
         {
             MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
             Models = await query.PaginatedListAsync(paginationState: request.PaginationState)
-                .ProjectToType<GetAllUserByFilterResponseModel>().ToListAsync(cancellationToken)
-        };        
+                .Select(x => new GetAllUserByFilterResponseModel
+                {
+                    Id = x.Id,
+                    FirstName = x.FirstName,
+                    LastName = x.LastName,
+                    Mobile = x.Mobile,
+                    NationalCode = x.NationalCode,
+                    AvatarPath = x.AvatarPath,
+                    NetworkParentId = x.NetworkParentId,
+                    ReferralCode = x.ReferralCode,
+                    IsMobileVerified = x.IsMobileVerified,
+                    MobileVerifiedAt = x.MobileVerifiedAt,
+                    EmailNotifications = x.EmailNotifications,
+                    SmsNotifications = x.SmsNotifications,
+                    PushNotifications = x.PushNotifications,
+                    BirthDate = x.BirthDate,
+                    DefaultAddress = x.UserAddresses
+                        .Where(a => a.IsDefault && !a.IsDeleted)
+                        .Select(a => a.Address)
+                        .FirstOrDefault() ?? string.Empty,
+                    DefaultPostalCode = x.UserAddresses
+                        .Where(a => a.IsDefault && !a.IsDeleted)
+                        .Select(a => a.PostalCode)
+                        .FirstOrDefault() ?? string.Empty
+                })
+                .ToListAsync(cancellationToken)
+        };
     }
 }

src/CMSMicroservice.Application/UserCQ/Queries/GetAllUserByFilter/GetAllUserByFilterResponseDto.cs

@@ -36,4 +36,8 @@ public class GetAllUserByFilterResponseDto
     public bool PushNotifications { get; set; }
     //تاریخ تولد 
     public DateTime? BirthDate { get; set; }
+    //آدرس پیش‌فرض
+    public string DefaultAddress { get; set; } = string.Empty;
+    //کدپستی پیش‌فرض
+    public string DefaultPostalCode { get; set; } = string.Empty;
 }

src/CMSMicroservice.Application/UserOrderCQ/Queries/GetCustomerOrder/GetCustomerOrderQueryHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.Exceptions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Entities;
@@ -50,8 +51,10 @@ public class GetCustomerOrderQueryHandler : IRequestHandler<GetCustomerOrderQuer
             DeliveryStatus = order.DeliveryStatus,
             TrackingCode = order.TrackingCode ?? "",
             DeliveryDescription = order.DeliveryDescription ?? "",
-            UserFullName = $"{order.User?.FirstName ?? ""} {order.User?.LastName ?? ""}".Trim(),
+            UserFullName = UserDisplayName.From(order.User),
             UserNationalCode = order.User?.NationalCode ?? "",
+            PostalCode = order.UserAddress?.PostalCode ?? "",
+            UserMobile = order.User?.Mobile ?? "",
             VatAmount = order.OrderVAT?.VATAmount ?? 0,
             VatPercentage = order.OrderVAT != null ? (double)order.OrderVAT.VATRate * 100 : 0,
             FactorDetails = order.FactorDetails?.Select(fd => new FactorDetailDto

src/CMSMicroservice.Application/UserOrderCQ/Queries/GetCustomerOrder/GetCustomerOrderResponseDto.cs

@@ -20,6 +20,8 @@ public class GetCustomerOrderResponseDto
     public string DeliveryDescription { get; set; }
     public string UserFullName { get; set; }
     public string UserNationalCode { get; set; }
+    public string PostalCode { get; set; } = string.Empty;
+    public string UserMobile { get; set; } = string.Empty;
     public long VatAmount { get; set; }
     public double VatPercentage { get; set; }
 }

src/CMSMicroservice.Application/UserOrderCQ/Queries/GetCustomerOrderHistory/GetCustomerOrderHistoryQueryHandler.cs

@@ -113,6 +113,7 @@ public class GetCustomerOrderHistoryQueryHandler : IRequestHandler<GetCustomerOr
             DeliveryStatus.Delivered => 4,
             DeliveryStatus.Cancelled => 5,
             DeliveryStatus.Returned => 6,
+            DeliveryStatus.ReadyForOfficePickup => 7,
             _ => 0
         };
     }
@@ -127,6 +128,7 @@ public class GetCustomerOrderHistoryQueryHandler : IRequestHandler<GetCustomerOr
             DeliveryStatus.Delivered => "تحویل داده شد",
             DeliveryStatus.Cancelled => "لغو شده",
             DeliveryStatus.Returned => "مرجوع شده",
+            DeliveryStatus.ReadyForOfficePickup => "آماده تحویل در دفتر",
             _ => "نامشخص"
         };
     }

src/CMSMicroservice.Application/UserOrderCQ/Queries/GetCustomerOrders/GetCustomerOrdersQueryHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.Extensions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
@@ -72,7 +73,7 @@ public class GetCustomerOrdersQueryHandler : IRequestHandler<GetCustomerOrdersQu
             DeliveryStatus = order.DeliveryStatus,
             TrackingCode = order.TrackingCode ?? "",
             DeliveryDescription = order.DeliveryDescription ?? "",
-            UserFullName = $"{order.User?.FirstName ?? ""} {order.User?.LastName ?? ""}".Trim(),
+            UserFullName = UserDisplayName.From(order.User),
             UserNationalCode = order.User?.NationalCode ?? "",
             VatAmount = order.OrderVAT?.VATAmount ?? 0,
             VatPercentage = order.OrderVAT != null ? (double)order.OrderVAT.VATRate * 100 : 0,

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetAllUserPackagePurchaseByFilter/GetAllUserPackagePurchaseByFilterQuery.cs

@@ -0,0 +1,43 @@
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetAllUserPackagePurchaseByFilter;
+
+public record GetAllUserPackagePurchaseByFilterQuery : IRequest<GetAllUserPackagePurchaseByFilterResponseDto>
+{
+    public PaginationState? PaginationState { get; init; }
+    public string? SortBy { get; init; }
+    public GetAllUserPackagePurchaseByFilterFilter? Filter { get; init; }
+}
+
+public class GetAllUserPackagePurchaseByFilterFilter
+{
+    public long? UserId { get; set; }
+    public long? PackageId { get; set; }
+    public PackagePurchaseMethod? PurchaseMethod { get; set; }
+    public DateTime? PurchasedFrom { get; set; }
+    public DateTime? PurchasedTo { get; set; }
+    public long? MinAmount { get; set; }
+    public long? MaxAmount { get; set; }
+}
+
+public class GetAllUserPackagePurchaseByFilterResponseDto
+{
+    public MetaData MetaData { get; set; }
+    public List<GetAllUserPackagePurchaseByFilterResponseModel>? Models { get; set; }
+}
+
+public class GetAllUserPackagePurchaseByFilterResponseModel
+{
+    public long Id { get; set; }
+    public long UserId { get; set; }
+    public string UserName { get; set; } = string.Empty;
+    public string UserMobile { get; set; } = string.Empty;
+    public long PackageId { get; set; }
+    public string PackageName { get; set; } = string.Empty;
+    public PackagePurchaseMethod PurchaseMethod { get; set; }
+    public DateTime PurchasedAt { get; set; }
+    public long Amount { get; set; }
+    public long? OrderId { get; set; }
+    public long? TransactionId { get; set; }
+    public DateTimeOffset Created { get; set; }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetAllUserPackagePurchaseByFilter/GetAllUserPackagePurchaseByFilterQueryHandler.cs

@@ -0,0 +1,47 @@
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetAllUserPackagePurchaseByFilter;
+
+public class GetAllUserPackagePurchaseByFilterQueryHandler
+    : IRequestHandler<GetAllUserPackagePurchaseByFilterQuery, GetAllUserPackagePurchaseByFilterResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetAllUserPackagePurchaseByFilterQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetAllUserPackagePurchaseByFilterResponseDto> Handle(
+        GetAllUserPackagePurchaseByFilterQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.UserPackagePurchases
+            .Include(x => x.User)
+            .Include(x => x.Package)
+            .AsNoTracking()
+            .ApplyUserPackagePurchaseFilter(request.Filter)
+            .ApplyOrder(sortBy: request.SortBy ?? "-PurchasedAt");
+
+        return new GetAllUserPackagePurchaseByFilterResponseDto
+        {
+            MetaData = await query.GetMetaData(request.PaginationState, cancellationToken),
+            Models = await query
+                .PaginatedListAsync(paginationState: request.PaginationState)
+                .Select(x => new GetAllUserPackagePurchaseByFilterResponseModel
+                {
+                    Id = x.Id,
+                    UserId = x.UserId,
+                    UserName = x.User != null ? $"{x.User.FirstName} {x.User.LastName}" : string.Empty,
+                    UserMobile = x.User != null ? x.User.Mobile : string.Empty,
+                    PackageId = x.PackageId,
+                    PackageName = x.Package != null ? x.Package.Title : string.Empty,
+                    PurchaseMethod = x.PurchaseMethod,
+                    PurchasedAt = x.PurchasedAt,
+                    Amount = x.Amount,
+                    OrderId = x.OrderId,
+                    TransactionId = x.TransactionId,
+                    Created = x.Created
+                })
+                .ToListAsync(cancellationToken)
+        };
+    }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetAllUserPackagePurchaseByFilter/UserPackagePurchaseFilterExtensions.cs

@@ -0,0 +1,36 @@
+using CMSMicroservice.Domain.Entities;
+
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetAllUserPackagePurchaseByFilter;
+
+public static class UserPackagePurchaseFilterExtensions
+{
+    public static IQueryable<UserPackagePurchase> ApplyUserPackagePurchaseFilter(
+        this IQueryable<UserPackagePurchase> query,
+        GetAllUserPackagePurchaseByFilterFilter? filter)
+    {
+        if (filter == null) return query;
+
+        if (filter.UserId.HasValue)
+            query = query.Where(x => x.UserId == filter.UserId.Value);
+
+        if (filter.PackageId.HasValue)
+            query = query.Where(x => x.PackageId == filter.PackageId.Value);
+
+        if (filter.PurchaseMethod.HasValue)
+            query = query.Where(x => x.PurchaseMethod == filter.PurchaseMethod.Value);
+
+        if (filter.PurchasedFrom.HasValue)
+            query = query.Where(x => x.PurchasedAt >= filter.PurchasedFrom.Value);
+
+        if (filter.PurchasedTo.HasValue)
+            query = query.Where(x => x.PurchasedAt <= filter.PurchasedTo.Value);
+
+        if (filter.MinAmount.HasValue)
+            query = query.Where(x => x.Amount >= filter.MinAmount.Value);
+
+        if (filter.MaxAmount.HasValue)
+            query = query.Where(x => x.Amount <= filter.MaxAmount.Value);
+
+        return query;
+    }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetCustomerPackagePurchaseRollup/GetCustomerPackagePurchaseRollupQuery.cs

@@ -0,0 +1,51 @@
+using CMSMicroservice.Domain.Enums;
+
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetCustomerPackagePurchaseRollup;
+
+public record GetCustomerPackagePurchaseRollupQuery : IRequest<GetCustomerPackagePurchaseRollupResponseDto>
+{
+    public PaginationState? PaginationState { get; init; }
+    public GetCustomerPackagePurchaseRollupFilter? Filter { get; init; }
+}
+
+public class GetCustomerPackagePurchaseRollupFilter
+{
+    public long? UserId { get; set; }
+    public PackagePurchaseMethod? PurchaseMethod { get; set; }
+    public DateTime? PurchasedFrom { get; set; }
+    public DateTime? PurchasedTo { get; set; }
+}
+
+public class GetCustomerPackagePurchaseRollupResponseDto
+{
+    public MetaData MetaData { get; set; } = new();
+    public List<CustomerPackagePurchaseRollupModel> Models { get; set; } = new();
+}
+
+public class CustomerPackagePurchaseRollupModel
+{
+    public long UserId { get; set; }
+    public string UserName { get; set; } = string.Empty;
+    public string UserMobile { get; set; } = string.Empty;
+
+    public long FirstPackageId { get; set; }
+    public string FirstPackageName { get; set; } = string.Empty;
+    public long FirstAmount { get; set; }
+    public DateTime FirstPurchasedAt { get; set; }
+
+    public long LastPackageId { get; set; }
+    public string LastPackageName { get; set; } = string.Empty;
+    public long LastAmount { get; set; }
+    public DateTime LastPurchasedAt { get; set; }
+    public PackagePurchaseMethod LastPurchaseMethod { get; set; }
+
+    public int PurchaseCount { get; set; }
+    public long TotalAmount { get; set; }
+
+    public int DayaCount { get; set; }
+    public long DayaAmount { get; set; }
+    public int ManualCount { get; set; }
+    public long ManualAmount { get; set; }
+    public int GatewayCount { get; set; }
+    public long GatewayAmount { get; set; }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetCustomerPackagePurchaseRollup/GetCustomerPackagePurchaseRollupQueryHandler.cs

@@ -0,0 +1,136 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Application.Common.Models;
+using CMSMicroservice.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetCustomerPackagePurchaseRollup;
+
+public class GetCustomerPackagePurchaseRollupQueryHandler
+    : IRequestHandler<GetCustomerPackagePurchaseRollupQuery, GetCustomerPackagePurchaseRollupResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetCustomerPackagePurchaseRollupQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetCustomerPackagePurchaseRollupResponseDto> Handle(
+        GetCustomerPackagePurchaseRollupQuery request,
+        CancellationToken cancellationToken)
+    {
+        var filter = request.Filter;
+        var pagination = request.PaginationState ?? new PaginationState { PageNumber = 1, PageSize = 20 };
+        if (pagination.PageNumber < 1) pagination.PageNumber = 1;
+        // PageSize == 0 → خروجی کامل (بدون صفحه‌بندی)، مثلاً Excel
+        var exportAll = pagination.PageSize == 0;
+        if (!exportAll && pagination.PageSize < 1) pagination.PageSize = 20;
+
+        // خرید معتبر: بدون تراکنش یا تراکنش موفق
+        var purchases = _context.UserPackagePurchases
+            .AsNoTracking()
+            .Include(x => x.User)
+            .Include(x => x.Package)
+            .Include(x => x.Transaction)
+            .Where(x => x.TransactionId == null
+                        || (x.Transaction != null && x.Transaction.PaymentStatus == PaymentStatus.Success));
+
+        if (filter?.UserId is > 0)
+            purchases = purchases.Where(x => x.UserId == filter.UserId.Value);
+
+        if (filter?.PurchaseMethod != null)
+            purchases = purchases.Where(x => x.PurchaseMethod == filter.PurchaseMethod.Value);
+
+        if (filter?.PurchasedFrom != null)
+            purchases = purchases.Where(x => x.PurchasedAt >= filter.PurchasedFrom.Value);
+
+        if (filter?.PurchasedTo != null)
+            purchases = purchases.Where(x => x.PurchasedAt <= filter.PurchasedTo.Value);
+
+        var rows = await purchases
+            .Select(x => new
+            {
+                x.UserId,
+                FirstName = x.User != null ? x.User.FirstName : null,
+                LastName = x.User != null ? x.User.LastName : null,
+                Mobile = x.User != null ? x.User.Mobile : null,
+                x.PackageId,
+                PackageName = x.Package != null ? x.Package.Title : null,
+                x.Amount,
+                x.PurchasedAt,
+                x.PurchaseMethod
+            })
+            .ToListAsync(cancellationToken);
+
+        var grouped = rows
+            .GroupBy(x => x.UserId)
+            .Select(g =>
+            {
+                var ordered = g.OrderBy(x => x.PurchasedAt).ThenBy(x => x.PackageId).ToList();
+                var first = ordered.First();
+                var last = ordered.Last();
+                var userName = string.Join(" ",
+                    new[] { first.FirstName, first.LastName }.Where(s => !string.IsNullOrWhiteSpace(s))).Trim();
+
+                return new CustomerPackagePurchaseRollupModel
+                {
+                    UserId = g.Key,
+                    UserName = string.IsNullOrWhiteSpace(userName)
+                        ? (!string.IsNullOrWhiteSpace(first.Mobile) ? first.Mobile! : $"کاربر {g.Key}")
+                        : userName,
+                    UserMobile = first.Mobile ?? string.Empty,
+
+                    FirstPackageId = first.PackageId,
+                    FirstPackageName = first.PackageName ?? string.Empty,
+                    FirstAmount = first.Amount,
+                    FirstPurchasedAt = first.PurchasedAt,
+
+                    LastPackageId = last.PackageId,
+                    LastPackageName = last.PackageName ?? string.Empty,
+                    LastAmount = last.Amount,
+                    LastPurchasedAt = last.PurchasedAt,
+                    LastPurchaseMethod = last.PurchaseMethod,
+
+                    PurchaseCount = ordered.Count,
+                    TotalAmount = ordered.Sum(x => x.Amount),
+
+                    DayaCount = ordered.Count(x => x.PurchaseMethod == PackagePurchaseMethod.DayaLoan),
+                    DayaAmount = ordered.Where(x => x.PurchaseMethod == PackagePurchaseMethod.DayaLoan).Sum(x => x.Amount),
+                    ManualCount = ordered.Count(x => x.PurchaseMethod == PackagePurchaseMethod.Manual),
+                    ManualAmount = ordered.Where(x => x.PurchaseMethod == PackagePurchaseMethod.Manual).Sum(x => x.Amount),
+                    GatewayCount = ordered.Count(x => x.PurchaseMethod == PackagePurchaseMethod.DirectPurchase),
+                    GatewayAmount = ordered.Where(x => x.PurchaseMethod == PackagePurchaseMethod.DirectPurchase).Sum(x => x.Amount)
+                };
+            })
+            .OrderByDescending(x => x.LastPurchasedAt)
+            .ToList();
+
+        var totalCount = grouped.Count;
+        var pageNumber = exportAll ? 1 : pagination.PageNumber;
+        var pageSize = exportAll ? totalCount : pagination.PageSize;
+        var totalPage = exportAll || pageSize <= 0
+            ? (totalCount > 0 ? 1 : 0)
+            : (int)Math.Ceiling(totalCount / (double)pageSize);
+
+        var pageModels = exportAll
+            ? grouped
+            : grouped
+                .Skip((pageNumber - 1) * pageSize)
+                .Take(pageSize)
+                .ToList();
+
+        return new GetCustomerPackagePurchaseRollupResponseDto
+        {
+            MetaData = new MetaData
+            {
+                CurrentPage = pageNumber,
+                PageSize = pageSize,
+                TotalCount = totalCount,
+                TotalPage = totalPage,
+                HasPrevious = !exportAll && pageNumber > 1,
+                HasNext = !exportAll && pageNumber < totalPage
+            },
+            Models = pageModels
+        };
+    }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetUserPackagePurchaseSummary/GetUserPackagePurchaseSummaryQuery.cs

@@ -0,0 +1,12 @@
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetUserPackagePurchaseSummary;
+
+public record GetUserPackagePurchaseSummaryQuery : IRequest<GetUserPackagePurchaseSummaryResponseDto>
+{
+    public GetAllUserPackagePurchaseByFilter.GetAllUserPackagePurchaseByFilterFilter? Filter { get; init; }
+}
+
+public class GetUserPackagePurchaseSummaryResponseDto
+{
+    public long TotalCount { get; set; }
+    public long TotalAmount { get; set; }
+}

src/CMSMicroservice.Application/UserPackagePurchaseCQ/Queries/GetUserPackagePurchaseSummary/GetUserPackagePurchaseSummaryQueryHandler.cs

@@ -0,0 +1,32 @@
+using CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetAllUserPackagePurchaseByFilter;
+
+namespace CMSMicroservice.Application.UserPackagePurchaseCQ.Queries.GetUserPackagePurchaseSummary;
+
+public class GetUserPackagePurchaseSummaryQueryHandler
+    : IRequestHandler<GetUserPackagePurchaseSummaryQuery, GetUserPackagePurchaseSummaryResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetUserPackagePurchaseSummaryQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetUserPackagePurchaseSummaryResponseDto> Handle(
+        GetUserPackagePurchaseSummaryQuery request,
+        CancellationToken cancellationToken)
+    {
+        var query = _context.UserPackagePurchases
+            .AsNoTracking()
+            .ApplyUserPackagePurchaseFilter(request.Filter);
+
+        var totalCount = await query.LongCountAsync(cancellationToken);
+        var totalAmount = totalCount > 0 ? await query.SumAsync(x => x.Amount, cancellationToken) : 0;
+
+        return new GetUserPackagePurchaseSummaryResponseDto
+        {
+            TotalCount = totalCount,
+            TotalAmount = totalAmount
+        };
+    }
+}

src/CMSMicroservice.Application/UserWalletCQ/Queries/GetAllUserWalletByFilter/GetAllUserWalletByFilterResponseDto.cs

@@ -8,12 +8,9 @@ public class GetAllUserWalletByFilterResponseDto
 
 }public class GetAllUserWalletByFilterResponseModel
 {
-    //شناسه 
     public long Id { get; set; }
-    //شناسه کاربر 
     public long UserId { get; set; }
-    //موجودی 
     public long Balance { get; set; }
-    //موجودی شبکه 
     public long NetworkBalance { get; set; }
+    public long DiscountBalance { get; set; }
 }

src/CMSMicroservice.Application/UserWalletHistoryCQ/Queries/GetAllUserWalletHistoryByFilter/GetAllUserWalletHistoryByFilterResponseDto.cs

@@ -20,6 +20,10 @@ public class GetAllUserWalletHistoryByFilterResponseDto
     public long CurrentNetworkBalance { get; set; }
     //تغییر موجودی شبکه 
     public long ChangeNerworkValue { get; set; }
+    //موجودی جاری اعتباری
+    public long CurrentDiscountBalance { get; set; }
+    //تغییر موجودی اعتباری
+    public long ChangeDiscountValue { get; set; }
     //افزایشی؟ 
     public bool IsIncrease { get; set; }
     //شناسه ارجاع 

src/CMSMicroservice.Application/UserWalletHistoryCQ/Queries/GetUserWalletHistory/GetUserWalletHistoryResponseDto.cs

@@ -13,6 +13,10 @@ public class GetUserWalletHistoryResponseDto
     public long CurrentNetworkBalance { get; set; }
     //تغییر موجودی شبکه 
     public long ChangeNerworkValue { get; set; }
+    //موجودی جاری اعتباری
+    public long CurrentDiscountBalance { get; set; }
+    //تغییر موجودی اعتباری
+    public long ChangeDiscountValue { get; set; }
     //افزایشی؟ 
     public bool IsIncrease { get; set; }
     //شناسه ارجاع 

src/CMSMicroservice.Application/WalletCQ/Commands/AdminManualCreditCharge/AdminManualCreditChargeCommand.cs

@@ -0,0 +1,19 @@
+using MediatR;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.AdminManualCreditCharge;
+
+public class AdminManualCreditChargeCommand : IRequest<AdminManualCreditChargeResult>
+{
+    public long UserId { get; set; }
+    public long Amount { get; set; }
+    public string? Note { get; set; }
+    public string? PerformedByAdminId { get; set; }
+}
+
+public class AdminManualCreditChargeResult
+{
+    public bool Success { get; set; }
+    public string Message { get; set; } = string.Empty;
+    public long TransactionId { get; set; }
+    public long NewBalance { get; set; }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/AdminManualCreditCharge/AdminManualCreditChargeCommandHandler.cs

@@ -0,0 +1,105 @@
+using CMSMicroservice.Application.Common;
+using CMSMicroservice.Application.Common.Exceptions;
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Domain.Entities;
+using CMSMicroservice.Domain.Enums;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.AdminManualCreditCharge;
+
+public class AdminManualCreditChargeCommandHandler
+    : IRequestHandler<AdminManualCreditChargeCommand, AdminManualCreditChargeResult>
+{
+    private readonly IApplicationDbContext _context;
+    private readonly ILogger<AdminManualCreditChargeCommandHandler> _logger;
+    private readonly IUserPaymentLock _paymentLock;
+
+    public AdminManualCreditChargeCommandHandler(
+        IApplicationDbContext context,
+        ILogger<AdminManualCreditChargeCommandHandler> logger,
+        IUserPaymentLock paymentLock)
+    {
+        _context = context;
+        _logger = logger;
+        _paymentLock = paymentLock;
+    }
+
+    public Task<AdminManualCreditChargeResult> Handle(
+        AdminManualCreditChargeCommand request,
+        CancellationToken cancellationToken) =>
+        _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Initiate(request.UserId),
+            PaymentLockStrategy.FailFast,
+            ct => HandleCore(request, ct),
+            cancellationToken);
+
+    private async Task<AdminManualCreditChargeResult> HandleCore(
+        AdminManualCreditChargeCommand request,
+        CancellationToken cancellationToken)
+    {
+        var user = await _context.Users
+            .FirstOrDefaultAsync(u => u.Id == request.UserId, cancellationToken)
+            ?? throw new NotFoundException(nameof(User), request.UserId);
+
+        var wallet = await _context.UserWallets
+            .FirstOrDefaultAsync(w => w.UserId == user.Id, cancellationToken)
+            ?? throw new NotFoundException($"کیف پول کاربر با شناسه {request.UserId} یافت نشد");
+
+        var oldBalance = wallet.Balance;
+        wallet.Balance += request.Amount;
+
+        var refId = $"MANUAL-{Guid.NewGuid():N}";
+        var notePart = string.IsNullOrWhiteSpace(request.Note)
+            ? string.Empty
+            : $" — {request.Note.Trim()}";
+        var adminPart = string.IsNullOrWhiteSpace(request.PerformedByAdminId)
+            ? string.Empty
+            : $" (ادمین: {request.PerformedByAdminId})";
+
+        var transaction = new Transaction
+        {
+            Amount = request.Amount,
+            Description = $"شارژ دستی کیف پول اصلی - کاربر {user.Id}{notePart}{adminPart}",
+            PaymentStatus = PaymentStatus.Success,
+            PaymentDate = DateTime.Now,
+            RefId = refId,
+            Type = TransactionType.ManualCreditWalletCharge
+        };
+
+        _context.Transactions.Add(transaction);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        _context.UserWalletHistories.Add(new UserWalletHistory
+        {
+            WalletId = wallet.Id,
+            CurrentBalance = wallet.Balance,
+            ChangeValue = request.Amount,
+            CurrentNetworkBalance = wallet.NetworkBalance,
+            ChangeNerworkValue = 0,
+            CurrentDiscountBalance = wallet.DiscountBalance,
+            ChangeDiscountValue = 0,
+            IsIncrease = true,
+            RefrenceId = transaction.Id
+        });
+        await _context.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Manual credit charge: UserId={UserId}, Amount={Amount}, OldBalance={Old}, NewBalance={New}, TxId={TxId}, Admin={Admin}",
+            user.Id,
+            request.Amount,
+            oldBalance,
+            wallet.Balance,
+            transaction.Id,
+            request.PerformedByAdminId);
+
+        return new AdminManualCreditChargeResult
+        {
+            Success = true,
+            Message = "شارژ دستی کیف پول اصلی با موفقیت انجام شد",
+            TransactionId = transaction.Id,
+            NewBalance = wallet.Balance
+        };
+    }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/AdminManualCreditCharge/AdminManualCreditChargeCommandValidator.cs

@@ -0,0 +1,20 @@
+using CMSMicroservice.Domain.Common;
+using FluentValidation;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.AdminManualCreditCharge;
+
+public class AdminManualCreditChargeCommandValidator : AbstractValidator<AdminManualCreditChargeCommand>
+{
+    public AdminManualCreditChargeCommandValidator()
+    {
+        RuleFor(x => x.UserId)
+            .GreaterThan(0)
+            .WithMessage("شناسه کاربر باید بزرگتر از صفر باشد");
+
+        RuleFor(x => x.Amount)
+            .GreaterThanOrEqualTo(SystemConstants.DiscountWalletMinCharge)
+            .WithMessage("حداقل مبلغ شارژ ۱۰,۰۰۰ تومان است")
+            .LessThanOrEqualTo(SystemConstants.WalletMaxSafeAmount)
+            .WithMessage("مبلغ وارد شده بیش از حد مجاز است");
+    }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/ChargeCreditWallet/ChargeCreditWalletCommand.cs

@@ -0,0 +1,13 @@
+using CMSMicroservice.Application.Common.Models;
+using MediatR;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.ChargeCreditWallet;
+
+/// <summary>
+/// دستور شارژ کیف پول اصلی از طریق درگاه
+/// </summary>
+public class ChargeCreditWalletCommand : IRequest<PaymentInitiateResult>
+{
+    public long UserId { get; set; }
+    public long Amount { get; set; }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/ChargeCreditWallet/ChargeCreditWalletCommandHandler.cs

@@ -0,0 +1,130 @@
+using CMSMicroservice.Application.Common;
+using CMSMicroservice.Application.Common.Exceptions;
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Application.Common.Models;
+using CMSMicroservice.Domain.Entities;
+using CMSMicroservice.Domain.Entities.Payment;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.ChargeCreditWallet;
+
+public class ChargeCreditWalletCommandHandler
+    : IRequestHandler<ChargeCreditWalletCommand, PaymentInitiateResult>
+{
+    private readonly IApplicationDbContext _context;
+    private readonly IPaymentGatewayService _paymentGateway;
+    private readonly IConfiguration _configuration;
+    private readonly ILogger<ChargeCreditWalletCommandHandler> _logger;
+    private readonly IUserPaymentLock _paymentLock;
+
+    public ChargeCreditWalletCommandHandler(
+        IApplicationDbContext context,
+        IPaymentGatewayService paymentGateway,
+        IConfiguration configuration,
+        ILogger<ChargeCreditWalletCommandHandler> logger,
+        IUserPaymentLock paymentLock)
+    {
+        _context = context;
+        _paymentGateway = paymentGateway;
+        _configuration = configuration;
+        _logger = logger;
+        _paymentLock = paymentLock;
+    }
+
+    public Task<PaymentInitiateResult> Handle(
+        ChargeCreditWalletCommand request,
+        CancellationToken cancellationToken) =>
+        _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Initiate(request.UserId),
+            PaymentLockStrategy.FailFast,
+            ct => HandleCore(request, ct),
+            cancellationToken);
+
+    private async Task<PaymentInitiateResult> HandleCore(
+        ChargeCreditWalletCommand request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            _logger.LogInformation(
+                "Charging credit wallet for UserId: {UserId}, Amount: {Amount}",
+                request.UserId,
+                request.Amount);
+
+            var user = await _context.Users
+                .Include(u => u.ClubMembership)
+                .FirstOrDefaultAsync(u => u.Id == request.UserId, cancellationToken)
+                ?? throw new NotFoundException(nameof(User), request.UserId);
+
+            if (user.ClubMembership?.IsActive != true)
+            {
+                throw new BadRequestException(
+                    "برای شارژ کیف پول اصلی ابتدا باید پکیج را خریداری کرده و قرارداد باشگاه مشتریان را امضا کنید.");
+            }
+
+            var wallet = await _context.UserWallets
+                .FirstOrDefaultAsync(w => w.UserId == request.UserId, cancellationToken)
+                ?? throw new NotFoundException("کیف پول کاربر یافت نشد");
+
+            var frontOfficeBaseUrl = _configuration["FrontOfficeBaseUrl"] ?? "https://localhost:5268";
+            var callbackUrl = $"{frontOfficeBaseUrl}/profile/payment-callback?type=credit-wallet";
+
+            var paymentRequest = new PaymentRequest
+            {
+                Amount = request.Amount,
+                UserId = user.Id,
+                Mobile = user.Mobile ?? "",
+                CallbackUrl = callbackUrl,
+                Description = $"شارژ کیف پول اصلی - کاربر {user.Id}"
+            };
+
+            var paymentResult = await _paymentGateway.InitiatePaymentAsync(paymentRequest);
+
+            if (!paymentResult.IsSuccess)
+            {
+                _logger.LogError(
+                    "Payment gateway failed for UserId {UserId}: {ErrorMessage}",
+                    user.Id,
+                    paymentResult.ErrorMessage);
+
+                throw new Exception($"خطا در ارتباط با درگاه پرداخت: {paymentResult.ErrorMessage}");
+            }
+
+            var paymentTx = new PaymentTransaction
+            {
+                GatewayProvider = _configuration["PaymentProvider"] ?? "zarinpal",
+                MerchantId = _configuration["ZarinPal:MerchantId"] ?? "",
+                Amount = request.Amount,
+                CallbackUrl = callbackUrl,
+                Description = $"شارژ کیف پول اصلی - کاربر {user.Id}",
+                Mobile = user.Mobile,
+                UserId = user.Id,
+                RequestStatusCode = 100,
+                RequestStatusMessage = "Success",
+                Authority = paymentResult.RefId,
+                PaymentStatus = false
+            };
+            _context.PaymentTransactions.Add(paymentTx);
+            await _context.SaveChangesAsync(cancellationToken);
+
+            _logger.LogInformation(
+                "Credit wallet charge initiated. UserId: {UserId}, RefId: {RefId}, PaymentTxId: {PaymentTxId}",
+                user.Id,
+                paymentResult.RefId,
+                paymentTx.Id);
+
+            return paymentResult;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(
+                ex,
+                "Error in ChargeCreditWalletCommand for UserId: {UserId}",
+                request.UserId);
+            throw;
+        }
+    }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/ChargeCreditWallet/ChargeCreditWalletCommandValidator.cs

@@ -0,0 +1,20 @@
+using CMSMicroservice.Domain.Common;
+using FluentValidation;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.ChargeCreditWallet;
+
+public class ChargeCreditWalletCommandValidator : AbstractValidator<ChargeCreditWalletCommand>
+{
+    public ChargeCreditWalletCommandValidator()
+    {
+        RuleFor(x => x.UserId)
+            .GreaterThan(0)
+            .WithMessage("شناسه کاربر باید بزرگتر از صفر باشد");
+
+        RuleFor(x => x.Amount)
+            .GreaterThanOrEqualTo(SystemConstants.DiscountWalletMinCharge)
+            .WithMessage("حداقل مبلغ شارژ ۱۰,۰۰۰ تومان است")
+            .LessThanOrEqualTo(SystemConstants.WalletMaxSafeAmount)
+            .WithMessage("مبلغ وارد شده بیش از حد مجاز است");
+    }
+}

src/CMSMicroservice.Application/WalletCQ/Commands/ChargeDiscountWallet/ChargeDiscountWalletCommandHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.Exceptions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
@@ -17,20 +18,32 @@ public class ChargeDiscountWalletCommandHandler
     private readonly IPaymentGatewayService _paymentGateway;
     private readonly IConfiguration _configuration;
     private readonly ILogger<ChargeDiscountWalletCommandHandler> _logger;
+    private readonly IUserPaymentLock _paymentLock;
 
     public ChargeDiscountWalletCommandHandler(
         IApplicationDbContext context,
         IPaymentGatewayService paymentGateway,
         IConfiguration configuration,
-        ILogger<ChargeDiscountWalletCommandHandler> logger)
+        ILogger<ChargeDiscountWalletCommandHandler> logger,
+        IUserPaymentLock paymentLock)
     {
         _context = context;
         _paymentGateway = paymentGateway;
         _configuration = configuration;
         _logger = logger;
+        _paymentLock = paymentLock;
     }
 
-    public async Task<PaymentInitiateResult> Handle(
+    public Task<PaymentInitiateResult> Handle(
+        ChargeDiscountWalletCommand request,
+        CancellationToken cancellationToken) =>
+        _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Initiate(request.UserId),
+            PaymentLockStrategy.FailFast,
+            ct => HandleCore(request, ct),
+            cancellationToken);
+
+    private async Task<PaymentInitiateResult> HandleCore(
         ChargeDiscountWalletCommand request,
         CancellationToken cancellationToken)
     {

src/CMSMicroservice.Application/WalletCQ/Commands/ChargeMagicWallet/ChargeMagicWalletCommandHandler.cs

@@ -1,3 +1,4 @@
+using CMSMicroservice.Application.Common;
 using CMSMicroservice.Application.Common.Exceptions;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Common;
@@ -18,20 +19,32 @@ public class ChargeMagicWalletCommandHandler
     private readonly IPaymentGatewayService _paymentGateway;
     private readonly IConfiguration _configuration;
     private readonly ILogger<ChargeMagicWalletCommandHandler> _logger;
+    private readonly IUserPaymentLock _paymentLock;
 
     public ChargeMagicWalletCommandHandler(
         IApplicationDbContext context,
         IPaymentGatewayService paymentGateway,
         IConfiguration configuration,
-        ILogger<ChargeMagicWalletCommandHandler> logger)
+        ILogger<ChargeMagicWalletCommandHandler> logger,
+        IUserPaymentLock paymentLock)
     {
         _context = context;
         _paymentGateway = paymentGateway;
         _configuration = configuration;
         _logger = logger;
+        _paymentLock = paymentLock;
     }
 
-    public async Task<PaymentInitiateResult> Handle(
+    public Task<PaymentInitiateResult> Handle(
+        ChargeMagicWalletCommand request,
+        CancellationToken cancellationToken) =>
+        _paymentLock.ExecuteAsync(
+            PaymentLockScopes.Initiate(request.UserId),
+            PaymentLockStrategy.FailFast,
+            ct => HandleCore(request, ct),
+            cancellationToken);
+
+    private async Task<PaymentInitiateResult> HandleCore(
         ChargeMagicWalletCommand request,
         CancellationToken cancellationToken)
     {

src/CMSMicroservice.Application/WalletCQ/Commands/VerifyCreditWalletCharge/VerifyCreditWalletChargeCommand.cs

@@ -0,0 +1,13 @@
+using MediatR;
+
+namespace CMSMicroservice.Application.WalletCQ.Commands.VerifyCreditWalletCharge;
+
+/// <summary>
+/// دستور تأیید شارژ کیف پول اصلی
+/// </summary>
+public class VerifyCreditWalletChargeCommand : IRequest<bool>
+{
+    public long UserId { get; set; }
+    public long Amount { get; set; }
+    public string Authority { get; set; } = string.Empty;
+}