275 lines
12 KiB
C#
275 lines
12 KiB
C#
using System.Globalization;
|
|
using Marco.Pms.DataAccess.Data;
|
|
using Marco.Pms.Model.Dtos.Attendance;
|
|
using Marco.Pms.Model.MongoDBModels;
|
|
using Marco.Pms.Model.ViewModels.Report;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Marco.Pms.Services.Helpers
|
|
{
|
|
public class ReportHelper
|
|
{
|
|
private readonly ApplicationDbContext _context;
|
|
private readonly CacheUpdateHelper _cache;
|
|
public ReportHelper(CacheUpdateHelper cache, ApplicationDbContext context)
|
|
{
|
|
_cache = cache;
|
|
_context = context;
|
|
}
|
|
public async Task<ProjectStatisticReport?> GetDailyProjectReport(Guid projectId, Guid tenantId)
|
|
{
|
|
// await _cache.GetBuildingAndFloorByWorkAreaId();
|
|
DateTime reportDate = DateTime.UtcNow.AddDays(-1).Date;
|
|
var project = await _cache.GetProjectDetails(projectId);
|
|
if (project == null)
|
|
{
|
|
var projectSQL = await _context.Projects
|
|
.AsNoTracking()
|
|
.FirstOrDefaultAsync(p => p.Id == projectId && p.TenantId == tenantId);
|
|
if (projectSQL != null)
|
|
{
|
|
project = new ProjectMongoDB
|
|
{
|
|
Id = projectSQL.Id.ToString(),
|
|
Name = projectSQL.Name,
|
|
ShortName = projectSQL.ShortName,
|
|
ProjectAddress = projectSQL.ProjectAddress,
|
|
ContactPerson = projectSQL.ContactPerson
|
|
};
|
|
await _cache.AddProjectDetails(projectSQL);
|
|
}
|
|
}
|
|
if (project != null)
|
|
{
|
|
|
|
var statisticReport = new ProjectStatisticReport
|
|
{
|
|
Date = reportDate,
|
|
ProjectName = project.Name ?? "",
|
|
TimeStamp = DateTime.Now.ToString("dd-MMM-yyyy HH:mm:ss", CultureInfo.InvariantCulture)
|
|
};
|
|
|
|
// Preload relevant data
|
|
var projectAllocations = await _context.ProjectAllocations
|
|
.Include(p => p.Employee)
|
|
.Where(p => p.ProjectId == projectId && p.IsActive)
|
|
.ToListAsync();
|
|
|
|
var assignedEmployeeIds = projectAllocations.Select(p => p.EmployeeId).ToHashSet();
|
|
|
|
var attendances = await _context.Attendes
|
|
.AsNoTracking()
|
|
.Where(a => a.ProjectID == projectId && a.InTime != null && a.InTime.Value.Date == reportDate)
|
|
.ToListAsync();
|
|
|
|
var checkedInEmployeeIds = attendances.Select(a => a.EmployeeID).Distinct().ToHashSet();
|
|
var checkoutPendingIds = attendances.Where(a => a.OutTime == null).Select(a => a.EmployeeID).Distinct().ToHashSet();
|
|
var regularizationIds = attendances
|
|
.Where(a => a.Activity == ATTENDANCE_MARK_TYPE.REQUEST_REGULARIZE)
|
|
.Select(a => a.EmployeeID).Distinct().ToHashSet();
|
|
|
|
// Preload buildings, floors, areas
|
|
List<BuildingMongoDBVM>? buildings = null;
|
|
List<FloorMongoDBVM>? floors = null;
|
|
List<WorkAreaMongoDB>? areas = null;
|
|
List<WorkItemMongoDB>? workItems = null;
|
|
|
|
// Fetch Buildings
|
|
buildings = project.Buildings
|
|
.Select(b => new BuildingMongoDBVM
|
|
{
|
|
Id = b.Id,
|
|
ProjectId = b.ProjectId,
|
|
BuildingName = b.BuildingName,
|
|
Description = b.Description
|
|
}).ToList();
|
|
if (buildings == null)
|
|
{
|
|
buildings = await _context.Buildings
|
|
.Where(b => b.ProjectId == projectId)
|
|
.Select(b => new BuildingMongoDBVM
|
|
{
|
|
Id = b.Id.ToString(),
|
|
ProjectId = b.ProjectId.ToString(),
|
|
BuildingName = b.Name,
|
|
Description = b.Description
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
// fetch Floors
|
|
floors = project.Buildings
|
|
.SelectMany(b => b.Floors.Select(f => new FloorMongoDBVM
|
|
{
|
|
Id = f.Id.ToString(),
|
|
BuildingId = f.BuildingId,
|
|
FloorName = f.FloorName
|
|
})).ToList();
|
|
if (floors == null)
|
|
{
|
|
var buildingIds = buildings.Select(b => Guid.Parse(b.Id)).ToList();
|
|
floors = await _context.Floor
|
|
.Where(f => buildingIds.Contains(f.BuildingId))
|
|
.Select(f => new FloorMongoDBVM
|
|
{
|
|
Id = f.Id.ToString(),
|
|
BuildingId = f.BuildingId.ToString(),
|
|
FloorName = f.FloorName
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
// fetch Work Areas
|
|
areas = project.Buildings
|
|
.SelectMany(b => b.Floors)
|
|
.SelectMany(f => f.WorkAreas).ToList();
|
|
if (areas == null)
|
|
{
|
|
var floorIds = floors.Select(f => Guid.Parse(f.Id)).ToList();
|
|
areas = await _context.WorkAreas
|
|
.Where(a => floorIds.Contains(a.FloorId))
|
|
.Select(wa => new WorkAreaMongoDB
|
|
{
|
|
Id = wa.Id.ToString(),
|
|
FloorId = wa.FloorId.ToString(),
|
|
AreaName = wa.AreaName,
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
var areaIds = areas.Select(a => Guid.Parse(a.Id)).ToList();
|
|
|
|
// fetch Work Items
|
|
workItems = await _cache.GetWorkItemsByWorkAreaIds(areaIds);
|
|
if (workItems == null)
|
|
{
|
|
workItems = await _context.WorkItems
|
|
.Include(w => w.ActivityMaster)
|
|
.Where(w => areaIds.Contains(w.WorkAreaId))
|
|
.Select(wi => new WorkItemMongoDB
|
|
{
|
|
Id = wi.Id.ToString(),
|
|
WorkAreaId = wi.WorkAreaId.ToString(),
|
|
PlannedWork = wi.PlannedWork,
|
|
CompletedWork = wi.CompletedWork,
|
|
Description = wi.Description,
|
|
TaskDate = wi.TaskDate,
|
|
ActivityMaster = new ActivityMasterMongoDB
|
|
{
|
|
ActivityName = wi.ActivityMaster != null ? wi.ActivityMaster.ActivityName : null,
|
|
UnitOfMeasurement = wi.ActivityMaster != null ? wi.ActivityMaster.UnitOfMeasurement : null
|
|
}
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
var itemIds = workItems.Select(i => Guid.Parse(i.Id)).ToList();
|
|
|
|
var tasks = await _context.TaskAllocations
|
|
.Where(t => itemIds.Contains(t.WorkItemId))
|
|
.ToListAsync();
|
|
|
|
var taskIds = tasks.Select(t => t.Id).ToList();
|
|
|
|
var taskMembers = await _context.TaskMembers
|
|
.Include(m => m.Employee)
|
|
.Where(m => taskIds.Contains(m.TaskAllocationId))
|
|
.ToListAsync();
|
|
|
|
// Aggregate data
|
|
double totalPlannedWork = workItems.Sum(w => w.PlannedWork);
|
|
double totalCompletedWork = workItems.Sum(w => w.CompletedWork);
|
|
|
|
var todayAssignedTasks = tasks.Where(t => t.AssignmentDate.Date == reportDate).ToList();
|
|
var reportPending = tasks.Where(t => t.ReportedDate == null).ToList();
|
|
|
|
double totalPlannedTask = todayAssignedTasks.Sum(t => t.PlannedTask);
|
|
double totalCompletedTask = todayAssignedTasks.Sum(t => t.CompletedTask);
|
|
var jobRoleIds = projectAllocations.Select(pa => pa.JobRoleId).ToList();
|
|
var jobRoles = await _context.JobRoles
|
|
.Where(j => j.TenantId == tenantId && jobRoleIds.Contains(j.Id))
|
|
.ToListAsync();
|
|
|
|
// Team on site
|
|
var teamOnSite = jobRoles
|
|
.Select(role =>
|
|
{
|
|
var count = projectAllocations.Count(p => p.JobRoleId == role.Id && checkedInEmployeeIds.Contains(p.EmployeeId));
|
|
return new TeamOnSite { RoleName = role.Name, NumberofEmployees = count };
|
|
})
|
|
.OrderByDescending(t => t.NumberofEmployees)
|
|
.ToList();
|
|
|
|
// Task details
|
|
var performedTasks = todayAssignedTasks.Select(task =>
|
|
{
|
|
var workItem = workItems.FirstOrDefault(w => w.Id == task.WorkItemId.ToString());
|
|
var area = areas.FirstOrDefault(a => a.Id == workItem?.WorkAreaId);
|
|
var floor = floors.FirstOrDefault(f => f.Id == area?.FloorId);
|
|
var building = buildings.FirstOrDefault(b => b.Id == floor?.BuildingId);
|
|
|
|
string activityName = workItem?.ActivityMaster?.ActivityName ?? "";
|
|
string location = $"{building?.BuildingName} > {floor?.FloorName}</span><br/><span style=\"color: gray; font-size: small; padding-left: 10px;\"> {floor?.FloorName}-{area?.AreaName}";
|
|
double pending = (workItem?.PlannedWork ?? 0) - (workItem?.CompletedWork ?? 0);
|
|
|
|
var taskTeam = taskMembers
|
|
.Where(m => m.TaskAllocationId == task.Id)
|
|
.Select(m =>
|
|
{
|
|
string name = $"{m.Employee?.FirstName ?? ""} {m.Employee?.LastName ?? ""}";
|
|
var role = jobRoles.FirstOrDefault(r => r.Id == m.Employee?.JobRoleId);
|
|
return new TaskTeam { Name = name, RoleName = role?.Name ?? "" };
|
|
})
|
|
.ToList();
|
|
|
|
return new PerformedTask
|
|
{
|
|
Activity = activityName,
|
|
Location = location,
|
|
AssignedToday = task.PlannedTask,
|
|
CompletedToday = task.CompletedTask,
|
|
Pending = pending,
|
|
Comment = task.Description,
|
|
Team = taskTeam
|
|
};
|
|
}).ToList();
|
|
|
|
// Attendance details
|
|
var performedAttendance = attendances.Select(att =>
|
|
{
|
|
var alloc = projectAllocations.FirstOrDefault(p => p.EmployeeId == att.EmployeeID);
|
|
var role = jobRoles.FirstOrDefault(r => r.Id == alloc?.JobRoleId);
|
|
string name = $"{alloc?.Employee?.FirstName ?? ""} {alloc?.Employee?.LastName ?? ""}";
|
|
|
|
return new PerformedAttendance
|
|
{
|
|
Name = name,
|
|
RoleName = role?.Name ?? "",
|
|
InTime = att.InTime ?? DateTime.UtcNow,
|
|
OutTime = att.OutTime,
|
|
Comment = att.Comment
|
|
};
|
|
}).ToList();
|
|
|
|
// Fill report
|
|
statisticReport.TodaysAttendances = checkedInEmployeeIds.Count;
|
|
statisticReport.TotalEmployees = assignedEmployeeIds.Count;
|
|
statisticReport.RegularizationPending = regularizationIds.Count;
|
|
statisticReport.CheckoutPending = checkoutPendingIds.Count;
|
|
statisticReport.TotalPlannedWork = totalPlannedWork;
|
|
statisticReport.TotalCompletedWork = totalCompletedWork;
|
|
statisticReport.TotalPlannedTask = totalPlannedTask;
|
|
statisticReport.TotalCompletedTask = totalCompletedTask;
|
|
statisticReport.CompletionStatus = totalPlannedWork > 0 ? totalCompletedWork / totalPlannedWork : 0;
|
|
statisticReport.TodaysAssignTasks = todayAssignedTasks.Count;
|
|
statisticReport.ReportPending = reportPending.Count;
|
|
statisticReport.TeamOnSite = teamOnSite;
|
|
statisticReport.PerformedTasks = performedTasks;
|
|
statisticReport.PerformedAttendance = performedAttendance;
|
|
return statisticReport;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|