feat: Implement Public Message management features including create, update, delete, and publish functionalities

src/BackOffice.BFF.Application/CommissionCQ/Commands/ProcessWithdrawal/ProcessWithdrawalCommandHandler.cs

@@ -1,4 +1,5 @@
 using BackOffice.BFF.Commission.Protobuf;
+using Google.Protobuf.WellKnownTypes;
 
 namespace BackOffice.BFF.Application.CommissionCQ.Commands.ProcessWithdrawal;
 
@@ -13,30 +14,21 @@ public class ProcessWithdrawalCommandHandler : IRequestHandler<ProcessWithdrawal
 
     public async Task<ProcessWithdrawalResponseDto> Handle(ProcessWithdrawalCommand request, CancellationToken cancellationToken)
     {
-        // TODO: Implement when CMS ProcessWithdrawal endpoint is ready
+        var grpcRequest = new ProcessWithdrawalRequest
-        await Task.CompletedTask;
+        {
-        
+            PayoutId = request.WithdrawalId,
+            IsApproved = true,
+            Reason = request.AdminNote != null 
+                ? new StringValue { Value = request.AdminNote } 
+                : null
+        };
+
+        await _context.Commissions.ProcessWithdrawalAsync(grpcRequest, cancellationToken: cancellationToken);
+
         return new ProcessWithdrawalResponseDto
         {
             Success = true,
-            Message = "Withdrawal processing pending CMS implementation"
+            Message = "درخواست برداشت برای پرداخت ارسال شد"
         };
-        
-        /* Uncomment when CMS endpoint is ready:
-        var grpcRequest = new ProcessWithdrawalRequest
-        {
-            WithdrawalId = request.WithdrawalId,
-            TransactionId = request.TransactionId ?? string.Empty,
-            AdminNote = request.AdminNote ?? string.Empty
-        };
-
-        var response = await _context.Commissions.ProcessWithdrawalAsync(grpcRequest, cancellationToken: cancellationToken);
-
-        return new ProcessWithdrawalResponseDto
-        {
-            Success = response.Success,
-            Message = response.Message
-        };
-        */
     }
 }

src/BackOffice.BFF.Application/Common/Interfaces/IApplicationContractContext.cs

@@ -20,6 +20,7 @@ using CMSMicroservice.Protobuf.Protos.DiscountShoppingCart;
 using CMSMicroservice.Protobuf.Protos.DiscountOrder;
 using CMSMicroservice.Protobuf.Protos.Tag;
 using CMSMicroservice.Protobuf.Protos.ProductTag;
+using CMSMicroservice.Protobuf.Protos;
 
 namespace BackOffice.BFF.Application.Common.Interfaces;
 
@@ -57,5 +58,8 @@ public interface IApplicationContractContext
     TagContract.TagContractClient Tags { get; }
     ProductTagContract.ProductTagContractClient ProductTags { get; }
 
+    // Public Messages
+    PublicMessageContract.PublicMessageContractClient PublicMessages { get; }
+
     #endregion
 }

src/BackOffice.BFF.Application/PackageCQ/Queries/GetUserPackageStatus/GetUserPackageStatusQueryHandler.cs

@@ -1,4 +1,6 @@
+using BackOffice.BFF.Application.Common.Interfaces;
 using BackOffice.BFF.Package.Protobuf.Protos.Package;
+using CMSMicroservice.Protobuf.Protos.Package;
 using MediatR;
 using Microsoft.Extensions.Logging;
 
@@ -6,47 +8,49 @@ namespace BackOffice.BFF.Application.PackageCQ.Queries.GetUserPackageStatus;
 
 public class GetUserPackageStatusQueryHandler : IRequestHandler<GetUserPackageStatusQuery, GetUserPackageStatusResponse>
 {
-    private readonly PackageContract.PackageContractClient _packageClient;
+    private readonly IApplicationContractContext _context;
     private readonly ILogger<GetUserPackageStatusQueryHandler> _logger;
 
     public GetUserPackageStatusQueryHandler(
-        PackageContract.PackageContractClient packageClient,
+        IApplicationContractContext context,
         ILogger<GetUserPackageStatusQueryHandler> logger)
     {
-        _packageClient = packageClient;
+        _context = context;
         _logger = logger;
     }
 
     public async Task<GetUserPackageStatusResponse> Handle(GetUserPackageStatusQuery request, CancellationToken cancellationToken)
     {
-        // TODO: پیاده‌سازی GetUserPackageStatus
+        var grpcRequest = new GetUserPackageStatusRequest
-        // 
+        {
-        // 1. ایجاد gRPC Request:
+            UserId = request.UserId
-        //    - var grpcRequest = new CMSMicroservice.Protobuf.Protos.Package.GetUserPackageStatusRequest {
+        };
-        //        UserId = request.UserId
-        //      }
-        //
-        // 2. فراخوانی CMS:
-        //    - var response = await _packageClient.GetUserPackageStatusAsync(grpcRequest, cancellationToken: cancellationToken)
-        //
-        // 3. تبدیل به BFF Response:
-        //    - return new GetUserPackageStatusResponse {
-        //        UserId = response.UserId,
-        //        PackagePurchaseMethod = response.PackagePurchaseMethod,
-        //        HasPurchasedPackage = response.HasPurchasedPackage,
-        //        IsClubMemberActive = response.IsClubMemberActive,
-        //        WalletBalance = response.WalletBalance,
-        //        DiscountBalance = response.DiscountBalance,
-        //        CanActivateClubMembership = response.CanActivateClubMembership,
-        //        LastOrderNumber = response.LastOrderNumber,
-        //        LastPurchaseDate = response.LastPurchaseDate
-        //      }
-        //
-        // 4. Log:
-        //    - _logger.LogInformation("Retrieved package status for user {UserId}", request.UserId)
-        //
-        // نکته: این endpoint برای Admin است تا وضعیت کاربران را بررسی کند
 
-        throw new NotImplementedException("GetUserPackageStatus needs implementation");
+        var response = await _context.Packages.GetUserPackageStatusAsync(grpcRequest, cancellationToken: cancellationToken);
+
+        _logger.LogInformation("Retrieved package status for user {UserId}", request.UserId);
+
+        var result = new GetUserPackageStatusResponse
+        {
+            UserId = response.UserId,
+            PackagePurchaseMethod = response.PackagePurchaseMethod,
+            HasPurchasedPackage = response.HasPurchasedPackage,
+            IsClubMemberActive = response.IsClubMemberActive,
+            WalletBalance = response.WalletBalance,
+            DiscountBalance = response.DiscountBalance,
+            CanActivateClubMembership = response.CanActivateClubMembership
+        };
+
+        if (response.LastOrderNumber != null)
+        {
+            result.LastOrderNumber = response.LastOrderNumber;
+        }
+
+        if (response.LastPurchaseDate != null)
+        {
+            result.LastPurchaseDate = response.LastPurchaseDate;
+        }
+
+        return result;
     }
 }

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/ArchiveMessage/ArchiveMessageCommandHandler.cs

@@ -0,0 +1,35 @@
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+
+namespace BackOffice.BFF.Application.PublicMessageCQ.Commands.ArchiveMessage;
+
+public class ArchiveMessageCommandHandler : IRequestHandler<ArchiveMessageRequest, ArchiveMessageResponse>
+{
+    private readonly IApplicationContractContext _context;
+
+    public ArchiveMessageCommandHandler(IApplicationContractContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<ArchiveMessageResponse> Handle(ArchiveMessageRequest request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new ArchiveMessageRequest
+        {
+            MessageId = request.MessageId
+        };
+
+        var cmsResponse = await _context.PublicMessages.ArchiveMessageAsync(
+            cmsRequest,
+            cancellationToken: cancellationToken);
+
+        return new ArchiveMessageResponse
+        {
+            Success = cmsResponse.Success,
+            Message = cmsResponse.Message,
+            ArchivedAt = cmsResponse.ArchivedAt
+        };
+    }
+}
+

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/CreatePublicMessage/CreatePublicMessageCommandHandler.cs

@@ -0,0 +1,41 @@
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+using Google.Protobuf.WellKnownTypes;
+
+namespace BackOffice.BFF.Application.PublicMessageCQ.Commands.CreatePublicMessage;
+
+public class CreatePublicMessageCommandHandler : IRequestHandler<CreatePublicMessageRequest, CreatePublicMessageResponse>
+{
+    private readonly IApplicationContractContext _context;
+
+    public CreatePublicMessageCommandHandler(IApplicationContractContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<CreatePublicMessageResponse> Handle(CreatePublicMessageRequest request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new CreatePublicMessageRequest
+        {
+            Title = request.Title,
+            Content = request.Content,
+            Type = request.MessageType,
+            Priority = request.Priority,
+            StartDate = Timestamp.FromDateTime(request.StartsAt.ToUniversalTime()),
+            EndDate = Timestamp.FromDateTime(request.ExpiresAt.ToUniversalTime())
+        };
+
+        var cmsResponse = await _context.PublicMessages.CreatePublicMessageAsync(
+            cmsRequest,
+            cancellationToken: cancellationToken);
+
+        return new CreatePublicMessageResponse
+        {
+            Success = true,
+            Message = "پیام با موفقیت ایجاد شد",
+            MessageId = cmsResponse.Id
+        };
+    }
+}
+

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/DeletePublicMessage/DeletePublicMessageCommandHandler.cs

@@ -0,0 +1,30 @@
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+
+namespace BackOffice.BFF.Application.PublicMessageCQ.Commands.DeletePublicMessage;
+
+public class DeletePublicMessageCommandHandler : IRequestHandler<DeletePublicMessageRequest, DeletePublicMessageRequest>
+{
+    private readonly IApplicationContractContext _context;
+
+    public DeletePublicMessageCommandHandler(IApplicationContractContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<DeletePublicMessageRequest> Handle(DeletePublicMessageRequest request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new DeletePublicMessageRequest
+        {
+            MessageId = request.MessageId
+        };
+
+        await _context.PublicMessages.DeletePublicMessageAsync(
+            cmsRequest,
+            cancellationToken: cancellationToken);
+
+        return request;
+    }
+}
+

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/PublishMessage/PublishMessageCommandHandler.cs

@@ -0,0 +1,35 @@
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+
+namespace BackOffice.BFF.Application.PublicMessageCQ.Commands.PublishMessage;
+
+public class PublishMessageCommandHandler : IRequestHandler<PublishMessageRequest, PublishMessageResponse>
+{
+    private readonly IApplicationContractContext _context;
+
+    public PublishMessageCommandHandler(IApplicationContractContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<PublishMessageResponse> Handle(PublishMessageRequest request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new PublishMessageRequest
+        {
+            MessageId = request.MessageId
+        };
+
+        var cmsResponse = await _context.PublicMessages.PublishMessageAsync(
+            cmsRequest,
+            cancellationToken: cancellationToken);
+
+        return new PublishMessageResponse
+        {
+            Success = cmsResponse.Success,
+            Message = cmsResponse.Message,
+            PublishedAt = cmsResponse.PublishedAt
+        };
+    }
+}
+

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/README.md

@@ -1,4 +1,4 @@
-// TODO: PublicMessage Commands
+// PublicMessage Commands implemented:
 // - CreatePublicMessage
 // - UpdatePublicMessage  
 // - DeletePublicMessage

src/BackOffice.BFF.Application/PublicMessageCQ/Commands/UpdatePublicMessage/UpdatePublicMessageCommandHandler.cs

@@ -0,0 +1,38 @@
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+using Google.Protobuf.WellKnownTypes;
+
+namespace BackOffice.BFF.Application.PublicMessageCQ.Commands.UpdatePublicMessage;
+
+public class UpdatePublicMessageCommandHandler : IRequestHandler<UpdatePublicMessageRequest, UpdatePublicMessageRequest>
+{
+    private readonly IApplicationContractContext _context;
+
+    public UpdatePublicMessageCommandHandler(IApplicationContractContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<UpdatePublicMessageRequest> Handle(UpdatePublicMessageRequest request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new UpdatePublicMessageRequest
+        {
+            Id = request.MessageId,
+            Title = request.Title,
+            Content = request.Content,
+            Type = request.MessageType,
+            Priority = request.Priority,
+            StartDate = Timestamp.FromDateTime(request.StartsAt.ToUniversalTime()),
+            EndDate = Timestamp.FromDateTime(request.ExpiresAt.ToUniversalTime())
+        };
+
+        await _context.PublicMessages.UpdatePublicMessageAsync(
+            cmsRequest,
+            cancellationToken: cancellationToken);
+
+        // در حال حاضر پاسخ خاصی از CMS دریافت نمی‌کنیم؛ همان ورودی را برمی‌گردانیم
+        return request;
+    }
+}
+

src/BackOffice.BFF.Application/PublicMessageCQ/Queries/GetActiveMessages/GetActiveMessagesQuery.cs

@@ -1,17 +1,54 @@
 // GetActiveMessages - Public view
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+using Google.Protobuf.WellKnownTypes;
 using MediatR;
 
 namespace BackOffice.BFF.Application.PublicMessageCQ.Queries.GetActiveMessages;
 
-public record GetActiveMessagesQuery : IRequest<object> // TODO: define response
+public record GetActiveMessagesQuery : IRequest<GetActiveMessagesResponse>
 {
+    public int? MessageType { get; init; }
+    public string? TargetAudience { get; init; }
 }
 
-public class GetActiveMessagesQueryHandler : IRequestHandler<GetActiveMessagesQuery, object>
+public class GetActiveMessagesQueryHandler : IRequestHandler<GetActiveMessagesQuery, GetActiveMessagesResponse>
 {
-    public async Task<object> Handle(GetActiveMessagesQuery request, CancellationToken cancellationToken)
+    private readonly IApplicationContractContext _context;
+
+    public GetActiveMessagesQueryHandler(IApplicationContractContext context)
     {
-        // TODO: gRPC call to CMS PublicMessageContract.GetActiveMessages
+        _context = context;
-        throw new NotImplementedException();
+    }
+
+    public async Task<GetActiveMessagesResponse> Handle(GetActiveMessagesQuery request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new GetActiveMessagesRequest();
+
+        // نسخه فعلی CMS فیلدی برای فیلتر ندارد؛ در صورت اضافه شدن، اینجا مپ می‌شود.
+        var cmsResponse = await _context.PublicMessages.GetActiveMessagesAsync(cmsRequest, cancellationToken: cancellationToken);
+
+        var result = new GetActiveMessagesResponse();
+
+        foreach (var message in cmsResponse.Messages)
+        {
+            result.Messages.Add(new PublicMessageDto
+            {
+                MessageId = message.Id,
+                Title = message.Title,
+                Content = message.Content,
+                MessageType = message.Type,
+                MessageTypeName = message.TypeName,
+                Priority = message.Priority,
+                PriorityName = message.PriorityName,
+                StartsAt = message.StartsAt,
+                ExpiresAt = message.ExpiresAt,
+                IsDismissible = false,
+                Tags = { }
+            });
+        }
+
+        return result;
     }
 }

src/BackOffice.BFF.Application/PublicMessageCQ/Queries/GetAllMessages/GetAllMessagesQuery.cs

@@ -1,19 +1,80 @@
 // GetAllMessages - Admin view
+using BackOffice.BFF.Application.Common.Interfaces;
+using BackOffice.BFF.PublicMessage.Protobuf;
+using CMSMicroservice.Protobuf.Protos;
+using Google.Protobuf.WellKnownTypes;
 using MediatR;
 
 namespace BackOffice.BFF.Application.PublicMessageCQ.Queries.GetAllMessages;
 
-public record GetAllMessagesQuery : IRequest<object> // TODO: define response
+public record GetAllMessagesQuery : IRequest<GetAllMessagesResponse>
 {
+    public int? Status { get; init; }
+    public int? MessageType { get; init; }
     public int PageNumber { get; init; }
     public int PageSize { get; init; }
 }
 
-public class GetAllMessagesQueryHandler : IRequestHandler<GetAllMessagesQuery, object>
+public class GetAllMessagesQueryHandler : IRequestHandler<GetAllMessagesQuery, GetAllMessagesResponse>
 {
-    public async Task<object> Handle(GetAllMessagesQuery request, CancellationToken cancellationToken)
+    private readonly IApplicationContractContext _context;
+
+    public GetAllMessagesQueryHandler(IApplicationContractContext context)
     {
-        // TODO: gRPC call to CMS PublicMessageContract.GetAllMessages
+        _context = context;
-        throw new NotImplementedException();
+    }
+
+    public async Task<GetAllMessagesResponse> Handle(GetAllMessagesQuery request, CancellationToken cancellationToken)
+    {
+        var cmsRequest = new GetAllMessagesRequest
+        {
+            PageNumber = request.PageNumber,
+            PageSize = request.PageSize
+        };
+
+        if (request.Status.HasValue)
+        {
+            cmsRequest.IsActive = new BoolValue { Value = request.Status.Value == 1 };
+        }
+
+        if (request.MessageType.HasValue)
+        {
+            cmsRequest.Type = new Int32Value { Value = request.MessageType.Value };
+        }
+
+        var cmsResponse = await _context.PublicMessages.GetAllMessagesAsync(cmsRequest, cancellationToken: cancellationToken);
+
+        var result = new GetAllMessagesResponse
+        {
+            TotalCount = (int)cmsResponse.MetaData.TotalCount,
+            PageNumber = request.PageNumber,
+            PageSize = request.PageSize
+        };
+
+        foreach (var message in cmsResponse.Messages)
+        {
+            result.Messages.Add(new AdminPublicMessageDto
+            {
+                MessageId = message.Id,
+                Title = message.Title,
+                Content = message.Content,
+                MessageType = message.Type,
+                MessageTypeName = message.TypeName,
+                Priority = message.Priority,
+                PriorityName = message.PriorityName,
+                Status = message.IsActive ? 1 : 0,
+                StatusName = message.IsActive ? "Active" : (message.IsExpired ? "Expired" : "Inactive"),
+                StartsAt = message.StartsAt,
+                ExpiresAt = message.ExpiresAt,
+                PublishedAt = null,
+                ArchivedAt = null,
+                IsDismissible = false,
+                TargetAudience = string.Empty,
+                Created = message.Created,
+                LastModified = message.LastModified
+            });
+        }
+
+        return result;
     }
 }

src/BackOffice.BFF.Application/UserOrderCQ/Commands/ApplyDiscountToOrder/ApplyDiscountToOrderCommandHandler.cs

@@ -1,4 +1,6 @@
+using BackOffice.BFF.Application.Common.Interfaces;
 using BackOffice.BFF.UserOrder.Protobuf.Protos.UserOrder;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
 using MediatR;
 using Microsoft.Extensions.Logging;
 
@@ -6,22 +8,42 @@ namespace BackOffice.BFF.Application.UserOrderCQ.Commands.ApplyDiscountToOrder;
 
 public class ApplyDiscountToOrderCommandHandler : IRequestHandler<ApplyDiscountToOrderCommand, ApplyDiscountToOrderResponse>
 {
-    private readonly UserOrderContract.UserOrderContractClient _orderClient;
+    private readonly IApplicationContractContext _context;
     private readonly ILogger<ApplyDiscountToOrderCommandHandler> _logger;
 
     public ApplyDiscountToOrderCommandHandler(
-        UserOrderContract.UserOrderContractClient orderClient,
+        IApplicationContractContext context,
         ILogger<ApplyDiscountToOrderCommandHandler> logger)
     {
-        _orderClient = orderClient;
+        _context = context;
         _logger = logger;
     }
 
     public async Task<ApplyDiscountToOrderResponse> Handle(ApplyDiscountToOrderCommand request, CancellationToken cancellationToken)
     {
-        // TODO: پیاده‌سازی ApplyDiscountToOrder
+        var grpcRequest = new ApplyDiscountToOrderRequest
-        // 1. ایجاد gRPC Request و فراخوانی CMS
+        {
-        // 2. return response از CMS
+            OrderId = request.OrderId,
-        throw new NotImplementedException("ApplyDiscountToOrder needs implementation");
+            DiscountAmount = request.DiscountAmount,
+            Reason = request.Reason ?? string.Empty
+        };
+
+        var response = await _context.UserOrders.ApplyDiscountToOrderAsync(grpcRequest, cancellationToken: cancellationToken);
+
+        _logger.LogInformation(
+            "Applied discount to order {OrderId}. Success={Success}, Discount={DiscountAmount}, FinalAmount={FinalAmount}",
+            request.OrderId,
+            response.Success,
+            response.DiscountAmount,
+            response.FinalAmount);
+
+        return new ApplyDiscountToOrderResponse
+        {
+            Success = response.Success,
+            Message = response.Message,
+            OriginalAmount = response.OriginalAmount,
+            DiscountAmount = response.DiscountAmount,
+            FinalAmount = response.FinalAmount
+        };
     }
 }

src/BackOffice.BFF.Application/UserOrderCQ/Commands/UpdateOrderStatus/UpdateOrderStatusCommandHandler.cs

@@ -1,4 +1,6 @@
+using BackOffice.BFF.Application.Common.Interfaces;
 using BackOffice.BFF.UserOrder.Protobuf.Protos.UserOrder;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
 using MediatR;
 using Microsoft.Extensions.Logging;
 
@@ -6,22 +8,40 @@ namespace BackOffice.BFF.Application.UserOrderCQ.Commands.UpdateOrderStatus;
 
 public class UpdateOrderStatusCommandHandler : IRequestHandler<UpdateOrderStatusCommand, UpdateOrderStatusResponse>
 {
-    private readonly UserOrderContract.UserOrderContractClient _orderClient;
+    private readonly IApplicationContractContext _context;
     private readonly ILogger<UpdateOrderStatusCommandHandler> _logger;
 
     public UpdateOrderStatusCommandHandler(
-        UserOrderContract.UserOrderContractClient orderClient,
+        IApplicationContractContext context,
         ILogger<UpdateOrderStatusCommandHandler> logger)
     {
-        _orderClient = orderClient;
+        _context = context;
         _logger = logger;
     }
 
     public async Task<UpdateOrderStatusResponse> Handle(UpdateOrderStatusCommand request, CancellationToken cancellationToken)
     {
-        // TODO: پیاده‌سازی UpdateOrderStatus
+        var grpcRequest = new UpdateOrderStatusRequest
-        // 1. ایجاد gRPC Request و فراخوانی CMS
+        {
-        // 2. return response از CMS
+            OrderId = request.OrderId,
-        throw new NotImplementedException("UpdateOrderStatus needs implementation");
+            NewStatus = request.NewStatus
+        };
+
+        var response = await _context.UserOrders.UpdateOrderStatusAsync(grpcRequest, cancellationToken: cancellationToken);
+
+        _logger.LogInformation(
+            "Updated order {OrderId} status from {OldStatus} to {NewStatus}. Success={Success}",
+            request.OrderId,
+            response.OldStatus,
+            response.NewStatus,
+            response.Success);
+
+        return new UpdateOrderStatusResponse
+        {
+            Success = response.Success,
+            Message = response.Message,
+            OldStatus = response.OldStatus,
+            NewStatus = response.NewStatus
+        };
     }
 }

src/BackOffice.BFF.Application/UserOrderCQ/Queries/CalculateOrderPV/CalculateOrderPVQueryHandler.cs

@@ -1,22 +1,46 @@
+using BackOffice.BFF.Application.Common.Interfaces;
 using BackOffice.BFF.UserOrder.Protobuf.Protos.UserOrder;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
 using MediatR;
 
 namespace BackOffice.BFF.Application.UserOrderCQ.Queries.CalculateOrderPV;
 
 public class CalculateOrderPVQueryHandler : IRequestHandler<CalculateOrderPVQuery, CalculateOrderPVResponse>
 {
-    private readonly UserOrderContract.UserOrderContractClient _orderClient;
+    private readonly IApplicationContractContext _context;
 
-    public CalculateOrderPVQueryHandler(UserOrderContract.UserOrderContractClient orderClient)
+    public CalculateOrderPVQueryHandler(IApplicationContractContext context)
     {
-        _orderClient = orderClient;
+        _context = context;
     }
 
     public async Task<CalculateOrderPVResponse> Handle(CalculateOrderPVQuery request, CancellationToken cancellationToken)
     {
-        // TODO: پیاده‌سازی CalculateOrderPV
+        var grpcRequest = new CalculateOrderPVRequest
-        // 1. ایجاد gRPC Request و فراخوانی CMS
+        {
-        // 2. return response از CMS
+            OrderId = request.OrderId
-        throw new NotImplementedException("CalculateOrderPV needs implementation");
+        };
+
+        var response = await _context.UserOrders.CalculateOrderPVAsync(grpcRequest, cancellationToken: cancellationToken);
+
+        var result = new CalculateOrderPVResponse
+        {
+            OrderId = response.OrderId,
+            TotalPv = response.TotalPv
+        };
+
+        foreach (var product in response.Products)
+        {
+            result.Products.Add(new ProductPVDto
+            {
+                ProductId = product.ProductId,
+                ProductTitle = product.ProductTitle,
+                Quantity = product.Quantity,
+                UnitPv = product.UnitPv,
+                TotalPv = product.TotalPv
+            });
+        }
+
+        return result;
     }
 }

src/BackOffice.BFF.Application/UserOrderCQ/Queries/GetOrdersByDateRange/GetOrdersByDateRangeQueryValidator.cs

@@ -1,22 +1,71 @@
+using BackOffice.BFF.Application.Common.Interfaces;
 using BackOffice.BFF.UserOrder.Protobuf.Protos.UserOrder;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+using Google.Protobuf.WellKnownTypes;
 using MediatR;
 
 namespace BackOffice.BFF.Application.UserOrderCQ.Queries.GetOrdersByDateRange;
 
 public class GetOrdersByDateRangeQueryHandler : IRequestHandler<GetOrdersByDateRangeQuery, GetOrdersByDateRangeResponse>
 {
-    private readonly UserOrderContract.UserOrderContractClient _orderClient;
+    private readonly IApplicationContractContext _context;
 
-    public GetOrdersByDateRangeQueryHandler(UserOrderContract.UserOrderContractClient orderClient)
+    public GetOrdersByDateRangeQueryHandler(IApplicationContractContext context)
     {
-        _orderClient = orderClient;
+        _context = context;
     }
 
     public async Task<GetOrdersByDateRangeResponse> Handle(GetOrdersByDateRangeQuery request, CancellationToken cancellationToken)
     {
-        // TODO: پیاده‌سازی GetOrdersByDateRange
+        var grpcRequest = new GetOrdersByDateRangeRequest
-        // 1. ایجاد gRPC Request و فراخوانی CMS
+        {
-        // 2. return response از CMS
+            StartDate = Timestamp.FromDateTime(request.StartDate.ToUniversalTime()),
-        throw new NotImplementedException("GetOrdersByDateRange needs implementation");
+            EndDate = Timestamp.FromDateTime(request.EndDate.ToUniversalTime()),
+            PageNumber = request.PageNumber,
+            PageSize = request.PageSize
+        };
+
+        if (request.Status.HasValue)
+        {
+            grpcRequest.Status = new Int32Value { Value = request.Status.Value };
+        }
+
+        if (request.UserId.HasValue)
+        {
+            grpcRequest.UserId = new Int64Value { Value = request.UserId.Value };
+        }
+
+        var response = await _context.UserOrders.GetOrdersByDateRangeAsync(grpcRequest, cancellationToken: cancellationToken);
+
+        var result = new GetOrdersByDateRangeResponse
+        {
+            MetaData = new MetaData
+            {
+                CurrentPage = response.MetaData.CurrentPage,
+                TotalPage = response.MetaData.TotalPage,
+                PageSize = response.MetaData.PageSize,
+                TotalCount = response.MetaData.TotalCount,
+                HasPrevious = response.MetaData.HasPrevious,
+                HasNext = response.MetaData.HasNext
+            }
+        };
+
+        foreach (var order in response.Orders)
+        {
+            result.Orders.Add(new OrderSummaryDto
+            {
+                OrderId = order.OrderId,
+                OrderNumber = order.OrderNumber,
+                UserId = order.UserId,
+                UserFullName = order.UserFullName,
+                TotalAmount = order.TotalAmount,
+                Status = order.Status,
+                StatusName = order.StatusName,
+                ItemsCount = order.ItemsCount,
+                CreatedAt = order.CreatedAt
+            });
+        }
+
+        return result;
     }
 }

src/BackOffice.BFF.Domain/BackOffice.BFF.Domain.csproj

@@ -7,8 +7,8 @@
 
 	<ItemGroup>
 		<PackageReference Include="Afrino.FMSMicroservice.Protobuf" Version="0.0.122" />
-		<!--<PackageReference Include="Foursat.CMSMicroservice.Protobuf" Version="0.0.141" />-->
+<!--		<PackageReference Include="Foursat.CMSMicroservice.Protobuf" Version="0.0.142" />-->
-
+        
 		<PackageReference Include="Google.Protobuf" Version="3.23.3" />
 		<PackageReference Include="Grpc.Net.ClientFactory" Version="2.54.0" />
 	</ItemGroup>

src/BackOffice.BFF.Infrastructure/Services/ApplicationContractContext.cs

@@ -21,6 +21,7 @@ using CMSMicroservice.Protobuf.Protos.DiscountShoppingCart;
 using CMSMicroservice.Protobuf.Protos.DiscountOrder;
 using CMSMicroservice.Protobuf.Protos.Tag;
 using CMSMicroservice.Protobuf.Protos.ProductTag;
+using CMSMicroservice.Protobuf.Protos;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace BackOffice.BFF.Infrastructure.Services;
@@ -80,5 +81,8 @@ public class ApplicationContractContext : IApplicationContractContext
     // Tag Management System
     public TagContract.TagContractClient Tags => GetService<TagContract.TagContractClient>();
     public ProductTagContract.ProductTagContractClient ProductTags => GetService<ProductTagContract.ProductTagContractClient>();
+    
+    // Public Messages
+    public PublicMessageContract.PublicMessageContractClient PublicMessages => GetService<PublicMessageContract.PublicMessageContractClient>();
     #endregion
 }

src/BackOffice.BFF.WebApi/Services/CommissionService.cs

@@ -4,6 +4,7 @@ using BackOffice.BFF.Application.CommissionCQ.Queries.GetUserPayouts;
 using BackOffice.BFF.Application.CommissionCQ.Queries.GetAllWeeklyPools;
 using BackOffice.BFF.Application.CommissionCQ.Queries.GetUserWeeklyBalances;
 using BackOffice.BFF.Application.CommissionCQ.Queries.GetWithdrawalRequests;
+using BackOffice.BFF.Application.CommissionCQ.Queries.GetWithdrawalReports;
 using BackOffice.BFF.Application.CommissionCQ.Commands.ApproveWithdrawal;
 using BackOffice.BFF.Application.CommissionCQ.Commands.RejectWithdrawal;
 using BackOffice.BFF.Application.CommissionCQ.Commands.ProcessWithdrawal;
@@ -57,8 +58,6 @@ public class CommissionService : CommissionContract.CommissionContractBase
             context);
     }
 
-    // TODO: Uncomment when CMS implements these endpoints
-    /*
     public override async Task<GetWithdrawalRequestsResponse> GetWithdrawalRequests(
         GetWithdrawalRequestsRequest request,
         ServerCallContext context)
@@ -87,5 +86,23 @@ public class CommissionService : CommissionContract.CommissionContractBase
             context);
         return new Empty();
     }
-    */
+
+    public override async Task<Empty> ProcessWithdrawal(
+        ProcessWithdrawalRequest request,
+        ServerCallContext context)
+    {
+        await _dispatchRequestToCQRS.Handle<ProcessWithdrawalRequest, ProcessWithdrawalCommand, ProcessWithdrawalResponseDto>(
+            request,
+            context);
+        return new Empty();
+    }
+
+    public override async Task<GetWithdrawalReportsResponse> GetWithdrawalReports(
+        GetWithdrawalReportsRequest request,
+        ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetWithdrawalReportsRequest, GetWithdrawalReportsQuery, GetWithdrawalReportsResponse>(
+            request,
+            context);
+    }
 }

src/BackOffice.BFF.WebApi/Services/PublicMessageService.cs

@@ -14,13 +14,52 @@ public class PublicMessageService : PublicMessageContract.PublicMessageContractB
         _dispatchRequestToCQRS = dispatchRequestToCQRS;
     }
 
+    public override async Task<CreatePublicMessageResponse> CreatePublicMessage(CreatePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<CreatePublicMessageRequest, CreatePublicMessageRequest, CreatePublicMessageResponse>(
+            request,
+            context);
+    }
+
+    public override async Task<UpdatePublicMessageRequest> UpdatePublicMessage(UpdatePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<UpdatePublicMessageRequest, UpdatePublicMessageRequest, UpdatePublicMessageRequest>(
+            request,
+            context);
+    }
+
+    public override async Task<DeletePublicMessageRequest> DeletePublicMessage(DeletePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<DeletePublicMessageRequest, DeletePublicMessageRequest, DeletePublicMessageRequest>(
+            request,
+            context);
+    }
+
+    public override async Task<PublishMessageResponse> PublishMessage(PublishMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<PublishMessageRequest, PublishMessageRequest, PublishMessageResponse>(
+            request,
+            context);
+    }
+
+    public override async Task<ArchiveMessageResponse> ArchiveMessage(ArchiveMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<ArchiveMessageRequest, ArchiveMessageRequest, ArchiveMessageResponse>(
+            request,
+            context);
+    }
+
     public override async Task<GetAllMessagesResponse> GetAllMessages(GetAllMessagesRequest request, ServerCallContext context)
     {
-        return await _dispatchRequestToCQRS.Handle<GetAllMessagesRequest, GetAllMessagesQuery, GetAllMessagesResponse>(request, context);
+        return await _dispatchRequestToCQRS.Handle<GetAllMessagesRequest, GetAllMessagesQuery, GetAllMessagesResponse>(
+            request,
+            context);
     }
 
     public override async Task<GetActiveMessagesResponse> GetActiveMessages(GetActiveMessagesRequest request, ServerCallContext context)
     {
-        return await _dispatchRequestToCQRS.Handle<GetActiveMessagesRequest, GetActiveMessagesQuery, GetActiveMessagesResponse>(request, context);
+        return await _dispatchRequestToCQRS.Handle<GetActiveMessagesRequest, GetActiveMessagesQuery, GetActiveMessagesResponse>(
+            request,
+            context);
     }
 }