Marco.Pms.Model/ViewModels/DashBoard/ProjectDashboardVM.cs

@@ -0,0 +1,8 @@
+namespace Marco.Pms.Model.ViewModels.DashBoard
+{
+    public class ProjectDashboardVM
+    {
+        public int TotalProjects { get; set; }
+        public int OngoingProjects { get; set; }
+    }
+}

Marco.Pms.Model/ViewModels/DashBoard/ProjectProgressionVM.cs

@@ -0,0 +1,12 @@
+namespace Marco.Pms.Model.ViewModels.DashBoard
+{
+    public class ProjectProgressionVM
+    {
+        public int ProjectId { get; set; }
+        public string? ProjectName { get; set; }
+        public double PlannedTask { get; set; }
+        public double CompletedTask { get; set; }
+        public DateTime? Date { get; set; }
+
+    }
+}

Marco.Pms.Model/ViewModels/DashBoard/TasksDashboardVM.cs

@@ -0,0 +1,8 @@
+namespace Marco.Pms.Model.ViewModels.DashBoard
+{
+    public class TasksDashboardVM
+    {
+        public double TotalTasks { get; set; }
+        public double CompletedTasks { get; set; }
+    }
+}

Marco.Pms.Model/ViewModels/DashBoard/TeamDashboardVM.cs

@@ -0,0 +1,8 @@
+namespace Marco.Pms.Model.ViewModels.DashBoard
+{
+    public class TeamDashboardVM
+    {
+        public int TotalEmployees { get; set; }
+        public int InToday { get; set; }
+    }
+}

Marco.Pms.Services/Controllers/DashboardController.cs

@@ -0,0 +1,175 @@
+using Marco.Pms.DataAccess.Data;
+using Marco.Pms.Model.Activities;
+using Marco.Pms.Model.Projects;
+using Marco.Pms.Model.Utilities;
+using Marco.Pms.Model.ViewModels.DashBoard;
+using MarcoBMS.Services.Helpers;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace Marco.Pms.Services.Controllers
+{
+    [Authorize]
+    [Route("api/[controller]")]
+    [ApiController]
+    public class DashboardController : ControllerBase
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly UserHelper _userHelper;
+        public DashboardController(ApplicationDbContext context,UserHelper userHelper)
+        {
+            _context = context;
+            _userHelper = userHelper;
+        }
+        [HttpGet("progression")]
+        public async Task<IActionResult> GetGraph([FromQuery] double days,[FromQuery] int projectId, [FromQuery] string? FromDate)
+        {
+            var tenantId = _userHelper.GetTenantId();
+            DateTime fromDate = new DateTime();
+            DateTime toDate = new DateTime();
+            List<ProjectProgressionVM>? projectProgressionVMs = new List<ProjectProgressionVM>();
+            if (FromDate != null && DateTime.TryParse(FromDate, out fromDate) == false)
+            {
+                return BadRequest(ApiResponse<object>.ErrorResponse("Invalid starting date.", "Invalid starting date.", 400));
+
+            }
+            if(projectId == null) { projectId = 0; }
+
+            if (FromDate == null) fromDate = DateTime.UtcNow.Date;
+
+            if (days >= 0)
+            {
+                double negativeDays = 0 - days;
+                toDate = fromDate.AddDays(negativeDays);
+                if (projectId == 0)
+                {
+                    List<TaskAllocation> tasks = await _context.TaskAllocations.Where(t => t.AssignmentDate <= fromDate && t.AssignmentDate >= toDate && t.TenantId == tenantId).ToListAsync();
+                    
+                    double flagDays = 0;
+                    while (negativeDays < flagDays)
+                    {
+                        ProjectProgressionVM ProjectProgressionVM = new ProjectProgressionVM();
+                        ProjectProgressionVM.ProjectId = projectId;
+                        ProjectProgressionVM.ProjectName = "";
+                        var date = fromDate.AddDays(flagDays);
+                        var todayTasks = tasks.Where(t => t.AssignmentDate.Date == date.Date).ToList();
+                        double plannedTaks = 0;
+                        double completedTasks = 0;
+                        ProjectProgressionVM.Date = date;
+
+                        foreach (var task in todayTasks)
+                        {
+                            plannedTaks += task.PlannedTask;
+                            completedTasks += task.CompletedTask;
+                        }
+                        ProjectProgressionVM.PlannedTask = plannedTaks;
+                        ProjectProgressionVM.CompletedTask = completedTasks;
+
+                        projectProgressionVMs.Add(ProjectProgressionVM);
+                        flagDays -= 1;
+                    }
+                }
+                else
+                {
+                    var project = await _context.Projects.FirstOrDefaultAsync(p => p.Id == projectId);
+                    List<Building> buildings = await _context.Buildings.Where(b => b.ProjectId == projectId && b.TenantId == tenantId).ToListAsync();
+                    List<int> idList = buildings.Select(b => b.Id).ToList();
+
+                    List<Floor> floors = await _context.Floor.Where(f => idList.Contains(f.BuildingId) && f.TenantId == tenantId).ToListAsync();
+                    idList = floors.Select(f => f.Id).ToList();
+
+                    List<WorkArea> workAreas = await _context.WorkAreas.Where(a => idList.Contains(a.FloorId) && a.TenantId == tenantId).ToListAsync();
+                    idList = workAreas.Select(a => a.Id).ToList();
+
+                    List<WorkItem> workItems = await _context.WorkItems.Where(i => idList.Contains(i.WorkAreaId) && i.TenantId == tenantId).ToListAsync();
+                    idList = workItems.Select(i => i.Id).ToList();
+
+                    List<TaskAllocation> tasks = await _context.TaskAllocations.Where(t => idList.Contains(t.WorkItemId) && t.AssignmentDate <= fromDate && t.AssignmentDate >= toDate && t.TenantId == tenantId).ToListAsync();
+                    if(project != null)
+                    {
+                        double flagDays = 0;
+                        while (negativeDays < flagDays)
+                        {
+                            ProjectProgressionVM projectProgressionVM = new ProjectProgressionVM();
+                            projectProgressionVM.ProjectId = projectId;
+                            projectProgressionVM.ProjectName = project.Name;
+                            var date = fromDate.AddDays(flagDays);
+                            var todayTasks = tasks.Where(t => t.AssignmentDate.Date == date.Date).ToList();
+                            double plannedTaks = 0;
+                            double completedTasks = 0;
+                            projectProgressionVM.Date = date;
+
+                            foreach (var task in todayTasks)
+                            {
+                                plannedTaks += task.PlannedTask;
+                                completedTasks += task.CompletedTask;
+                            }
+                            projectProgressionVM.PlannedTask = plannedTaks;
+                            projectProgressionVM.CompletedTask = completedTasks;
+
+                            projectProgressionVMs.Add(projectProgressionVM);
+                            flagDays -= 1;
+                        }
+                    }
+                }
+            }
+            return Ok(ApiResponse<object>.SuccessResponse(projectProgressionVMs, "Success", 200));
+        }
+
+        [HttpGet("projects")]
+        public async Task<IActionResult> GetProjectCount()
+        {
+            var tenantId = _userHelper.GetTenantId();
+
+            var projects = await _context.Projects.Where(p => p.TenantId == tenantId && p.ProjectStatusId != 4).ToListAsync();
+            var ongoingProjects = projects.Where(p => p.ProjectStatusId == 1).ToList();
+
+            ProjectDashboardVM projectDashboardVM = new ProjectDashboardVM
+            {
+                TotalProjects = projects.Count(),
+                OngoingProjects = ongoingProjects.Count()
+            };
+            return Ok(ApiResponse<object>.SuccessResponse(projectDashboardVM, "Success", 200));
+        }
+
+
+        [HttpGet("teams")]
+        public async Task<IActionResult> GetTotalEmployees()
+        {
+            var tenantId = _userHelper.GetTenantId();
+            var date = DateTime.UtcNow.Date;
+
+            var Employees = await _context.Employees.Where(e => e.TenantId == tenantId && e.IsActive == true).Select(e => e.Id).ToListAsync();
+
+            var checkedInEmployee = await _context.Attendes.Where(e => e.Date.Date == date ).ToListAsync();
+
+            TeamDashboardVM teamDashboardVM = new TeamDashboardVM
+            {
+                TotalEmployees = Employees.Count(),
+                InToday = checkedInEmployee.Count()
+            };
+            return Ok(ApiResponse<object>.SuccessResponse(teamDashboardVM, "Success", 200));
+        }
+
+        [HttpGet("tasks")]
+        public async Task<IActionResult> GetTotalTasks()
+        {
+            var tenantId = _userHelper.GetTenantId();
+
+            var Tasks = await _context.WorkItems.Where(t => t.TenantId == tenantId).Select(t => new { PlannedWork = t.PlannedWork, CompletedWork = t.CompletedWork}).ToListAsync();
+            TasksDashboardVM tasksDashboardVM = new TasksDashboardVM
+            {
+                TotalTasks = 0,
+                CompletedTasks = 0
+            };
+            foreach (var task in Tasks)
+            {
+                tasksDashboardVM.TotalTasks += task.PlannedWork;
+                tasksDashboardVM.CompletedTasks += task.CompletedWork;
+            }
+
+            return Ok(ApiResponse<object>.SuccessResponse(tasksDashboardVM, "Success", 200));
+        }
+    }
+}