feat: Implement Public Message Management Commands and Queries

- Add GetUserPackageStatusQueryValidator for user package status validation.
- Create ArchiveMessageCommand and ArchiveMessageCommandHandler for archiving public messages.
- Implement ArchiveMessageCommandValidator to validate message ID.
- Introduce PublishMessageCommand and PublishMessageCommandHandler for publishing messages.
- Add PublishMessageCommandValidator for validating publish message requests.
- Implement GetPublicMessageQuery and GetPublicMessageQueryHandler for retrieving public messages.
- Create GetPublicMessageQueryValidator for validating public message requests.
- Add ApplyDiscountToOrderCommand and ApplyDiscountToOrderCommandHandler for applying discounts to orders.
- Implement ApplyDiscountToOrderCommandValidator for validating discount application requests.
- Create UpdateOrderStatusCommand and UpdateOrderStatusCommandHandler for changing order statuses.
- Implement UpdateOrderStatusCommandValidator for validating order status updates.
- Add CalculateOrderPVQuery and CalculateOrderPVQueryHandler for calculating order PV.
- Implement CalculateOrderPVQueryValidator for validating PV calculation requests.
- Create GetOrdersByDateRangeQuery and GetOrdersByDateRangeQueryHandler for retrieving orders by date range.
- Implement GetOrdersByDateRangeQueryValidator for validating date range queries.
- Add PublicMessage entity to represent public messages in the system.
- Implement PublicMessageService for handling public message operations via gRPC.

src/CMSMicroservice.WebApi/Services/PackageService.cs

@@ -3,8 +3,11 @@ using CMSMicroservice.WebApi.Common.Services;
 using CMSMicroservice.Application.PackageCQ.Commands.CreateNewPackage;
 using CMSMicroservice.Application.PackageCQ.Commands.UpdatePackage;
 using CMSMicroservice.Application.PackageCQ.Commands.DeletePackage;
+using CMSMicroservice.Application.PackageCQ.Commands.PurchaseGoldenPackage;
+using CMSMicroservice.Application.PackageCQ.Commands.VerifyGoldenPackagePurchase;
 using CMSMicroservice.Application.PackageCQ.Queries.GetPackage;
 using CMSMicroservice.Application.PackageCQ.Queries.GetAllPackageByFilter;
+using CMSMicroservice.Application.PackageCQ.Queries.GetUserPackageStatus;
 namespace CMSMicroservice.WebApi.Services;
 public class PackageService : PackageContract.PackageContractBase
 {
@@ -34,4 +37,19 @@ public class PackageService : PackageContract.PackageContractBase
     {
         return await _dispatchRequestToCQRS.Handle<GetAllPackageByFilterRequest, GetAllPackageByFilterQuery, GetAllPackageByFilterResponse>(request, context);
     }
+    
+    public override async Task<PurchaseGoldenPackageResponse> PurchaseGoldenPackage(PurchaseGoldenPackageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<PurchaseGoldenPackageRequest, PurchaseGoldenPackageCommand, PurchaseGoldenPackageResponse>(request, context);
+    }
+    
+    public override async Task<VerifyGoldenPackagePurchaseResponse> VerifyGoldenPackagePurchase(VerifyGoldenPackagePurchaseRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<VerifyGoldenPackagePurchaseRequest, VerifyGoldenPackagePurchaseCommand, VerifyGoldenPackagePurchaseResponse>(request, context);
+    }
+    
+    public override async Task<GetUserPackageStatusResponse> GetUserPackageStatus(GetUserPackageStatusRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetUserPackageStatusRequest, GetUserPackageStatusQuery, GetUserPackageStatusResponse>(request, context);
+    }
 }

src/CMSMicroservice.WebApi/Services/PublicMessageService.cs

@@ -0,0 +1,63 @@
+using CMSMicroservice.Protobuf.Protos;
+using CMSMicroservice.WebApi.Common.Services;
+using CMSMicroservice.Application.PublicMessageCQ.Commands.CreatePublicMessage;
+using CMSMicroservice.Application.PublicMessageCQ.Commands.UpdatePublicMessage;
+using CMSMicroservice.Application.PublicMessageCQ.Commands.DeletePublicMessage;
+using CMSMicroservice.Application.PublicMessageCQ.Commands.PublishMessage;
+using CMSMicroservice.Application.PublicMessageCQ.Commands.ArchiveMessage;
+using CMSMicroservice.Application.PublicMessageCQ.Queries.GetAllMessages;
+using CMSMicroservice.Application.PublicMessageCQ.Queries.GetActiveMessages;
+using CMSMicroservice.Application.PublicMessageCQ.Queries.GetPublicMessage;
+using Google.Protobuf.WellKnownTypes;
+
+namespace CMSMicroservice.WebApi.Services;
+
+public class PublicMessageService : PublicMessageContract.PublicMessageContractBase
+{
+    private readonly IDispatchRequestToCQRS _dispatchRequestToCQRS;
+
+    public PublicMessageService(IDispatchRequestToCQRS dispatchRequestToCQRS)
+    {
+        _dispatchRequestToCQRS = dispatchRequestToCQRS;
+    }
+
+    public override async Task<CreatePublicMessageResponse> CreatePublicMessage(CreatePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<CreatePublicMessageRequest, CreatePublicMessageCommand, CreatePublicMessageResponse>(request, context);
+    }
+
+    public override async Task<Empty> UpdatePublicMessage(UpdatePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<UpdatePublicMessageRequest, UpdatePublicMessageCommand>(request, context);
+    }
+
+    public override async Task<Empty> DeletePublicMessage(DeletePublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<DeletePublicMessageRequest, DeletePublicMessageCommand>(request, context);
+    }
+
+    public override async Task<PublishMessageResponse> PublishMessage(PublishMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<PublishMessageRequest, PublishMessageCommand, PublishMessageResponse>(request, context);
+    }
+
+    public override async Task<ArchiveMessageResponse> ArchiveMessage(ArchiveMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<ArchiveMessageRequest, ArchiveMessageCommand, ArchiveMessageResponse>(request, context);
+    }
+
+    public override async Task<GetAllMessagesResponse> GetAllMessages(GetAllMessagesRequest request, ServerCallContext 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);
+    }
+
+    public override async Task<GetPublicMessageResponse> GetPublicMessage(GetPublicMessageRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetPublicMessageRequest, GetPublicMessageQuery, GetPublicMessageResponse>(request, context);
+    }
+}

src/CMSMicroservice.WebApi/Services/UserOrderService.cs

@@ -3,8 +3,12 @@ using CMSMicroservice.WebApi.Common.Services;
 using CMSMicroservice.Application.UserOrderCQ.Commands.CreateNewUserOrder;
 using CMSMicroservice.Application.UserOrderCQ.Commands.UpdateUserOrder;
 using CMSMicroservice.Application.UserOrderCQ.Commands.DeleteUserOrder;
+using CMSMicroservice.Application.UserOrderCQ.Commands.UpdateOrderStatus;
+using CMSMicroservice.Application.UserOrderCQ.Commands.ApplyDiscountToOrder;
 using CMSMicroservice.Application.UserOrderCQ.Queries.GetUserOrder;
 using CMSMicroservice.Application.UserOrderCQ.Queries.GetAllUserOrderByFilter;
+using CMSMicroservice.Application.UserOrderCQ.Queries.GetOrdersByDateRange;
+using CMSMicroservice.Application.UserOrderCQ.Queries.CalculateOrderPV;
 using CMSMicroservice.Application.UserOrderCQ.Commands.SubmitShopBuyOrder;
 using CMSMicroservice.Application.UserOrderCQ.Commands.CancelOrder;
 
@@ -46,4 +50,24 @@ public class UserOrderService : UserOrderContract.UserOrderContractBase
     {
         return await _dispatchRequestToCQRS.Handle<CancelOrderRequest, CancelOrderCommand, CancelOrderResponse>(request, context);
     }
+    
+    public override async Task<UpdateOrderStatusResponse> UpdateOrderStatus(UpdateOrderStatusRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<UpdateOrderStatusRequest, UpdateOrderStatusCommand, UpdateOrderStatusResponse>(request, context);
+    }
+    
+    public override async Task<GetOrdersByDateRangeResponse> GetOrdersByDateRange(GetOrdersByDateRangeRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetOrdersByDateRangeRequest, GetOrdersByDateRangeQuery, GetOrdersByDateRangeResponse>(request, context);
+    }
+    
+    public override async Task<ApplyDiscountToOrderResponse> ApplyDiscountToOrder(ApplyDiscountToOrderRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<ApplyDiscountToOrderRequest, ApplyDiscountToOrderCommand, ApplyDiscountToOrderResponse>(request, context);
+    }
+    
+    public override async Task<CalculateOrderPVResponse> CalculateOrderPV(CalculateOrderPVRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<CalculateOrderPVRequest, CalculateOrderPVQuery, CalculateOrderPVResponse>(request, context);
+    }
 }