From ff1c1d5d61851e72424336b86ce2e860c12d323d Mon Sep 17 00:00:00 2001
From: masoodafar-web <masoud.afarin.moghaddam@outlook.com>
Date: Fri, 12 Dec 2025 01:40:26 +0330
Subject: [PATCH] feat: add IsActive field to UserClubFeatures for admin
 management

---
 docs/club-feature-management-services.md      |  490 +++
 .../ToggleUserClubFeatureCommand.cs           |   24 +
 .../ToggleUserClubFeatureCommandHandler.cs    |   78 +
 .../ToggleUserClubFeatureResponse.cs          |   27 +
 .../GetUserClubFeaturesQuery.cs               |   14 +
 .../GetUserClubFeaturesQueryHandler.cs        |   40 +
 .../GetUserClubFeatures/UserClubFeatureDto.cs |   52 +
 .../ActivateClubMembershipCommandHandler.cs   |  118 +-
 .../AssignClubFeatureCommandHandler.cs        |    2 +-
 .../GetClubStatisticsQueryHandler.cs          |    2 +-
 .../ApproveWithdrawalCommandHandler.cs        |    8 +-
 .../CalculateWeeklyBalancesCommandHandler.cs  |  160 +-
 ...ulateWeeklyCommissionPoolCommandHandler.cs |  140 +-
 .../ProcessWithdrawalCommandHandler.cs        |    2 +-
 .../RejectWithdrawalCommandHandler.cs         |    6 +-
 .../TriggerWeeklyCalculationCommand.cs        |    9 +-
 .../TriggerWeeklyCalculationCommandHandler.cs |   23 +-
 .../GetAvailableWeeksQuery.cs                 |   13 +
 .../GetAvailableWeeksQueryHandler.cs          |  132 +
 .../GetAvailableWeeksResponseDto.cs           |   46 +
 .../GetWithdrawalReportsQueryHandler.cs       |    2 +-
 .../GetWorkerStatusQueryHandler.cs            |    4 +-
 .../CheckDayaLoanStatusCommandHandler.cs      |    4 +-
 .../ProcessDayaLoanApprovalCommandHandler.cs  |    6 +-
 .../CompleteOrderPaymentCommandHandler.cs     |    4 +-
 .../CreateDiscountCategoryCommandHandler.cs   |    2 +-
 .../ApproveManualPaymentCommandHandler.cs     |    4 +-
 .../RejectManualPaymentCommandHandler.cs      |    2 +-
 .../GetNetworkStatisticsQueryHandler.cs       |    2 +-
 ...rifyGoldenPackagePurchaseCommandHandler.cs |    4 +-
 .../VerifyPackagePurchaseCommandHandler.cs    |    4 +-
 .../ArchiveMessageCommandHandler.cs           |    2 +-
 .../CreatePublicMessageCommandValidator.cs    |    2 +-
 .../PublishMessageCommandHandler.cs           |    4 +-
 .../GetActiveMessagesQueryHandler.cs          |    2 +-
 .../GetAllMessagesQueryHandler.cs             |    2 +-
 .../RefundTransactionCommandHandler.cs        |    2 +-
 .../ApplyDiscountToOrderCommandHandler.cs     |    2 +-
 .../CancelOrder/CancelOrderCommandHandler.cs  |    2 +-
 .../SubmitShopBuyOrderCommandHandler.cs       |    2 +-
 .../GetOrdersByDateRangeQueryValidator.cs     |    2 +-
 ...erifyDiscountWalletChargeCommandHandler.cs |    2 +-
 .../Entities/Club/UserClubFeature.cs          |    5 +
 .../Entities/Network/NetworkWeeklyBalance.cs  |   17 +
 .../BackgroundJobs/WeeklyCommissionJob.cs     |   84 +-
 .../WeeklyNetworkCommissionWorker.cs.backup   |    8 +-
 ...50601_MigrateParentIdToNetworkParentId.sql |   36 +-
 .../UserClubFeatureConfiguration.cs           |    1 +
 ..._AddIsActiveToUserClubFeatures.Designer.cs | 3232 ++++++++++++++++
 ...209185136_AddIsActiveToUserClubFeatures.cs |   31 +
 ...edFieldsToNetworkWeeklyBalance.Designer.cs | 3238 ++++++++++++++++
 ..._AddFlushedFieldsToNetworkWeeklyBalance.cs |   44 +
 ...BalancesToNetworkWeeklyBalance.Designer.cs | 3241 +++++++++++++++++
 ...bordinateBalancesToNetworkWeeklyBalance.cs |   31 +
 .../ApplicationDbContextModelSnapshot.cs      |   14 +
 .../Services/DayaLoanApiService.cs            |    2 +-
 .../Services/Payment/DayaPaymentService.cs    |   12 +-
 .../Payment/MockPaymentGatewayService.cs      |    6 +-
 .../Protos/clubmembership.proto               |   53 +
 .../Protos/commission.proto                   |   37 +-
 .../Common/Mappings/ClubFeatureProfile.cs     |   47 +
 .../Common/Mappings/CommissionProfile.cs      |   38 +
 .../Controllers/AdminController.cs            |    4 +-
 src/CMSMicroservice.WebApi/Program.cs         |    2 +-
 .../Services/ClubMembershipService.cs         |   12 +
 .../Services/CommissionService.cs             |    6 +
 .../Services/NetworkMembershipService.cs      |    1 -
 .../Workers/DayaLoanCheckWorker.cs            |    4 +-
 68 files changed, 11456 insertions(+), 198 deletions(-)
 create mode 100644 docs/club-feature-management-services.md
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommand.cs
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommandHandler.cs
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureResponse.cs
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQuery.cs
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQueryHandler.cs
 create mode 100644 src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/UserClubFeatureDto.cs
 create mode 100644 src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQuery.cs
 create mode 100644 src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQueryHandler.cs
 create mode 100644 src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksResponseDto.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.Designer.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.Designer.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.Designer.cs
 create mode 100644 src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.cs
 create mode 100644 src/CMSMicroservice.WebApi/Common/Mappings/ClubFeatureProfile.cs
 create mode 100644 src/CMSMicroservice.WebApi/Common/Mappings/CommissionProfile.cs

diff --git a/docs/club-feature-management-services.md b/docs/club-feature-management-services.md
new file mode 100644
index 0000000..851ba2d
--- /dev/null
+++ b/docs/club-feature-management-services.md
@@ -0,0 +1,490 @@
+# Club Feature Management Services - Implementation Guide
+
+## Overview
+Admin services for managing user club features (enable/disable features per user).
+
+## Created Files
+
+### 1. CQRS Layer (Application)
+
+#### Query: GetUserClubFeatures
+**Location:** `/CMS/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/`
+
+**Files:**
+- `GetUserClubFeaturesQuery.cs` - Query definition
+- `GetUserClubFeaturesQueryHandler.cs` - Query handler
+- `UserClubFeatureDto.cs` - Response DTO
+
+**Purpose:** Get list of all club features for a specific user with their active status.
+
+**Input:**
+```csharp
+public record GetUserClubFeaturesQuery : IRequest<List<UserClubFeatureDto>>
+{
+    public long UserId { get; init; }
+}
+```
+
+**Output:**
+```csharp
+public class UserClubFeatureDto
+{
+    public long Id { get; set; }
+    public long UserId { get; set; }
+    public long ClubMembershipId { get; set; }
+    public long ClubFeatureId { get; set; }
+    public string FeatureTitle { get; set; }
+    public string? FeatureDescription { get; set; }
+    public bool IsActive { get; set; }
+    public DateTime GrantedAt { get; set; }
+    public string? Notes { get; set; }
+}
+```
+
+**Logic:**
+- Joins `UserClubFeatures` with `ClubFeature` table
+- Filters by `UserId` and `!IsDeleted`
+- Returns list of features with their active status
+
+---
+
+#### Command: ToggleUserClubFeature
+**Location:** `/CMS/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/`
+
+**Files:**
+- `ToggleUserClubFeatureCommand.cs` - Command definition
+- `ToggleUserClubFeatureCommandHandler.cs` - Command handler
+- `ToggleUserClubFeatureResponse.cs` - Response DTO
+
+**Purpose:** Enable or disable a specific club feature for a user.
+
+**Input:**
+```csharp
+public record ToggleUserClubFeatureCommand : IRequest<ToggleUserClubFeatureResponse>
+{
+    public long UserId { get; init; }
+    public long ClubFeatureId { get; init; }
+    public bool IsActive { get; init; }
+}
+```
+
+**Output:**
+```csharp
+public class ToggleUserClubFeatureResponse
+{
+    public bool Success { get; set; }
+    public string Message { get; set; }
+    public long? UserClubFeatureId { get; set; }
+    public bool? IsActive { get; set; }
+}
+```
+
+**Validations:**
+1. ✅ User exists and not deleted
+2. ✅ Club feature exists and not deleted
+3. ✅ User has this feature assigned (exists in UserClubFeatures)
+
+**Logic:**
+- Find `UserClubFeature` record by `UserId` + `ClubFeatureId`
+- Update `IsActive` field
+- Set `LastModified` timestamp
+- Save changes
+
+**Error Messages:**
+- "کاربر یافت نشد" - User not found
+- "ویژگی باشگاه یافت نشد" - Club feature not found
+- "این ویژگی برای کاربر یافت نشد" - User doesn't have this feature
+
+**Success Messages:**
+- "ویژگی با موفقیت فعال شد" - Feature activated successfully
+- "ویژگی با موفقیت غیرفعال شد" - Feature deactivated successfully
+
+---
+
+### 2. gRPC Layer (Protobuf + WebApi)
+
+#### Proto Definition
+**File:** `/CMS/src/CMSMicroservice.Protobuf/Protos/clubmembership.proto`
+
+**Added RPC Methods:**
+```protobuf
+rpc GetUserClubFeatures(GetUserClubFeaturesRequest) returns (GetUserClubFeaturesResponse){
+    option (google.api.http) = {
+        get: "/ClubFeature/GetUserFeatures"
+    };
+};
+
+rpc ToggleUserClubFeature(ToggleUserClubFeatureRequest) returns (ToggleUserClubFeatureResponse){
+    option (google.api.http) = {
+        post: "/ClubFeature/ToggleFeature"
+        body: "*"
+    };
+};
+```
+
+**Message Definitions:**
+```protobuf
+message GetUserClubFeaturesRequest {
+    int64 user_id = 1;
+}
+
+message GetUserClubFeaturesResponse {
+    repeated UserClubFeatureModel features = 1;
+}
+
+message UserClubFeatureModel {
+    int64 id = 1;
+    int64 user_id = 2;
+    int64 club_membership_id = 3;
+    int64 club_feature_id = 4;
+    string feature_title = 5;
+    string feature_description = 6;
+    bool is_active = 7;
+    google.protobuf.Timestamp granted_at = 8;
+    string notes = 9;
+}
+
+message ToggleUserClubFeatureRequest {
+    int64 user_id = 1;
+    int64 club_feature_id = 2;
+    bool is_active = 3;
+}
+
+message ToggleUserClubFeatureResponse {
+    bool success = 1;
+    string message = 2;
+    google.protobuf.Int64Value user_club_feature_id = 3;
+    google.protobuf.BoolValue is_active = 4;
+}
+```
+
+---
+
+#### gRPC Service Implementation
+**File:** `/CMS/src/CMSMicroservice.WebApi/Services/ClubMembershipService.cs`
+
+**Added Methods:**
+```csharp
+public override async Task<GetUserClubFeaturesResponse> GetUserClubFeatures(
+    GetUserClubFeaturesRequest request, 
+    ServerCallContext context)
+{
+    return await _dispatchRequestToCQRS.Handle<
+        GetUserClubFeaturesRequest, 
+        GetUserClubFeaturesQuery, 
+        GetUserClubFeaturesResponse>(request, context);
+}
+
+public override async Task<Protobuf.Protos.ClubMembership.ToggleUserClubFeatureResponse> 
+    ToggleUserClubFeature(
+        ToggleUserClubFeatureRequest request, 
+        ServerCallContext context)
+{
+    return await _dispatchRequestToCQRS.Handle<
+        ToggleUserClubFeatureRequest, 
+        ToggleUserClubFeatureCommand, 
+        Protobuf.Protos.ClubMembership.ToggleUserClubFeatureResponse>(request, context);
+}
+```
+
+---
+
+#### AutoMapper Profile
+**File:** `/CMS/src/CMSMicroservice.WebApi/Common/Mappings/ClubFeatureProfile.cs`
+
+**Mappings:**
+1. `GetUserClubFeaturesRequest` → `GetUserClubFeaturesQuery`
+2. `UserClubFeatureDto` → `UserClubFeatureModel` (Proto)
+3. `List<UserClubFeatureDto>` → `GetUserClubFeaturesResponse`
+4. `ToggleUserClubFeatureRequest` → `ToggleUserClubFeatureCommand`
+5. `ToggleUserClubFeatureResponse` (App) → `ToggleUserClubFeatureResponse` (Proto)
+
+**Special Handling:**
+- DateTime conversion to `Timestamp` (Protobuf format)
+- Null-safe mapping for optional fields
+- Fully qualified type names to avoid ambiguity
+
+---
+
+## API Endpoints
+
+### 1. Get User Club Features
+**Method:** GET  
+**Endpoint:** `/ClubFeature/GetUserFeatures`  
+**Request:**
+```json
+{
+  "user_id": 123
+}
+```
+
+**Response:**
+```json
+{
+  "features": [
+    {
+      "id": 1,
+      "user_id": 123,
+      "club_membership_id": 456,
+      "club_feature_id": 1,
+      "feature_title": "دسترسی به فروشگاه تخفیف",
+      "feature_description": "امکان خرید از فروشگاه تخفیف",
+      "is_active": true,
+      "granted_at": "2025-12-09T18:30:00Z",
+      "notes": "اعطا شده به‌طور خودکار هنگام فعالسازی"
+    }
+  ]
+}
+```
+
+---
+
+### 2. Toggle User Club Feature
+**Method:** POST  
+**Endpoint:** `/ClubFeature/ToggleFeature`  
+**Request:**
+```json
+{
+  "user_id": 123,
+  "club_feature_id": 1,
+  "is_active": false
+}
+```
+
+**Response (Success):**
+```json
+{
+  "success": true,
+  "message": "ویژگی با موفقیت غیرفعال شد",
+  "user_club_feature_id": 1,
+  "is_active": false
+}
+```
+
+**Response (Error - User Not Found):**
+```json
+{
+  "success": false,
+  "message": "کاربر یافت نشد"
+}
+```
+
+**Response (Error - Feature Not Found):**
+```json
+{
+  "success": false,
+  "message": "ویژگی باشگاه یافت نشد"
+}
+```
+
+**Response (Error - User Doesn't Have Feature):**
+```json
+{
+  "success": false,
+  "message": "این ویژگی برای کاربر یافت نشد"
+}
+```
+
+---
+
+## Database Schema
+
+### Table: UserClubFeatures
+Existing table with newly added `IsActive` field:
+
+```sql
+CREATE TABLE [CMS].[UserClubFeatures]
+(
+    [Id] BIGINT IDENTITY(1,1) PRIMARY KEY,
+    [UserId] BIGINT NOT NULL,
+    [ClubMembershipId] BIGINT NOT NULL,
+    [ClubFeatureId] BIGINT NOT NULL,
+    [GrantedAt] DATETIME2 NOT NULL,
+    [IsActive] BIT NOT NULL DEFAULT 1, -- ← NEW FIELD
+    [Notes] NVARCHAR(MAX) NULL,
+    [Created] DATETIME2 NOT NULL,
+    [CreatedBy] NVARCHAR(MAX) NULL,
+    [LastModified] DATETIME2 NULL,
+    [LastModifiedBy] NVARCHAR(MAX) NULL,
+    [IsDeleted] BIT NOT NULL DEFAULT 0,
+    
+    CONSTRAINT FK_UserClubFeatures_Users FOREIGN KEY ([UserId]) 
+        REFERENCES [Identity].[Users]([Id]),
+    CONSTRAINT FK_UserClubFeatures_ClubMembership FOREIGN KEY ([ClubMembershipId]) 
+        REFERENCES [CMS].[ClubMembership]([Id]),
+    CONSTRAINT FK_UserClubFeatures_ClubFeatures FOREIGN KEY ([ClubFeatureId]) 
+        REFERENCES [CMS].[ClubFeatures]([Id])
+);
+```
+
+---
+
+## Usage Examples
+
+### Admin Panel Scenario
+
+#### 1. View User's Club Features
+```csharp
+// Admin selects user ID: 123
+var request = new GetUserClubFeaturesRequest { UserId = 123 };
+var response = await client.GetUserClubFeaturesAsync(request);
+
+// Display in grid:
+foreach (var feature in response.Features)
+{
+    Console.WriteLine($"Feature: {feature.FeatureTitle}");
+    Console.WriteLine($"Status: {(feature.IsActive ? "فعال" : "غیرفعال")}");
+    Console.WriteLine($"Granted: {feature.GrantedAt}");
+    Console.WriteLine("---");
+}
+```
+
+**Output:**
+```
+Feature: دسترسی به فروشگاه تخفیف
+Status: فعال
+Granted: 2025-12-09 18:30:00
+---
+Feature: دسترسی به کمیسیون هفتگی
+Status: فعال
+Granted: 2025-12-09 18:30:00
+---
+Feature: دسترسی به شارژ شبکه
+Status: غیرفعال
+Granted: 2025-12-09 18:30:00
+---
+```
+
+---
+
+#### 2. Disable a Feature
+```csharp
+// Admin clicks "Disable" on Feature ID: 3
+var request = new ToggleUserClubFeatureRequest 
+{ 
+    UserId = 123, 
+    ClubFeatureId = 3, 
+    IsActive = false 
+};
+
+var response = await client.ToggleUserClubFeatureAsync(request);
+
+if (response.Success)
+{
+    Console.WriteLine(response.Message); 
+    // Output: ویژگی با موفقیت غیرفعال شد
+}
+```
+
+---
+
+#### 3. Re-enable a Feature
+```csharp
+// Admin clicks "Enable" on Feature ID: 3
+var request = new ToggleUserClubFeatureRequest 
+{ 
+    UserId = 123, 
+    ClubFeatureId = 3, 
+    IsActive = true 
+};
+
+var response = await client.ToggleUserClubFeatureAsync(request);
+
+if (response.Success)
+{
+    Console.WriteLine(response.Message); 
+    // Output: ویژگی با موفقیت فعال شد
+}
+```
+
+---
+
+## Testing Checklist
+
+### Unit Tests (Recommended)
+- [ ] GetUserClubFeaturesQueryHandler returns correct DTOs
+- [ ] ToggleUserClubFeatureCommandHandler validates user exists
+- [ ] ToggleUserClubFeatureCommandHandler validates feature exists
+- [ ] ToggleUserClubFeatureCommandHandler validates user has feature
+- [ ] ToggleUserClubFeatureCommandHandler updates IsActive correctly
+- [ ] ToggleUserClubFeatureCommandHandler sets LastModified timestamp
+
+### Integration Tests
+- [ ] gRPC GetUserClubFeatures endpoint returns data
+- [ ] gRPC ToggleUserClubFeature endpoint updates database
+- [ ] AutoMapper mappings work correctly
+- [ ] Proto serialization/deserialization works
+
+### Manual Testing
+1. **Get Features:**
+   ```bash
+   grpcurl -d '{"user_id": 123}' \
+     -plaintext localhost:5000 \
+     clubmembership.ClubMembershipContract/GetUserClubFeatures
+   ```
+
+2. **Disable Feature:**
+   ```bash
+   grpcurl -d '{"user_id": 123, "club_feature_id": 1, "is_active": false}' \
+     -plaintext localhost:5000 \
+     clubmembership.ClubMembershipContract/ToggleUserClubFeature
+   ```
+
+3. **Verify in Database:**
+   ```sql
+   SELECT Id, UserId, ClubFeatureId, IsActive, LastModified
+   FROM CMS.UserClubFeatures
+   WHERE UserId = 123;
+   ```
+
+---
+
+## Build Status
+✅ **All projects build successfully**
+- CMSMicroservice.Domain: ✅
+- CMSMicroservice.Application: ✅ (0 errors, 274 warnings)
+- CMSMicroservice.Protobuf: ✅
+- CMSMicroservice.WebApi: ✅ (0 errors, 17 warnings)
+
+---
+
+## Next Steps (Optional Enhancements)
+
+1. **Authorization:**
+   - Add `[Authorize(Roles = "Admin")]` attribute
+   - Validate admin permissions before toggling
+
+2. **Audit Logging:**
+   - Log who changed the feature status
+   - Track `LastModifiedBy` field
+
+3. **Bulk Operations:**
+   - Add endpoint to toggle multiple features at once
+   - Add endpoint to enable/disable all features for a user
+
+4. **History Tracking:**
+   - Create `UserClubFeatureHistory` table
+   - Log every status change with timestamp and reason
+
+5. **Notifications:**
+   - Send notification to user when feature is disabled
+   - Email/SMS alert for important features
+
+6. **Business Rules:**
+   - Add validation: prevent disabling critical features
+   - Add expiration dates for features
+   - Add feature dependencies (e.g., Feature B requires Feature A)
+
+---
+
+## Summary
+✅ Created CQRS Query + Command for club feature management  
+✅ Created gRPC Proto definitions and services  
+✅ Created AutoMapper mappings  
+✅ All builds successful  
+✅ Ready for deployment and testing  
+
+**Total Files Created:** 8  
+**Total Lines of Code:** ~350  
+**Build Errors:** 0  
+**Status:** ✅ Complete and ready for use
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommand.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommand.cs
new file mode 100644
index 0000000..4ff51f3
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommand.cs
@@ -0,0 +1,24 @@
+using MediatR;
+
+namespace CMSMicroservice.Application.ClubFeatureCQ.Commands.ToggleUserClubFeature;
+
+/// <summary>
+/// کامند برای فعال/غیرفعال کردن یک ویژگی باشگاه برای کاربر
+/// </summary>
+public record ToggleUserClubFeatureCommand : IRequest<ToggleUserClubFeatureResponse>
+{
+    /// <summary>
+    /// شناسه کاربر
+    /// </summary>
+    public long UserId { get; init; }
+
+    /// <summary>
+    /// شناسه ویژگی باشگاه
+    /// </summary>
+    public long ClubFeatureId { get; init; }
+
+    /// <summary>
+    /// وضعیت مورد نظر (فعال/غیرفعال)
+    /// </summary>
+    public bool IsActive { get; init; }
+}
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommandHandler.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommandHandler.cs
new file mode 100644
index 0000000..ea0a47e
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureCommandHandler.cs
@@ -0,0 +1,78 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace CMSMicroservice.Application.ClubFeatureCQ.Commands.ToggleUserClubFeature;
+
+/// <summary>
+/// هندلر برای فعال/غیرفعال کردن ویژگی باشگاه کاربر
+/// </summary>
+public class ToggleUserClubFeatureCommandHandler : IRequestHandler<ToggleUserClubFeatureCommand, ToggleUserClubFeatureResponse>
+{
+    private readonly IApplicationDbContext _context;
+
+    public ToggleUserClubFeatureCommandHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<ToggleUserClubFeatureResponse> Handle(ToggleUserClubFeatureCommand request, CancellationToken cancellationToken)
+    {
+        // بررسی وجود کاربر
+        var userExists = await _context.Users
+            .AnyAsync(u => u.Id == request.UserId && !u.IsDeleted, cancellationToken);
+
+        if (!userExists)
+        {
+            return new ToggleUserClubFeatureResponse
+            {
+                Success = false,
+                Message = "کاربر یافت نشد"
+            };
+        }
+
+        // بررسی وجود ویژگی
+        var featureExists = await _context.ClubFeatures
+            .AnyAsync(cf => cf.Id == request.ClubFeatureId && !cf.IsDeleted, cancellationToken);
+
+        if (!featureExists)
+        {
+            return new ToggleUserClubFeatureResponse
+            {
+                Success = false,
+                Message = "ویژگی باشگاه یافت نشد"
+            };
+        }
+
+        // یافتن رکورد UserClubFeature
+        var userClubFeature = await _context.UserClubFeatures
+            .FirstOrDefaultAsync(
+                ucf => ucf.UserId == request.UserId 
+                    && ucf.ClubFeatureId == request.ClubFeatureId 
+                    && !ucf.IsDeleted,
+                cancellationToken);
+
+        if (userClubFeature == null)
+        {
+            return new ToggleUserClubFeatureResponse
+            {
+                Success = false,
+                Message = "این ویژگی برای کاربر یافت نشد"
+            };
+        }
+
+        // به‌روزرسانی وضعیت
+        userClubFeature.IsActive = request.IsActive;
+        userClubFeature.LastModified = DateTime.UtcNow;
+
+        await _context.SaveChangesAsync(cancellationToken);
+
+        return new ToggleUserClubFeatureResponse
+        {
+            Success = true,
+            Message = request.IsActive ? "ویژگی با موفقیت فعال شد" : "ویژگی با موفقیت غیرفعال شد",
+            UserClubFeatureId = userClubFeature.Id,
+            IsActive = userClubFeature.IsActive
+        };
+    }
+}
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureResponse.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureResponse.cs
new file mode 100644
index 0000000..e264e12
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Commands/ToggleUserClubFeature/ToggleUserClubFeatureResponse.cs
@@ -0,0 +1,27 @@
+namespace CMSMicroservice.Application.ClubFeatureCQ.Commands.ToggleUserClubFeature;
+
+/// <summary>
+/// پاسخ کامند فعال/غیرفعال کردن ویژگی باشگاه
+/// </summary>
+public class ToggleUserClubFeatureResponse
+{
+    /// <summary>
+    /// موفقیت عملیات
+    /// </summary>
+    public bool Success { get; set; }
+
+    /// <summary>
+    /// پیام
+    /// </summary>
+    public string Message { get; set; }
+
+    /// <summary>
+    /// شناسه رکورد UserClubFeature
+    /// </summary>
+    public long? UserClubFeatureId { get; set; }
+
+    /// <summary>
+    /// وضعیت جدید
+    /// </summary>
+    public bool? IsActive { get; set; }
+}
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQuery.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQuery.cs
new file mode 100644
index 0000000..08b52a7
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQuery.cs
@@ -0,0 +1,14 @@
+using MediatR;
+
+namespace CMSMicroservice.Application.ClubFeatureCQ.Queries.GetUserClubFeatures;
+
+/// <summary>
+/// دریافت لیست ویژگی‌های باشگاه اختصاص یافته به کاربر
+/// </summary>
+public record GetUserClubFeaturesQuery : IRequest<List<UserClubFeatureDto>>
+{
+    /// <summary>
+    /// شناسه کاربر
+    /// </summary>
+    public long UserId { get; init; }
+}
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQueryHandler.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQueryHandler.cs
new file mode 100644
index 0000000..7db05e7
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/GetUserClubFeaturesQueryHandler.cs
@@ -0,0 +1,40 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace CMSMicroservice.Application.ClubFeatureCQ.Queries.GetUserClubFeatures;
+
+/// <summary>
+/// هندلر برای دریافت لیست ویژگی‌های باشگاه یک کاربر
+/// </summary>
+public class GetUserClubFeaturesQueryHandler : IRequestHandler<GetUserClubFeaturesQuery, List<UserClubFeatureDto>>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetUserClubFeaturesQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<List<UserClubFeatureDto>> Handle(GetUserClubFeaturesQuery request, CancellationToken cancellationToken)
+    {
+        var userClubFeatures = await _context.UserClubFeatures
+            .Include(ucf => ucf.ClubFeature)
+            .Where(ucf => ucf.UserId == request.UserId && !ucf.IsDeleted)
+            .Select(ucf => new UserClubFeatureDto
+            {
+                Id = ucf.Id,
+                UserId = ucf.UserId,
+                ClubMembershipId = ucf.ClubMembershipId,
+                ClubFeatureId = ucf.ClubFeatureId,
+                FeatureTitle = ucf.ClubFeature.Title,
+                FeatureDescription = ucf.ClubFeature.Description,
+                IsActive = ucf.IsActive,
+                GrantedAt = ucf.GrantedAt,
+                Notes = ucf.Notes
+            })
+            .ToListAsync(cancellationToken);
+
+        return userClubFeatures;
+    }
+}
diff --git a/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/UserClubFeatureDto.cs b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/UserClubFeatureDto.cs
new file mode 100644
index 0000000..386e05d
--- /dev/null
+++ b/src/CMSMicroservice.Application/ClubFeatureCQ/Queries/GetUserClubFeatures/UserClubFeatureDto.cs
@@ -0,0 +1,52 @@
+namespace CMSMicroservice.Application.ClubFeatureCQ.Queries.GetUserClubFeatures;
+
+/// <summary>
+/// DTO برای ویژگی‌های باشگاه کاربر
+/// </summary>
+public class UserClubFeatureDto
+{
+    /// <summary>
+    /// شناسه رکورد UserClubFeature
+    /// </summary>
+    public long Id { get; set; }
+
+    /// <summary>
+    /// شناسه کاربر
+    /// </summary>
+    public long UserId { get; set; }
+
+    /// <summary>
+    /// شناسه عضویت باشگاه
+    /// </summary>
+    public long ClubMembershipId { get; set; }
+
+    /// <summary>
+    /// شناسه ویژگی باشگاه
+    /// </summary>
+    public long ClubFeatureId { get; set; }
+
+    /// <summary>
+    /// عنوان ویژگی
+    /// </summary>
+    public string FeatureTitle { get; set; }
+
+    /// <summary>
+    /// توضیحات ویژگی
+    /// </summary>
+    public string? FeatureDescription { get; set; }
+
+    /// <summary>
+    /// وضعیت فعال/غیرفعال ویژگی برای این کاربر
+    /// </summary>
+    public bool IsActive { get; set; }
+
+    /// <summary>
+    /// تاریخ اعطای ویژگی
+    /// </summary>
+    public DateTime GrantedAt { get; set; }
+
+    /// <summary>
+    /// یادداشت
+    /// </summary>
+    public string? Notes { get; set; }
+}
diff --git a/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommandHandler.cs b/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommandHandler.cs
index 75dee01..2c7fddf 100644
--- a/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommandHandler.cs
+++ b/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/ActivateClubMembership/ActivateClubMembershipCommandHandler.cs
@@ -3,11 +3,13 @@ using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.Common.Models;
 using CMSMicroservice.Domain.Entities;
 using CMSMicroservice.Domain.Entities.Club;
+using CMSMicroservice.Domain.Entities.Commission;
 using CMSMicroservice.Domain.Entities.History;
 using CMSMicroservice.Domain.Enums;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using System.Globalization;
 
 namespace CMSMicroservice.Application.ClubMembershipCQ.Commands.ActivateClubMembership;
 
@@ -135,9 +137,15 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
                 .FirstOrDefaultAsync(
                     c => c.Key == "Club.MembershipGiftValue" && c.IsActive,
                     cancellationToken
+                ); 
+            
+            var activationFeeConfig = await _context.SystemConfigurations
+                .FirstOrDefaultAsync(
+                    c => c.Key == "Club.ActivationFee" && c.IsActive,
+                    cancellationToken
                 );
             
-            long giftValue = 25_200_000; // مقدار پیش‌فرض
+            long giftValue = 28_000_000; // مقدار پیش‌فرض
             if (giftValueConfig != null && long.TryParse(giftValueConfig.Value, out var configValue))
             {
                 giftValue = configValue;
@@ -152,11 +160,27 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
                     "Club.MembershipGiftValue not found in configuration, using default: {GiftValue}",
                     giftValue
                 );
+            }  
+            long activationFeeValue = 25_200_000; // مقدار پیش‌فرض
+            if (activationFeeConfig != null && long.TryParse(activationFeeConfig.Value, out var activationFeeConfigValue))
+            {
+                activationFeeValue = activationFeeConfigValue;
+                _logger.LogInformation(
+                    "Using Club.ActivationFee from configuration: {activationFeeValue}",
+                    activationFeeValue
+                );
+            }
+            else
+            {
+                _logger.LogWarning(
+                    "Club.ActivationFee not found in configuration, using default: {activationFeeValue}",
+                    activationFeeValue
+                );
             }
 
             ClubMembership entity;
             bool isNewMembership = existingMembership == null;
-            var activationDate = DateTime.UtcNow;
+            var activationDate = DateTime.Now;
 
             if (isNewMembership)
             {
@@ -166,7 +190,7 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
                     UserId = user.Id,
                     IsActive = true,
                     ActivatedAt = activationDate,
-                    InitialContribution = 56_000_000,
+                    InitialContribution =activationFeeValue,
                     GiftValue = giftValue, // مقدار از تنظیمات
                     TotalEarned = 0,
                     PurchaseMethod = user.PackagePurchaseMethod
@@ -225,6 +249,83 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
             _context.ClubMembershipHistories.Add(history);
             await _context.SaveChangesAsync(cancellationToken);
 
+            // ⭐ 8. اضافه کردن مبلغ به Pool هفته جاری
+            var currentWeekNumber = GetCurrentWeekNumber();
+            var weeklyPool = await _context.WeeklyCommissionPools
+                .FirstOrDefaultAsync(p => p.WeekNumber == currentWeekNumber, cancellationToken);
+
+            if (weeklyPool == null)
+            {
+                // ایجاد Pool جدید برای این هفته
+                weeklyPool = new WeeklyCommissionPool
+                {
+                    WeekNumber = currentWeekNumber,
+                    TotalPoolAmount = activationFeeValue, // مبلغ هدیه به Pool اضافه میشه
+                    TotalBalances = 0, // در CalculateWeeklyBalances محاسبه میشه
+                    ValuePerBalance = 0, // در CalculateWeeklyCommissionPool محاسبه میشه
+                    IsCalculated = false,
+                    CalculatedAt = null
+                };
+
+                await _context.WeeklyCommissionPools.AddAsync(weeklyPool, cancellationToken);
+                
+                _logger.LogInformation(
+                    "Created new WeeklyCommissionPool for {WeekNumber} with initial amount: {Amount}",
+                    currentWeekNumber,
+                    giftValue
+                );
+            }
+            else
+            {
+                // اضافه کردن به Pool موجود
+                weeklyPool.TotalPoolAmount += activationFeeValue;
+                _context.WeeklyCommissionPools.Update(weeklyPool);
+                
+                _logger.LogInformation(
+                    "Added {Amount} to existing WeeklyCommissionPool for {WeekNumber}. New total: {NewTotal}",
+                    activationFeeValue,
+                    currentWeekNumber,
+                    weeklyPool.TotalPoolAmount
+                );
+            }
+
+            await _context.SaveChangesAsync(cancellationToken);
+
+            // 9. اضافه کردن ویژگی‌های باشگاه برای کاربر (فقط برای عضویت جدید)
+            if (isNewMembership)
+            {
+                var clubFeatures = await _context.ClubFeatures
+                    .Where(f => !f.IsDeleted && new long[] { 1, 2, 3, 4 }.Contains(f.Id))
+                    .ToListAsync(cancellationToken);
+
+                if (clubFeatures.Any())
+                {
+                var userClubFeatures = clubFeatures.Select(feature => new UserClubFeature
+                {
+                    UserId = user.Id,
+                    ClubMembershipId = entity.Id,
+                    ClubFeatureId = feature.Id,
+                    GrantedAt = activationDate,
+                    IsActive = true,
+                    Notes = "اعطا شده به‌طور خودکار هنگام فعالسازی"
+                }).ToList();                    _context.UserClubFeatures.AddRange(userClubFeatures);
+                    await _context.SaveChangesAsync(cancellationToken);
+
+                    _logger.LogInformation(
+                        "Granted {Count} club features to UserId {UserId}",
+                        clubFeatures.Count,
+                        user.Id
+                    );
+                }
+                else
+                {
+                    _logger.LogWarning(
+                        "No club features found to grant to UserId {UserId}",
+                        user.Id
+                    );
+                }
+            }
+
             _logger.LogInformation(
                 "Club membership activated successfully. UserId: {UserId}, MembershipId: {MembershipId}",
                 user.Id,
@@ -243,4 +344,15 @@ public class ActivateClubMembershipCommandHandler : IRequestHandler<ActivateClub
             throw;
         }
     }
+
+    /// <summary>
+    /// دریافت شماره هفته جاری (مثال: "2025-W50")
+    /// </summary>
+    private string GetCurrentWeekNumber()
+    {
+        var now = DateTime.Now;
+        var calendar = CultureInfo.CurrentCulture.Calendar;
+        var weekOfYear = calendar.GetWeekOfYear(now, CalendarWeekRule.FirstDay, DayOfWeek.Saturday);
+        return $"{now.Year}-W{weekOfYear:D2}";
+    }
 }
diff --git a/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/AssignClubFeature/AssignClubFeatureCommandHandler.cs b/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/AssignClubFeature/AssignClubFeatureCommandHandler.cs
index 1b33ecb..b849d65 100644
--- a/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/AssignClubFeature/AssignClubFeatureCommandHandler.cs
+++ b/src/CMSMicroservice.Application/ClubMembershipCQ/Commands/AssignClubFeature/AssignClubFeatureCommandHandler.cs
@@ -54,7 +54,7 @@ public class AssignClubFeatureCommandHandler : IRequestHandler<AssignClubFeature
                 UserId = request.UserId,
                 ClubMembershipId = membership.Id,
                 ClubFeatureId = request.FeatureId,
-                GrantedAt = request.GrantedAt ?? DateTime.UtcNow,
+                GrantedAt = request.GrantedAt ?? DateTime.Now,
                 Notes = request.Notes
             };
 
diff --git a/src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubStatistics/GetClubStatisticsQueryHandler.cs b/src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubStatistics/GetClubStatisticsQueryHandler.cs
index 9893658..4218fa1 100644
--- a/src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubStatistics/GetClubStatisticsQueryHandler.cs
+++ b/src/CMSMicroservice.Application/ClubMembershipCQ/Queries/GetClubStatistics/GetClubStatisticsQueryHandler.cs
@@ -11,7 +11,7 @@ public class GetClubStatisticsQueryHandler : IRequestHandler<GetClubStatisticsQu
 
     public async Task<GetClubStatisticsResponseDto> Handle(GetClubStatisticsQuery request, CancellationToken cancellationToken)
     {
-        var now = DateTime.UtcNow;
+        var now = DateTime.Now;
 
         // Basic statistics
         var totalMembers = await _context.ClubMemberships.CountAsync(cancellationToken);
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/ApproveWithdrawal/ApproveWithdrawalCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/ApproveWithdrawal/ApproveWithdrawalCommandHandler.cs
index 6d1bcc8..ae6d4cc 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/ApproveWithdrawal/ApproveWithdrawalCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/ApproveWithdrawal/ApproveWithdrawalCommandHandler.cs
@@ -33,10 +33,10 @@ public class ApproveWithdrawalCommandHandler : IRequestHandler<ApproveWithdrawal
 
         // Update status to Withdrawn (approved)
         payout.Status = CommissionPayoutStatus.Withdrawn;
-        payout.WithdrawnAt = DateTime.UtcNow;
+        payout.WithdrawnAt = DateTime.Now;
         payout.ProcessedBy = _currentUser.GetPerformedBy();
-        payout.ProcessedAt = DateTime.UtcNow;
-        payout.LastModified = DateTime.UtcNow;
+        payout.ProcessedAt = DateTime.Now;
+        payout.LastModified = DateTime.Now;
 
         // TODO: Add PayoutHistory record
         // var history = new CommissionPayoutHistory
@@ -51,7 +51,7 @@ public class ApproveWithdrawalCommandHandler : IRequestHandler<ApproveWithdrawal
         //     Action = (int)CommissionPayoutAction.Approved,
         //     PerformedBy = "Admin", // TODO: Get from authenticated user
         //     Reason = request.Notes,
-        //     Created = DateTime.UtcNow
+        //     Created = DateTime.Now
         // };
         // _context.CommissionPayoutHistories.Add(history);
 
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyBalances/CalculateWeeklyBalancesCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyBalances/CalculateWeeklyBalancesCommandHandler.cs
index 247e533..f9fe8d5 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyBalances/CalculateWeeklyBalancesCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyBalances/CalculateWeeklyBalancesCommandHandler.cs
@@ -28,9 +28,17 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
             await _context.SaveChangesAsync(cancellationToken);
         }
 
-        // دریافت کاربران فعال در شبکه
+        // ⭐ دریافت همه کاربرانی که عضو فعال باشگاه هستند
+        // بدون محدودیت زمانی - همه اعضای فعال کلاب باید کمیسیون بگیرند
+        var activeClubMemberUserIds = await _context.ClubMemberships
+            .Where(c => c.IsActive)
+            .Select(c => c.UserId)
+            .ToHashSetAsync(cancellationToken);
+
+        // دریافت کاربران فعال در شبکه که عضو باشگاه هستند
+        // نکته: شرط NetworkParentId.HasValue نداریم چون ریشه شبکه (اولین نفر) هم باید حساب بشه
         var usersInNetwork = await _context.Users
-            .Where(x => x.NetworkParentId.HasValue)
+            .Where(x => activeClubMemberUserIds.Contains(x.Id))
             .Select(x => new { x.Id })
             .ToListAsync(cancellationToken);
 
@@ -47,7 +55,7 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
             .ToDictionaryAsync(x => x.UserId, cancellationToken);
 
         var balancesList = new List<NetworkWeeklyBalance>();
-        var calculatedAt = DateTime.UtcNow;
+        var calculatedAt = DateTime.Now;
 
         // خواندن یکباره Configuration ها (بهینه‌سازی - به جای N query)
         var configs = await _context.SystemConfigurations
@@ -57,15 +65,15 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
                 x.Key == "Commission.MaxWeeklyBalancesPerLeg" ||
                 x.Key == "Commission.MaxNetworkLevel"))
             .ToDictionaryAsync(x => x.Key, x => x.Value, cancellationToken);
-
-        var activationFee = long.Parse(configs.GetValueOrDefault("Club.ActivationFee", "25000000"));
-        var poolPercent = decimal.Parse(configs.GetValueOrDefault("Commission.WeeklyPoolContributionPercent", "20")) / 100m;
+        
+        // var activationFee = long.Parse(configs.GetValueOrDefault("Club.ActivationFee", "25000000"));
+        // var poolPercent = decimal.Parse(configs.GetValueOrDefault("Commission.WeeklyPoolContributionPercent", "20")) / 100m;
         // سقف تعادل هفتگی برای هر دست (نه کل) - 300 برای چپ + 300 برای راست = حداکثر 600 تعادل
         var maxBalancesPerLeg = int.Parse(configs.GetValueOrDefault("Commission.MaxWeeklyBalancesPerLeg", "300"));
         // حداکثر عمق شبکه برای شمارش اعضا (15 لول)
         var maxNetworkLevel = int.Parse(configs.GetValueOrDefault("Commission.MaxNetworkLevel", "15"));
 
-        foreach (var user in usersInNetwork)
+        foreach (var user in usersInNetwork.OrderBy(o=>o.Id))
         {
             // دریافت باقیمانده هفته قبل
             var leftCarryover = 0;
@@ -84,29 +92,34 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
             var leftTotal = leftNewMembers + leftCarryover;
             var rightTotal = rightNewMembers + rightCarryover;
 
-            // ✅ اصلاح شده: اعمال سقف روی هر دست جداگانه (نه روی کل)
-            // سقف 300 برای دست چپ + 300 برای دست راست = حداکثر 600 تعادل در هفته
-            var cappedLeftTotal = Math.Min(leftTotal, maxBalancesPerLeg);
-            var cappedRightTotal = Math.Min(rightTotal, maxBalancesPerLeg);
+            // ✅ مرحله 1: محاسبه تعادل اولیه (قبل از اعمال سقف)
+            // تعادل = کمترین مقدار بین چپ و راست
+            // مثال: چپ=500، راست=600 → تعادل=500
+            var totalBalances = Math.Min(leftTotal, rightTotal);
 
-            // محاسبه تعادل (کمترین مقدار بعد از اعمال سقف)
-            var totalBalances = Math.Min(cappedLeftTotal, cappedRightTotal);
+            // ✅ مرحله 2: محاسبه باقیمانده (قبل از سقف)
+            // باقیمانده = اضافه‌ای که یک طرف دارد
+            // مثال: چپ=500، راست=600، تعادل=500
+            //   → باقی چپ = 500-500 = 0
+            //   → باقی راست = 600-500 = 100 (می‌رود برای هفته بعد)
+            var leftRemainder = leftTotal - totalBalances;
+            var rightRemainder = rightTotal - totalBalances;
 
-            // محاسبه باقیمانده برای هفته بعد
-            // باقیمانده = مقداری که از سقف هر دست رد شده
-            // مثال: چپ=350، راست=450، سقف=300
-            // cappedLeft = MIN(350, 300) = 300
-            // cappedRight = MIN(450, 300) = 300
-            // totalBalances = MIN(300, 300) = 300
-            // leftRemainder = 350 - 300 = 50 (مازاد سقف)
-            // rightRemainder = 450 - 300 = 150 (مازاد سقف)
-            var leftRemainder = leftTotal - cappedLeftTotal;
-            var rightRemainder = rightTotal - cappedRightTotal;
+            // ✅ مرحله 3: اعمال سقف 300 (برای امتیاز نهایی)
+            // از تعادل، فقط 300 از هر طرف حساب می‌شود
+            // مثال: تعادل=500 → امتیاز=300
+            //   از چپ: 300 حساب می‌شود، 200 فلش می‌شود
+            //   از راست: 300 حساب می‌شود، 200 فلش می‌شود
+            //   جمع فلش = 400 (از بین می‌رود)
+            var cappedBalances = Math.Min(totalBalances, maxBalancesPerLeg);
+            
+            // ✅ مرحله 4: محاسبه فلش (از هر دو طرف)
+            var flushedPerSide = totalBalances - cappedBalances; // 500-300=200
+            var totalFlushed = flushedPerSide * 2; // 200×2=400 (از بین می‌رود)
 
-            // محاسبه سهم استخر (20% از مجموع فعال‌سازی‌های جدید کل شبکه)
-            // طبق گفته دکتر: کل افراد جدید در شبکه × هزینه فعال‌سازی × 20%
-            var totalNewMembers = leftNewMembers + rightNewMembers;
-            var weeklyPoolContribution = (long)(totalNewMembers * activationFee * poolPercent);
+            // ⚠️ توجه: تعادل زیرمجموعه در این مرحله محاسبه نمیشه
+            // چون هنوز تمام تعادل‌ها محاسبه نشدن
+            // بعد از ذخیره همه تعادل‌ها، در یک حلقه دوم محاسبه خواهد شد
 
             var balance = new NetworkWeeklyBalance
             {
@@ -122,19 +135,26 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
                 // مجموع
                 LeftLegTotal = leftTotal,
                 RightLegTotal = rightTotal,
-                TotalBalances = totalBalances, // تعادل واقعی بعد از اعمال سقف روی هر دست
+                TotalBalances = cappedBalances, // امتیاز نهایی بعد از اعمال سقف 300
                 
-                // باقیمانده برای هفته بعد (مازاد سقف هر دست)
+                // باقیمانده برای هفته بعد (اضافه‌ای که یک طرف دارد)
                 LeftLegRemainder = leftRemainder,
                 RightLegRemainder = rightRemainder,
                 
+                // فلش (از دست رفته)
+                FlushedPerSide = flushedPerSide,
+                TotalFlushed = totalFlushed,
+                
+                // تعادل زیرمجموعه - فعلاً 0 (بعد از ذخیره همه تعادل‌ها محاسبه میشه)
+                SubordinateBalances = 0,
+                
                 // فیلدهای قدیمی (deprecated) - برای سازگاری با کدهای قبلی
 #pragma warning disable CS0618
                 LeftLegBalances = leftTotal,
                 RightLegBalances = rightTotal,
 #pragma warning restore CS0618
                 
-                WeeklyPoolContribution = weeklyPoolContribution,
+                WeeklyPoolContribution = 0, // Pool در مرحله بعد محاسبه میشه
                 CalculatedAt = calculatedAt,
                 IsExpired = false
             };
@@ -145,6 +165,26 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
         await _context.NetworkWeeklyBalances.AddRangeAsync(balancesList, cancellationToken);
         await _context.SaveChangesAsync(cancellationToken);
 
+        // ⭐ مرحله 2: محاسبه تعادل زیرمجموعه برای هر کاربر (تا 15 لول)
+        // حالا که همه تعادل‌ها ذخیره شدن، می‌تونیم تعادل زیرمجموعه رو حساب کنیم
+        var balancesDictionary = balancesList.ToDictionary(x => x.UserId);
+        
+        foreach (var balance in balancesList)
+        {
+            var subordinateBalances = await CalculateSubordinateBalancesAsync(
+                balance.UserId,
+                balancesDictionary,
+                maxNetworkLevel,
+                cancellationToken
+            );
+
+            balance.SubordinateBalances = subordinateBalances;
+        }
+
+        // ذخیره تعادل‌های زیرمجموعه
+        _context.NetworkWeeklyBalances.UpdateRange(balancesList);
+        await _context.SaveChangesAsync(cancellationToken);
+
         return balancesList.Count;
     }
 
@@ -248,4 +288,64 @@ public class CalculateWeeklyBalancesCommandHandler : IRequestHandler<CalculateWe
 
         return (weekStart, weekEnd);
     }
+
+    /// <summary>
+    /// محاسبه مجموع تعادل‌های زیرمجموعه یک کاربر تا maxLevel لول پایین‌تر
+    /// </summary>
+    private async Task<int> CalculateSubordinateBalancesAsync(
+        long userId,
+        Dictionary<long, NetworkWeeklyBalance> allBalances,
+        int maxLevel,
+        CancellationToken cancellationToken)
+    {
+        // پیدا کردن همه زیرمجموعه‌ها تا maxLevel لول
+        var subordinates = await GetSubordinatesRecursive(userId, 1, maxLevel, cancellationToken);
+
+        // جمع تعادل‌های آنها
+        var totalSubordinateBalances = 0;
+        foreach (var subordinateId in subordinates)
+        {
+            if (allBalances.ContainsKey(subordinateId))
+            {
+                totalSubordinateBalances += allBalances[subordinateId].TotalBalances;
+            }
+        }
+
+        return totalSubordinateBalances;
+    }
+
+    /// <summary>
+    /// پیدا کردن بازگشتی زیرمجموعه‌ها تا maxLevel لول
+    /// </summary>
+    private async Task<List<long>> GetSubordinatesRecursive(
+        long userId,
+        int currentLevel,
+        int maxLevel,
+        CancellationToken cancellationToken)
+    {
+        // محدودیت عمق
+        if (currentLevel > maxLevel)
+        {
+            return new List<long>();
+        }
+
+        var result = new List<long>();
+
+        // پیدا کردن فرزندان مستقیم
+        var children = await _context.Users
+            .Where(x => x.NetworkParentId == userId)
+            .Select(x => x.Id)
+            .ToListAsync(cancellationToken);
+
+        result.AddRange(children);
+
+        // بازگشت برای هر فرزند
+        foreach (var childId in children)
+        {
+            var grandChildren = await GetSubordinatesRecursive(childId, currentLevel + 1, maxLevel, cancellationToken);
+            result.AddRange(grandChildren);
+        }
+
+        return result;
+    }
 }
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommandHandler.cs
index af4b89f..5b0d627 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/CalculateWeeklyCommissionPool/CalculateWeeklyCommissionPoolCommandHandler.cs
@@ -11,11 +11,19 @@ public class CalculateWeeklyCommissionPoolCommandHandler : IRequestHandler<Calcu
 
     public async Task<long> Handle(CalculateWeeklyCommissionPoolCommand request, CancellationToken cancellationToken)
     {
-        // بررسی وجود استخر قبلی
+        // بررسی وجود استخر
         var existingPool = await _context.WeeklyCommissionPools
             .FirstOrDefaultAsync(x => x.WeekNumber == request.WeekNumber, cancellationToken);
 
-        if (existingPool != null && existingPool.IsCalculated && !request.ForceRecalculate)
+        if (existingPool == null)
+        {
+            throw new InvalidOperationException(
+                $"Pool هفته {request.WeekNumber} وجود ندارد. " +
+                "Pool باید در هنگام فعالسازی باشگاه مشتریان ایجاد شده باشد"
+            );
+        }
+
+        if (existingPool.IsCalculated && !request.ForceRecalculate)
         {
             throw new InvalidOperationException($"استخر کمیسیون هفته {request.WeekNumber} قبلاً محاسبه شده است");
         }
@@ -30,48 +38,122 @@ public class CalculateWeeklyCommissionPoolCommandHandler : IRequestHandler<Calcu
             throw new InvalidOperationException($"تعادل‌های هفته {request.WeekNumber} هنوز محاسبه نشده است. ابتدا CalculateWeeklyBalances را اجرا کنید");
         }
 
-        // محاسبه مجموع مشارکت‌ها در استخر
-        var totalPoolAmount = weeklyBalances.Sum(x => x.WeeklyPoolContribution);
+        // ⭐ Pool از قبل پُر شده (توسط ActivateClubMembership)
+        var totalPoolAmount = existingPool.TotalPoolAmount;
 
-        // محاسبه مجموع Balances
-        var totalBalances = weeklyBalances.Sum(x => x.TotalBalances);
+        // محاسبه مجموع تعادل‌های کل شبکه
+        // نکته: SubordinateBalances اضافه نمی‌کنیم چون وقتی همه TotalBalances رو جمع می‌زنیم،
+        // خودش شامل بالانس‌های زیرمجموعه‌ها هم هست (تکراری نشه)
+        var totalBalancesInNetwork = weeklyBalances.Sum(x => x.TotalBalances);
 
-        // محاسبه ارزش هر Balance (تقسیم صحیح برای ریال)
+        // محاسبه ارزش هر امتیاز
         long valuePerBalance = 0;
-        if (totalBalances > 0)
+        if (totalBalancesInNetwork > 0)
         {
-            valuePerBalance = totalPoolAmount / totalBalances;
+            valuePerBalance = totalPoolAmount / totalBalancesInNetwork;
         }
 
-        if (existingPool != null)
-        {
-            // به‌روزرسانی
-            existingPool.TotalPoolAmount = totalPoolAmount;
-            existingPool.TotalBalances = totalBalances;
-            existingPool.ValuePerBalance = valuePerBalance;
-            existingPool.IsCalculated = true;
-            existingPool.CalculatedAt = DateTime.UtcNow;
+        // به‌روزرسانی Pool
+        existingPool.TotalBalances = totalBalancesInNetwork;
+        existingPool.ValuePerBalance = valuePerBalance;
+        existingPool.IsCalculated = true;
+        existingPool.CalculatedAt = DateTime.Now;
 
-            _context.WeeklyCommissionPools.Update(existingPool);
-        }
-        else
+        _context.WeeklyCommissionPools.Update(existingPool);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        // حذف پرداخت‌های قبلی در صورت ForceRecalculate
+        if (request.ForceRecalculate)
         {
-            // ایجاد جدید
-            var pool = new WeeklyCommissionPool
+            var oldPayouts = await _context.UserCommissionPayouts
+                .Where(p => p.WeekNumber == request.WeekNumber)
+                .ToListAsync(cancellationToken);
+            
+            if (oldPayouts.Any())
             {
+                var oldPayoutIds = oldPayouts.Select(p => p.Id).ToList();
+                
+                // ⭐ اول باید تاریخچه‌ها حذف بشن (به خاطر FK constraint)
+                var oldHistories = await _context.CommissionPayoutHistories
+                    .Where(h => oldPayoutIds.Contains(h.UserCommissionPayoutId))
+                    .ToListAsync(cancellationToken);
+                
+                if (oldHistories.Any())
+                {
+                    _context.CommissionPayoutHistories.RemoveRange(oldHistories);
+                }
+                
+                // بعد پرداخت‌ها حذف می‌شن
+                _context.UserCommissionPayouts.RemoveRange(oldPayouts);
+                await _context.SaveChangesAsync(cancellationToken);
+            }
+        }
+
+        // ⭐ ثبت پرداخت برای کاربرانی که تعادل دارند
+        // تعادل شخصی + زیرمجموعه قبلاً در CalculateWeeklyBalances محاسبه شده
+        var payouts = new List<UserCommissionPayout>();
+        
+        foreach (var balance in weeklyBalances)
+        {
+            // فقط تعادل شخصی (SubordinateBalances اضافه نمی‌شه چون در SUM کل شبکه خودش حساب میشه)
+            var userBalance = balance.TotalBalances;
+
+            // اگر تعادل صفر است، نیازی به ثبت نیست
+            if (userBalance <= 0)
+            {
+                continue;
+            }
+
+            // محاسبه مبلغ کمیسیون
+            var totalAmount = (long)(userBalance * valuePerBalance);
+
+            var payout = new UserCommissionPayout
+            {
+                UserId = balance.UserId,
                 WeekNumber = request.WeekNumber,
-                TotalPoolAmount = totalPoolAmount,
-                TotalBalances = totalBalances,
+                WeeklyPoolId = existingPool.Id,
+                BalancesEarned = userBalance,
                 ValuePerBalance = valuePerBalance,
-                IsCalculated = true,
-                CalculatedAt = DateTime.UtcNow
+                TotalAmount = totalAmount,
+                Status = CommissionPayoutStatus.Pending,
+                PaidAt = null,
+                WithdrawalMethod = null,
+                IbanNumber = null,
+                WithdrawnAt = null
             };
 
-            await _context.WeeklyCommissionPools.AddAsync(pool, cancellationToken);
-            existingPool = pool;
+            payouts.Add(payout);
         }
 
-        await _context.SaveChangesAsync(cancellationToken);
+        if (payouts.Any())
+        {
+            await _context.UserCommissionPayouts.AddRangeAsync(payouts, cancellationToken);
+            await _context.SaveChangesAsync(cancellationToken);
+
+            // ثبت تاریخچه برای هر پرداخت
+            var historyList = new List<CommissionPayoutHistory>();
+            foreach (var payout in payouts)
+            {
+                var history = new CommissionPayoutHistory
+                {
+                    UserCommissionPayoutId = payout.Id,
+                    UserId = payout.UserId,
+                    WeekNumber = request.WeekNumber,
+                    AmountBefore = 0,
+                    AmountAfter = payout.TotalAmount,
+                    OldStatus = default(CommissionPayoutStatus),
+                    NewStatus = CommissionPayoutStatus.Pending,
+                    Action = CommissionPayoutAction.Created,
+                    PerformedBy = "System",
+                    Reason = "پردازش خودکار کمیسیون هفتگی"
+                };
+
+                historyList.Add(history);
+            }
+
+            await _context.CommissionPayoutHistories.AddRangeAsync(historyList, cancellationToken);
+            await _context.SaveChangesAsync(cancellationToken);
+        }
 
         return existingPool.Id;
     }
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/ProcessWithdrawal/ProcessWithdrawalCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/ProcessWithdrawal/ProcessWithdrawalCommandHandler.cs
index 0ff6d05..c4cb67d 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/ProcessWithdrawal/ProcessWithdrawalCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/ProcessWithdrawal/ProcessWithdrawalCommandHandler.cs
@@ -39,7 +39,7 @@ public class ProcessWithdrawalCommandHandler : IRequestHandler<ProcessWithdrawal
         }
 
         var oldStatus = payout.Status;
-        var now = DateTime.UtcNow;
+        var now = DateTime.Now;
 
         if (request.IsApproved)
         {
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/RejectWithdrawal/RejectWithdrawalCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/RejectWithdrawal/RejectWithdrawalCommandHandler.cs
index d7eb131..29f8274 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/RejectWithdrawal/RejectWithdrawalCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/RejectWithdrawal/RejectWithdrawalCommandHandler.cs
@@ -34,9 +34,9 @@ public class RejectWithdrawalCommandHandler : IRequestHandler<RejectWithdrawalCo
         // Update status to Cancelled (rejected)
         payout.Status = CommissionPayoutStatus.Cancelled;
         payout.ProcessedBy = _currentUser.GetPerformedBy();
-        payout.ProcessedAt = DateTime.UtcNow;
+        payout.ProcessedAt = DateTime.Now;
         payout.RejectionReason = request.Reason;
-        payout.LastModified = DateTime.UtcNow;
+        payout.LastModified = DateTime.Now;
 
         // TODO: Add PayoutHistory record with rejection reason
         // var history = new CommissionPayoutHistory
@@ -51,7 +51,7 @@ public class RejectWithdrawalCommandHandler : IRequestHandler<RejectWithdrawalCo
         //     Action = (int)CommissionPayoutAction.Rejected,
         //     PerformedBy = "Admin", // TODO: Get from authenticated user
         //     Reason = request.Reason,
-        //     Created = DateTime.UtcNow
+        //     Created = DateTime.Now
         // };
         // _context.CommissionPayoutHistories.Add(history);
 
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommand.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommand.cs
index 44288c5..3f91ba5 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommand.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommand.cs
@@ -13,17 +13,12 @@ public record TriggerWeeklyCalculationCommand : IRequest<TriggerWeeklyCalculatio
     public bool ForceRecalculate { get; init; }
 
     /// <summary>
-    /// Skip balance calculation
+    /// Skip balance calculation (Step 1)
     /// </summary>
     public bool SkipBalances { get; init; }
 
     /// <summary>
-    /// Skip pool calculation
-    /// </summary>
-    public bool SkipPool { get; init; }
-
-    /// <summary>
-    /// Skip payout processing
+    /// Skip pool calculation and payout processing (Step 2)
     /// </summary>
     public bool SkipPayouts { get; init; }
 }
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommandHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommandHandler.cs
index 410968a..aa3ebd2 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommandHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Commands/TriggerWeeklyCalculation/TriggerWeeklyCalculationCommandHandler.cs
@@ -1,7 +1,6 @@
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Application.CommissionCQ.Commands.CalculateWeeklyBalances;
 using CMSMicroservice.Application.CommissionCQ.Commands.CalculateWeeklyCommissionPool;
-using CMSMicroservice.Application.CommissionCQ.Commands.ProcessUserPayouts;
 
 namespace CMSMicroservice.Application.CommissionCQ.Commands.TriggerWeeklyCalculation;
 
@@ -23,7 +22,7 @@ public class TriggerWeeklyCalculationCommandHandler : IRequestHandler<TriggerWee
         CancellationToken cancellationToken)
     {
         var executionId = Guid.NewGuid().ToString();
-        var startedAt = DateTime.UtcNow;
+        var startedAt = DateTime.Now;
 
         try
         {
@@ -41,7 +40,7 @@ public class TriggerWeeklyCalculationCommandHandler : IRequestHandler<TriggerWee
 
             var steps = new List<string>();
 
-            // Step 1: Calculate Weekly Balances
+            // Step 1: Calculate Weekly Balances (تا 15 لول)
             if (!request.SkipBalances)
             {
                 await _mediator.Send(new CalculateWeeklyBalancesCommand
@@ -52,25 +51,15 @@ public class TriggerWeeklyCalculationCommandHandler : IRequestHandler<TriggerWee
                 steps.Add("محاسبه امتیازات هفتگی");
             }
 
-            // Step 2: Calculate Weekly Commission Pool
-            if (!request.SkipPool)
+            // Step 2: Calculate Pool & Process Payouts (محاسبه استخر + پرداخت کاربران)
+            if (!request.SkipPayouts)
             {
                 await _mediator.Send(new CalculateWeeklyCommissionPoolCommand
-                {
-                    WeekNumber = request.WeekNumber
-                }, cancellationToken);
-                steps.Add("محاسبه استخر کمیسیون");
-            }
-
-            // Step 3: Process User Payouts
-            if (!request.SkipPayouts)
-            {
-                await _mediator.Send(new ProcessUserPayoutsCommand
                 {
                     WeekNumber = request.WeekNumber,
-                    ForceReprocess = request.ForceRecalculate
+                    ForceRecalculate = request.ForceRecalculate
                 }, cancellationToken);
-                steps.Add("پردازش پرداخت‌های کاربران");
+                steps.Add("محاسبه استخر و پرداخت کاربران");
             }
 
             return new TriggerWeeklyCalculationResponseDto
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQuery.cs b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQuery.cs
new file mode 100644
index 0000000..5443f78
--- /dev/null
+++ b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQuery.cs
@@ -0,0 +1,13 @@
+namespace CMSMicroservice.Application.CommissionCQ.Queries.GetAvailableWeeks;
+
+/// <summary>
+/// دریافت لیست هفته‌های قابل انتخاب برای محاسبه کمیسیون
+/// </summary>
+public class GetAvailableWeeksQuery : IRequest<GetAvailableWeeksResponseDto>
+{
+    /// <summary>تعداد هفته‌های آینده برای نمایش (پیش‌فرض: 4)</summary>
+    public int FutureWeeksCount { get; init; } = 4;
+    
+    /// <summary>تعداد هفته‌های گذشته برای نمایش (پیش‌فرض: 12)</summary>
+    public int PastWeeksCount { get; init; } = 12;
+}
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQueryHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQueryHandler.cs
new file mode 100644
index 0000000..1ac83e9
--- /dev/null
+++ b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksQueryHandler.cs
@@ -0,0 +1,132 @@
+using CMSMicroservice.Application.Common.Interfaces;
+using CMSMicroservice.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using System.Globalization;
+
+namespace CMSMicroservice.Application.CommissionCQ.Queries.GetAvailableWeeks;
+
+public class GetAvailableWeeksQueryHandler : IRequestHandler<GetAvailableWeeksQuery, GetAvailableWeeksResponseDto>
+{
+    private readonly IApplicationDbContext _context;
+
+    public GetAvailableWeeksQueryHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<GetAvailableWeeksResponseDto> Handle(
+        GetAvailableWeeksQuery request, 
+        CancellationToken cancellationToken)
+    {
+        var currentDate = DateTime.Now;
+        var currentWeekNumber = GetWeekNumber(currentDate);
+        
+        // دریافت هفته‌های محاسبه شده از دیتابیس
+        var calculatedPools = await _context.WeeklyCommissionPools
+            .Where(p => p.IsCalculated)
+            .OrderByDescending(p => p.WeekNumber)
+            .Take(request.PastWeeksCount)
+            .ToListAsync(cancellationToken);
+
+        // دریافت لاگ‌های اجرا
+        var executionLogs = await _context.WorkerExecutionLogs
+            .Where(log => log.Status == WorkerExecutionStatus.Success || 
+                          log.Status == WorkerExecutionStatus.Failed)
+            .GroupBy(log => log.WeekNumber)
+            .Select(g => new 
+            { 
+                WeekNumber = g.Key, 
+                LastLog = g.OrderByDescending(l => l.StartedAt).First()
+            })
+            .ToDictionaryAsync(x => x.WeekNumber, x => x.LastLog, cancellationToken);
+
+        var allWeeks = new List<WeekInfoDto>();
+        
+        // هفته جاری
+        var currentWeekInfo = CreateWeekInfo(currentDate, currentWeekNumber, calculatedPools, executionLogs);
+        
+        // هفته‌های گذشته (12 هفته)
+        var pastWeeks = new List<WeekInfoDto>();
+        for (int i = 1; i <= request.PastWeeksCount; i++)
+        {
+            var pastDate = currentDate.AddDays(-7 * i);
+            var weekNumber = GetWeekNumber(pastDate);
+            pastWeeks.Add(CreateWeekInfo(pastDate, weekNumber, calculatedPools, executionLogs));
+        }
+        
+        // هفته‌های آینده (4 هفته)
+        var futureWeeks = new List<WeekInfoDto>();
+        for (int i = 1; i <= request.FutureWeeksCount; i++)
+        {
+            var futureDate = currentDate.AddDays(7 * i);
+            var weekNumber = GetWeekNumber(futureDate);
+            futureWeeks.Add(CreateWeekInfo(futureDate, weekNumber, calculatedPools, executionLogs));
+        }
+        
+        // تفکیک به calculated و pending
+        var calculatedWeeks = pastWeeks.Where(w => w.IsCalculated).ToList();
+        var pendingWeeks = pastWeeks.Where(w => !w.IsCalculated).ToList();
+        
+        return new GetAvailableWeeksResponseDto
+        {
+            CurrentWeek = currentWeekInfo,
+            CalculatedWeeks = calculatedWeeks,
+            PendingWeeks = pendingWeeks,
+            FutureWeeks = futureWeeks
+        };
+    }
+
+    private WeekInfoDto CreateWeekInfo(
+        DateTime date, 
+        string weekNumber,
+        List<Domain.Entities.Commission.WeeklyCommissionPool> calculatedPools,
+        Dictionary<string, Domain.Entities.Commission.WorkerExecutionLog> executionLogs)
+    {
+        var (startDate, endDate) = GetWeekRange(date);
+        var pool = calculatedPools.FirstOrDefault(p => p.WeekNumber == weekNumber);
+        var log = executionLogs.GetValueOrDefault(weekNumber);
+        
+        var isCalculated = pool != null && pool.IsCalculated;
+        var displayText = $"{weekNumber} ({startDate:yyyy/MM/dd} - {endDate:yyyy/MM/dd})";
+        
+        if (isCalculated)
+        {
+            displayText += " ✅ محاسبه شده";
+        }
+        
+        return new WeekInfoDto
+        {
+            WeekNumber = weekNumber,
+            StartDate = startDate,
+            EndDate = endDate,
+            IsCalculated = isCalculated,
+            CalculatedAt = pool?.CalculatedAt,
+            LastExecutionStatus = log?.Status.ToString(),
+            TotalPoolAmount = pool?.TotalPoolAmount,
+            EligibleUsersCount = pool?.UserCommissionPayouts?.Count ?? 0,
+            DisplayText = displayText
+        };
+    }
+
+    private static string GetWeekNumber(DateTime date)
+    {
+        var calendar = CultureInfo.InvariantCulture.Calendar;
+        var weekOfYear = calendar.GetWeekOfYear(
+            date, 
+            CalendarWeekRule.FirstFourDayWeek, 
+            DayOfWeek.Monday);
+        
+        return $"{date.Year}-W{weekOfYear:D2}";
+    }
+
+    private static (DateTime startDate, DateTime endDate) GetWeekRange(DateTime date)
+    {
+        var dayOfWeek = (int)date.DayOfWeek;
+        var daysToMonday = dayOfWeek == 0 ? 6 : dayOfWeek - 1; // اگر یکشنبه باشد، 6 روز عقب برو
+        
+        var startDate = date.Date.AddDays(-daysToMonday);
+        var endDate = startDate.AddDays(6);
+        
+        return (startDate, endDate);
+    }
+}
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksResponseDto.cs b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksResponseDto.cs
new file mode 100644
index 0000000..905940e
--- /dev/null
+++ b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetAvailableWeeks/GetAvailableWeeksResponseDto.cs
@@ -0,0 +1,46 @@
+namespace CMSMicroservice.Application.CommissionCQ.Queries.GetAvailableWeeks;
+
+public class GetAvailableWeeksResponseDto
+{
+    /// <summary>هفته جاری</summary>
+    public required WeekInfoDto CurrentWeek { get; init; }
+    
+    /// <summary>هفته‌های محاسبه شده (از جدیدترین به قدیمی‌ترین)</summary>
+    public required List<WeekInfoDto> CalculatedWeeks { get; init; }
+    
+    /// <summary>هفته‌های محاسبه نشده (از جدیدترین به قدیمی‌ترین)</summary>
+    public required List<WeekInfoDto> PendingWeeks { get; init; }
+    
+    /// <summary>هفته‌های آینده قابل انتخاب</summary>
+    public required List<WeekInfoDto> FutureWeeks { get; init; }
+}
+
+public class WeekInfoDto
+{
+    /// <summary>شماره هفته (YYYY-Www)</summary>
+    public required string WeekNumber { get; init; }
+    
+    /// <summary>تاریخ شروع هفته</summary>
+    public required DateTime StartDate { get; init; }
+    
+    /// <summary>تاریخ پایان هفته</summary>
+    public required DateTime EndDate { get; init; }
+    
+    /// <summary>آیا محاسبه شده؟</summary>
+    public bool IsCalculated { get; init; }
+    
+    /// <summary>تاریخ محاسبه (اگر محاسبه شده باشد)</summary>
+    public DateTime? CalculatedAt { get; init; }
+    
+    /// <summary>وضعیت اجرای آخرین محاسبه</summary>
+    public string? LastExecutionStatus { get; init; }
+    
+    /// <summary>مبلغ کل استخر کمیسیون (اگر محاسبه شده باشد)</summary>
+    public long? TotalPoolAmount { get; init; }
+    
+    /// <summary>تعداد کاربران واجد شرایط</summary>
+    public int? EligibleUsersCount { get; init; }
+    
+    /// <summary>نمایش فارسی (برای UI)</summary>
+    public required string DisplayText { get; init; }
+}
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWithdrawalReports/GetWithdrawalReportsQueryHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWithdrawalReports/GetWithdrawalReportsQueryHandler.cs
index 347b577..e148991 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWithdrawalReports/GetWithdrawalReportsQueryHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWithdrawalReports/GetWithdrawalReportsQueryHandler.cs
@@ -19,7 +19,7 @@ public class GetWithdrawalReportsQueryHandler : IRequestHandler<GetWithdrawalRep
     public async Task<WithdrawalReportsDto> Handle(GetWithdrawalReportsQuery request, CancellationToken cancellationToken)
     {
         // تعیین بازه زمانی پیش‌فرض (30 روز گذشته)
-        var endDate = request.EndDate ?? DateTime.UtcNow;
+        var endDate = request.EndDate ?? DateTime.Now;
         var startDate = request.StartDate ?? endDate.AddDays(-30);
 
         // Query پایه
diff --git a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWorkerStatus/GetWorkerStatusQueryHandler.cs b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWorkerStatus/GetWorkerStatusQueryHandler.cs
index 05ee75a..5cfd066 100644
--- a/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWorkerStatus/GetWorkerStatusQueryHandler.cs
+++ b/src/CMSMicroservice.Application/CommissionCQ/Queries/GetWorkerStatus/GetWorkerStatusQueryHandler.cs
@@ -27,8 +27,8 @@ public class GetWorkerStatusQueryHandler : IRequestHandler<GetWorkerStatusQuery,
             CurrentExecutionId = null,
             CurrentWeekNumber = null,
             CurrentStep = "Idle",
-            LastRunAt = DateTime.UtcNow.AddHours(-24),
-            NextScheduledRun = DateTime.UtcNow.AddDays(7),
+            LastRunAt = DateTime.Now.AddHours(-24),
+            NextScheduledRun = DateTime.Now.AddDays(7),
             TotalExecutions = 48,
             SuccessfulExecutions = 47,
             FailedExecutions = 1
diff --git a/src/CMSMicroservice.Application/DayaLoanCQ/Commands/CheckDayaLoanStatus/CheckDayaLoanStatusCommandHandler.cs b/src/CMSMicroservice.Application/DayaLoanCQ/Commands/CheckDayaLoanStatus/CheckDayaLoanStatusCommandHandler.cs
index 3e1555a..3261853 100644
--- a/src/CMSMicroservice.Application/DayaLoanCQ/Commands/CheckDayaLoanStatus/CheckDayaLoanStatusCommandHandler.cs
+++ b/src/CMSMicroservice.Application/DayaLoanCQ/Commands/CheckDayaLoanStatus/CheckDayaLoanStatusCommandHandler.cs
@@ -48,7 +48,7 @@ public class CheckDayaLoanStatusCommandHandler : IRequestHandler<CheckDayaLoanSt
                     
                     if (existingContract != null)
                     {
-                        existingContract.LastCheckDate = DateTime.UtcNow;
+                        existingContract.LastCheckDate = DateTime.Now;
                         existingContract.Status = dayaResult.Status;
                         existingContract.ContractNumber = dayaResult.ContractNumber;
                     }
@@ -65,7 +65,7 @@ public class CheckDayaLoanStatusCommandHandler : IRequestHandler<CheckDayaLoanSt
                                 NationalCode = dayaResult.NationalCode,
                                 Status = dayaResult.Status,
                                 ContractNumber = dayaResult.ContractNumber,
-                                LastCheckDate = DateTime.UtcNow,
+                                LastCheckDate = DateTime.Now,
                                 IsProcessed = false
                             };
                             
diff --git a/src/CMSMicroservice.Application/DayaLoanCQ/Commands/ProcessDayaLoanApproval/ProcessDayaLoanApprovalCommandHandler.cs b/src/CMSMicroservice.Application/DayaLoanCQ/Commands/ProcessDayaLoanApproval/ProcessDayaLoanApprovalCommandHandler.cs
index 4e7dfbe..08958fd 100644
--- a/src/CMSMicroservice.Application/DayaLoanCQ/Commands/ProcessDayaLoanApproval/ProcessDayaLoanApprovalCommandHandler.cs
+++ b/src/CMSMicroservice.Application/DayaLoanCQ/Commands/ProcessDayaLoanApproval/ProcessDayaLoanApprovalCommandHandler.cs
@@ -36,7 +36,7 @@ public class ProcessDayaLoanApprovalCommandHandler : IRequestHandler<ProcessDaya
             Amount = request.WalletAmount + request.LockedWalletAmount + request.DiscountWalletAmount, // 168 میلیون
             Description = $"دریافت اعتبار دایا - قرارداد {request.ContractNumber}",
             PaymentStatus = PaymentStatus.Success,
-            PaymentDate = DateTime.UtcNow,
+            PaymentDate = DateTime.Now,
             RefId = request.ContractNumber, // شماره قرارداد دایا
             Type = TransactionType.DepositExternal1
         };
@@ -114,7 +114,7 @@ public class ProcessDayaLoanApprovalCommandHandler : IRequestHandler<ProcessDaya
         
         // به‌روزرسانی وضعیت کاربر
         user.HasReceivedDayaCredit = true;
-        user.DayaCreditReceivedAt = DateTime.UtcNow;
+        user.DayaCreditReceivedAt = DateTime.Now;
         
         // تنظیم نحوه خرید پکیج به DayaLoan
         user.PackagePurchaseMethod = PackagePurchaseMethod.DayaLoan;
@@ -139,7 +139,7 @@ public class ProcessDayaLoanApprovalCommandHandler : IRequestHandler<ProcessDaya
                     PackageId = goldenPackage.Id,
                     Amount = request.WalletAmount, // 56 میلیون
                     PaymentStatus = PaymentStatus.Success,
-                    PaymentDate = DateTime.UtcNow,
+                    PaymentDate = DateTime.Now,
                     DeliveryStatus = DeliveryStatus.None,
                     UserAddressId = defaultAddress.Id,
                     TransactionId = transaction.Id,
diff --git a/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CompleteOrderPayment/CompleteOrderPaymentCommandHandler.cs b/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CompleteOrderPayment/CompleteOrderPaymentCommandHandler.cs
index b3b88e8..002f14c 100644
--- a/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CompleteOrderPayment/CompleteOrderPaymentCommandHandler.cs
+++ b/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CompleteOrderPayment/CompleteOrderPaymentCommandHandler.cs
@@ -46,12 +46,12 @@ public class CompleteOrderPaymentCommandHandler : IRequestHandler<CompleteOrderP
         {
             // Update transaction
             transaction.PaymentStatus = PaymentStatus.Success;
-            transaction.PaymentDate = DateTime.UtcNow;
+            transaction.PaymentDate = DateTime.Now;
             transaction.RefId = request.RefId;
 
             // Update order
             order.PaymentStatus = PaymentStatus.Success;
-            order.PaymentDate = DateTime.UtcNow;
+            order.PaymentDate = DateTime.Now;
             order.DeliveryStatus = DeliveryStatus.InTransit;
 
             // Deduct discount balance from user wallet
diff --git a/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CreateDiscountCategory/CreateDiscountCategoryCommandHandler.cs b/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CreateDiscountCategory/CreateDiscountCategoryCommandHandler.cs
index 278d772..4750013 100644
--- a/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CreateDiscountCategory/CreateDiscountCategoryCommandHandler.cs
+++ b/src/CMSMicroservice.Application/DiscountShopCQ/Commands/CreateDiscountCategory/CreateDiscountCategoryCommandHandler.cs
@@ -47,7 +47,7 @@ public class CreateDiscountCategoryCommandHandler : IRequestHandler<CreateDiscou
             ParentCategoryId = request.ParentCategoryId,
             SortOrder = request.SortOrder,
             IsActive = request.IsActive,
-            Created = DateTime.UtcNow
+            Created = DateTime.Now
         };
 
         _context.DiscountCategories.Add(category);
diff --git a/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/ApproveManualPayment/ApproveManualPaymentCommandHandler.cs b/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/ApproveManualPayment/ApproveManualPaymentCommandHandler.cs
index 99f8938..6aaec42 100644
--- a/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/ApproveManualPayment/ApproveManualPaymentCommandHandler.cs
+++ b/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/ApproveManualPayment/ApproveManualPaymentCommandHandler.cs
@@ -86,7 +86,7 @@ public class ApproveManualPaymentCommandHandler : IRequestHandler<ApproveManualP
                 Amount = manualPayment.Amount,
                 Description = $"پرداخت دستی - {manualPayment.Type} - {manualPayment.Description}",
                 PaymentStatus = PaymentStatus.Success,
-                PaymentDate = DateTime.UtcNow,
+                PaymentDate = DateTime.Now,
                 RefId = manualPayment.ReferenceNumber,
                 Type = MapToTransactionType(manualPayment.Type)
             };
@@ -219,7 +219,7 @@ public class ApproveManualPaymentCommandHandler : IRequestHandler<ApproveManualP
             // 7. به‌روزرسانی ManualPayment
             manualPayment.Status = ManualPaymentStatus.Approved;
             manualPayment.ApprovedBy = approvedById;
-            manualPayment.ApprovedAt = DateTime.UtcNow;
+            manualPayment.ApprovedAt = DateTime.Now;
             manualPayment.TransactionId = transaction.Id;
 
             await _context.SaveChangesAsync(cancellationToken);
diff --git a/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/RejectManualPayment/RejectManualPaymentCommandHandler.cs b/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/RejectManualPayment/RejectManualPaymentCommandHandler.cs
index a8dbfae..7da604f 100644
--- a/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/RejectManualPayment/RejectManualPaymentCommandHandler.cs
+++ b/src/CMSMicroservice.Application/ManualPaymentCQ/Commands/RejectManualPayment/RejectManualPaymentCommandHandler.cs
@@ -71,7 +71,7 @@ public class RejectManualPaymentCommandHandler : IRequestHandler<RejectManualPay
             // 4. رد درخواست
             manualPayment.Status = ManualPaymentStatus.Rejected;
             manualPayment.ApprovedBy = rejectedById;
-            manualPayment.ApprovedAt = DateTime.UtcNow;
+            manualPayment.ApprovedAt = DateTime.Now;
             manualPayment.RejectionReason = request.RejectionReason;
 
             await _context.SaveChangesAsync(cancellationToken);
diff --git a/src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkStatistics/GetNetworkStatisticsQueryHandler.cs b/src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkStatistics/GetNetworkStatisticsQueryHandler.cs
index 058966d..2ccbfa7 100644
--- a/src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkStatistics/GetNetworkStatisticsQueryHandler.cs
+++ b/src/CMSMicroservice.Application/NetworkMembershipCQ/Queries/GetNetworkStatistics/GetNetworkStatisticsQueryHandler.cs
@@ -55,7 +55,7 @@ public class GetNetworkStatisticsQueryHandler : IRequestHandler<GetNetworkStatis
         }
 
         // Monthly growth (last 6 months) - using Created date
-        var sixMonthsAgo = DateTime.UtcNow.AddMonths(-6);
+        var sixMonthsAgo = DateTime.Now.AddMonths(-6);
         var monthlyGrowth = await _context.Users
             .Where(x => x.NetworkParentId != null && x.Created >= sixMonthsAgo)
             .GroupBy(x => new { x.Created.Year, x.Created.Month })
diff --git a/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyGoldenPackagePurchase/VerifyGoldenPackagePurchaseCommandHandler.cs b/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyGoldenPackagePurchase/VerifyGoldenPackagePurchaseCommandHandler.cs
index c60c18a..913ccd4 100644
--- a/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyGoldenPackagePurchase/VerifyGoldenPackagePurchaseCommandHandler.cs
+++ b/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyGoldenPackagePurchase/VerifyGoldenPackagePurchaseCommandHandler.cs
@@ -125,7 +125,7 @@ public class VerifyGoldenPackagePurchaseCommandHandler : IRequestHandler<VerifyG
                 Amount = order.Amount,
                 Description = $"خرید پکیج طلایی از درگاه - سفارش #{order.Id}",
                 PaymentStatus = PaymentStatus.Success,
-                PaymentDate = DateTime.UtcNow,
+                PaymentDate = DateTime.Now,
                 RefId = verifyResult.RefId,
                 Type = TransactionType.DepositIpg
             };
@@ -152,7 +152,7 @@ public class VerifyGoldenPackagePurchaseCommandHandler : IRequestHandler<VerifyG
             // 7. به‌روزرسانی سفارش و کاربر
             order.TransactionId = transaction.Id;
             order.PaymentStatus = PaymentStatus.Success;
-            order.PaymentDate = DateTime.UtcNow;
+            order.PaymentDate = DateTime.Now;
             order.PaymentMethod = PaymentMethod.IPG;
             order.User.PackagePurchaseMethod = PackagePurchaseMethod.DirectPurchase;
 
diff --git a/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyPackagePurchase/VerifyPackagePurchaseCommandHandler.cs b/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyPackagePurchase/VerifyPackagePurchaseCommandHandler.cs
index 4907abc..fa85c70 100644
--- a/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyPackagePurchase/VerifyPackagePurchaseCommandHandler.cs
+++ b/src/CMSMicroservice.Application/PackageCQ/Commands/VerifyPackagePurchase/VerifyPackagePurchaseCommandHandler.cs
@@ -116,7 +116,7 @@ public class VerifyPackagePurchaseCommandHandler
                 Amount = order.Amount,
                 Description = $"خرید پکیج از درگاه - سفارش #{order.Id}",
                 PaymentStatus = PaymentStatus.Success,
-                PaymentDate = DateTime.UtcNow,
+                PaymentDate = DateTime.Now,
                 RefId = verifyResult.RefId,
                 Type = TransactionType.DepositIpg
             };
@@ -157,7 +157,7 @@ public class VerifyPackagePurchaseCommandHandler
             // 8. به‌روزرسانی Order
             order.TransactionId = transaction.Id;
             order.PaymentStatus = PaymentStatus.Success;
-            order.PaymentDate = DateTime.UtcNow;
+            order.PaymentDate = DateTime.Now;
             order.PaymentMethod = PaymentMethod.IPG;
 
             // 9. تغییر User.PackagePurchaseMethod
diff --git a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/ArchiveMessage/ArchiveMessageCommandHandler.cs b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/ArchiveMessage/ArchiveMessageCommandHandler.cs
index ce79ce1..756f6a5 100644
--- a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/ArchiveMessage/ArchiveMessageCommandHandler.cs
+++ b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/ArchiveMessage/ArchiveMessageCommandHandler.cs
@@ -31,7 +31,7 @@ public class ArchiveMessageCommandHandler : IRequestHandler<ArchiveMessageComman
         // 3. آرشیو کردن:
         //    - message.IsArchived = true
         //    - message.IsActive = false  // غیرفعال هم می‌شود
-        //    - message.ArchivedAt = DateTime.UtcNow
+        //    - message.ArchivedAt = DateTime.Now
         //
         // 4. ذخیره و Log:
         //    - await _context.SaveChangesAsync(cancellationToken)
diff --git a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/CreatePublicMessage/CreatePublicMessageCommandValidator.cs b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/CreatePublicMessage/CreatePublicMessageCommandValidator.cs
index 0183a9b..7fb0bf2 100644
--- a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/CreatePublicMessage/CreatePublicMessageCommandValidator.cs
+++ b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/CreatePublicMessage/CreatePublicMessageCommandValidator.cs
@@ -26,7 +26,7 @@ public class CreatePublicMessageCommandValidator : AbstractValidator<CreatePubli
 
         RuleFor(x => x.ExpiresAt)
             .NotEmpty().WithMessage("تاریخ پایان الزامی است")
-            .GreaterThan(DateTime.UtcNow).WithMessage("تاریخ پایان باید در آینده باشد");
+            .GreaterThan(DateTime.Now).WithMessage("تاریخ پایان باید در آینده باشد");
 
         RuleFor(x => x.LinkUrl)
             .MaximumLength(500).WithMessage("لینک نمی‌تواند بیشتر از 500 کاراکتر باشد")
diff --git a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/PublishMessage/PublishMessageCommandHandler.cs b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/PublishMessage/PublishMessageCommandHandler.cs
index e83458a..9077284 100644
--- a/src/CMSMicroservice.Application/PublicMessageCQ/Commands/PublishMessage/PublishMessageCommandHandler.cs
+++ b/src/CMSMicroservice.Application/PublicMessageCQ/Commands/PublishMessage/PublishMessageCommandHandler.cs
@@ -33,10 +33,10 @@ public class PublishMessageCommandHandler : IRequestHandler<PublishMessageComman
         //
         // 3. فعال‌سازی پیام:
         //    - message.IsActive = true
-        //    - message.PublishedAt = DateTime.UtcNow
+        //    - message.PublishedAt = DateTime.Now
         //    - اگر StartDate خالی است، از الان شروع کن:
         //      if (!message.StartDate.HasValue)
-        //        message.StartDate = DateTime.UtcNow
+        //        message.StartDate = DateTime.Now
         //
         // 4. ذخیره و Log:
         //    - await _context.SaveChangesAsync(cancellationToken)
diff --git a/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetActiveMessages/GetActiveMessagesQueryHandler.cs b/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetActiveMessages/GetActiveMessagesQueryHandler.cs
index 305b73e..35b67c7 100644
--- a/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetActiveMessages/GetActiveMessagesQueryHandler.cs
+++ b/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetActiveMessages/GetActiveMessagesQueryHandler.cs
@@ -21,7 +21,7 @@ public class GetActiveMessagesQueryHandler : IRequestHandler<GetActiveMessagesQu
 
     public async Task<List<PublicMessageDto>> Handle(GetActiveMessagesQuery request, CancellationToken cancellationToken)
     {
-        var now = DateTime.UtcNow;
+        var now = DateTime.Now;
 
         var query = _context.PublicMessages
             .Where(x => !x.IsDeleted 
diff --git a/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetAllMessages/GetAllMessagesQueryHandler.cs b/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetAllMessages/GetAllMessagesQueryHandler.cs
index 4c64b3a..d112f9f 100644
--- a/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetAllMessages/GetAllMessagesQueryHandler.cs
+++ b/src/CMSMicroservice.Application/PublicMessageCQ/Queries/GetAllMessages/GetAllMessagesQueryHandler.cs
@@ -22,7 +22,7 @@ public class GetAllMessagesQueryHandler : IRequestHandler<GetAllMessagesQuery, G
 
     public async Task<GetAllMessagesResponseDto> Handle(GetAllMessagesQuery request, CancellationToken cancellationToken)
     {
-        var now = DateTime.UtcNow;
+        var now = DateTime.Now;
 
         // Query پایه
         var query = _context.PublicMessages
diff --git a/src/CMSMicroservice.Application/TransactionsCQ/Commands/RefundTransaction/RefundTransactionCommandHandler.cs b/src/CMSMicroservice.Application/TransactionsCQ/Commands/RefundTransaction/RefundTransactionCommandHandler.cs
index 92078dc..8cbd776 100644
--- a/src/CMSMicroservice.Application/TransactionsCQ/Commands/RefundTransaction/RefundTransactionCommandHandler.cs
+++ b/src/CMSMicroservice.Application/TransactionsCQ/Commands/RefundTransaction/RefundTransactionCommandHandler.cs
@@ -43,7 +43,7 @@ public class RefundTransactionCommandHandler : IRequestHandler<RefundTransaction
             Amount = -refundAmount, // مبلغ منفی برای استرداد
             Description = $"استرداد تراکنش {request.TransactionId}: {request.RefundReason}",
             PaymentStatus = PaymentStatus.Success,
-            PaymentDate = DateTime.UtcNow,
+            PaymentDate = DateTime.Now,
             RefId = $"REFUND-{originalTransaction.RefId}",
             Type = TransactionType.Buy // یا می‌تونیم یک نوع جدید برای Refund تعریف کنیم
         };
diff --git a/src/CMSMicroservice.Application/UserOrderCQ/Commands/ApplyDiscountToOrder/ApplyDiscountToOrderCommandHandler.cs b/src/CMSMicroservice.Application/UserOrderCQ/Commands/ApplyDiscountToOrder/ApplyDiscountToOrderCommandHandler.cs
index cfe6519..13f2018 100644
--- a/src/CMSMicroservice.Application/UserOrderCQ/Commands/ApplyDiscountToOrder/ApplyDiscountToOrderCommandHandler.cs
+++ b/src/CMSMicroservice.Application/UserOrderCQ/Commands/ApplyDiscountToOrder/ApplyDiscountToOrderCommandHandler.cs
@@ -49,7 +49,7 @@ public class ApplyDiscountToOrderCommandHandler : IRequestHandler<ApplyDiscountT
         //        DiscountAmount = request.DiscountAmount,
         //        Reason = request.Reason,
         //        DiscountCode = request.DiscountCode,
-        //        AppliedAt = DateTime.UtcNow
+        //        AppliedAt = DateTime.Now
         //      }
         //    - await _context.OrderDiscountLogs.AddAsync(discountLog, cancellationToken)
         //
diff --git a/src/CMSMicroservice.Application/UserOrderCQ/Commands/CancelOrder/CancelOrderCommandHandler.cs b/src/CMSMicroservice.Application/UserOrderCQ/Commands/CancelOrder/CancelOrderCommandHandler.cs
index 45fdc9d..1f51d09 100644
--- a/src/CMSMicroservice.Application/UserOrderCQ/Commands/CancelOrder/CancelOrderCommandHandler.cs
+++ b/src/CMSMicroservice.Application/UserOrderCQ/Commands/CancelOrder/CancelOrderCommandHandler.cs
@@ -50,7 +50,7 @@ public class CancelOrderCommandHandler : IRequestHandler<CancelOrderCommand, Can
                 Amount = -order.Amount,
                 Description = $"بازگشت وجه سفارش {request.OrderId}: {request.CancelReason}",
                 PaymentStatus = PaymentStatus.Success,
-                PaymentDate = DateTime.UtcNow,
+                PaymentDate = DateTime.Now,
                 RefId = $"REFUND-ORDER-{order.Id}",
                 Type = TransactionType.Buy
             };
diff --git a/src/CMSMicroservice.Application/UserOrderCQ/Commands/SubmitShopBuyOrder/SubmitShopBuyOrderCommandHandler.cs b/src/CMSMicroservice.Application/UserOrderCQ/Commands/SubmitShopBuyOrder/SubmitShopBuyOrderCommandHandler.cs
index 044c41a..88a980a 100644
--- a/src/CMSMicroservice.Application/UserOrderCQ/Commands/SubmitShopBuyOrder/SubmitShopBuyOrderCommandHandler.cs
+++ b/src/CMSMicroservice.Application/UserOrderCQ/Commands/SubmitShopBuyOrder/SubmitShopBuyOrderCommandHandler.cs
@@ -147,7 +147,7 @@ public class
                 VATAmount = vatAmount,
                 TotalAmount = totalAmount,
                 IsPaid = true,
-                PaidAt = DateTime.UtcNow
+                PaidAt = DateTime.Now
             };
 
             await _context.OrderVATs.AddAsync(orderVAT, cancellationToken);
diff --git a/src/CMSMicroservice.Application/UserOrderCQ/Queries/GetOrdersByDateRange/GetOrdersByDateRangeQueryValidator.cs b/src/CMSMicroservice.Application/UserOrderCQ/Queries/GetOrdersByDateRange/GetOrdersByDateRangeQueryValidator.cs
index f11541f..5e239c2 100644
--- a/src/CMSMicroservice.Application/UserOrderCQ/Queries/GetOrdersByDateRange/GetOrdersByDateRangeQueryValidator.cs
+++ b/src/CMSMicroservice.Application/UserOrderCQ/Queries/GetOrdersByDateRange/GetOrdersByDateRangeQueryValidator.cs
@@ -9,7 +9,7 @@ public class GetOrdersByDateRangeQueryValidator : AbstractValidator<GetOrdersByD
             .WithMessage("تاریخ شروع باید کوچکتر یا مساوی تاریخ پایان باشد");
 
         RuleFor(x => x.EndDate)
-            .LessThanOrEqualTo(DateTime.UtcNow.AddDays(1))
+            .LessThanOrEqualTo(DateTime.Now.AddDays(1))
             .WithMessage("تاریخ پایان نمی‌تواند در آینده باشد");
 
         RuleFor(x => x.PageIndex)
diff --git a/src/CMSMicroservice.Application/WalletCQ/Commands/VerifyDiscountWalletCharge/VerifyDiscountWalletChargeCommandHandler.cs b/src/CMSMicroservice.Application/WalletCQ/Commands/VerifyDiscountWalletCharge/VerifyDiscountWalletChargeCommandHandler.cs
index a03c784..292555d 100644
--- a/src/CMSMicroservice.Application/WalletCQ/Commands/VerifyDiscountWalletCharge/VerifyDiscountWalletChargeCommandHandler.cs
+++ b/src/CMSMicroservice.Application/WalletCQ/Commands/VerifyDiscountWalletCharge/VerifyDiscountWalletChargeCommandHandler.cs
@@ -92,7 +92,7 @@ public class VerifyDiscountWalletChargeCommandHandler
                 Amount = request.Amount,
                 Description = $"شارژ کیف پول تخفیفی - کاربر {user.Id}",
                 PaymentStatus = PaymentStatus.Success,
-                PaymentDate = DateTime.UtcNow,
+                PaymentDate = DateTime.Now,
                 RefId = verifyResult.RefId,
                 Type = TransactionType.DiscountWalletCharge
             };
diff --git a/src/CMSMicroservice.Domain/Entities/Club/UserClubFeature.cs b/src/CMSMicroservice.Domain/Entities/Club/UserClubFeature.cs
index 4160091..44dee79 100644
--- a/src/CMSMicroservice.Domain/Entities/Club/UserClubFeature.cs
+++ b/src/CMSMicroservice.Domain/Entities/Club/UserClubFeature.cs
@@ -40,6 +40,11 @@ public class UserClubFeature : BaseAuditableEntity
     /// </summary>
     public DateTime GrantedAt { get; set; }
 
+    /// <summary>
+    /// وضعیت فعال/غیرفعال بودن ویژگی برای کاربر (قابل مدیریت توسط ادمین)
+    /// </summary>
+    public bool IsActive { get; set; } = true;
+
     /// <summary>
     /// یادداشت اختیاری
     /// </summary>
diff --git a/src/CMSMicroservice.Domain/Entities/Network/NetworkWeeklyBalance.cs b/src/CMSMicroservice.Domain/Entities/Network/NetworkWeeklyBalance.cs
index 83a6085..f84ccbe 100644
--- a/src/CMSMicroservice.Domain/Entities/Network/NetworkWeeklyBalance.cs
+++ b/src/CMSMicroservice.Domain/Entities/Network/NetworkWeeklyBalance.cs
@@ -65,6 +65,23 @@ public class NetworkWeeklyBalance : BaseAuditableEntity
     /// </summary>
     public int RightLegRemainder { get; set; }
 
+    /// <summary>
+    /// مقدار فلش هر طرف (بعد از اعمال Cap): TotalBalances - CappedBalances
+    /// </summary>
+    public int FlushedPerSide { get; set; }
+
+    /// <summary>
+    /// مجموع فلش از دو طرف: FlushedPerSide × 2
+    /// این مقدار از دست می‌رود (نه به هفته بعد، نه به کمیسیون)
+    /// </summary>
+    public int TotalFlushed { get; set; }
+
+    /// <summary>
+    /// مجموع تعادل زیرمجموعه این کاربر (تا 15 لول پایین‌تر)
+    /// این مقدار در CalculateWeeklyBalances محاسبه و ذخیره می‌شود
+    /// </summary>
+    public int SubordinateBalances { get; set; }
+
     /// <summary>
     /// [DEPRECATED] تعداد تعادل شاخه چپ - استفاده نشود
     /// </summary>
diff --git a/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyCommissionJob.cs b/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyCommissionJob.cs
index a7aa098..5c8d740 100644
--- a/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyCommissionJob.cs
+++ b/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyCommissionJob.cs
@@ -1,6 +1,7 @@
 using CMSMicroservice.Application.CommissionCQ.Commands.CalculateWeeklyBalances;
 using CMSMicroservice.Application.CommissionCQ.Commands.CalculateWeeklyCommissionPool;
 using CMSMicroservice.Application.CommissionCQ.Commands.ProcessUserPayouts;
+using CMSMicroservice.Application.CommissionCQ.Commands.TriggerWeeklyCalculation;
 using CMSMicroservice.Application.Common.Interfaces;
 using CMSMicroservice.Domain.Entities;
 using CMSMicroservice.Domain.Enums;
@@ -54,16 +55,30 @@ public class WeeklyCommissionJob
 
     /// <summary>
     /// Execute weekly commission calculation with retry logic
-    /// Called by Hangfire scheduler
+    /// Called by Hangfire scheduler or manually triggered
     /// </summary>
-    public async Task ExecuteAsync(CancellationToken cancellationToken = default)
+    /// <param name="weekNumber">Week number in YYYY-Www format (e.g., 2025-W48). If null, uses previous week.</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    public async Task ExecuteAsync(string? weekNumber = null, CancellationToken cancellationToken = default)
     {
         var executionId = Guid.NewGuid();
-        var startTime = DateTime.UtcNow;
+        var startTime = DateTime.Now;
 
-        // Calculate for PREVIOUS week (completed week)
-        var previousWeek = DateTime.UtcNow.AddDays(-7);
-        var previousWeekNumber = GetWeekNumber(previousWeek);
+        // Use provided week number or calculate for PREVIOUS week (completed week)
+        string targetWeekNumber;
+        if (!string.IsNullOrWhiteSpace(weekNumber))
+        {
+            targetWeekNumber = weekNumber;
+            _logger.LogInformation("📅 Using manually specified week: {WeekNumber}", targetWeekNumber);
+        }
+        else
+        {
+            var previousWeek = DateTime.Now.AddDays(-7);
+            targetWeekNumber = GetWeekNumber(previousWeek);
+            _logger.LogInformation("📅 Using previous week (auto-calculated): {WeekNumber}", targetWeekNumber);
+        }
+
+        var previousWeekNumber = targetWeekNumber;
 
         _logger.LogInformation(
             "🚀 [{ExecutionId}] Starting weekly commission calculation for {WeekNumber}",
@@ -89,7 +104,7 @@ public class WeeklyCommissionJob
             }, cancellationToken);
 
             // Update log on success
-            var completedAt = DateTime.UtcNow;
+            var completedAt = DateTime.Now;
             var duration = completedAt - startTime;
 
             log.Status = WorkerExecutionStatus.Success;
@@ -113,7 +128,7 @@ public class WeeklyCommissionJob
         catch (Exception ex)
         {
             // Update log on failure
-            var completedAt = DateTime.UtcNow;
+            var completedAt = DateTime.Now;
             var duration = completedAt - startTime;
 
             log.Status = WorkerExecutionStatus.Failed;
@@ -165,38 +180,43 @@ public class WeeklyCommissionJob
                 "📊 [{ExecutionId}] Step 1/3: Calculating weekly balances...",
                 executionId);
 
-            await _mediator.Send(new CalculateWeeklyBalancesCommand
+            await _mediator.Send(new TriggerWeeklyCalculationCommand
             {
                 WeekNumber = weekNumber,
                 ForceRecalculate = false
             }, cancellationToken);
-
-            // Step 2: Calculate global commission pool
-            _logger.LogInformation(
-                "💰 [{ExecutionId}] Step 2/3: Calculating commission pool...",
-                executionId);
-
-            await _mediator.Send(new CalculateWeeklyCommissionPoolCommand
-            {
-                WeekNumber = weekNumber,
-                ForceRecalculate = false
-            }, cancellationToken);
-
-            // Step 3: Distribute commissions to users
-            _logger.LogInformation(
-                "💸 [{ExecutionId}] Step 3/3: Processing user payouts...",
-                executionId);
-
-            await _mediator.Send(new ProcessUserPayoutsCommand
-            {
-                WeekNumber = weekNumber,
-                ForceReprocess = false
-            }, cancellationToken);
+      // await _mediator.Send(new CalculateWeeklyBalancesCommand
+      //       {
+      //           WeekNumber = weekNumber,
+      //           ForceRecalculate = false
+      //       }, cancellationToken);
+      //
+      //       // Step 2: Calculate global commission pool
+      //       _logger.LogInformation(
+      //           "💰 [{ExecutionId}] Step 2/3: Calculating commission pool...",
+      //           executionId);
+      //
+      //       await _mediator.Send(new CalculateWeeklyCommissionPoolCommand
+      //       {
+      //           WeekNumber = weekNumber,
+      //           ForceRecalculate = false
+      //       }, cancellationToken);
+      //
+      //       // Step 3: Distribute commissions to users
+      //       _logger.LogInformation(
+      //           "💸 [{ExecutionId}] Step 3/3: Processing user payouts...",
+      //           executionId);
+      //
+      //       await _mediator.Send(new ProcessUserPayoutsCommand
+      //       {
+      //           WeekNumber = weekNumber,
+      //           ForceReprocess = false
+      //       }, cancellationToken);
 
             transaction.Complete();
 
             _logger.LogInformation(
-                "✅ [{ExecutionId}] All 3 steps completed successfully",
+                "✅ [{ExecutionId}] All 2 steps completed successfully",
                 executionId);
         }
         catch (Exception ex)
diff --git a/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyNetworkCommissionWorker.cs.backup b/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyNetworkCommissionWorker.cs.backup
index d14e9b2..1405d23 100644
--- a/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyNetworkCommissionWorker.cs.backup
+++ b/src/CMSMicroservice.Infrastructure/BackgroundJobs/WeeklyNetworkCommissionWorker.cs.backup
@@ -109,7 +109,7 @@ public class WeeklyNetworkCommissionWorker : BackgroundService
     private async Task ExecuteWeeklyCalculationAsync(CancellationToken cancellationToken)
     {
         var executionId = Guid.NewGuid();
-        var startTime = DateTime.UtcNow;
+        var startTime = DateTime.Now;
         _logger.LogInformation("=== Starting Weekly Commission Calculation [{ExecutionId}] at {Time} (UTC) ===", 
             executionId, startTime);
 
@@ -154,7 +154,7 @@ public class WeeklyNetworkCommissionWorker : BackgroundService
                 
                 // Update log
                 log.Status = WorkerExecutionStatus.SuccessWithWarnings;
-                log.CompletedAt = DateTime.UtcNow;
+                log.CompletedAt = DateTime.Now;
                 log.DurationMs = (long)(log.CompletedAt.Value - log.StartedAt).TotalMilliseconds;
                 log.Details = "Week already calculated - skipped";
                 await context.SaveChangesAsync(cancellationToken);
@@ -222,7 +222,7 @@ public class WeeklyNetworkCommissionWorker : BackgroundService
                 // Commit Transaction
                 transaction.Complete();
 
-                var completedAt = DateTime.UtcNow;
+                var completedAt = DateTime.Now;
                 var duration = completedAt - startTime;
                 
                 // Update log - Success
@@ -297,7 +297,7 @@ public class WeeklyNetworkCommissionWorker : BackgroundService
                     var context = errorScope.ServiceProvider.GetRequiredService<IApplicationDbContext>();
                     
                     log.Status = WorkerExecutionStatus.Failed;
-                    log.CompletedAt = DateTime.UtcNow;
+                    log.CompletedAt = DateTime.Now;
                     log.DurationMs = (long)(log.CompletedAt.Value - log.StartedAt).TotalMilliseconds;
                     log.ErrorCount = 1;
                     log.ErrorMessage = ex.Message;
diff --git a/src/CMSMicroservice.Infrastructure/Migrations/Scripts/20250601_MigrateParentIdToNetworkParentId.sql b/src/CMSMicroservice.Infrastructure/Migrations/Scripts/20250601_MigrateParentIdToNetworkParentId.sql
index d33d9b5..7d85d66 100644
--- a/src/CMSMicroservice.Infrastructure/Migrations/Scripts/20250601_MigrateParentIdToNetworkParentId.sql
+++ b/src/CMSMicroservice.Infrastructure/Migrations/Scripts/20250601_MigrateParentIdToNetworkParentId.sql
@@ -6,13 +6,13 @@
 
 BEGIN TRANSACTION;
 
--- Step 1: Validation - Find users with more than 2 children (INVALID for binary tree)
+-- Step 1: Validation - Find CMS.Users with more than 2 children (INVALID for binary tree)
 -- این کاربران باید قبل از Migration بررسی شوند
 SELECT 
     ParentId, 
     COUNT(*) as ChildCount,
     STRING_AGG(CAST(Id AS VARCHAR), ', ') as ChildIds
-FROM Users
+FROM CMS.Users
 WHERE ParentId IS NOT NULL
 GROUP BY ParentId
 HAVING COUNT(*) > 2;
@@ -20,8 +20,8 @@ HAVING COUNT(*) > 2;
 -- اگر نتیجه‌ای بود، باید دستی تصمیم بگیرید کدام 2 فرزند باقی بمانند!
 -- اگر نتیجه‌ای نبود، ادامه دهید:
 
--- Step 2: Copy ParentId → NetworkParentId for all users
-UPDATE Users
+-- Step 2: Copy ParentId → NetworkParentId for all CMS.Users
+UPDATE CMS.Users
 SET NetworkParentId = ParentId
 WHERE ParentId IS NOT NULL
   AND NetworkParentId IS NULL;
@@ -33,16 +33,16 @@ WITH RankedChildren AS (
         Id,
         ParentId,
         ROW_NUMBER() OVER (PARTITION BY ParentId ORDER BY Id ASC) as ChildRank
-    FROM Users
+    FROM CMS.Users
     WHERE ParentId IS NOT NULL
 )
-UPDATE Users
+UPDATE CMS.Users
 SET LegPosition = CASE 
     WHEN rc.ChildRank = 1 THEN 0  -- Left = 0 (enum value)
     WHEN rc.ChildRank = 2 THEN 1  -- Right = 1 (enum value)
     ELSE NULL  -- اگر بیشتر از 2 فرزند بود (نباید اتفاق بیفته)
 END
-FROM Users u
+FROM CMS.Users u
 INNER JOIN RankedChildren rc ON u.Id = rc.Id;
 
 -- Step 4: Validation - Check for orphaned nodes (Parent doesn't exist)
@@ -50,9 +50,9 @@ SELECT
     Id,
     NetworkParentId,
     'Orphaned: Parent does not exist' as Issue
-FROM Users
+FROM CMS.Users
 WHERE NetworkParentId IS NOT NULL
-  AND NetworkParentId NOT IN (SELECT Id FROM Users);
+  AND NetworkParentId NOT IN (SELECT Id FROM CMS.Users);
 
 -- اگر Orphan یافت شد، باید آنها را NULL کنید یا Parent صحیح تخصیص دهید
 
@@ -62,7 +62,7 @@ SELECT
     NetworkParentId, 
     COUNT(*) as ChildCount,
     STRING_AGG(CAST(Id AS VARCHAR), ', ') as ChildIds
-FROM Users
+FROM CMS.Users
 WHERE NetworkParentId IS NOT NULL
 GROUP BY NetworkParentId
 HAVING COUNT(*) > 2;
@@ -71,26 +71,26 @@ HAVING COUNT(*) > 2;
 
 -- Step 6: Statistics
 SELECT 
-    'Total Users' as Metric, 
+    'Total CMS.Users' as Metric, 
     COUNT(*) as Count 
-FROM Users
+FROM CMS.Users
 UNION ALL
 SELECT 
-    'Users with NetworkParentId', 
+    'CMS.Users with NetworkParentId', 
     COUNT(*) 
-FROM Users 
+FROM CMS.Users 
 WHERE NetworkParentId IS NOT NULL
 UNION ALL
 SELECT 
-    'Users with LegPosition Left', 
+    'CMS.Users with LegPosition Left', 
     COUNT(*) 
-FROM Users 
+FROM CMS.Users 
 WHERE LegPosition = 0
 UNION ALL
 SELECT 
-    'Users with LegPosition Right', 
+    'CMS.Users with LegPosition Right', 
     COUNT(*) 
-FROM Users 
+FROM CMS.Users 
 WHERE LegPosition = 1;
 
 -- Commit if validation passes
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Configurations/UserClubFeatureConfiguration.cs b/src/CMSMicroservice.Infrastructure/Persistence/Configurations/UserClubFeatureConfiguration.cs
index 8d1e333..b9d476b 100644
--- a/src/CMSMicroservice.Infrastructure/Persistence/Configurations/UserClubFeatureConfiguration.cs
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Configurations/UserClubFeatureConfiguration.cs
@@ -20,6 +20,7 @@ public class UserClubFeatureConfiguration : IEntityTypeConfiguration<UserClubFea
         builder.Property(entity => entity.ClubMembershipId).IsRequired();
         builder.Property(entity => entity.ClubFeatureId).IsRequired();
         builder.Property(entity => entity.GrantedAt).IsRequired();
+        builder.Property(entity => entity.IsActive).IsRequired().HasDefaultValue(true);
         builder.Property(entity => entity.Notes).IsRequired(false).HasMaxLength(500);
         
         // رابطه با User
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.Designer.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.Designer.cs
new file mode 100644
index 0000000..aa14abc
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.Designer.cs
@@ -0,0 +1,3232 @@
+// <auto-generated />
+using System;
+using CMSMicroservice.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20251209185136_AddIsActiveToUserClubFeatures")]
+    partial class AddIsActiveToUserClubFeatures
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("CMS")
+                .HasAnnotation("ProductVersion", "9.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Categories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("RequiredPoints")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive", "SortOrder")
+                        .HasDatabaseName("IX_ClubFeature_IsActive_SortOrder");
+
+                    b.ToTable("ClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ActivatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("GiftValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("InitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalEarned")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_ClubMembership_IsActive");
+
+                    b.HasIndex("UserId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_ClubMembership_UserId");
+
+                    b.ToTable("ClubMemberships", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ClubFeatureId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("GrantedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClubFeatureId");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_UserClubFeature_ClubMembershipId");
+
+                    b.HasIndex("UserId", "ClubFeatureId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserClubFeature_UserId_ClubFeatureId");
+
+                    b.ToTable("UserClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("BalancesEarned")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankReferenceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankTrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("IbanNumber")
+                        .HasMaxLength(26)
+                        .HasColumnType("nvarchar(26)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("PaymentFailureReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ProcessedBy")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("WithdrawalMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("WithdrawnAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("IX_UserCommissionPayout_Status");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeekNumber");
+
+                    b.HasIndex("WeeklyPoolId")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeeklyPoolId");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserCommissionPayout_UserId_WeekNumber");
+
+                    b.ToTable("UserCommissionPayouts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsCalculated")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalPoolAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsCalculated")
+                        .HasDatabaseName("IX_WeeklyCommissionPool_IsCalculated");
+
+                    b.HasIndex("WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_WeeklyCommissionPool_WeekNumber");
+
+                    b.ToTable("WeeklyCommissionPools", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WorkerExecutionLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ErrorCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ErrorStackTrace")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ExecutionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProcessedCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartedAt");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WeekNumber");
+
+                    b.ToTable("WorkerExecutionLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DataType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_SystemConfiguration_IsActive");
+
+                    b.HasIndex("Scope", "Key")
+                        .IsUnique()
+                        .HasDatabaseName("IX_SystemConfiguration_Scope_Key");
+
+                    b.ToTable("SystemConfigurations", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HtmlContent")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsProcessed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastCheckDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NationalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DayaLoanContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ImagePath")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("ParentCategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentCategoryId");
+
+                    b.ToTable("DiscountCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("DiscountBalanceUsed")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("GatewayAmountPaid")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("TrackingCode")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VatAmount")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DiscountOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("DiscountOrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("DiscountPercentUsed")
+                        .HasColumnType("int");
+
+                    b.Property<long>("FinalPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiscountOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("DiscountOrderDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MaxDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DiscountProducts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId", "CategoryId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountShoppingCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsChangePrice")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("UnitDiscount")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UnitDiscountPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("FactorDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NewInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("NewIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<long?>("OldInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("OldIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_ClubMembershipHistory_Action");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_ClubMembershipHistory_ClubMembershipId");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_ClubMembershipHistory_UserId_Created");
+
+                    b.ToTable("ClubMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("AmountAfter")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("AmountBefore")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("NewStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OldStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserCommissionPayoutId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_Action");
+
+                    b.HasIndex("UserCommissionPayoutId")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_PayoutId");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_WeekNumber");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_UserId_Created");
+
+                    b.ToTable("CommissionPayoutHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.NetworkMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("NewLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("NewParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("OldLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("OldParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_Action");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_UserId_Created");
+
+                    b.ToTable("NetworkMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ConfigurationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OldValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConfigurationId", "Created")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_ConfigId_Created");
+
+                    b.HasIndex("Scope", "Key")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_Scope_Key");
+
+                    b.ToTable("SystemConfigurationHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsExpired")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("LeftLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolContribution")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsExpired")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_IsExpired");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_WeekNumber");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_UserId_WeekNumber");
+
+                    b.ToTable("NetworkWeeklyBalances", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("BaseAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsPaid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VATAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("VATRate")
+                        .HasColumnType("decimal(5,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Created")
+                        .HasDatabaseName("IX_OrderVATs_Created");
+
+                    b.HasIndex("IsPaid")
+                        .HasDatabaseName("IX_OrderVATs_IsPaid");
+
+                    b.HasIndex("OrderId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_OrderVATs_OrderId");
+
+                    b.ToTable("OrderVATs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.OtpToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Attempts")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CodeHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsUsed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Purpose")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("OtpTokens", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Packages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("ApprovedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("RequestedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("Created");
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("ManualPayments", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("ClubDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Discount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsClubExclusive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsClubExclusive")
+                        .HasDatabaseName("IX_Products_IsClubExclusive");
+
+                    b.ToTable("Products", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("ProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductImageId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ProductImageId");
+
+                    b.ToTable("ProductGalleries", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImageThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ProductImages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("TagId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("ProductTags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.PublicMessage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ArchivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CreatedByUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkText")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("LinkUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PublishedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("StartsAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ViewCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId")
+                        .HasDatabaseName("IX_PublicMessages_CreatedByUserId");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_ExpiresAt");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_PublicMessages_IsActive");
+
+                    b.HasIndex("Priority")
+                        .HasDatabaseName("IX_PublicMessages_Priority");
+
+                    b.HasIndex("StartsAt")
+                        .HasDatabaseName("IX_PublicMessages_StartsAt");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_PublicMessages_Type");
+
+                    b.HasIndex("IsActive", "ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_IsActive_ExpiresAt");
+
+                    b.ToTable("PublicMessages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RefId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Transactions", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AvatarPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("BirthDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DayaCreditReceivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("EmailNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("HasReceivedDayaCredit")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("HashPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsMobileVerified")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsRulesAccepted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("MobileVerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("NationalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NetworkParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PackagePurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("PushNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ReferralCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("RulesAcceptedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("SmsNotifications")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LegPosition")
+                        .HasDatabaseName("IX_User_LegPosition");
+
+                    b.HasIndex("NetworkParentId")
+                        .HasDatabaseName("IX_User_NetworkParentId");
+
+                    b.ToTable("Users", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CityId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ContractId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignGuid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignedPdfFile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("HasVAT")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderVATId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("PaymentMethod")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderVATId");
+
+                    b.HasIndex("PackageId");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("PurchasedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("PackageId")
+                        .HasDatabaseName("IX_UserPackagePurchase_PackageId");
+
+                    b.HasIndex("PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_PurchasedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId");
+
+                    b.HasIndex("UserId", "PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId_PurchasedAt");
+
+                    b.ToTable("UserPackagePurchases", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("RoleId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRoles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Balance")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("NetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserWallets", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ChangeDiscountValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeNerworkValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CurrentBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentDiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentNetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsIncrease")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("RefrenceId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("WalletId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("UserWalletChangeLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Parent")
+                        .WithMany("Categories")
+                        .HasForeignKey("ParentId");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithOne("ClubMembership")
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Club.ClubMembership", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubFeature", "ClubFeature")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubFeatureId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubFeature");
+
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("CommissionPayouts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", "WeeklyPool")
+                        .WithMany("UserCommissionPayouts")
+                        .HasForeignKey("WeeklyPoolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WeeklyPool");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DayaLoanContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "ParentCategory")
+                        .WithMany("ChildCategories")
+                        .HasForeignKey("ParentCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ParentCategory");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany()
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", "DiscountOrder")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("DiscountOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DiscountOrder");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ShoppingCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountShoppingCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("ClubMembershipHistories")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubMembership");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", "UserCommissionPayout")
+                        .WithMany("CommissionPayoutHistories")
+                        .HasForeignKey("UserCommissionPayoutId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("UserCommissionPayout");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", "Configuration")
+                        .WithMany("SystemConfigurationHistories")
+                        .HasForeignKey("ConfigurationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Configuration");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("NetworkWeeklyBalances")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithOne()
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.ProductImage", "ProductImage")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductImageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ProductImage");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Tag", "Tag")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "NetworkParent")
+                        .WithMany("NetworkChildren")
+                        .HasForeignKey("NetworkParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("NetworkParent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserAddresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Contract", "Contract")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contract");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderVAT")
+                        .WithMany()
+                        .HasForeignKey("OrderVATId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("PackageId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OrderVAT");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany()
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany()
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Role", "Role")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserWallets")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserWallet", "Wallet")
+                        .WithMany("UserWalletChangeLogs")
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("Categories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Navigation("ClubMembershipHistories");
+
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Navigation("CommissionPayoutHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Navigation("UserCommissionPayouts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Navigation("SystemConfigurationHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Navigation("UserContracts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Navigation("ChildCategories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Navigation("OrderDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Navigation("OrderDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ShoppingCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Navigation("FactorDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ProductGalleries");
+
+                    b.Navigation("ProductTags");
+
+                    b.Navigation("UserCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Navigation("ProductGalleries");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Navigation("ProductTags");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("CommissionPayouts");
+
+                    b.Navigation("DayaLoanContracts");
+
+                    b.Navigation("DiscountOrders");
+
+                    b.Navigation("DiscountShoppingCarts");
+
+                    b.Navigation("NetworkChildren");
+
+                    b.Navigation("NetworkWeeklyBalances");
+
+                    b.Navigation("UserAddresses");
+
+                    b.Navigation("UserCarts");
+
+                    b.Navigation("UserClubFeatures");
+
+                    b.Navigation("UserContracts");
+
+                    b.Navigation("UserOrders");
+
+                    b.Navigation("UserRoles");
+
+                    b.Navigation("UserWallets");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Navigation("FactorDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Navigation("UserWalletChangeLogs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.cs
new file mode 100644
index 0000000..d87912d
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251209185136_AddIsActiveToUserClubFeatures.cs
@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddIsActiveToUserClubFeatures : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsActive",
+                schema: "CMS",
+                table: "UserClubFeatures",
+                type: "bit",
+                nullable: false,
+                defaultValue: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsActive",
+                schema: "CMS",
+                table: "UserClubFeatures");
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.Designer.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.Designer.cs
new file mode 100644
index 0000000..8383e32
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.Designer.cs
@@ -0,0 +1,3238 @@
+// <auto-generated />
+using System;
+using CMSMicroservice.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20251210185237_AddFlushedFieldsToNetworkWeeklyBalance")]
+    partial class AddFlushedFieldsToNetworkWeeklyBalance
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("CMS")
+                .HasAnnotation("ProductVersion", "9.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Categories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("RequiredPoints")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive", "SortOrder")
+                        .HasDatabaseName("IX_ClubFeature_IsActive_SortOrder");
+
+                    b.ToTable("ClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ActivatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("GiftValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("InitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalEarned")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_ClubMembership_IsActive");
+
+                    b.HasIndex("UserId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_ClubMembership_UserId");
+
+                    b.ToTable("ClubMemberships", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ClubFeatureId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("GrantedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClubFeatureId");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_UserClubFeature_ClubMembershipId");
+
+                    b.HasIndex("UserId", "ClubFeatureId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserClubFeature_UserId_ClubFeatureId");
+
+                    b.ToTable("UserClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("BalancesEarned")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankReferenceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankTrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("IbanNumber")
+                        .HasMaxLength(26)
+                        .HasColumnType("nvarchar(26)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("PaymentFailureReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ProcessedBy")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("WithdrawalMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("WithdrawnAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("IX_UserCommissionPayout_Status");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeekNumber");
+
+                    b.HasIndex("WeeklyPoolId")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeeklyPoolId");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserCommissionPayout_UserId_WeekNumber");
+
+                    b.ToTable("UserCommissionPayouts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsCalculated")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalPoolAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsCalculated")
+                        .HasDatabaseName("IX_WeeklyCommissionPool_IsCalculated");
+
+                    b.HasIndex("WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_WeeklyCommissionPool_WeekNumber");
+
+                    b.ToTable("WeeklyCommissionPools", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WorkerExecutionLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ErrorCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ErrorStackTrace")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ExecutionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProcessedCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartedAt");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WeekNumber");
+
+                    b.ToTable("WorkerExecutionLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DataType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_SystemConfiguration_IsActive");
+
+                    b.HasIndex("Scope", "Key")
+                        .IsUnique()
+                        .HasDatabaseName("IX_SystemConfiguration_Scope_Key");
+
+                    b.ToTable("SystemConfigurations", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HtmlContent")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsProcessed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastCheckDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NationalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DayaLoanContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ImagePath")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("ParentCategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentCategoryId");
+
+                    b.ToTable("DiscountCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("DiscountBalanceUsed")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("GatewayAmountPaid")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("TrackingCode")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VatAmount")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DiscountOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("DiscountOrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("DiscountPercentUsed")
+                        .HasColumnType("int");
+
+                    b.Property<long>("FinalPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiscountOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("DiscountOrderDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MaxDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DiscountProducts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId", "CategoryId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountShoppingCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsChangePrice")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("UnitDiscount")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UnitDiscountPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("FactorDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NewInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("NewIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<long?>("OldInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("OldIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_ClubMembershipHistory_Action");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_ClubMembershipHistory_ClubMembershipId");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_ClubMembershipHistory_UserId_Created");
+
+                    b.ToTable("ClubMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("AmountAfter")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("AmountBefore")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("NewStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OldStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserCommissionPayoutId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_Action");
+
+                    b.HasIndex("UserCommissionPayoutId")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_PayoutId");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_WeekNumber");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_UserId_Created");
+
+                    b.ToTable("CommissionPayoutHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.NetworkMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("NewLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("NewParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("OldLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("OldParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_Action");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_UserId_Created");
+
+                    b.ToTable("NetworkMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ConfigurationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OldValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConfigurationId", "Created")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_ConfigId_Created");
+
+                    b.HasIndex("Scope", "Key")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_Scope_Key");
+
+                    b.ToTable("SystemConfigurationHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FlushedPerSide")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsExpired")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("LeftLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalFlushed")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolContribution")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsExpired")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_IsExpired");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_WeekNumber");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_UserId_WeekNumber");
+
+                    b.ToTable("NetworkWeeklyBalances", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("BaseAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsPaid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VATAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("VATRate")
+                        .HasColumnType("decimal(5,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Created")
+                        .HasDatabaseName("IX_OrderVATs_Created");
+
+                    b.HasIndex("IsPaid")
+                        .HasDatabaseName("IX_OrderVATs_IsPaid");
+
+                    b.HasIndex("OrderId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_OrderVATs_OrderId");
+
+                    b.ToTable("OrderVATs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.OtpToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Attempts")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CodeHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsUsed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Purpose")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("OtpTokens", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Packages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("ApprovedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("RequestedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("Created");
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("ManualPayments", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("ClubDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Discount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsClubExclusive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsClubExclusive")
+                        .HasDatabaseName("IX_Products_IsClubExclusive");
+
+                    b.ToTable("Products", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("ProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductImageId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ProductImageId");
+
+                    b.ToTable("ProductGalleries", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImageThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ProductImages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("TagId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("ProductTags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.PublicMessage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ArchivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CreatedByUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkText")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("LinkUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PublishedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("StartsAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ViewCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId")
+                        .HasDatabaseName("IX_PublicMessages_CreatedByUserId");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_ExpiresAt");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_PublicMessages_IsActive");
+
+                    b.HasIndex("Priority")
+                        .HasDatabaseName("IX_PublicMessages_Priority");
+
+                    b.HasIndex("StartsAt")
+                        .HasDatabaseName("IX_PublicMessages_StartsAt");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_PublicMessages_Type");
+
+                    b.HasIndex("IsActive", "ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_IsActive_ExpiresAt");
+
+                    b.ToTable("PublicMessages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RefId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Transactions", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AvatarPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("BirthDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DayaCreditReceivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("EmailNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("HasReceivedDayaCredit")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("HashPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsMobileVerified")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsRulesAccepted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("MobileVerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("NationalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NetworkParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PackagePurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("PushNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ReferralCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("RulesAcceptedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("SmsNotifications")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LegPosition")
+                        .HasDatabaseName("IX_User_LegPosition");
+
+                    b.HasIndex("NetworkParentId")
+                        .HasDatabaseName("IX_User_NetworkParentId");
+
+                    b.ToTable("Users", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CityId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ContractId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignGuid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignedPdfFile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("HasVAT")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderVATId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("PaymentMethod")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderVATId");
+
+                    b.HasIndex("PackageId");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("PurchasedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("PackageId")
+                        .HasDatabaseName("IX_UserPackagePurchase_PackageId");
+
+                    b.HasIndex("PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_PurchasedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId");
+
+                    b.HasIndex("UserId", "PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId_PurchasedAt");
+
+                    b.ToTable("UserPackagePurchases", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("RoleId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRoles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Balance")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("NetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserWallets", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ChangeDiscountValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeNerworkValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CurrentBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentDiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentNetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsIncrease")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("RefrenceId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("WalletId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("UserWalletChangeLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Parent")
+                        .WithMany("Categories")
+                        .HasForeignKey("ParentId");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithOne("ClubMembership")
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Club.ClubMembership", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubFeature", "ClubFeature")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubFeatureId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubFeature");
+
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("CommissionPayouts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", "WeeklyPool")
+                        .WithMany("UserCommissionPayouts")
+                        .HasForeignKey("WeeklyPoolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WeeklyPool");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DayaLoanContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "ParentCategory")
+                        .WithMany("ChildCategories")
+                        .HasForeignKey("ParentCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ParentCategory");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany()
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", "DiscountOrder")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("DiscountOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DiscountOrder");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ShoppingCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountShoppingCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("ClubMembershipHistories")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubMembership");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", "UserCommissionPayout")
+                        .WithMany("CommissionPayoutHistories")
+                        .HasForeignKey("UserCommissionPayoutId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("UserCommissionPayout");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", "Configuration")
+                        .WithMany("SystemConfigurationHistories")
+                        .HasForeignKey("ConfigurationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Configuration");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("NetworkWeeklyBalances")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithOne()
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.ProductImage", "ProductImage")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductImageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ProductImage");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Tag", "Tag")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "NetworkParent")
+                        .WithMany("NetworkChildren")
+                        .HasForeignKey("NetworkParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("NetworkParent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserAddresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Contract", "Contract")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contract");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderVAT")
+                        .WithMany()
+                        .HasForeignKey("OrderVATId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("PackageId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OrderVAT");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany()
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany()
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Role", "Role")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserWallets")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserWallet", "Wallet")
+                        .WithMany("UserWalletChangeLogs")
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("Categories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Navigation("ClubMembershipHistories");
+
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Navigation("CommissionPayoutHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Navigation("UserCommissionPayouts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Navigation("SystemConfigurationHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Navigation("UserContracts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Navigation("ChildCategories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Navigation("OrderDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Navigation("OrderDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ShoppingCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Navigation("FactorDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ProductGalleries");
+
+                    b.Navigation("ProductTags");
+
+                    b.Navigation("UserCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Navigation("ProductGalleries");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Navigation("ProductTags");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("CommissionPayouts");
+
+                    b.Navigation("DayaLoanContracts");
+
+                    b.Navigation("DiscountOrders");
+
+                    b.Navigation("DiscountShoppingCarts");
+
+                    b.Navigation("NetworkChildren");
+
+                    b.Navigation("NetworkWeeklyBalances");
+
+                    b.Navigation("UserAddresses");
+
+                    b.Navigation("UserCarts");
+
+                    b.Navigation("UserClubFeatures");
+
+                    b.Navigation("UserContracts");
+
+                    b.Navigation("UserOrders");
+
+                    b.Navigation("UserRoles");
+
+                    b.Navigation("UserWallets");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Navigation("FactorDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Navigation("UserWalletChangeLogs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.cs
new file mode 100644
index 0000000..0caf263
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251210185237_AddFlushedFieldsToNetworkWeeklyBalance.cs
@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddFlushedFieldsToNetworkWeeklyBalance : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "FlushedPerSide",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "TotalFlushed",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "FlushedPerSide",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances");
+
+            migrationBuilder.DropColumn(
+                name: "TotalFlushed",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances");
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.Designer.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.Designer.cs
new file mode 100644
index 0000000..cf9f470
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.Designer.cs
@@ -0,0 +1,3241 @@
+// <auto-generated />
+using System;
+using CMSMicroservice.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance")]
+    partial class AddSubordinateBalancesToNetworkWeeklyBalance
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("CMS")
+                .HasAnnotation("ProductVersion", "9.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Categories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("RequiredPoints")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive", "SortOrder")
+                        .HasDatabaseName("IX_ClubFeature_IsActive_SortOrder");
+
+                    b.ToTable("ClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ActivatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("GiftValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("InitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalEarned")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_ClubMembership_IsActive");
+
+                    b.HasIndex("UserId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_ClubMembership_UserId");
+
+                    b.ToTable("ClubMemberships", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ClubFeatureId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("GrantedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClubFeatureId");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_UserClubFeature_ClubMembershipId");
+
+                    b.HasIndex("UserId", "ClubFeatureId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserClubFeature_UserId_ClubFeatureId");
+
+                    b.ToTable("UserClubFeatures", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("BalancesEarned")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankReferenceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BankTrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("IbanNumber")
+                        .HasMaxLength(26)
+                        .HasColumnType("nvarchar(26)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("PaymentFailureReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ProcessedBy")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("WithdrawalMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("WithdrawnAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("IX_UserCommissionPayout_Status");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeekNumber");
+
+                    b.HasIndex("WeeklyPoolId")
+                        .HasDatabaseName("IX_UserCommissionPayout_WeeklyPoolId");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_UserCommissionPayout_UserId_WeekNumber");
+
+                    b.ToTable("UserCommissionPayouts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsCalculated")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalPoolAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ValuePerBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsCalculated")
+                        .HasDatabaseName("IX_WeeklyCommissionPool_IsCalculated");
+
+                    b.HasIndex("WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_WeeklyCommissionPool_WeekNumber");
+
+                    b.ToTable("WeeklyCommissionPools", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WorkerExecutionLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ErrorCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ErrorStackTrace")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ExecutionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProcessedCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartedAt");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WeekNumber");
+
+                    b.ToTable("WorkerExecutionLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DataType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_SystemConfiguration_IsActive");
+
+                    b.HasIndex("Scope", "Key")
+                        .IsUnique()
+                        .HasDatabaseName("IX_SystemConfiguration_Scope_Key");
+
+                    b.ToTable("SystemConfigurations", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("HtmlContent")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsProcessed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastCheckDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NationalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ProcessedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DayaLoanContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ImagePath")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("ParentCategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentCategoryId");
+
+                    b.ToTable("DiscountCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("DiscountBalanceUsed")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("GatewayAmountPaid")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("TrackingCode")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VatAmount")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DiscountOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("DiscountOrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("DiscountPercentUsed")
+                        .HasColumnType("int");
+
+                    b.Property<long>("FinalPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DiscountOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("DiscountOrderDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MaxDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DiscountProducts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId", "CategoryId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("DiscountShoppingCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsChangePrice")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("UnitDiscount")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UnitDiscountPrice")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UnitPrice")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("FactorDetails", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("ClubMembershipId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NewInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("NewIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<long?>("OldInitialContribution")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("OldIsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_ClubMembershipHistory_Action");
+
+                    b.HasIndex("ClubMembershipId")
+                        .HasDatabaseName("IX_ClubMembershipHistory_ClubMembershipId");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_ClubMembershipHistory_UserId_Created");
+
+                    b.ToTable("ClubMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<long>("AmountAfter")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("AmountBefore")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("NewStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OldStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserCommissionPayoutId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_Action");
+
+                    b.HasIndex("UserCommissionPayoutId")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_PayoutId");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_WeekNumber");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_CommissionPayoutHistory_UserId_Created");
+
+                    b.ToTable("CommissionPayoutHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.NetworkMembershipHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("NewLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("NewParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("OldLegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("OldParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_Action");
+
+                    b.HasIndex("UserId", "Created")
+                        .HasDatabaseName("IX_NetworkMembershipHistory_UserId_Created");
+
+                    b.ToTable("NetworkMembershipHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ConfigurationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OldValue")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PerformedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Scope")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConfigurationId", "Created")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_ConfigId_Created");
+
+                    b.HasIndex("Scope", "Key")
+                        .HasDatabaseName("IX_SystemConfigurationHistory_Scope_Key");
+
+                    b.ToTable("SystemConfigurationHistories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("CalculatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FlushedPerSide")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsExpired")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("LeftLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeftLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegCarryover")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegNewMembers")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegRemainder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RightLegTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubordinateBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalBalances")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalFlushed")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("WeekNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("WeeklyPoolContribution")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsExpired")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_IsExpired");
+
+                    b.HasIndex("WeekNumber")
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_WeekNumber");
+
+                    b.HasIndex("UserId", "WeekNumber")
+                        .IsUnique()
+                        .HasDatabaseName("IX_NetworkWeeklyBalance_UserId_WeekNumber");
+
+                    b.ToTable("NetworkWeeklyBalances", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("BaseAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsPaid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaidAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long>("TotalAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VATAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("VATRate")
+                        .HasColumnType("decimal(5,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Created")
+                        .HasDatabaseName("IX_OrderVATs_Created");
+
+                    b.HasIndex("IsPaid")
+                        .HasDatabaseName("IX_OrderVATs_IsPaid");
+
+                    b.HasIndex("OrderId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_OrderVATs_OrderId");
+
+                    b.ToTable("OrderVATs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.OtpToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Attempts")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CodeHash")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsUsed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Purpose")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("OtpTokens", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Packages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("ApprovedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("RequestedBy")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("Created");
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("ManualPayments", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("ClubDiscountPercent")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Discount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FullInformation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsClubExclusive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RemainingCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortInfomation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ViewCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsClubExclusive")
+                        .HasDatabaseName("IX_Products_IsClubExclusive");
+
+                    b.ToTable("Products", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("CategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("ProductCategories", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProductImageId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ProductImageId");
+
+                    b.ToTable("ProductGalleries", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ImageThumbnailPath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ProductImages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("TagId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("ProductTags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.PublicMessage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("ArchivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CreatedByUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkText")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("LinkUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PublishedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("StartsAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ViewCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId")
+                        .HasDatabaseName("IX_PublicMessages_CreatedByUserId");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_ExpiresAt");
+
+                    b.HasIndex("IsActive")
+                        .HasDatabaseName("IX_PublicMessages_IsActive");
+
+                    b.HasIndex("Priority")
+                        .HasDatabaseName("IX_PublicMessages_Priority");
+
+                    b.HasIndex("StartsAt")
+                        .HasDatabaseName("IX_PublicMessages_StartsAt");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_PublicMessages_Type");
+
+                    b.HasIndex("IsActive", "ExpiresAt")
+                        .HasDatabaseName("IX_PublicMessages_IsActive_ExpiresAt");
+
+                    b.ToTable("PublicMessages", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RefId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Transactions", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AvatarPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("BirthDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DayaCreditReceivedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("EmailNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("HasReceivedDayaCredit")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("HashPassword")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsMobileVerified")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsRulesAccepted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LegPosition")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("MobileVerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("NationalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("NetworkParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PackagePurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("PushNotifications")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ReferralCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("RulesAcceptedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("SmsNotifications")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LegPosition")
+                        .HasDatabaseName("IX_User_LegPosition");
+
+                    b.HasIndex("NetworkParentId")
+                        .HasDatabaseName("IX_User_NetworkParentId");
+
+                    b.ToTable("Users", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CityId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostalCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("ProductId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserCarts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ContractId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignGuid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignedPdfFile")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserContracts", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeliveryDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DeliveryStatus")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("HasVAT")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderVATId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("PaymentMethod")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PaymentStatus")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderVATId");
+
+                    b.HasIndex("PackageId");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserAddressId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserOrders", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Amount")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("OrderId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PackageId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("PurchaseMethod")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("PurchasedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<long?>("TransactionId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("PackageId")
+                        .HasDatabaseName("IX_UserPackagePurchase_PackageId");
+
+                    b.HasIndex("PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_PurchasedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("UserId")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId");
+
+                    b.HasIndex("UserId", "PurchasedAt")
+                        .HasDatabaseName("IX_UserPackagePurchase_UserId_PurchasedAt");
+
+                    b.ToTable("UserPackagePurchases", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("RoleId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRoles", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("Balance")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("DiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("NetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UserId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserWallets", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ChangeDiscountValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeNerworkValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ChangeValue")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("CurrentBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentDiscountBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CurrentNetworkBalance")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsIncrease")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModified")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("RefrenceId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("WalletId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("UserWalletChangeLogs", "CMS");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Parent")
+                        .WithMany("Categories")
+                        .HasForeignKey("ParentId");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithOne("ClubMembership")
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Club.ClubMembership", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.UserClubFeature", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubFeature", "ClubFeature")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubFeatureId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserClubFeatures")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubFeature");
+
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("CommissionPayouts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", "WeeklyPool")
+                        .WithMany("UserCommissionPayouts")
+                        .HasForeignKey("WeeklyPoolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WeeklyPool");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DayaLoanContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DayaLoanContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "ParentCategory")
+                        .WithMany("ChildCategories")
+                        .HasForeignKey("ParentCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ParentCategory");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany()
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrderDetail", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", "DiscountOrder")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("DiscountOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("OrderDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DiscountOrder");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountShoppingCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", "Product")
+                        .WithMany("ShoppingCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("DiscountShoppingCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.FactorDetails", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("FactorDetails")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.ClubMembershipHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Club.ClubMembership", "ClubMembership")
+                        .WithMany("ClubMembershipHistories")
+                        .HasForeignKey("ClubMembershipId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ClubMembership");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.CommissionPayoutHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", "UserCommissionPayout")
+                        .WithMany("CommissionPayoutHistories")
+                        .HasForeignKey("UserCommissionPayoutId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("UserCommissionPayout");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.History.SystemConfigurationHistory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", "Configuration")
+                        .WithMany("SystemConfigurationHistories")
+                        .HasForeignKey("ConfigurationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Configuration");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Network.NetworkWeeklyBalance", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("NetworkWeeklyBalances")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Order.OrderVAT", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithOne()
+                        .HasForeignKey("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Payment.ManualPayment", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductCategory", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Category", "Category")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductCategories")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductGallery", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.ProductImage", "ProductImage")
+                        .WithMany("ProductGalleries")
+                        .HasForeignKey("ProductImageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ProductImage");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductTag", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Tag", "Tag")
+                        .WithMany("ProductTags")
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "NetworkParent")
+                        .WithMany("NetworkChildren")
+                        .HasForeignKey("NetworkParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("NetworkParent");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserAddresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserCart", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Product", "Product")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserCarts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserContract", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Contract", "Contract")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserContracts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Contract");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Order.OrderVAT", "OrderVAT")
+                        .WithMany()
+                        .HasForeignKey("OrderVATId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("PackageId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("TransactionId");
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserAddress", "UserAddress")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserAddressId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserOrders")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OrderVAT");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserAddress");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserPackagePurchase", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserOrder", "Order")
+                        .WithMany()
+                        .HasForeignKey("OrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Package", "Package")
+                        .WithMany()
+                        .HasForeignKey("PackageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.Transaction", "Transaction")
+                        .WithMany()
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Package");
+
+                    b.Navigation("Transaction");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserRole", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.Role", "Role")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.User", "User")
+                        .WithMany("UserWallets")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWalletChangeLog", b =>
+                {
+                    b.HasOne("CMSMicroservice.Domain.Entities.UserWallet", "Wallet")
+                        .WithMany("UserWalletChangeLogs")
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("Categories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubFeature", b =>
+                {
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Club.ClubMembership", b =>
+                {
+                    b.Navigation("ClubMembershipHistories");
+
+                    b.Navigation("UserClubFeatures");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.UserCommissionPayout", b =>
+                {
+                    b.Navigation("CommissionPayoutHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Commission.WeeklyCommissionPool", b =>
+                {
+                    b.Navigation("UserCommissionPayouts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Configuration.SystemConfiguration", b =>
+                {
+                    b.Navigation("SystemConfigurationHistories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Contract", b =>
+                {
+                    b.Navigation("UserContracts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountCategory", b =>
+                {
+                    b.Navigation("ChildCategories");
+
+                    b.Navigation("ProductCategories");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountOrder", b =>
+                {
+                    b.Navigation("OrderDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.DiscountShop.DiscountProduct", b =>
+                {
+                    b.Navigation("OrderDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ShoppingCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Package", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Product", b =>
+                {
+                    b.Navigation("FactorDetails");
+
+                    b.Navigation("ProductCategories");
+
+                    b.Navigation("ProductGalleries");
+
+                    b.Navigation("ProductTags");
+
+                    b.Navigation("UserCarts");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.ProductImage", b =>
+                {
+                    b.Navigation("ProductGalleries");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Tag", b =>
+                {
+                    b.Navigation("ProductTags");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.Transaction", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.User", b =>
+                {
+                    b.Navigation("ClubMembership");
+
+                    b.Navigation("CommissionPayouts");
+
+                    b.Navigation("DayaLoanContracts");
+
+                    b.Navigation("DiscountOrders");
+
+                    b.Navigation("DiscountShoppingCarts");
+
+                    b.Navigation("NetworkChildren");
+
+                    b.Navigation("NetworkWeeklyBalances");
+
+                    b.Navigation("UserAddresses");
+
+                    b.Navigation("UserCarts");
+
+                    b.Navigation("UserClubFeatures");
+
+                    b.Navigation("UserContracts");
+
+                    b.Navigation("UserOrders");
+
+                    b.Navigation("UserRoles");
+
+                    b.Navigation("UserWallets");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserAddress", b =>
+                {
+                    b.Navigation("UserOrders");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserOrder", b =>
+                {
+                    b.Navigation("FactorDetails");
+                });
+
+            modelBuilder.Entity("CMSMicroservice.Domain.Entities.UserWallet", b =>
+                {
+                    b.Navigation("UserWalletChangeLogs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.cs
new file mode 100644
index 0000000..a9a8b49
--- /dev/null
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/20251211142107_AddSubordinateBalancesToNetworkWeeklyBalance.cs
@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace CMSMicroservice.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSubordinateBalancesToNetworkWeeklyBalance : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "SubordinateBalances",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SubordinateBalances",
+                schema: "CMS",
+                table: "NetworkWeeklyBalances");
+        }
+    }
+}
diff --git a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs
index b710a50..a359194 100644
--- a/src/CMSMicroservice.Infrastructure/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/src/CMSMicroservice.Infrastructure/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -204,6 +204,11 @@ namespace CMSMicroservice.Infrastructure.Persistence.Migrations
                     b.Property<DateTime>("GrantedAt")
                         .HasColumnType("datetime2");
 
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
                     b.Property<bool>("IsDeleted")
                         .HasColumnType("bit");
 
@@ -1289,6 +1294,9 @@ namespace CMSMicroservice.Infrastructure.Persistence.Migrations
                     b.Property<string>("CreatedBy")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<int>("FlushedPerSide")
+                        .HasColumnType("int");
+
                     b.Property<bool>("IsDeleted")
                         .HasColumnType("bit");
 
@@ -1331,9 +1339,15 @@ namespace CMSMicroservice.Infrastructure.Persistence.Migrations
                     b.Property<int>("RightLegTotal")
                         .HasColumnType("int");
 
+                    b.Property<int>("SubordinateBalances")
+                        .HasColumnType("int");
+
                     b.Property<int>("TotalBalances")
                         .HasColumnType("int");
 
+                    b.Property<int>("TotalFlushed")
+                        .HasColumnType("int");
+
                     b.Property<long>("UserId")
                         .HasColumnType("bigint");
 
diff --git a/src/CMSMicroservice.Infrastructure/Services/DayaLoanApiService.cs b/src/CMSMicroservice.Infrastructure/Services/DayaLoanApiService.cs
index 9e5b233..3ac0f97 100644
--- a/src/CMSMicroservice.Infrastructure/Services/DayaLoanApiService.cs
+++ b/src/CMSMicroservice.Infrastructure/Services/DayaLoanApiService.cs
@@ -130,7 +130,7 @@ public class DayaLoanApiService : IDayaLoanApiService
                 "/api/merchant/contracts", 
                 requestBody, 
                 cancellationToken);
-
+            var x = await response.Content.ReadAsStringAsync();
             // خواندن پاسخ
             var apiResponse = await response.Content.ReadFromJsonAsync<DayaContractsResponse>(cancellationToken);
 
diff --git a/src/CMSMicroservice.Infrastructure/Services/Payment/DayaPaymentService.cs b/src/CMSMicroservice.Infrastructure/Services/Payment/DayaPaymentService.cs
index b6bb4a4..d31972b 100644
--- a/src/CMSMicroservice.Infrastructure/Services/Payment/DayaPaymentService.cs
+++ b/src/CMSMicroservice.Infrastructure/Services/Payment/DayaPaymentService.cs
@@ -211,7 +211,7 @@ public class DayaPaymentService : IPaymentGatewayService
                 {
                     IsSuccess = false,
                     Message = "فرمت شماره شبا نامعتبر است",
-                    ProcessedAt = DateTime.UtcNow
+                    ProcessedAt = DateTime.Now
                 };
             }
 
@@ -222,7 +222,7 @@ public class DayaPaymentService : IPaymentGatewayService
                 {
                     IsSuccess = false,
                     Message = "حداقل مبلغ برداشت 10,000 تومان است",
-                    ProcessedAt = DateTime.UtcNow
+                    ProcessedAt = DateTime.Now
                 };
             }
 
@@ -252,7 +252,7 @@ public class DayaPaymentService : IPaymentGatewayService
                 {
                     IsSuccess = false,
                     Message = $"خطا در واریز: {response.StatusCode}",
-                    ProcessedAt = DateTime.UtcNow
+                    ProcessedAt = DateTime.Now
                 };
             }
 
@@ -264,7 +264,7 @@ public class DayaPaymentService : IPaymentGatewayService
                 {
                     IsSuccess = false,
                     Message = "پاسخ نامعتبر از درگاه",
-                    ProcessedAt = DateTime.UtcNow
+                    ProcessedAt = DateTime.Now
                 };
             }
 
@@ -278,7 +278,7 @@ public class DayaPaymentService : IPaymentGatewayService
                 BankRefId = result.BankRefId,
                 TrackingCode = result.TrackingCode,
                 Message = result.Message,
-                ProcessedAt = DateTime.UtcNow
+                ProcessedAt = DateTime.Now
             };
         }
         catch (Exception ex)
@@ -288,7 +288,7 @@ public class DayaPaymentService : IPaymentGatewayService
             {
                 IsSuccess = false,
                 Message = "خطا در پردازش واریز",
-                ProcessedAt = DateTime.UtcNow
+                ProcessedAt = DateTime.Now
             };
         }
     }
diff --git a/src/CMSMicroservice.Infrastructure/Services/Payment/MockPaymentGatewayService.cs b/src/CMSMicroservice.Infrastructure/Services/Payment/MockPaymentGatewayService.cs
index 88c0eee..46e22df 100644
--- a/src/CMSMicroservice.Infrastructure/Services/Payment/MockPaymentGatewayService.cs
+++ b/src/CMSMicroservice.Infrastructure/Services/Payment/MockPaymentGatewayService.cs
@@ -91,7 +91,7 @@ public class MockPaymentGatewayService : IPaymentGatewayService
             {
                 IsSuccess = false,
                 Message = "فرمت شماره شبا نامعتبر است",
-                ProcessedAt = DateTime.UtcNow
+                ProcessedAt = DateTime.Now
             };
         }
         
@@ -103,7 +103,7 @@ public class MockPaymentGatewayService : IPaymentGatewayService
             {
                 IsSuccess = false,
                 Message = "حداقل مبلغ برداشت 10,000 تومان است",
-                ProcessedAt = DateTime.UtcNow
+                ProcessedAt = DateTime.Now
             };
         }
         
@@ -121,7 +121,7 @@ public class MockPaymentGatewayService : IPaymentGatewayService
             BankRefId = bankRefId,
             TrackingCode = trackingCode,
             Message = $"واریز {request.Amount:N0} تومان به حساب {request.Iban} با موفقیت انجام شد (Mock)",
-            ProcessedAt = DateTime.UtcNow
+            ProcessedAt = DateTime.Now
         };
     }
 }
diff --git a/src/CMSMicroservice.Protobuf/Protos/clubmembership.proto b/src/CMSMicroservice.Protobuf/Protos/clubmembership.proto
index ffead4f..e979470 100644
--- a/src/CMSMicroservice.Protobuf/Protos/clubmembership.proto
+++ b/src/CMSMicroservice.Protobuf/Protos/clubmembership.proto
@@ -50,6 +50,19 @@ service ClubMembershipContract
             get: "/ClubMembership/GetStatistics"
         };
     };
+    
+    // New: Admin Club Feature Management
+    rpc GetUserClubFeatures(GetUserClubFeaturesRequest) returns (GetUserClubFeaturesResponse){
+        option (google.api.http) = {
+            get: "/ClubFeature/GetUserFeatures"
+        };
+    };
+    rpc ToggleUserClubFeature(ToggleUserClubFeatureRequest) returns (ToggleUserClubFeatureResponse){
+        option (google.api.http) = {
+            post: "/ClubFeature/ToggleFeature"
+            body: "*"
+        };
+    };
 }
 
 // Activate Command
@@ -205,3 +218,43 @@ message MonthlyMembershipTrend
     int32 expirations = 3;
     int32 net_change = 4;
 }
+
+// GetUserClubFeatures Query
+message GetUserClubFeaturesRequest
+{
+    int64 user_id = 1;
+}
+
+message GetUserClubFeaturesResponse
+{
+    repeated UserClubFeatureModel features = 1;
+}
+
+message UserClubFeatureModel
+{
+    int64 id = 1;
+    int64 user_id = 2;
+    int64 club_membership_id = 3;
+    int64 club_feature_id = 4;
+    string feature_title = 5;
+    string feature_description = 6;
+    bool is_active = 7;
+    google.protobuf.Timestamp granted_at = 8;
+    string notes = 9;
+}
+
+// ToggleUserClubFeature Command
+message ToggleUserClubFeatureRequest
+{
+    int64 user_id = 1;
+    int64 club_feature_id = 2;
+    bool is_active = 3;
+}
+
+message ToggleUserClubFeatureResponse
+{
+    bool success = 1;
+    string message = 2;
+    google.protobuf.Int64Value user_club_feature_id = 3;
+    google.protobuf.BoolValue is_active = 4;
+}
diff --git a/src/CMSMicroservice.Protobuf/Protos/commission.proto b/src/CMSMicroservice.Protobuf/Protos/commission.proto
index 879614e..87ecaaa 100644
--- a/src/CMSMicroservice.Protobuf/Protos/commission.proto
+++ b/src/CMSMicroservice.Protobuf/Protos/commission.proto
@@ -105,6 +105,11 @@ service CommissionContract
             get: "/Commission/GetWorkerLogs"
         };
     };
+    rpc GetAvailableWeeks(GetAvailableWeeksRequest) returns (GetAvailableWeeksResponse){
+        option (google.api.http) = {
+            get: "/Commission/GetAvailableWeeks"
+        };
+    };
 
     // Financial Reports
     rpc GetWithdrawalReports(GetWithdrawalReportsRequest) returns (GetWithdrawalReportsResponse){
@@ -247,9 +252,39 @@ message CommissionPayoutHistoryModel
     int32 action = 9; // CommissionPayoutAction enum
     string performed_by = 10;
     string reason = 11;
-    google.protobuf.Timestamp created = 12;
+    google.protobuf.Timestamp created = 13;
 }
 
+// ============ GetAvailableWeeks ============
+
+message GetAvailableWeeksRequest
+{
+    int32 future_weeks_count = 1; // تعداد هفته‌های آینده (پیش‌فرض: 4)
+    int32 past_weeks_count = 2;   // تعداد هفته‌های گذشته (پیش‌فرض: 12)
+}
+
+message GetAvailableWeeksResponse
+{
+    WeekInfo current_week = 1;
+    repeated WeekInfo calculated_weeks = 2;
+    repeated WeekInfo pending_weeks = 3;
+    repeated WeekInfo future_weeks = 4;
+}
+
+message WeekInfo
+{
+    string week_number = 1;              // YYYY-Www format
+    google.protobuf.Timestamp start_date = 2;
+    google.protobuf.Timestamp end_date = 3;
+    bool is_calculated = 4;
+    google.protobuf.Timestamp calculated_at = 5;
+    string last_execution_status = 6;
+    int64 total_pool_amount = 7;
+    int32 eligible_users_count = 8;
+    string display_text = 9;             // نمایش فارسی برای UI
+}
+
+
 // GetUserWeeklyBalances Query
 message GetUserWeeklyBalancesRequest
 {
diff --git a/src/CMSMicroservice.WebApi/Common/Mappings/ClubFeatureProfile.cs b/src/CMSMicroservice.WebApi/Common/Mappings/ClubFeatureProfile.cs
new file mode 100644
index 0000000..4095291
--- /dev/null
+++ b/src/CMSMicroservice.WebApi/Common/Mappings/ClubFeatureProfile.cs
@@ -0,0 +1,47 @@
+using CMSMicroservice.Application.ClubFeatureCQ.Commands.ToggleUserClubFeature;
+using CMSMicroservice.Application.ClubFeatureCQ.Queries.GetUserClubFeatures;
+using CMSMicroservice.Protobuf.Protos.ClubMembership;
+using Google.Protobuf.WellKnownTypes;
+using System;
+using System.Collections.Generic;
+
+namespace CMSMicroservice.WebApi.Common.Mappings;
+
+public class ClubFeatureProfile : IRegister
+{
+    void IRegister.Register(TypeAdapterConfig config)
+    {
+        // GetUserClubFeaturesRequest → GetUserClubFeaturesQuery
+        config.NewConfig<GetUserClubFeaturesRequest, GetUserClubFeaturesQuery>()
+            .Map(dest => dest.UserId, src => src.UserId);
+
+        // UserClubFeatureDto → UserClubFeatureModel
+        config.NewConfig<UserClubFeatureDto, UserClubFeatureModel>()
+            .Map(dest => dest.Id, src => src.Id)
+            .Map(dest => dest.UserId, src => src.UserId)
+            .Map(dest => dest.ClubMembershipId, src => src.ClubMembershipId)
+            .Map(dest => dest.ClubFeatureId, src => src.ClubFeatureId)
+            .Map(dest => dest.FeatureTitle, src => src.FeatureTitle)
+            .Map(dest => dest.FeatureDescription, src => src.FeatureDescription ?? "")
+            .Map(dest => dest.IsActive, src => src.IsActive)
+            .Map(dest => dest.GrantedAt, src => Timestamp.FromDateTime(DateTime.SpecifyKind(src.GrantedAt, DateTimeKind.Utc)))
+            .Map(dest => dest.Notes, src => src.Notes ?? "");
+
+        // List<UserClubFeatureDto> → GetUserClubFeaturesResponse
+        config.NewConfig<List<UserClubFeatureDto>, GetUserClubFeaturesResponse>()
+            .Map(dest => dest.Features, src => src.Adapt<List<UserClubFeatureModel>>());
+
+        // ToggleUserClubFeatureRequest → ToggleUserClubFeatureCommand
+        config.NewConfig<ToggleUserClubFeatureRequest, ToggleUserClubFeatureCommand>()
+            .Map(dest => dest.UserId, src => src.UserId)
+            .Map(dest => dest.ClubFeatureId, src => src.ClubFeatureId)
+            .Map(dest => dest.IsActive, src => src.IsActive);
+
+        // ToggleUserClubFeatureResponse (App) → ToggleUserClubFeatureResponse (Proto)
+        config.NewConfig<Application.ClubFeatureCQ.Commands.ToggleUserClubFeature.ToggleUserClubFeatureResponse, Protobuf.Protos.ClubMembership.ToggleUserClubFeatureResponse>()
+            .Map(dest => dest.Success, src => src.Success)
+            .Map(dest => dest.Message, src => src.Message)
+            .Map(dest => dest.UserClubFeatureId, src => src.UserClubFeatureId.HasValue ? (long?)src.UserClubFeatureId.Value : null)
+            .Map(dest => dest.IsActive, src => src.IsActive.HasValue ? (bool?)src.IsActive.Value : null);
+    }
+}
diff --git a/src/CMSMicroservice.WebApi/Common/Mappings/CommissionProfile.cs b/src/CMSMicroservice.WebApi/Common/Mappings/CommissionProfile.cs
new file mode 100644
index 0000000..d2c65d9
--- /dev/null
+++ b/src/CMSMicroservice.WebApi/Common/Mappings/CommissionProfile.cs
@@ -0,0 +1,38 @@
+using CMSMicroservice.Application.CommissionCQ.Queries.GetAvailableWeeks;
+using CMSMicroservice.Protobuf.Protos.Commission;
+using Google.Protobuf.WellKnownTypes;
+using Mapster;
+
+namespace CMSMicroservice.WebApi.Common.Mappings;
+
+public class CommissionProfile : IRegister
+{
+    public void Register(TypeAdapterConfig config)
+    {
+        // GetAvailableWeeks Request Mapping
+        config.NewConfig<GetAvailableWeeksRequest, GetAvailableWeeksQuery>()
+            .Map(dest => dest.FutureWeeksCount, src => src.FutureWeeksCount > 0 ? src.FutureWeeksCount : 4)
+            .Map(dest => dest.PastWeeksCount, src => src.PastWeeksCount > 0 ? src.PastWeeksCount : 12);
+
+        // GetAvailableWeeks Response Mapping
+        config.NewConfig<GetAvailableWeeksResponseDto, GetAvailableWeeksResponse>()
+            .Map(dest => dest.CurrentWeek, src => src.CurrentWeek)
+            .Map(dest => dest.CalculatedWeeks, src => src.CalculatedWeeks)
+            .Map(dest => dest.PendingWeeks, src => src.PendingWeeks)
+            .Map(dest => dest.FutureWeeks, src => src.FutureWeeks);
+
+        // WeekInfo Mapping
+        config.NewConfig<WeekInfoDto, WeekInfo>()
+            .Map(dest => dest.WeekNumber, src => src.WeekNumber)
+            .Map(dest => dest.StartDate, src => Timestamp.FromDateTime(src.StartDate.ToUniversalTime()))
+            .Map(dest => dest.EndDate, src => Timestamp.FromDateTime(src.EndDate.ToUniversalTime()))
+            .Map(dest => dest.IsCalculated, src => src.IsCalculated)
+            .Map(dest => dest.CalculatedAt, src => src.CalculatedAt.HasValue 
+                ? Timestamp.FromDateTime(src.CalculatedAt.Value.ToUniversalTime()) 
+                : null)
+            .Map(dest => dest.LastExecutionStatus, src => src.LastExecutionStatus ?? string.Empty)
+            .Map(dest => dest.TotalPoolAmount, src => src.TotalPoolAmount ?? 0)
+            .Map(dest => dest.EligibleUsersCount, src => src.EligibleUsersCount ?? 0)
+            .Map(dest => dest.DisplayText, src => src.DisplayText);
+    }
+}
diff --git a/src/CMSMicroservice.WebApi/Controllers/AdminController.cs b/src/CMSMicroservice.WebApi/Controllers/AdminController.cs
index c422434..4129eaa 100644
--- a/src/CMSMicroservice.WebApi/Controllers/AdminController.cs
+++ b/src/CMSMicroservice.WebApi/Controllers/AdminController.cs
@@ -38,9 +38,9 @@ public class AdminController : ControllerBase
     {
         _logger.LogInformation("🔧 Manual trigger requested by admin for week: {WeekNumber}", weekNumber ?? "previous");
 
-        // Enqueue immediate job execution
+        // Enqueue immediate job execution with specified week number
         var jobId = _backgroundJobClient.Enqueue<WeeklyCommissionJob>(
-            job => job.ExecuteAsync(CancellationToken.None));
+            job => job.ExecuteAsync(weekNumber, CancellationToken.None));
 
         _logger.LogInformation("✅ Job enqueued with ID: {JobId}", jobId);
 
diff --git a/src/CMSMicroservice.WebApi/Program.cs b/src/CMSMicroservice.WebApi/Program.cs
index a3aac6b..d168d00 100644
--- a/src/CMSMicroservice.WebApi/Program.cs
+++ b/src/CMSMicroservice.WebApi/Program.cs
@@ -196,7 +196,7 @@ using (var scope = app.Services.CreateScope())
     // Weekly Commission Calculation: Every Sunday at 00:05 (UTC)
     recurringJobManager.AddOrUpdate<CMSMicroservice.Infrastructure.BackgroundJobs.WeeklyCommissionJob>(
         recurringJobId: "weekly-commission-calculation",
-        methodCall: job => job.ExecuteAsync(CancellationToken.None),
+        methodCall: job => job.ExecuteAsync(null, CancellationToken.None),
         cronExpression: "5 0 * * 0", // Sunday at 00:05
         options: new RecurringJobOptions
         {
diff --git a/src/CMSMicroservice.WebApi/Services/ClubMembershipService.cs b/src/CMSMicroservice.WebApi/Services/ClubMembershipService.cs
index 7076787..af62c32 100644
--- a/src/CMSMicroservice.WebApi/Services/ClubMembershipService.cs
+++ b/src/CMSMicroservice.WebApi/Services/ClubMembershipService.cs
@@ -7,6 +7,8 @@ using CMSMicroservice.Application.ClubMembershipCQ.Queries.GetClubMembership;
 using CMSMicroservice.Application.ClubMembershipCQ.Queries.GetAllClubMemberships;
 using CMSMicroservice.Application.ClubMembershipCQ.Queries.GetClubMembershipHistory;
 using CMSMicroservice.Application.ClubMembershipCQ.Queries.GetClubStatistics;
+using CMSMicroservice.Application.ClubFeatureCQ.Queries.GetUserClubFeatures;
+using CMSMicroservice.Application.ClubFeatureCQ.Commands.ToggleUserClubFeature;
 
 namespace CMSMicroservice.WebApi.Services;
 
@@ -53,4 +55,14 @@ public class ClubMembershipService : ClubMembershipContract.ClubMembershipContra
     {
         return await _dispatchRequestToCQRS.Handle<GetClubStatisticsRequest, GetClubStatisticsQuery, GetClubStatisticsResponse>(request, context);
     }
+
+    public override async Task<GetUserClubFeaturesResponse> GetUserClubFeatures(GetUserClubFeaturesRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetUserClubFeaturesRequest, GetUserClubFeaturesQuery, GetUserClubFeaturesResponse>(request, context);
+    }
+
+    public override async Task<Protobuf.Protos.ClubMembership.ToggleUserClubFeatureResponse> ToggleUserClubFeature(ToggleUserClubFeatureRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<ToggleUserClubFeatureRequest, ToggleUserClubFeatureCommand, Protobuf.Protos.ClubMembership.ToggleUserClubFeatureResponse>(request, context);
+    }
 }
diff --git a/src/CMSMicroservice.WebApi/Services/CommissionService.cs b/src/CMSMicroservice.WebApi/Services/CommissionService.cs
index 04d9b3f..ecea530 100644
--- a/src/CMSMicroservice.WebApi/Services/CommissionService.cs
+++ b/src/CMSMicroservice.WebApi/Services/CommissionService.cs
@@ -17,6 +17,7 @@ using CMSMicroservice.Application.CommissionCQ.Queries.GetWithdrawalRequests;
 using CMSMicroservice.Application.CommissionCQ.Queries.GetWorkerStatus;
 using CMSMicroservice.Application.CommissionCQ.Queries.GetWorkerExecutionLogs;
 using CMSMicroservice.Application.CommissionCQ.Queries.GetWithdrawalReports;
+using CMSMicroservice.Application.CommissionCQ.Queries.GetAvailableWeeks;
 
 namespace CMSMicroservice.WebApi.Services;
 
@@ -112,6 +113,11 @@ public class CommissionService : CommissionContract.CommissionContractBase
         return await _dispatchRequestToCQRS.Handle<GetWorkerExecutionLogsRequest, GetWorkerExecutionLogsQuery, GetWorkerExecutionLogsResponse>(request, context);
     }
 
+    public override async Task<GetAvailableWeeksResponse> GetAvailableWeeks(GetAvailableWeeksRequest request, ServerCallContext context)
+    {
+        return await _dispatchRequestToCQRS.Handle<GetAvailableWeeksRequest, GetAvailableWeeksQuery, GetAvailableWeeksResponse>(request, context);
+    }
+
     public override async Task<GetWithdrawalReportsResponse> GetWithdrawalReports(GetWithdrawalReportsRequest request, ServerCallContext context)
     {
         return await _dispatchRequestToCQRS.Handle<GetWithdrawalReportsRequest, GetWithdrawalReportsQuery, GetWithdrawalReportsResponse>(request, context);
diff --git a/src/CMSMicroservice.WebApi/Services/NetworkMembershipService.cs b/src/CMSMicroservice.WebApi/Services/NetworkMembershipService.cs
index 1690065..12b7b44 100644
--- a/src/CMSMicroservice.WebApi/Services/NetworkMembershipService.cs
+++ b/src/CMSMicroservice.WebApi/Services/NetworkMembershipService.cs
@@ -42,7 +42,6 @@ public class NetworkMembershipService : NetworkMembershipContract.NetworkMembers
     public override async Task<GetNetworkTreeResponse> GetNetworkTree(GetNetworkTreeRequest request, ServerCallContext context)
     {
 
-        var x=request.Adapt<GetNetworkTreeQuery>();
         return await _dispatchRequestToCQRS.Handle<GetNetworkTreeRequest, GetNetworkTreeQuery, GetNetworkTreeResponse>(request, context);
     }
 
diff --git a/src/CMSMicroservice.WebApi/Workers/DayaLoanCheckWorker.cs b/src/CMSMicroservice.WebApi/Workers/DayaLoanCheckWorker.cs
index 79ed217..db27d66 100644
--- a/src/CMSMicroservice.WebApi/Workers/DayaLoanCheckWorker.cs
+++ b/src/CMSMicroservice.WebApi/Workers/DayaLoanCheckWorker.cs
@@ -35,7 +35,7 @@ public class DayaLoanCheckWorker
     [AutomaticRetry(Attempts = 3)]
     public async Task ExecuteAsync()
     {
-        _logger.LogInformation("DayaLoanCheckWorker started at {Time}", DateTime.UtcNow);
+        _logger.LogInformation("DayaLoanCheckWorker started at {Time}", DateTime.Now);
         
         try
         {
@@ -114,7 +114,7 @@ public class DayaLoanCheckWorker
         recurringJobManager.AddOrUpdate<DayaLoanCheckWorker>(
             "daya-loan-check",
             worker => worker.ExecuteAsync(),
-            "*/15 * * * *", // هر 15 دقیقه
+            "*/01 * * * *", // هر 15 دقیقه
             TimeZoneInfo.Local
         );
     }