Added the get Recurring payment lsit API

Marco.Pms.DataAccess/Migrations/20251104115408_Changed_Forgin_Table_To_Category.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Marco.Pms.DataAccess.Migrations
+{
+    /// <inheritdoc />
+    public partial class Changed_Forgin_Table_To_Category : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_RecurringPayments_ExpensesTypeMaster_ExpenseCategoryId",
+                table: "RecurringPayments");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RecurringPayments_ExpenseCategoryMasters_ExpenseCategoryId",
+                table: "RecurringPayments",
+                column: "ExpenseCategoryId",
+                principalTable: "ExpenseCategoryMasters",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_RecurringPayments_ExpenseCategoryMasters_ExpenseCategoryId",
+                table: "RecurringPayments");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RecurringPayments_ExpensesTypeMaster_ExpenseCategoryId",
+                table: "RecurringPayments",
+                column: "ExpenseCategoryId",
+                principalTable: "ExpensesTypeMaster",
+                principalColumn: "Id");
+        }
+    }
+}

Marco.Pms.DataAccess/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -6653,7 +6653,7 @@ namespace Marco.Pms.DataAccess.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("Marco.Pms.Model.Master.ExpensesTypeMaster", "ExpenseCategory")
+                    b.HasOne("Marco.Pms.Model.Expenses.ExpenseCategoryMaster", "ExpenseCategory")
                         .WithMany()
                         .HasForeignKey("ExpenseCategoryId");
 

Marco.Pms.Model/Expenses/RecurringPayment.cs

@@ -36,7 +36,7 @@ namespace Marco.Pms.Model.Expenses
 
         [ValidateNever]
         [ForeignKey("ExpenseCategoryId")]
-        public ExpensesTypeMaster? ExpenseCategory { get; set; }
+        public ExpenseCategoryMaster? ExpenseCategory { get; set; }
         public Guid StatusId { get; set; }
 
         [ValidateNever]

Marco.Pms.Services/Controllers/ExpenseController.cs

@@ -214,6 +214,14 @@ namespace Marco.Pms.Services.Controllers
 
         #region =================================================================== Recurring Payment Functions ===================================================================
 
+        [HttpGet("get/recurring-payment/list")]
+        public async Task<IActionResult> GetRecurringRequestList([FromQuery] string? searchString, [FromQuery] string? filter, [FromQuery] bool isActive = true, [FromQuery] int pageSize = 20, [FromQuery] int pageNumber = 1)
+        {
+            var loggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
+            var response = await _expensesService.GetRecurringRequestListAsync(searchString, filter, isActive, pageSize, pageNumber, loggedInEmployee, tenantId);
+            return StatusCode(response.StatusCode, response);
+        }
+
         [HttpPost("recurring-payment/create")]
         public async Task<IActionResult> CreateRecurringPayment([FromBody] RecurringTemplateDto model)
         {

Marco.Pms.Services/Service/ExpensesService.cs

@@ -2308,6 +2308,36 @@ namespace Marco.Pms.Services.Service
         #endregion
 
         #region =================================================================== Recurring Payment Functions ===================================================================
+
+        public async Task<ApiResponse<object>> GetRecurringRequestListAsync(string? searchString, string? filter, bool isActive, int pageSize, int pageNumber, Employee loggedInEmployee, Guid tenantId)
+        {
+            var recurringPaymentQuery = _context.RecurringPayments
+                .Where(rp => rp.TenantId == tenantId && rp.IsActive == isActive);
+
+            var recurringPayments = await recurringPaymentQuery
+                .ToListAsync();
+
+            var totalEntities = await recurringPaymentQuery.CountAsync();
+
+            var totalPages = (int)Math.Ceiling((double)totalEntities / pageSize);
+
+            var results = recurringPayments.Select(rp =>
+            {
+                var result = _mapper.Map<RecurringPaymentVM>(rp);
+                result.RecurringPaymentUId = $"{rp.UIDPrefix}/{rp.UIDPostfix:D5}";
+                return result;
+            }).ToList();
+
+            var response = new
+            {
+                CurrentPage = pageNumber,
+                TotalPages = totalPages,
+                TotalEntities = totalEntities,
+                Data = results,
+            };
+            return ApiResponse<object>.SuccessResponse(response, $"{results.Count} Recurring payments fetched successfully", 200);
+        }
+
         public async Task<ApiResponse<object>> CreateRecurringPaymentAsync(RecurringTemplateDto model, Employee loggedInEmployee, Guid tenantId)
         {
             using var scope = _serviceScopeFactory.CreateScope();
@@ -2325,6 +2355,11 @@ namespace Marco.Pms.Services.Service
                 await using var context = await _dbContextFactory.CreateDbContextAsync();
                 return await context.ExpenseCategoryMasters.FirstOrDefaultAsync(et => et.Id == model.ExpenseCategoryId && et.IsActive);
             });
+            var recurringStatusTask = Task.Run(async () =>
+            {
+                await using var context = await _dbContextFactory.CreateDbContextAsync();
+                return await context.RecurringPaymentStatus.FirstOrDefaultAsync(et => et.Id == model.StatusId);
+            });
             var currencyTask = Task.Run(async () =>
             {
                 await using var context = await _dbContextFactory.CreateDbContextAsync();
@@ -2336,7 +2371,7 @@ namespace Marco.Pms.Services.Service
                 return await context.Projects.FirstOrDefaultAsync(P => model.ProjectId.HasValue && P.Id == model.ProjectId.Value);
             });
 
-            await Task.WhenAll(expenseCategoryTask, currencyTask, projectTask);
+            await Task.WhenAll(expenseCategoryTask, currencyTask, projectTask, recurringStatusTask);
 
             var expenseCategory = await expenseCategoryTask;
             if (expenseCategory == null)
@@ -2345,6 +2380,13 @@ namespace Marco.Pms.Services.Service
                 return ApiResponse<object>.ErrorResponse("Expense Category not found.", "Expense Category not found.", 404);
             }
 
+            var recurringStatus = await recurringStatusTask;
+            if (expenseCategory == null)
+            {
+                _logger.LogWarning("Recurring Payment Status not found with Id: {StatusId}", model.StatusId);
+                return ApiResponse<object>.ErrorResponse("Recurring Payment Status not found.", "Recurring Payment Status not found.", 404);
+            }
+
             var currency = await currencyTask;
             if (currency == null)
             {
@@ -2371,37 +2413,100 @@ namespace Marco.Pms.Services.Service
             recurringPayment.CreatedById = loggedInEmployee.Id;
             recurringPayment.TenantId = tenantId;
 
+            _context.RecurringPayments.Add(recurringPayment);
             await _context.SaveChangesAsync();
 
             var response = _mapper.Map<RecurringPaymentVM>(recurringPayment);
             response.RecurringPaymentUId = $"{recurringPayment.UIDPrefix}/{recurringPayment.UIDPostfix:D5}";
+            response.CreatedBy = _mapper.Map<BasicEmployeeVM>(loggedInEmployee);
+            response.ExpenseCategory = _mapper.Map<ExpensesCategoryMasterVM>(expenseCategory);
+            response.Status = recurringStatus;
+            response.Currency = currency;
+            response.Project = _mapper.Map<BasicProjectVM>(project);
 
             return ApiResponse<object>.SuccessResponse(response, "Recurring Payment Template created successfully", 201);
         }
 
         public async Task<ApiResponse<object>> EditRecurringPaymentAsync(Guid id, RecurringTemplateDto model, Employee loggedInEmployee, Guid tenantId)
         {
-            string uIDPrefix = $"RP/{DateTime.Now:MMyy}";
+            using var scope = _serviceScopeFactory.CreateScope();
+            var permissionService = scope.ServiceProvider.GetRequiredService<PermissionServices>();
+            var hasPermission = await permissionService.HasPermission(PermissionsMaster.ManageRecurring, loggedInEmployee.Id);
 
-            var lastExpense = await _context.RecurringPayments
+            if (!hasPermission)
-                .Where(e => e.UIDPrefix == uIDPrefix)
+            {
-                .OrderByDescending(e => e.UIDPostfix)
+                _logger.LogWarning("Employee {EmployeeId} attempted to create recurring template", loggedInEmployee.Id);
-                .FirstOrDefaultAsync();
+                return ApiResponse<object>.ErrorResponse("You do not have access to create recurring template", "You do not have access to create recurring template", 400);
+            }
 
-            int uIDPostfix = lastExpense == null ? 1 : (lastExpense.UIDPostfix + 1);
+            var expenseCategoryTask = Task.Run(async () =>
+            {
+                await using var context = await _dbContextFactory.CreateDbContextAsync();
+                return await context.ExpenseCategoryMasters.FirstOrDefaultAsync(et => et.Id == model.ExpenseCategoryId && et.IsActive);
+            });
+            var recurringStatusTask = Task.Run(async () =>
+            {
+                await using var context = await _dbContextFactory.CreateDbContextAsync();
+                return await context.RecurringPaymentStatus.FirstOrDefaultAsync(et => et.Id == model.StatusId);
+            });
+            var currencyTask = Task.Run(async () =>
+            {
+                await using var context = await _dbContextFactory.CreateDbContextAsync();
+                return await context.CurrencyMaster.FirstOrDefaultAsync(c => c.Id == model.CurrencyId);
+            });
+            var projectTask = Task.Run(async () =>
+            {
+                await using var context = await _dbContextFactory.CreateDbContextAsync();
+                return await context.Projects.FirstOrDefaultAsync(P => model.ProjectId.HasValue && P.Id == model.ProjectId.Value);
+            });
 
-            var recurringPayment = _mapper.Map<RecurringPayment>(model);
+            await Task.WhenAll(expenseCategoryTask, currencyTask, projectTask, recurringStatusTask);
-            recurringPayment.UIDPrefix = uIDPrefix;
+
-            recurringPayment.UIDPostfix = uIDPostfix;
+            var expenseCategory = await expenseCategoryTask;
-            recurringPayment.IsActive = true;
+            if (expenseCategory == null)
-            recurringPayment.CreatedAt = DateTime.UtcNow;
+            {
-            recurringPayment.CreatedById = loggedInEmployee.Id;
+                _logger.LogWarning("Expense Category not found with Id: {ExpenseCategoryId}", model.ExpenseCategoryId);
-            recurringPayment.TenantId = tenantId;
+                return ApiResponse<object>.ErrorResponse("Expense Category not found.", "Expense Category not found.", 404);
+            }
+
+            var recurringStatus = await recurringStatusTask;
+            if (expenseCategory == null)
+            {
+                _logger.LogWarning("Recurring Payment Status not found with Id: {StatusId}", model.StatusId);
+                return ApiResponse<object>.ErrorResponse("Recurring Payment Status not found.", "Recurring Payment Status not found.", 404);
+            }
+
+            var currency = await currencyTask;
+            if (currency == null)
+            {
+                _logger.LogWarning("Currency not found with Id: {CurrencyId}", model.CurrencyId);
+                return ApiResponse<object>.ErrorResponse("Currency not found.", "Currency not found.", 404);
+            }
+
+            var project = await projectTask;
+
+            var recurringPayment = await _context.RecurringPayments.FirstOrDefaultAsync(rp => rp.Id == id && rp.IsActive && rp.TenantId == tenantId);
+
+            if (recurringPayment == null)
+            {
+                return ApiResponse<object>.ErrorResponse("Recurring Payment Template not found", "Recurring Payment Template not found", 404);
+            }
+
+            _mapper.Map(model, recurringPayment);
+            recurringPayment.UpdatedAt = DateTime.UtcNow;
+            recurringPayment.UpdatedById = loggedInEmployee.Id;
+
+            await _context.SaveChangesAsync();
 
             var response = _mapper.Map<RecurringPaymentVM>(recurringPayment);
             response.RecurringPaymentUId = $"{recurringPayment.UIDPrefix}/{recurringPayment.UIDPostfix:D5}";
+            response.CreatedBy = _mapper.Map<BasicEmployeeVM>(loggedInEmployee);
+            response.ExpenseCategory = _mapper.Map<ExpensesCategoryMasterVM>(expenseCategory);
+            response.Status = recurringStatus;
+            response.Currency = currency;
+            response.Project = _mapper.Map<BasicProjectVM>(project);
 
-            return ApiResponse<object>.SuccessResponse(response, "Recurring Payment Template created successfully", 201);
+            return ApiResponse<object>.SuccessResponse(response, "Recurring Payment Template updated successfully", 200);
         }
         #endregion
 

Marco.Pms.Services/Service/ServiceInterfaces/IExpensesService.cs

@@ -29,6 +29,7 @@ namespace Marco.Pms.Services.Service.ServiceInterfaces
         #endregion
 
         #region =================================================================== Recurring Payment Functions ===================================================================
+        Task<ApiResponse<object>> GetRecurringRequestListAsync(string? searchString, string? filter, bool isActive, int pageSize, int pageNumber, Employee loggedInEmployee, Guid tenantId);
         Task<ApiResponse<object>> CreateRecurringPaymentAsync(RecurringTemplateDto model, Employee loggedInEmployee, Guid tenantId);
         Task<ApiResponse<object>> EditRecurringPaymentAsync(Guid id, RecurringTemplateDto model, Employee loggedInEmployee, Guid tenantId);
         #endregion