admin/marco.pms.api
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Merge pull request 'ProjectDetails_Split_API' (#103) from ProjectDetails_Split_API into main

Browse Source 
Reviewed-on: #103
This commit is contained in:
Gitea Admin 2025-07-11 11:32:33 +00:00
commit 852b079428
33 changed files with 2195 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
Marco.Pms.CacheHelper/EmployeeCache.cs Normal file
View File

@ -0,0 +1,202 @@
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.MongoDBModels;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MongoDB.Driver;
namespace Marco.Pms.CacheHelper
{
public class EmployeeCache
{
private readonly ApplicationDbContext _context;
//private readonly IMongoDatabase _mongoDB;
private readonly IMongoCollection<EmployeePermissionMongoDB> _collection;
public EmployeeCache(ApplicationDbContext context, IConfiguration configuration)
{
var connectionString = configuration["MongoDB:ConnectionString"];
_context = context;
var mongoUrl = new MongoUrl(connectionString);
var client = new MongoClient(mongoUrl); // Your MongoDB connection string
var mongoDB = client.GetDatabase(mongoUrl.DatabaseName); // Your MongoDB Database name
_collection = mongoDB.GetCollection<EmployeePermissionMongoDB>("EmployeeProfile");
}
public async Task<bool> AddApplicationRoleToCache(Guid employeeId, List<Guid> roleIds)
{
// 1. Guard Clause: Avoid unnecessary database work if there are no roles to add.
if (roleIds == null || !roleIds.Any())
{
return false; // Nothing to add, so the operation did not result in a change.
}
// 2. Perform database queries concurrently for better performance.
var employeeIdString = employeeId.ToString();
Task<List<string>> getPermissionIdsTask = _context.RolePermissionMappings
.Where(rp => roleIds.Contains(rp.ApplicationRoleId))
.Select(p => p.FeaturePermissionId.ToString())
.Distinct()
.ToListAsync();
// 3. Prepare role IDs in parallel with the database query.
var newRoleIds = roleIds.Select(r => r.ToString()).ToList();
// 4. Await the database query result.
var newPermissionIds = await getPermissionIdsTask;
// 5. Build a single, efficient update operation.
var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeIdString);
var update = Builders<EmployeePermissionMongoDB>.Update
.AddToSetEach(e => e.ApplicationRoleIds, newRoleIds)
.AddToSetEach(e => e.PermissionIds, newPermissionIds);
var options = new UpdateOptions { IsUpsert = true };
var result = await _collection.UpdateOneAsync(filter, update, options);
// 6. Return a more accurate result indicating success for both updates and upserts.
// The operation is successful if an existing document was modified OR a new one was created.
return result.IsAcknowledged && (result.ModifiedCount > 0 || result.UpsertedId != null);
}
public async Task<bool> AddProjectsToCache(Guid employeeId, List<Guid> projectIds)
{
var newprojectIds = projectIds.Select(p => p.ToString()).ToList();
var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.AddToSetEach(e => e.ProjectIds, newprojectIds);
var result = await _collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
if (result.MatchedCount == 0)
{
return false;
}
return true;
}
public async Task<List<Guid>> GetProjectsFromCache(Guid employeeId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());
var result = await _collection
.Find(filter)
.FirstOrDefaultAsync();
var projectIds = new List<Guid>();
if (result != null)
{
projectIds = result.ProjectIds.Select(Guid.Parse).ToList();
}
return projectIds;
}
public async Task<List<Guid>> GetPermissionsFromCache(Guid employeeId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());
var result = await _collection
.Find(filter)
.FirstOrDefaultAsync();
var permissionIds = new List<Guid>();
if (result != null)
{
permissionIds = result.PermissionIds.Select(Guid.Parse).ToList();
}
return permissionIds;
}
public async Task<bool> ClearAllProjectIdsFromCache(Guid employeeId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter
.Eq(e => e.Id, employeeId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Set(e => e.ProjectIds, new List<string>());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
return true;
}
public async Task<bool> ClearAllProjectIdsByRoleIdFromCache(Guid roleId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.ApplicationRoleIds, roleId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Set(e => e.ProjectIds, new List<string>());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
return true;
}
public async Task<bool> ClearAllProjectIdsByPermissionIdFromCache(Guid permissionId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.PermissionIds, permissionId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Set(e => e.ProjectIds, new List<string>());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
return true;
}
public async Task<bool> RemoveRoleIdFromCache(Guid employeeId, Guid roleId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter
.Eq(e => e.Id, employeeId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Pull(e => e.ApplicationRoleIds, roleId.ToString());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
if (result.ModifiedCount == 0)
return false;
return true;
}
public async Task<bool> ClearAllPermissionIdsByEmployeeIDFromCache(Guid employeeId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter
.Eq(e => e.Id, employeeId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Set(e => e.PermissionIds, new List<string>());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
return true;
}
public async Task<bool> ClearAllPermissionIdsByRoleIdFromCache(Guid roleId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.ApplicationRoleIds, roleId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.Set(e => e.PermissionIds, new List<string>());
var result = await _collection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
return false;
return true;
}
}
}

18
Marco.Pms.CacheHelper/Marco.Pms.CacheHelper.csproj Normal file
View File

@ -0,0 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="MongoDB.Driver" Version="3.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Marco.Pms.DataAccess\Marco.Pms.DataAccess.csproj" />
<ProjectReference Include="..\Marco.Pms.Model\Marco.Pms.Model.csproj" />
</ItemGroup>
</Project>

629
Marco.Pms.CacheHelper/ProjectCache.cs Normal file
View File

@ -0,0 +1,629 @@
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Master;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Marco.Pms.CacheHelper
{
public class ProjectCache
{
private readonly ApplicationDbContext _context;
private readonly IMongoCollection<ProjectMongoDB> _projetCollection;
private readonly IMongoCollection<WorkItemMongoDB> _taskCollection;
public ProjectCache(ApplicationDbContext context, IConfiguration configuration)
{
var connectionString = configuration["MongoDB:ConnectionString"];
_context = context;
var mongoUrl = new MongoUrl(connectionString);
var client = new MongoClient(mongoUrl); // Your MongoDB connection string
var mongoDB = client.GetDatabase(mongoUrl.DatabaseName); // Your MongoDB Database name
_projetCollection = mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
_taskCollection = mongoDB.GetCollection<WorkItemMongoDB>("WorkItemDetails");
}
public async Task AddProjectDetailsToCache(Project project)
{
//_logger.LogInfo("[AddProjectDetails] Initiated for ProjectId: {ProjectId}", project.Id);
var projectDetails = new ProjectMongoDB
{
Id = project.Id.ToString(),
Name = project.Name,
ShortName = project.ShortName,
ProjectAddress = project.ProjectAddress,
StartDate = project.StartDate,
EndDate = project.EndDate,
ContactPerson = project.ContactPerson
};
// Get project status
var status = await _context.StatusMasters
.AsNoTracking()
.FirstOrDefaultAsync(s => s.Id == project.ProjectStatusId);
projectDetails.ProjectStatus = new StatusMasterMongoDB
{
Id = status?.Id.ToString(),
Status = status?.Status
};
// Get project team size
var teamSize = await _context.ProjectAllocations
.AsNoTracking()
.CountAsync(pa => pa.ProjectId == project.Id && pa.IsActive);
projectDetails.TeamSize = teamSize;
// Fetch related infrastructure in parallel
var buildings = await _context.Buildings
.AsNoTracking()
.Where(b => b.ProjectId == project.Id)
.ToListAsync();
var buildingIds = buildings.Select(b => b.Id).ToList();
var floors = await _context.Floor
.AsNoTracking()
.Where(f => buildingIds.Contains(f.BuildingId))
.ToListAsync();
var floorIds = floors.Select(f => f.Id).ToList();
var workAreas = await _context.WorkAreas
.AsNoTracking()
.Where(wa => floorIds.Contains(wa.FloorId))
.ToListAsync();
var workAreaIds = workAreas.Select(wa => wa.Id).ToList();
var workItems = await _context.WorkItems
.Where(wi => workAreaIds.Contains(wi.WorkAreaId))
.ToListAsync();
double totalPlannedWork = 0, totalCompletedWork = 0;
var buildingMongoList = new List<BuildingMongoDB>();
foreach (var building in buildings)
{
double buildingPlanned = 0, buildingCompleted = 0;
var buildingFloors = floors.Where(f => f.BuildingId == building.Id).ToList();
var floorMongoList = new List<FloorMongoDB>();
foreach (var floor in buildingFloors)
{
double floorPlanned = 0, floorCompleted = 0;
var floorWorkAreas = workAreas.Where(wa => wa.FloorId == floor.Id).ToList();
var workAreaMongoList = new List<WorkAreaMongoDB>();
foreach (var wa in floorWorkAreas)
{
var items = workItems.Where(wi => wi.WorkAreaId == wa.Id).ToList();
double waPlanned = items.Sum(wi => wi.PlannedWork);
double waCompleted = items.Sum(wi => wi.CompletedWork);
workAreaMongoList.Add(new WorkAreaMongoDB
{
Id = wa.Id.ToString(),
FloorId = wa.FloorId.ToString(),
AreaName = wa.AreaName,
PlannedWork = waPlanned,
CompletedWork = waCompleted
});
floorPlanned += waPlanned;
floorCompleted += waCompleted;
}
floorMongoList.Add(new FloorMongoDB
{
Id = floor.Id.ToString(),
BuildingId = floor.BuildingId.ToString(),
FloorName = floor.FloorName,
PlannedWork = floorPlanned,
CompletedWork = floorCompleted,
WorkAreas = workAreaMongoList
});
buildingPlanned += floorPlanned;
buildingCompleted += floorCompleted;
}
buildingMongoList.Add(new BuildingMongoDB
{
Id = building.Id.ToString(),
ProjectId = building.ProjectId.ToString(),
BuildingName = building.Name,
Description = building.Description,
PlannedWork = buildingPlanned,
CompletedWork = buildingCompleted,
Floors = floorMongoList
});
totalPlannedWork += buildingPlanned;
totalCompletedWork += buildingCompleted;
}
projectDetails.Buildings = buildingMongoList;
projectDetails.PlannedWork = totalPlannedWork;
projectDetails.CompletedWork = totalCompletedWork;
await _projetCollection.InsertOneAsync(projectDetails);
//_logger.LogInfo("[AddProjectDetails] Project details inserted in MongoDB for ProjectId: {ProjectId}", project.Id);
}
public async Task<bool> UpdateProjectDetailsOnlyToCache(Project project)
{
//_logger.LogInfo("Starting update for project: {ProjectId}", project.Id);
var projectStatus = await _context.StatusMasters
.FirstOrDefaultAsync(s => s.Id == project.ProjectStatusId);
if (projectStatus == null)
{
//_logger.LogWarning("StatusMaster not found for ProjectStatusId: {StatusId}", project.ProjectStatusId);
}
// Build the update definition
var updates = Builders<ProjectMongoDB>.Update.Combine(
Builders<ProjectMongoDB>.Update.Set(r => r.Name, project.Name),
Builders<ProjectMongoDB>.Update.Set(r => r.ProjectAddress, project.ProjectAddress),
Builders<ProjectMongoDB>.Update.Set(r => r.ShortName, project.ShortName),
Builders<ProjectMongoDB>.Update.Set(r => r.ProjectStatus, new StatusMasterMongoDB
{
Id = projectStatus?.Id.ToString(),
Status = projectStatus?.Status
}),
Builders<ProjectMongoDB>.Update.Set(r => r.StartDate, project.StartDate),
Builders<ProjectMongoDB>.Update.Set(r => r.EndDate, project.EndDate),
Builders<ProjectMongoDB>.Update.Set(r => r.ContactPerson, project.ContactPerson)
);
// Perform the update
var result = await _projetCollection.UpdateOneAsync(
filter: r => r.Id == project.Id.ToString(),
update: updates
);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("No project matched in MongoDB for update. ProjectId: {ProjectId}", project.Id);
return false;
}
//_logger.LogInfo("Project {ProjectId} successfully updated in MongoDB", project.Id);
return true;
}
public async Task<ProjectMongoDB?> GetProjectDetailsFromCache(Guid projectId)
{
// Build filter and projection to exclude large 'Buildings' list
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, projectId.ToString());
var projection = Builders<ProjectMongoDB>.Projection.Exclude(p => p.Buildings);
//_logger.LogInfo("Fetching project details for ProjectId: {ProjectId} from MongoDB", projectId);
// Perform query
var project = await _projetCollection
.Find(filter)
.Project<ProjectMongoDB>(projection)
.FirstOrDefaultAsync();
if (project == null)
{
//_logger.LogWarning("No project found in MongoDB for ProjectId: {ProjectId}", projectId);
return null;
}
//_logger.LogInfo("Successfully fetched project details (excluding Buildings) for ProjectId: {ProjectId}", projectId);
return project;
}
public async Task<List<ProjectMongoDB>?> GetProjectDetailsListFromCache(List<Guid> projectIds)
{
List<string> stringProjectIds = projectIds.Select(p => p.ToString()).ToList();
var filter = Builders<ProjectMongoDB>.Filter.In(p => p.Id, stringProjectIds);
var projection = Builders<ProjectMongoDB>.Projection.Exclude(p => p.Buildings);
var projects = await _projetCollection
.Find(filter)
.Project<ProjectMongoDB>(projection)
.ToListAsync();
return projects;
}
public async Task AddBuildngInfraToCache(Guid projectId, Building? building, Floor? floor, WorkArea? workArea, Guid? buildingId)
{
var stringProjectId = projectId.ToString();
// Add Building
if (building != null)
{
var buildingMongo = new BuildingMongoDB
{
Id = building.Id.ToString(),
BuildingName = building.Name,
Description = building.Description,
PlannedWork = 0,
CompletedWork = 0,
Floors = new List<FloorMongoDB>()
};
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId);
var update = Builders<ProjectMongoDB>.Update.Push("Buildings", buildingMongo);
var result = await _projetCollection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Project not found while adding building. ProjectId: {ProjectId}", projectId);
return;
}
//_logger.LogInfo("Building {BuildingId} added to project {ProjectId}", building.Id, projectId);
return;
}
// Add Floor
if (floor != null)
{
var floorMongo = new FloorMongoDB
{
Id = floor.Id.ToString(),
FloorName = floor.FloorName,
PlannedWork = 0,
CompletedWork = 0,
WorkAreas = new List<WorkAreaMongoDB>()
};
var filter = Builders<ProjectMongoDB>.Filter.And(
Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId),
Builders<ProjectMongoDB>.Filter.Eq("Buildings._id", floor.BuildingId.ToString())
);
var update = Builders<ProjectMongoDB>.Update.Push("Buildings.$.Floors", floorMongo);
var result = await _projetCollection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Project or building not found while adding floor. ProjectId: {ProjectId}, BuildingId: {BuildingId}", projectId, floor.BuildingId);
return;
}
//_logger.LogInfo("Floor {FloorId} added to building {BuildingId} in project {ProjectId}", floor.Id, floor.BuildingId, projectId);
return;
}
// Add WorkArea
if (workArea != null && buildingId != null)
{
var workAreaMongo = new WorkAreaMongoDB
{
Id = workArea.Id.ToString(),
AreaName = workArea.AreaName,
PlannedWork = 0,
CompletedWork = 0
};
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId);
var arrayFilters = new List<ArrayFilterDefinition>
{
new JsonArrayFilterDefinition<BsonDocument>("{ 'b._id': '" + buildingId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'f._id': '" + workArea.FloorId + "' }")
};
var update = Builders<ProjectMongoDB>.Update.Push("Buildings.$[b].Floors.$[f].WorkAreas", workAreaMongo);
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var result = await _projetCollection.UpdateOneAsync(filter, update, updateOptions);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Project or nested structure not found while adding work area. ProjectId: {ProjectId}, BuildingId: {BuildingId}, FloorId: {FloorId}", projectId, buildingId, workArea.FloorId);
return;
}
//_logger.LogInfo("WorkArea {WorkAreaId} added to floor {FloorId} in building {BuildingId}, ProjectId: {ProjectId}", workArea.Id, workArea.FloorId, buildingId, projectId);
return;
}
// Fallback case when no valid data was passed
//_logger.LogWarning("No valid infra data provided to add for ProjectId: {ProjectId}", projectId);
}
public async Task<bool> UpdateBuildngInfraToCache(Guid projectId, Building? building, Floor? floor, WorkArea? workArea, Guid? buildingId)
{
var stringProjectId = projectId.ToString();
// Update Building
if (building != null)
{
var filter = Builders<ProjectMongoDB>.Filter.And(
Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId),
Builders<ProjectMongoDB>.Filter.Eq("Buildings._id", building.Id.ToString())
);
var update = Builders<ProjectMongoDB>.Update.Combine(
Builders<ProjectMongoDB>.Update.Set("Buildings.$.BuildingName", building.Name),
Builders<ProjectMongoDB>.Update.Set("Buildings.$.Description", building.Description)
);
var result = await _projetCollection.UpdateOneAsync(filter, update);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Update failed: Project or Building not found. ProjectId: {ProjectId}, BuildingId: {BuildingId}", projectId, building.Id);
return false;
}
//_logger.LogInfo("Building {BuildingId} updated successfully in project {ProjectId}", building.Id, projectId);
return true;
}
// Update Floor
if (floor != null)
{
var arrayFilters = new List<ArrayFilterDefinition>
{
new JsonArrayFilterDefinition<BsonDocument>("{ 'b._id': '" + floor.BuildingId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'f._id': '" + floor.Id + "' }")
};
var update = Builders<ProjectMongoDB>.Update.Set("Buildings.$[b].Floors.$[f].FloorName", floor.FloorName);
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId);
var result = await _projetCollection.UpdateOneAsync(filter, update, updateOptions);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Update failed: Project or Floor not found. ProjectId: {ProjectId}, BuildingId: {BuildingId}, FloorId: {FloorId}", projectId, floor.BuildingId, floor.Id);
return false;
}
//_logger.LogInfo("Floor {FloorId} updated successfully in Building {BuildingId}, ProjectId: {ProjectId}", floor.Id, floor.BuildingId, projectId);
return true;
}
// Update WorkArea
if (workArea != null && buildingId != null)
{
var arrayFilters = new List<ArrayFilterDefinition>
{
new JsonArrayFilterDefinition<BsonDocument>("{ 'b._id': '" + buildingId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'f._id': '" + workArea.FloorId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'a._id': '" + workArea.Id + "' }")
};
var update = Builders<ProjectMongoDB>.Update.Set("Buildings.$[b].Floors.$[f].WorkAreas.$[a].AreaName", workArea.AreaName);
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, stringProjectId);
var result = await _projetCollection.UpdateOneAsync(filter, update, updateOptions);
if (result.MatchedCount == 0)
{
//_logger.LogWarning("Update failed: Project or WorkArea not found. ProjectId: {ProjectId}, BuildingId: {BuildingId}, FloorId: {FloorId}, WorkAreaId: {WorkAreaId}",
//projectId, buildingId, workArea.FloorId, workArea.Id);
return false;
}
//_logger.LogInfo("WorkArea {WorkAreaId} updated successfully in Floor {FloorId}, Building {BuildingId}, ProjectId: {ProjectId}",
//workArea.Id, workArea.FloorId, buildingId, projectId);
return true;
}
//_logger.LogWarning("No update performed. Missing or invalid data for ProjectId: {ProjectId}", projectId);
return false;
}
public async Task<List<BuildingMongoDB>?> GetBuildingInfraFromCache(Guid projectId)
{
// Filter by project ID
var filter = Builders<ProjectMongoDB>.Filter.Eq(p => p.Id, projectId.ToString());
// Project only the "Buildings" field from the document
var buildings = await _projetCollection
.Find(filter)
.Project(p => p.Buildings)
.FirstOrDefaultAsync();
//if (buildings == null)
//{
// _logger.LogWarning("No building infrastructure found for ProjectId: {ProjectId}", projectId);
//}
//else
//{
// _logger.LogInfo("Fetched {Count} buildings for ProjectId: {ProjectId}", buildings.Count, projectId);
//}
return buildings;
}
public async Task UpdatePlannedAndCompleteWorksInBuildingFromCache(Guid workAreaId, double plannedWork, double completedWork)
{
var filter = Builders<ProjectMongoDB>.Filter.Eq("Buildings.Floors.WorkAreas._id", workAreaId.ToString());
var project = await _projetCollection.Find(filter).FirstOrDefaultAsync();
string? selectedBuildingId = null;
string? selectedFloorId = null;
string? selectedWorkAreaId = null;
foreach (var building in project.Buildings)
{
foreach (var floor in building.Floors)
{
foreach (var area in floor.WorkAreas)
{
if (area.Id == workAreaId.ToString())
{
selectedWorkAreaId = area.Id;
selectedFloorId = floor.Id;
selectedBuildingId = building.Id;
}
}
}
}
var arrayFilters = new List<ArrayFilterDefinition>
{
new JsonArrayFilterDefinition<BsonDocument>("{ 'b._id': '" + selectedBuildingId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'f._id': '" + selectedFloorId + "' }"),
new JsonArrayFilterDefinition<BsonDocument>("{ 'a._id': '" + selectedWorkAreaId + "' }")
};
var updateOptions = new UpdateOptions { ArrayFilters = arrayFilters };
var update = Builders<ProjectMongoDB>.Update
.Inc("Buildings.$[b].Floors.$[f].WorkAreas.$[a].PlannedWork", plannedWork)
.Inc("Buildings.$[b].Floors.$[f].WorkAreas.$[a].CompletedWork", completedWork)
.Inc("Buildings.$[b].Floors.$[f].PlannedWork", plannedWork)
.Inc("Buildings.$[b].Floors.$[f].CompletedWork", completedWork)
.Inc("Buildings.$[b].PlannedWork", plannedWork)
.Inc("Buildings.$[b].CompletedWork", completedWork)
.Inc("PlannedWork", plannedWork)
.Inc("CompletedWork", completedWork);
var result = await _projetCollection.UpdateOneAsync(filter, update, updateOptions);
}
public async Task<WorkAreaInfoMongoDB?> GetBuildingAndFloorByWorkAreaIdFromCache(Guid workAreaId)
{
var pipeline = new[]
{
new BsonDocument("$unwind", "$Buildings"),
new BsonDocument("$unwind", "$Buildings.Floors"),
new BsonDocument("$unwind", "$Buildings.Floors.WorkAreas"),
new BsonDocument("$match", new BsonDocument("Buildings.Floors.WorkAreas._id", workAreaId.ToString())),
new BsonDocument("$project", new BsonDocument
{
{ "_id", 0 },
{ "ProjectId", "$_id" },
{ "ProjectName", "$Name" },
{ "PlannedWork", "$PlannedWork" },
{ "CompletedWork", "$CompletedWork" },
{
"Building", new BsonDocument
{
{ "_id", "$Buildings._id" },
{ "BuildingName", "$Buildings.BuildingName" },
{ "Description", "$Buildings.Description" },
{ "PlannedWork", "$Buildings.PlannedWork" },
{ "CompletedWork", "$Buildings.CompletedWork" }
}
},
{
"Floor", new BsonDocument
{
{ "_id", "$Buildings.Floors._id" },
{ "FloorName", "$Buildings.Floors.FloorName" },
{ "PlannedWork", "$Buildings.Floors.PlannedWork" },
{ "CompletedWork", "$Buildings.Floors.CompletedWork" }
}
},
{ "WorkArea", "$Buildings.Floors.WorkAreas" }
})
};
var result = await _projetCollection.Aggregate<WorkAreaInfoMongoDB>(pipeline).FirstOrDefaultAsync();
if (result == null)
return null;
return result;
}
public async Task<List<WorkItemMongoDB>> GetWorkItemsByWorkAreaIdsFromCache(List<Guid> workAreaIds)
{
var stringWorkAreaIds = workAreaIds.Select(wa => wa.ToString()).ToList();
var filter = Builders<WorkItemMongoDB>.Filter.In(w => w.WorkAreaId, stringWorkAreaIds);
var workItems = await _taskCollection // replace with your actual collection name
.Find(filter)
.ToListAsync();
return workItems;
}
// ------------------------------------------------------- WorkItem -------------------------------------------------------
public async Task ManageWorkItemDetailsToCache(List<WorkItem> workItems)
{
var activityIds = workItems.Select(wi => wi.ActivityId).ToList();
var workCategoryIds = workItems.Select(wi => wi.WorkCategoryId).ToList();
var workItemIds = workItems.Select(wi => wi.Id).ToList();
// fetching Activity master
var activities = await _context.ActivityMasters.Where(a => activityIds.Contains(a.Id)).ToListAsync() ?? new List<ActivityMaster>();
// Fetching Work Category
var workCategories = await _context.WorkCategoryMasters.Where(wc => workCategoryIds.Contains(wc.Id)).ToListAsync() ?? new List<WorkCategoryMaster>();
var task = await _context.TaskAllocations.Where(t => workItemIds.Contains(t.WorkItemId) && t.AssignmentDate == DateTime.UtcNow).ToListAsync();
var todaysAssign = task.Sum(t => t.PlannedTask);
foreach (WorkItem workItem in workItems)
{
var activity = activities.FirstOrDefault(a => a.Id == workItem.ActivityId) ?? new ActivityMaster();
var workCategory = workCategories.FirstOrDefault(a => a.Id == workItem.WorkCategoryId) ?? new WorkCategoryMaster();
var filter = Builders<WorkItemMongoDB>.Filter.Eq(p => p.Id, workItem.Id.ToString());
var updates = Builders<WorkItemMongoDB>.Update.Combine(
Builders<WorkItemMongoDB>.Update.Set(r => r.WorkAreaId, workItem.WorkAreaId.ToString()),
Builders<WorkItemMongoDB>.Update.Set(r => r.ParentTaskId, (workItem.ParentTaskId != null ? workItem.ParentTaskId.ToString() : null)),
Builders<WorkItemMongoDB>.Update.Set(r => r.PlannedWork, workItem.PlannedWork),
Builders<WorkItemMongoDB>.Update.Set(r => r.TodaysAssigned, todaysAssign),
Builders<WorkItemMongoDB>.Update.Set(r => r.CompletedWork, workItem.CompletedWork),
Builders<WorkItemMongoDB>.Update.Set(r => r.Description, workItem.Description),
Builders<WorkItemMongoDB>.Update.Set(r => r.TaskDate, workItem.TaskDate),
Builders<WorkItemMongoDB>.Update.Set(r => r.ExpireAt, DateTime.UtcNow.Date.AddDays(1)),
Builders<WorkItemMongoDB>.Update.Set(r => r.ActivityMaster, new ActivityMasterMongoDB
{
Id = activity.Id.ToString(),
ActivityName = activity.ActivityName,
UnitOfMeasurement = activity.UnitOfMeasurement
}),
Builders<WorkItemMongoDB>.Update.Set(r => r.WorkCategoryMaster, new WorkCategoryMasterMongoDB
{
Id = workCategory.Id.ToString(),
Name = workCategory.Name,
Description = workCategory.Description,
})
);
var options = new UpdateOptions { IsUpsert = true };
var result = await _taskCollection.UpdateOneAsync(filter, updates, options);
if (result.UpsertedId != null)
{
var indexKeys = Builders<WorkItemMongoDB>.IndexKeys.Ascending(x => x.ExpireAt);
var indexOptions = new CreateIndexOptions
{
ExpireAfter = TimeSpan.Zero // required for fixed expiration time
};
var indexModel = new CreateIndexModel<WorkItemMongoDB>(indexKeys, indexOptions);
await _taskCollection.Indexes.CreateOneAsync(indexModel);
}
}
}
public async Task<List<WorkItemMongoDB>> GetWorkItemDetailsByWorkAreaFromCache(Guid workAreaId)
{
var filter = Builders<WorkItemMongoDB>.Filter.Eq(p => p.WorkAreaId, workAreaId.ToString());
var options = new UpdateOptions { IsUpsert = true };
var workItems = await _taskCollection
.Find(filter)
.ToListAsync();
return workItems;
}
public async Task<WorkItemMongoDB> GetWorkItemDetailsByIdFromCache(Guid id)
{
var filter = Builders<WorkItemMongoDB>.Filter.Eq(p => p.Id, id.ToString());
var options = new UpdateOptions { IsUpsert = true };
var workItem = await _taskCollection
.Find(filter)
.FirstOrDefaultAsync();
return workItem;
}
public async Task<bool> UpdatePlannedAndCompleteWorksInWorkItemToCache(Guid id, double plannedWork, double completedWork, double todaysAssigned)
{
var filter = Builders<WorkItemMongoDB>.Filter.Eq(p => p.Id, id.ToString());
var updates = Builders<WorkItemMongoDB>.Update
.Inc("PlannedWork", plannedWork)
.Inc("CompletedWork", completedWork)
.Inc("TodaysAssigned", todaysAssigned);
var result = await _taskCollection.UpdateOneAsync(filter, updates);
if (result.ModifiedCount > 0)
{
return true;
}
return false;
}
}
}

1
Marco.Pms.Model/Marco.Pms.Model.csproj
View File

@ -10,6 +10,7 @@
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="7.0.20" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.ViewFeatures" Version="2.2.0" />
<PackageReference Include="MongoDB.Bson" Version="3.0.0" />
</ItemGroup>
<ItemGroup>

9
Marco.Pms.Model/MongoDBModels/ActivityMasterMongoDB.cs Normal file
View File

@ -0,0 +1,9 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class ActivityMasterMongoDB
{
public string Id { get; set; } = string.Empty;
public string? ActivityName { get; set; }
public string? UnitOfMeasurement { get; set; }
}
}

22
Marco.Pms.Model/MongoDBModels/BuildingMongoDB.cs Normal file
View File

@ -0,0 +1,22 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class BuildingMongoDB
{
public string Id { get; set; } = string.Empty;
public string? BuildingName { get; set; }
public string? Description { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
public string ProjectId { get; set; } = string.Empty;
public List<FloorMongoDB> Floors { get; set; } = new List<FloorMongoDB>();
}
public class BuildingMongoDBVM
{
public string Id { get; set; } = string.Empty;
public string? BuildingName { get; set; }
public string? Description { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
public string ProjectId { get; set; } = string.Empty;
}
}

13
Marco.Pms.Model/MongoDBModels/EmployeePermissionMongoDB.cs Normal file
View File

@ -0,0 +1,13 @@
using MongoDB.Bson.Serialization.Attributes;
namespace Marco.Pms.Model.MongoDBModels
{
[BsonIgnoreExtraElements]
public class EmployeePermissionMongoDB
{
public string Id { get; set; } = string.Empty; // Employee ID
public List<string> ApplicationRoleIds { get; set; } = new List<string>();
public List<string> PermissionIds { get; set; } = new List<string>();
public List<string> ProjectIds { get; set; } = new List<string>();
}
}

21
Marco.Pms.Model/MongoDBModels/FloorMongoDB.cs Normal file
View File

@ -0,0 +1,21 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class FloorMongoDB
{
public string Id { get; set; } = string.Empty;
public string BuildingId { get; set; } = string.Empty;
public string? FloorName { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
public List<WorkAreaMongoDB> WorkAreas { get; set; } = new List<WorkAreaMongoDB>();
}
public class FloorMongoDBVM
{
public string Id { get; set; } = string.Empty;
public string BuildingId { get; set; } = string.Empty;
public string? FloorName { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
}
}

18
Marco.Pms.Model/MongoDBModels/ProjectMongoDB.cs Normal file
View File

@ -0,0 +1,18 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class ProjectMongoDB
{
public string Id { get; set; } = string.Empty;
public string? Name { get; set; }
public string? ShortName { get; set; }
public string? ProjectAddress { get; set; }
public string? ContactPerson { get; set; }
public List<BuildingMongoDB> Buildings { get; set; } = new List<BuildingMongoDB>();
public DateTime? StartDate { get; set; }
public DateTime? EndDate { get; set; }
public StatusMasterMongoDB? ProjectStatus { get; set; }
public int TeamSize { get; set; }
public double CompletedWork { get; set; }
public double PlannedWork { get; set; }
}
}

8
Marco.Pms.Model/MongoDBModels/StatusMasterMongoDB.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class StatusMasterMongoDB
{
public string? Id { get; set; }
public string? Status { get; set; }
}
}

13
Marco.Pms.Model/MongoDBModels/WorkAreaInfoMongoDB.cs Normal file
View File

@ -0,0 +1,13 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkAreaInfoMongoDB
{
public string ProjectId { get; set; } = string.Empty;
public string? ProjectName { get; set; }
public BuildingMongoDBVM? Building { get; set; }
public FloorMongoDBVM? Floor { get; set; }
public WorkAreaMongoDB? WorkArea { get; set; }
public double CompletedWork { get; set; }
public double PlannedWork { get; set; }
}
}

16
Marco.Pms.Model/MongoDBModels/WorkAreaMongoDB.cs Normal file
View File

@ -0,0 +1,16 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkAreaMongoDB
{
public string Id { get; set; } = string.Empty;
public string FloorId { get; set; } = string.Empty;
public string? AreaName { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
}
public class WorkAreaMongoDBVM
{
public string Id { get; set; } = string.Empty;
public string? AreaName { get; set; }
}
}

9
Marco.Pms.Model/MongoDBModels/WorkCategoryMasterMongoDB.cs Normal file
View File

@ -0,0 +1,9 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkCategoryMasterMongoDB
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
}
}

17
Marco.Pms.Model/MongoDBModels/WorkItemMongoDB.cs Normal file
View File

@ -0,0 +1,17 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkItemMongoDB
{
public string Id { get; set; } = string.Empty;
public string WorkAreaId { get; set; } = string.Empty;
public ActivityMasterMongoDB? ActivityMaster { get; set; }
public WorkCategoryMasterMongoDB? WorkCategoryMaster { get; set; }
public string? ParentTaskId { get; set; } = null;
public double PlannedWork { get; set; } = 0;
public double TodaysAssigned { get; set; } = 0;
public double CompletedWork { get; set; } = 0;
public string? Description { get; set; }
public DateTime TaskDate { get; set; }
public DateTime ExpireAt { get; set; } = DateTime.UtcNow.Date.AddDays(1);
}
}

10
Marco.Pms.Model/ViewModels/Projects/OldProjectVM.cs Normal file
View File

@ -0,0 +1,10 @@
using Marco.Pms.Model.Dtos.Project;
namespace Marco.Pms.Model.ViewModels.Projects
{
public class OldProjectVM : ProjectDto
{
public List<BuildingVM>? Buildings { get; set; }
}
}

13
Marco.Pms.Model/ViewModels/Projects/ProjectVM.cs
View File

@ -1,10 +1,17 @@
using Marco.Pms.Model.Dtos.Project;
using Marco.Pms.Model.Master;
namespace Marco.Pms.Model.ViewModels.Projects
{
public class ProjectVM : ProjectDto
public class ProjectVM
{
public List<BuildingVM>? Buildings { get; set; }
public Guid Id { get; set; }
public string? Name { get; set; }
public string? ShortName { get; set; }
public string? ProjectAddress { get; set; }
public string? ContactPerson { get; set; }
public DateTime? StartDate { get; set; }
public DateTime? EndDate { get; set; }
public StatusMaster? ProjectStatus { get; set; }
}
}

454
Marco.Pms.Services/Controllers/ProjectController.cs
View File

@ -4,17 +4,22 @@ using Marco.Pms.Model.Dtos.Project;
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Master;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Employee;
using Marco.Pms.Model.ViewModels.Projects;
using Marco.Pms.Services.Helpers;
using Marco.Pms.Services.Hubs;
using Marco.Pms.Services.Service;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using MongoDB.Driver;
namespace MarcoBMS.Services.Controllers
{
@ -26,20 +31,36 @@ namespace MarcoBMS.Services.Controllers
private readonly ApplicationDbContext _context;
private readonly UserHelper _userHelper;
private readonly ILoggingService _logger;
private readonly RolesHelper _rolesHelper;
//private readonly RolesHelper _rolesHelper;
private readonly ProjectsHelper _projectsHelper;
private readonly IHubContext<MarcoHub> _signalR;
private readonly PermissionServices _permission;
private readonly CacheUpdateHelper _cache;
private readonly IServiceScopeFactory _serviceScopeFactory;
private readonly Guid ViewProjects;
private readonly Guid ManageProject;
private readonly Guid ViewInfra;
private readonly Guid ManageInfra;
private readonly Guid tenantId;
public ProjectController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger, RolesHelper rolesHelper, ProjectsHelper projectHelper, IHubContext<MarcoHub> signalR)
public ProjectController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger, RolesHelper rolesHelper, ProjectsHelper projectHelper,
IHubContext<MarcoHub> signalR, PermissionServices permission, CacheUpdateHelper cache, IServiceScopeFactory serviceScopeFactory)
{
_context = context;
_userHelper = userHelper;
_logger = logger;
_rolesHelper = rolesHelper;
//_rolesHelper = rolesHelper;
_projectsHelper = projectHelper;
_signalR = signalR;
_cache = cache;
_permission = permission;
ViewProjects = Guid.Parse("6ea44136-987e-44ba-9e5d-1cf8f5837ebc");
ManageProject = Guid.Parse("172fc9b6-755b-4f62-ab26-55c34a330614");
ViewInfra = Guid.Parse("8d7cc6e3-9147-41f7-aaa7-fa507e450bd4");
ManageInfra = Guid.Parse("f2aee20a-b754-4537-8166-f9507b44585b");
tenantId = _userHelper.GetTenantId();
_serviceScopeFactory = serviceScopeFactory;
}
[HttpGet("list/basic")]
@ -176,6 +197,107 @@ namespace MarcoBMS.Services.Controllers
[HttpGet("details/{id}")]
public async Task<IActionResult> Details([FromRoute] Guid id)
{
// Step 1: Validate model state
if (!ModelState.IsValid)
{
var errors = ModelState.Values
.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage)
.ToList();
_logger.LogWarning("Invalid model state in Details endpoint. Errors: {@Errors}", errors);
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
}
// Step 2: Get logged-in employee
var loggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
_logger.LogInfo("Details requested by EmployeeId: {EmployeeId} for ProjectId: {ProjectId}", loggedInEmployee.Id, id);
// Step 3: Check global view project permission
var hasViewProjectPermission = await _permission.HasPermission(ViewProjects, loggedInEmployee.Id);
if (!hasViewProjectPermission)
{
_logger.LogWarning("ViewProjects permission denied for EmployeeId: {EmployeeId}", loggedInEmployee.Id);
return StatusCode(403, ApiResponse<object>.ErrorResponse("Access denied", "You don't have permission to view projects", 403));
}
// Step 4: Check permission for this specific project
var hasProjectPermission = await _permission.HasProjectPermission(loggedInEmployee, id.ToString());
if (!hasProjectPermission)
{
_logger.LogWarning("Project-specific access denied. EmployeeId: {EmployeeId}, ProjectId: {ProjectId}", loggedInEmployee.Id, id);
return StatusCode(403, ApiResponse<object>.ErrorResponse("Access denied", "You don't have access to this project", 403));
}
// Step 5: Fetch project with status
var projectDetails = await _cache.GetProjectDetails(id);
ProjectVM? projectVM = null;
if (projectDetails == null)
{
var project = await _context.Projects
.Include(c => c.ProjectStatus)
.FirstOrDefaultAsync(c => c.TenantId == tenantId && c.Id == id);
projectVM = GetProjectViewModel(project);
if (project != null)
{
await _cache.AddProjectDetails(project);
}
}
else
{
projectVM = new ProjectVM
{
Id = projectDetails.Id != null ? Guid.Parse(projectDetails.Id) : Guid.Empty,
Name = projectDetails.Name,
ShortName = projectDetails.ShortName,
ProjectAddress = projectDetails.ProjectAddress,
StartDate = projectDetails.StartDate,
EndDate = projectDetails.EndDate,
ContactPerson = projectDetails.ContactPerson,
ProjectStatus = new StatusMaster
{
Id = projectDetails.ProjectStatus?.Id != null ? Guid.Parse(projectDetails.ProjectStatus.Id) : Guid.Empty,
Status = projectDetails.ProjectStatus?.Status,
TenantId = tenantId
}
//ProjectStatusId = projectDetails.ProjectStatus?.Id != null ? Guid.Parse(projectDetails.ProjectStatus.Id) : Guid.Empty,
};
}
if (projectVM == null)
{
_logger.LogWarning("Project not found. ProjectId: {ProjectId}", id);
return NotFound(ApiResponse<object>.ErrorResponse("Project not found", "Project not found", 404));
}
// Step 6: Return result
_logger.LogInfo("Project details fetched successfully. ProjectId: {ProjectId}", id);
return Ok(ApiResponse<object>.SuccessResponse(projectVM, "Project details fetched successfully", 200));
}
private ProjectVM? GetProjectViewModel(Project? project)
{
if (project == null)
{
return null;
}
return new ProjectVM
{
Id = project.Id,
Name = project.Name,
ShortName = project.ShortName,
StartDate = project.StartDate,
EndDate = project.EndDate,
ProjectStatus = project.ProjectStatus,
ContactPerson = project.ContactPerson,
ProjectAddress = project.ProjectAddress,
};
}
[HttpGet("details-old/{id}")]
public async Task<IActionResult> DetailsOld([FromRoute] Guid id)
{
// ProjectDetailsVM vm = new ProjectDetailsVM();
@ -201,7 +323,7 @@ namespace MarcoBMS.Services.Controllers
//var project = projects.Where(c => c.Id == id).SingleOrDefault();
ProjectDetailsVM vm = await GetProjectViewModel(id, project);
ProjectVM projectVM = new ProjectVM();
OldProjectVM projectVM = new OldProjectVM();
if (vm.project != null)
{
projectVM.Id = vm.project.Id;
@ -316,28 +438,56 @@ namespace MarcoBMS.Services.Controllers
[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateProjectDto projectDto)
{
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
// 1. Validate input first (early exit)
if (!ModelState.IsValid)
{
var errors = ModelState.Values
.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage)
.ToList();
var errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage).ToList();
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
}
Guid TenantId = GetTenantId();
var project = projectDto.ToProjectFromCreateProjectDto(TenantId);
// 2. Prepare data without I/O
Guid tenantId = _userHelper.GetTenantId(); // Assuming this is fast and from claims
Employee loggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
var loggedInUserId = loggedInEmployee.Id;
var project = projectDto.ToProjectFromCreateProjectDto(tenantId);
_context.Projects.Add(project);
// 3. Store it to database
try
{
_context.Projects.Add(project);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
// Log the detailed exception
_logger.LogError("Failed to create project in database. Rolling back transaction. : {Error}", ex.Message);
// Return a server error as the primary operation failed
return StatusCode(500, ApiResponse<object>.ErrorResponse("An error occurred while saving the project.", ex.Message, 500));
}
await _context.SaveChangesAsync();
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Create_Project", Response = project.ToProjectDto() };
// 4. Perform non-critical side-effects (caching, notifications) concurrently
try
{
// These operations do not depend on each other, so they can run in parallel.
Task cacheAddDetailsTask = _cache.AddProjectDetails(project);
Task cacheClearListTask = _cache.ClearAllProjectIdsByPermissionId(ManageProject);
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);
var notification = new { LoggedInUserId = loggedInUserId, Keyword = "Create_Project", Response = project.ToProjectDto() };
// Send notification only to the relevant group (e.g., users in the same tenant)
Task notificationTask = _signalR.Clients.Group(tenantId.ToString()).SendAsync("NotificationEventHandler", notification);
return Ok(ApiResponse<object>.SuccessResponse(project.ToProjectDto(), "Success.", 200));
// Await all side-effect tasks to complete in parallel
await Task.WhenAll(cacheAddDetailsTask, cacheClearListTask, notificationTask);
}
catch (Exception ex)
{
// The project was created successfully, but a side-effect failed.
// Log this as a warning, as the primary operation succeeded. Don't return an error to the user.
_logger.LogWarning("Project {ProjectId} was created, but a post-creation side-effect (caching/notification) failed. : {Error}", project.Id, ex.Message);
}
// 5. Return a success response to the user as soon as the critical data is saved.
return Ok(ApiResponse<object>.SuccessResponse(project.ToProjectDto(), "Project created successfully.", 200));
}
[HttpPut]
@ -363,6 +513,13 @@ namespace MarcoBMS.Services.Controllers
await _context.SaveChangesAsync();
// Cache functions
bool isUpdated = await _cache.UpdateProjectDetailsOnly(project);
if (!isUpdated)
{
await _cache.AddProjectDetails(project);
}
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Update_Project", Response = project.ToProjectDto() };
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);
@ -577,6 +734,7 @@ namespace MarcoBMS.Services.Controllers
employeeIds.Add(projectAllocation.EmployeeId);
projectIds.Add(projectAllocation.ProjectId);
}
await _cache.ClearAllProjectIds(item.EmpID);
}
catch (Exception ex)
@ -594,6 +752,194 @@ namespace MarcoBMS.Services.Controllers
}
[HttpGet("infra-details/{projectId}")]
public async Task<IActionResult> GetInfraDetails(Guid projectId)
{
_logger.LogInfo("GetInfraDetails called for ProjectId: {ProjectId}", projectId);
// Step 1: Get logged-in employee
var loggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
// Step 2: Check project-specific permission
var hasProjectPermission = await _permission.HasProjectPermission(loggedInEmployee, projectId.ToString());
if (!hasProjectPermission)
{
_logger.LogWarning("Project access denied for EmployeeId: {EmployeeId} on ProjectId: {ProjectId}", loggedInEmployee.Id, projectId);
return StatusCode(403, ApiResponse<object>.ErrorResponse("Access denied", "You don't have access to this project", 403));
}
// Step 3: Check 'ViewInfra' permission
var hasViewInfraPermission = await _permission.HasPermission(ViewInfra, loggedInEmployee.Id);
if (!hasViewInfraPermission)
{
_logger.LogWarning("ViewInfra permission denied for EmployeeId: {EmployeeId}", loggedInEmployee.Id);
return StatusCode(403, ApiResponse<object>.ErrorResponse("Access denied", "You don't have access to view infra", 403));
}
var result = await _cache.GetBuildingInfra(projectId);
if (result == null)
{
// Step 4: Fetch buildings for the project
var buildings = await _context.Buildings
.Where(b => b.ProjectId == projectId)
.ToListAsync();
var buildingIds = buildings.Select(b => b.Id).ToList();
// Step 5: Fetch floors associated with the buildings
var floors = await _context.Floor
.Where(f => buildingIds.Contains(f.BuildingId))
.ToListAsync();
var floorIds = floors.Select(f => f.Id).ToList();
// Step 6: Fetch work areas associated with the floors
var workAreas = await _context.WorkAreas
.Where(wa => floorIds.Contains(wa.FloorId))
.ToListAsync();
var workAreaIds = workAreas.Select(wa => wa.Id).ToList();
// Step 7: Fetch work items associated with the work area
var workItems = await _context.WorkItems
.Where(wi => workAreaIds.Contains(wi.WorkAreaId))
.ToListAsync();
// Step 8: Build the infra hierarchy (Building > Floors > Work Areas)
List<BuildingMongoDB> Buildings = new List<BuildingMongoDB>();
foreach (var building in buildings)
{
double buildingPlannedWorks = 0;
double buildingCompletedWorks = 0;
var selectedFloors = floors.Where(f => f.BuildingId == building.Id).ToList();
List<FloorMongoDB> Floors = new List<FloorMongoDB>();
foreach (var floor in selectedFloors)
{
double floorPlannedWorks = 0;
double floorCompletedWorks = 0;
var selectedWorkAreas = workAreas.Where(wa => wa.FloorId == floor.Id).ToList();
List<WorkAreaMongoDB> WorkAreas = new List<WorkAreaMongoDB>();
foreach (var workArea in selectedWorkAreas)
{
double workAreaPlannedWorks = 0;
double workAreaCompletedWorks = 0;
var selectedWorkItems = workItems.Where(wi => wi.WorkAreaId == workArea.Id).ToList();
foreach (var workItem in selectedWorkItems)
{
workAreaPlannedWorks += workItem.PlannedWork;
workAreaCompletedWorks += workItem.CompletedWork;
}
WorkAreaMongoDB workAreaMongo = new WorkAreaMongoDB
{
Id = workArea.Id.ToString(),
AreaName = workArea.AreaName,
PlannedWork = workAreaPlannedWorks,
CompletedWork = workAreaCompletedWorks
};
WorkAreas.Add(workAreaMongo);
floorPlannedWorks += workAreaPlannedWorks;
floorCompletedWorks += workAreaCompletedWorks;
}
FloorMongoDB floorMongoDB = new FloorMongoDB
{
Id = floor.Id.ToString(),
FloorName = floor.FloorName,
PlannedWork = floorPlannedWorks,
CompletedWork = floorCompletedWorks,
WorkAreas = WorkAreas
};
Floors.Add(floorMongoDB);
buildingPlannedWorks += floorPlannedWorks;
buildingCompletedWorks += floorCompletedWorks;
}
var buildingMongo = new BuildingMongoDB
{
Id = building.Id.ToString(),
BuildingName = building.Name,
Description = building.Description,
PlannedWork = buildingPlannedWorks,
CompletedWork = buildingCompletedWorks,
Floors = Floors
};
Buildings.Add(buildingMongo);
}
result = Buildings;
}
_logger.LogInfo("Infra details fetched successfully for ProjectId: {ProjectId}, EmployeeId: {EmployeeId}, Buildings: {Count}",
projectId, loggedInEmployee.Id, result.Count);
return Ok(ApiResponse<object>.SuccessResponse(result, "Infra details fetched successfully", 200));
}
[HttpGet("tasks/{workAreaId}")]
public async Task<IActionResult> GetWorkItems(Guid workAreaId)
{
_logger.LogInfo("GetWorkItems called for WorkAreaId: {WorkAreaId}", workAreaId);
// Step 1: Get the currently logged-in employee
var loggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
// Step 2: Check if the employee has ViewInfra permission
var hasViewInfraPermission = await _permission.HasPermission(ViewInfra, loggedInEmployee.Id);
if (!hasViewInfraPermission)
{
_logger.LogWarning("ViewInfra permission denied for EmployeeId: {EmployeeId}", loggedInEmployee.Id);
return StatusCode(403, ApiResponse<object>.ErrorResponse("Access denied", "You don't have permission to view infrastructure", 403));
}
// Step 3: Check if the specified Work Area exists
var isWorkAreaExist = await _context.WorkAreas.AnyAsync(wa => wa.Id == workAreaId);
if (!isWorkAreaExist)
{
_logger.LogWarning("Work Area not found for WorkAreaId: {WorkAreaId}", workAreaId);
return NotFound(ApiResponse<object>.ErrorResponse("Work Area not found", "Work Area not found in database", 404));
}
// Step 4: Fetch WorkItems with related Activity and Work Category data
var workItemVMs = await _cache.GetWorkItemDetailsByWorkArea(workAreaId);
if (workItemVMs == null)
{
var workItems = await _context.WorkItems
.Include(wi => wi.ActivityMaster)
.Include(wi => wi.WorkCategoryMaster)
.Where(wi => wi.WorkAreaId == workAreaId)
.ToListAsync();
workItemVMs = workItems.Select(wi => new WorkItemMongoDB
{
Id = wi.Id.ToString(),
WorkAreaId = wi.WorkAreaId.ToString(),
ParentTaskId = wi.ParentTaskId.ToString(),
ActivityMaster = new ActivityMasterMongoDB
{
Id = wi.ActivityId.ToString(),
ActivityName = wi.ActivityMaster != null ? wi.ActivityMaster.ActivityName : null,
UnitOfMeasurement = wi.ActivityMaster != null ? wi.ActivityMaster.UnitOfMeasurement : null
},
WorkCategoryMaster = new WorkCategoryMasterMongoDB
{
Id = wi.WorkCategoryId.ToString() ?? "",
Name = wi.WorkCategoryMaster != null ? wi.WorkCategoryMaster.Name : "",
Description = wi.WorkCategoryMaster != null ? wi.WorkCategoryMaster.Description : ""
},
PlannedWork = wi.PlannedWork,
CompletedWork = wi.CompletedWork,
Description = wi.Description,
TaskDate = wi.TaskDate,
}).ToList();
await _cache.ManageWorkItemDetails(workItems);
}
_logger.LogInfo("{Count} work items fetched successfully for WorkAreaId: {WorkAreaId}", workItemVMs.Count, workAreaId);
// Step 5: Return result
return Ok(ApiResponse<object>.SuccessResponse(workItemVMs, $"{workItemVMs.Count} records of tasks fetched successfully", 200));
}
[HttpPost("task")]
public async Task<IActionResult> CreateProjectTask(List<WorkItemDot> workItemDtos)
{
@ -612,7 +958,9 @@ namespace MarcoBMS.Services.Controllers
var responseList = new List<WorkItemVM>();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
string message = "";
List<Guid> projectIds = new List<Guid>();
List<Guid> workAreaIds = new List<Guid>();
var workItemIds = workItemDtos.Where(wi => wi.Id != null && wi.Id != Guid.Empty).Select(wi => wi.Id).ToList();
var workItems = await _context.WorkItems.AsNoTracking().Where(wi => workItemIds.Contains(wi.Id)).ToListAsync();
foreach (var itemDto in workItemDtos)
{
@ -626,6 +974,28 @@ namespace MarcoBMS.Services.Controllers
// Update existing
workItemsToUpdate.Add(workItem);
message = $"Task Updated in Building: {building.Name}, on Floor: {workArea.Floor?.FloorName}, in Area: {workArea.AreaName} by {LoggedInEmployee.FirstName} {LoggedInEmployee.LastName}";
var existingWorkItem = workItems.FirstOrDefault(wi => wi.Id == workItem.Id);
double plannedWork = 0;
double completedWork = 0;
if (existingWorkItem != null)
{
if (existingWorkItem.PlannedWork != workItem.PlannedWork && existingWorkItem.CompletedWork != workItem.CompletedWork)
{
plannedWork = workItem.PlannedWork - existingWorkItem.PlannedWork;
completedWork = workItem.CompletedWork - existingWorkItem.CompletedWork;
}
else if (existingWorkItem.PlannedWork == workItem.PlannedWork && existingWorkItem.CompletedWork != workItem.CompletedWork)
{
plannedWork = 0;
completedWork = workItem.CompletedWork - existingWorkItem.CompletedWork;
}
else if (existingWorkItem.PlannedWork != workItem.PlannedWork && existingWorkItem.CompletedWork == workItem.CompletedWork)
{
plannedWork = workItem.PlannedWork - existingWorkItem.PlannedWork;
completedWork = 0;
}
await _cache.UpdatePlannedAndCompleteWorksInBuilding(workArea.Id, plannedWork, completedWork);
}
}
else
{
@ -633,6 +1003,7 @@ namespace MarcoBMS.Services.Controllers
workItem.Id = Guid.NewGuid();
workItemsToCreate.Add(workItem);
message = $"Task Added in Building: {building.Name}, on Floor: {workArea.Floor?.FloorName}, in Area: {workArea.AreaName} by {LoggedInEmployee.FirstName} {LoggedInEmployee.LastName}";
await _cache.UpdatePlannedAndCompleteWorksInBuilding(workArea.Id, workItem.PlannedWork, workItem.CompletedWork);
}
responseList.Add(new WorkItemVM
@ -640,7 +1011,8 @@ namespace MarcoBMS.Services.Controllers
WorkItemId = workItem.Id,
WorkItem = workItem
});
projectIds.Add(building.ProjectId);
workAreaIds.Add(workItem.WorkAreaId);
}
string responseMessage = "";
// Apply DB changes
@ -649,7 +1021,7 @@ namespace MarcoBMS.Services.Controllers
_logger.LogInfo("Adding {Count} new work items", workItemsToCreate.Count);
await _context.WorkItems.AddRangeAsync(workItemsToCreate);
responseMessage = "Task Added Successfully";
await _cache.ManageWorkItemDetails(workItemsToCreate);
}
if (workItemsToUpdate.Any())
@ -657,7 +1029,7 @@ namespace MarcoBMS.Services.Controllers
_logger.LogInfo("Updating {Count} existing work items", workItemsToUpdate.Count);
_context.WorkItems.UpdateRange(workItemsToUpdate);
responseMessage = "Task Updated Successfully";
await _cache.ManageWorkItemDetails(workItemsToUpdate);
}
await _context.SaveChangesAsync();
@ -666,7 +1038,7 @@ namespace MarcoBMS.Services.Controllers
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Infra", ProjectIds = projectIds, Message = message };
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "WorkItem", WorkAreaIds = workAreaIds, Message = message };
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);
@ -678,7 +1050,7 @@ namespace MarcoBMS.Services.Controllers
{
Guid tenantId = _userHelper.GetTenantId();
var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
List<Guid> projectIds = new List<Guid>();
List<Guid> workAreaIds = new List<Guid>();
WorkItem? task = await _context.WorkItems.AsNoTracking().Include(t => t.WorkArea).FirstOrDefaultAsync(t => t.Id == id && t.TenantId == tenantId);
if (task != null)
{
@ -695,9 +1067,9 @@ namespace MarcoBMS.Services.Controllers
var floor = await _context.Floor.Include(f => f.Building).FirstOrDefaultAsync(f => f.Id == floorId);
projectIds.Add(floor?.Building?.ProjectId ?? Guid.Empty);
workAreaIds.Add(task.WorkAreaId);
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Infra", ProjectIds = projectIds, Message = $"Task Deleted in Building: {floor?.Building?.Name}, on Floor: {floor?.FloorName}, in Area: {task.WorkArea?.AreaName} by {LoggedInEmployee.FirstName} {LoggedInEmployee.LastName}" };
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "WorkItem", WorkAreaIds = workAreaIds, Message = $"Task Deleted in Building: {floor?.Building?.Name}, on Floor: {floor?.FloorName}, in Area: {task.WorkArea?.AreaName} by {LoggedInEmployee.FirstName} {LoggedInEmployee.LastName}" };
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);
}
else
@ -750,6 +1122,7 @@ namespace MarcoBMS.Services.Controllers
responseData.building = building;
responseMessage = "Buliding Added Successfully";
message = "Building Added";
await _cache.AddBuildngInfra(building.ProjectId, building);
}
else
{
@ -759,7 +1132,7 @@ namespace MarcoBMS.Services.Controllers
responseData.building = building;
responseMessage = "Buliding Updated Successfully";
message = "Building Updated";
await _cache.UpdateBuildngInfra(building.ProjectId, building);
}
projectIds.Add(building.ProjectId);
}
@ -767,6 +1140,7 @@ namespace MarcoBMS.Services.Controllers
{
Floor floor = item.Floor.ToFloorFromFloorDto(tenantId);
floor.TenantId = GetTenantId();
bool isCreated = false;
if (item.Floor.Id == null)
{
@ -776,6 +1150,7 @@ namespace MarcoBMS.Services.Controllers
responseData.floor = floor;
responseMessage = "Floor Added Successfully";
message = "Floor Added";
isCreated = true;
}
else
{
@ -787,13 +1162,23 @@ namespace MarcoBMS.Services.Controllers
message = "Floor Updated";
}
Building? building = await _context.Buildings.FirstOrDefaultAsync(b => b.Id == floor.BuildingId);
projectIds.Add(building?.ProjectId ?? Guid.Empty);
var projectId = building?.ProjectId ?? Guid.Empty;
projectIds.Add(projectId);
message = $"{message} in Building: {building?.Name}";
if (isCreated)
{
await _cache.AddBuildngInfra(projectId, floor: floor);
}
else
{
await _cache.UpdateBuildngInfra(projectId, floor: floor);
}
}
if (item.WorkArea != null)
{
WorkArea workArea = item.WorkArea.ToWorkAreaFromWorkAreaDto(tenantId);
workArea.TenantId = GetTenantId();
bool isCreated = false;
if (item.WorkArea.Id == null)
{
@ -803,6 +1188,7 @@ namespace MarcoBMS.Services.Controllers
responseData.workArea = workArea;
responseMessage = "Work Area Added Successfully";
message = "Work Area Added";
isCreated = true;
}
else
{
@ -814,8 +1200,17 @@ namespace MarcoBMS.Services.Controllers
message = "Work Area Updated";
}
Floor? floor = await _context.Floor.Include(f => f.Building).FirstOrDefaultAsync(f => f.Id == workArea.FloorId);
projectIds.Add(floor?.Building?.ProjectId ?? Guid.Empty);
var projectId = floor?.Building?.ProjectId ?? Guid.Empty;
projectIds.Add(projectId);
message = $"{message} in Building: {floor?.Building?.Name}, on Floor: {floor?.FloorName}";
if (isCreated)
{
await _cache.AddBuildngInfra(projectId, workArea: workArea, buildingId: floor?.BuildingId);
}
else
{
await _cache.UpdateBuildngInfra(projectId, workArea: workArea, buildingId: floor?.BuildingId);
}
}
}
message = $"{message} by {LoggedInEmployee.FirstName} {LoggedInEmployee.LastName}";
@ -939,6 +1334,7 @@ namespace MarcoBMS.Services.Controllers
return Ok(ApiResponse<object>.ErrorResponse(ex.Message, ex, 400));
}
}
await _cache.ClearAllProjectIds(employeeId);
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Assign_Project", ProjectIds = projectIds, EmployeeId = employeeId };
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);

161
Marco.Pms.Services/Controllers/ReportController.cs
View File

@ -1,12 +1,10 @@
using System.Data;
using System.Globalization;
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Dtos.Attendance;
using Marco.Pms.Model.Dtos.Mail;
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Mail;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Report;
using Marco.Pms.Services.Helpers;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
@ -26,13 +24,15 @@ namespace Marco.Pms.Services.Controllers
private readonly ILoggingService _logger;
private readonly UserHelper _userHelper;
private readonly IWebHostEnvironment _env;
public ReportController(ApplicationDbContext context, IEmailSender emailSender, ILoggingService logger, UserHelper userHelper, IWebHostEnvironment env)
private readonly ReportHelper _reportHelper;
public ReportController(ApplicationDbContext context, IEmailSender emailSender, ILoggingService logger, UserHelper userHelper, IWebHostEnvironment env, ReportHelper reportHelper)
{
_context = context;
_emailSender = emailSender;
_logger = logger;
_userHelper = userHelper;
_env = env;
_reportHelper = reportHelper;
}
[HttpPost("set-mail")]
@ -151,7 +151,6 @@ namespace Marco.Pms.Services.Controllers
/// <returns>An ApiResponse indicating the success or failure of retrieving statistics and sending the email.</returns>
private async Task<ApiResponse<object>> GetProjectStatistics(Guid projectId, List<string> recipientEmails, string body, string subject, Guid tenantId)
{
DateTime reportDate = DateTime.UtcNow.AddDays(-1).Date;
if (projectId == Guid.Empty)
{
@ -159,161 +158,15 @@ namespace Marco.Pms.Services.Controllers
return ApiResponse<object>.ErrorResponse("Provided empty Project ID.", "Provided empty Project ID.", 400);
}
var project = await _context.Projects
.AsNoTracking()
.FirstOrDefaultAsync(p => p.Id == projectId);
if (project == null)
var statisticReport = await _reportHelper.GetDailyProjectReport(projectId, tenantId);
if (statisticReport == null)
{
_logger.LogWarning("User attempted to fetch project progress for project ID {ProjectId} but not found.", projectId);
return ApiResponse<object>.ErrorResponse("Project not found.", "Project not found.", 404);
}
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 == project.Id && p.IsActive)
.ToListAsync();
var assignedEmployeeIds = projectAllocations.Select(p => p.EmployeeId).ToHashSet();
var attendances = await _context.Attendes
.AsNoTracking()
.Where(a => a.ProjectID == project.Id && 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
var buildings = await _context.Buildings.Where(b => b.ProjectId == project.Id).ToListAsync();
var buildingIds = buildings.Select(b => b.Id).ToList();
var floors = await _context.Floor.Where(f => buildingIds.Contains(f.BuildingId)).ToListAsync();
var floorIds = floors.Select(f => f.Id).ToList();
var areas = await _context.WorkAreas.Where(a => floorIds.Contains(a.FloorId)).ToListAsync();
var areaIds = areas.Select(a => a.Id).ToList();
var workItems = await _context.WorkItems
.Include(w => w.ActivityMaster)
.Where(w => areaIds.Contains(w.WorkAreaId))
.ToListAsync();
var itemIds = workItems.Select(i => 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 jobRoles = await _context.JobRoles
.Where(j => j.TenantId == project.TenantId)
.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);
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?.Name} > {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;
// Send Email
var emailBody = await _emailSender.SendProjectStatisticsEmail(recipientEmails, body, subject, statisticReport);
var employee = await _context.Employees.FirstOrDefaultAsync(e => e.Email != null && recipientEmails.Contains(e.Email)) ?? new Employee();

16
Marco.Pms.Services/Controllers/RolesController.cs
View File

@ -10,6 +10,7 @@ using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels;
using Marco.Pms.Model.ViewModels.Master;
using Marco.Pms.Model.ViewModels.Roles;
using Marco.Pms.Services.Helpers;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
@ -29,14 +30,17 @@ namespace MarcoBMS.Services.Controllers
private readonly UserHelper _userHelper;
private readonly UserManager<ApplicationUser> _userManager;
private readonly ILoggingService _logger;
private readonly CacheUpdateHelper _cache;
public RolesController(UserManager<ApplicationUser> userManager, ApplicationDbContext context, RolesHelper rolesHelper, UserHelper userHelper, ILoggingService logger)
public RolesController(UserManager<ApplicationUser> userManager, ApplicationDbContext context, RolesHelper rolesHelper, UserHelper userHelper, ILoggingService logger,
CacheUpdateHelper cache)
{
_context = context;
_userManager = userManager;
_rolesHelper = rolesHelper;
_userHelper = userHelper;
_logger = logger;
_cache = cache;
}
private Guid GetTenantId()
@ -288,10 +292,16 @@ namespace MarcoBMS.Services.Controllers
_context.RolePermissionMappings.Add(item);
modified = true;
}
if (item.FeaturePermissionId == Guid.Parse("172fc9b6-755b-4f62-ab26-55c34a330614"))
{
await _cache.ClearAllProjectIdsByRoleId(id);
}
}
if (modified)
await _context.SaveChangesAsync();
await _cache.ClearAllPermissionIdsByRoleId(id);
ApplicationRolesVM response = role.ToRoleVMFromApplicationRole();
List<FeaturePermission> permissions = await _rolesHelper.GetFeaturePermissionByRoleID(response.Id);
response.FeaturePermission = permissions.Select(c => c.ToFeaturePermissionVMFromFeaturePermission()).ToList();
@ -424,12 +434,16 @@ namespace MarcoBMS.Services.Controllers
if (role.IsEnabled == true)
{
_context.EmployeeRoleMappings.Add(mapping);
await _cache.AddApplicationRole(role.EmployeeId, [mapping.RoleId]);
}
}
else if (role.IsEnabled == false)
{
_context.EmployeeRoleMappings.Remove(existingItem);
await _cache.RemoveRoleId(existingItem.EmployeeId, existingItem.RoleId);
await _cache.ClearAllPermissionIdsByEmployeeID(existingItem.EmployeeId);
}
await _cache.ClearAllProjectIds(role.EmployeeId);
}
await _context.SaveChangesAsync();

12
Marco.Pms.Services/Controllers/TaskController.cs
View File

@ -6,6 +6,7 @@ using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Projects;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Activities;
using Marco.Pms.Services.Helpers;
using Marco.Pms.Services.Hubs;
using Marco.Pms.Services.Service;
using MarcoBMS.Services.Helpers;
@ -30,16 +31,18 @@ namespace MarcoBMS.Services.Controllers
private readonly S3UploadService _s3Service;
private readonly ILoggingService _logger;
private readonly IHubContext<MarcoHub> _signalR;
private readonly CacheUpdateHelper _cache;
private readonly PermissionServices _permissionServices;
public TaskController(ApplicationDbContext context, UserHelper userHelper, S3UploadService s3Service, ILoggingService logger, PermissionServices permissionServices,
IHubContext<MarcoHub> signalR)
IHubContext<MarcoHub> signalR, CacheUpdateHelper cache)
{
_context = context;
_userHelper = userHelper;
_s3Service = s3Service;
_logger = logger;
_signalR = signalR;
_cache = cache;
_permissionServices = permissionServices;
}
@ -82,6 +85,8 @@ namespace MarcoBMS.Services.Controllers
_context.TaskAllocations.Add(taskAllocation);
await _context.SaveChangesAsync();
await _cache.UpdatePlannedAndCompleteWorksInWorkItem(taskAllocation.WorkItemId, todaysAssigned: taskAllocation.PlannedTask);
_logger.LogInfo("Task {TaskId} assigned by Employee {EmployeeId}", taskAllocation.Id, employee.Id);
var response = taskAllocation.ToAssignTaskVMFromTaskAllocation();
@ -255,6 +260,10 @@ namespace MarcoBMS.Services.Controllers
}
await _context.SaveChangesAsync();
var selectedWorkAreaId = taskAllocation.WorkItem?.WorkAreaId ?? Guid.Empty;
await _cache.UpdatePlannedAndCompleteWorksInWorkItem(taskAllocation.WorkItemId, completedWork: taskAllocation.CompletedTask);
await _cache.UpdatePlannedAndCompleteWorksInBuilding(selectedWorkAreaId, completedWork: taskAllocation.CompletedTask);
var response = taskAllocation.ToReportTaskVMFromTaskAllocation();
var comments = await _context.TaskComments
@ -675,6 +684,7 @@ namespace MarcoBMS.Services.Controllers
/// </summary>
/// <param name="approveTask">DTO containing task approval details.</param>
/// <returns>IActionResult indicating success or failure.</returns>
[HttpPost("approve")]
public async Task<IActionResult> ApproveTask(ApproveTaskDto approveTask)
{

1
Marco.Pms.Services/Dockerfile
View File

@ -19,6 +19,7 @@ COPY ["Marco.Pms.Services/Marco.Pms.Services.csproj", "Marco.Pms.Services/"]
COPY ["Marco.Pms.DataAccess/Marco.Pms.DataAccess.csproj", "Marco.Pms.DataAccess/"]
COPY ["Marco.Pms.Model/Marco.Pms.Model.csproj", "Marco.Pms.Model/"]
COPY ["Marco.Pms.Utility/Marco.Pms.Utility.csproj", "Marco.Pms.Utility/"]
COPY ["Marco.Pms.CacheHelper/Marco.Pms.CacheHelper.csproj", "Marco.Pms.CacheHelper/"]
RUN dotnet restore "./Marco.Pms.Services/Marco.Pms.Services.csproj"
COPY . .
WORKDIR "/src/Marco.Pms.Services"

346
Marco.Pms.Services/Helpers/CacheUpdateHelper.cs Normal file
View File

@ -0,0 +1,346 @@
using Marco.Pms.CacheHelper;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using MarcoBMS.Services.Service;
using Project = Marco.Pms.Model.Projects.Project;
namespace Marco.Pms.Services.Helpers
{
public class CacheUpdateHelper
{
private readonly ProjectCache _projectCache;
private readonly EmployeeCache _employeeCache;
private readonly ILoggingService _logger;
public CacheUpdateHelper(ProjectCache projectCache, EmployeeCache employeeCache, ILoggingService logger)
{
_projectCache = projectCache;
_employeeCache = employeeCache;
_logger = logger;
}
// ------------------------------------ Project Details and Infrastructure Cache ---------------------------------------
public async Task AddProjectDetails(Project project)
{
try
{
await _projectCache.AddProjectDetailsToCache(project);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding project {ProjectId} to Cache : {Error}", project.Id, ex.Message);
}
}
public async Task<bool> UpdateProjectDetailsOnly(Project project)
{
try
{
bool response = await _projectCache.UpdateProjectDetailsOnlyToCache(project);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating project {ProjectId} to Cache: {Error}", project.Id, ex.Message);
return false;
}
}
public async Task<ProjectMongoDB?> GetProjectDetails(Guid projectId)
{
try
{
var response = await _projectCache.GetProjectDetailsFromCache(projectId);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting project {ProjectId} to Cache: {Error}", ex.Message);
return null;
}
}
public async Task<List<ProjectMongoDB>?> GetProjectDetailsList(List<Guid> projectIds)
{
try
{
var response = await _projectCache.GetProjectDetailsListFromCache(projectIds);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting list od project details from to Cache: {Error}", ex.Message);
return null;
}
}
public async Task AddBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
try
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding project infra for project {ProjectId} to Cache: {Error}", projectId, ex.Message);
}
}
public async Task UpdateBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
try
{
var response = await _projectCache.UpdateBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
if (!response)
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating project infra for project {ProjectId} to Cache: {Error}", projectId, ex.Message);
}
}
public async Task<List<BuildingMongoDB>?> GetBuildingInfra(Guid projectId)
{
try
{
var response = await _projectCache.GetBuildingInfraFromCache(projectId);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting project infra for project {ProjectId} form Cache: {Error}", projectId, ex.Message);
return null;
}
}
public async Task UpdatePlannedAndCompleteWorksInBuilding(Guid workAreaId, double plannedWork = 0, double completedWork = 0)
{
try
{
await _projectCache.UpdatePlannedAndCompleteWorksInBuildingFromCache(workAreaId, plannedWork, completedWork);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating planned work and completed work in building infra form Cache: {Error}", ex.Message);
}
}
public async Task<WorkAreaInfoMongoDB?> GetBuildingAndFloorByWorkAreaId(Guid workAreaId)
{
try
{
var response = await _projectCache.GetBuildingAndFloorByWorkAreaIdFromCache(workAreaId);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while fetching workArea Details using its ID form Cache: {Error}", ex.Message);
return null;
}
}
public async Task<List<WorkItemMongoDB>?> GetWorkItemsByWorkAreaIds(List<Guid> workAreaIds)
{
try
{
var response = await _projectCache.GetWorkItemsByWorkAreaIdsFromCache(workAreaIds);
if (response.Count > 0)
{
return response;
}
return null;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while fetching workItems list using workArea IDs list form Cache: {Error}", ex.Message);
return null;
}
}
// ------------------------------------------------------- WorkItem -------------------------------------------------------
public async Task ManageWorkItemDetails(List<WorkItem> workItems)
{
try
{
await _projectCache.ManageWorkItemDetailsToCache(workItems);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while saving workItems form Cache: {Error}", ex.Message);
}
}
public async Task<List<WorkItemMongoDB>?> GetWorkItemDetailsByWorkArea(Guid workAreaId)
{
try
{
var workItems = await _projectCache.GetWorkItemDetailsByWorkAreaFromCache(workAreaId);
if (workItems.Count > 0)
{
return workItems;
}
else
{
return null;
}
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while fetching list of workItems form Cache: {Error}", ex.Message);
return null;
}
}
public async Task<WorkItemMongoDB?> GetWorkItemDetailsById(Guid id)
{
try
{
var workItem = await _projectCache.GetWorkItemDetailsByIdFromCache(id);
if (workItem.Id != "")
{
return workItem;
}
else
{
return null;
}
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while fetching list of workItems form Cache: {Error}", ex.Message);
return null;
}
}
public async Task UpdatePlannedAndCompleteWorksInWorkItem(Guid id, double plannedWork = 0, double completedWork = 0, double todaysAssigned = 0)
{
try
{
var response = await _projectCache.UpdatePlannedAndCompleteWorksInWorkItemToCache(id, plannedWork, completedWork, todaysAssigned);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating planned work, completed work, and today's assigned work in workItems in Cache: {Error}", ex.Message);
}
}
// ------------------------------------ Employee Profile Cache ---------------------------------------
public async Task AddApplicationRole(Guid employeeId, List<Guid> roleIds)
{
try
{
var response = await _employeeCache.AddApplicationRoleToCache(employeeId, roleIds);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding Application roleIds to Cache to employee {Employee}: {Error}", employeeId, ex.Message);
}
}
public async Task<bool> AddProjects(Guid employeeId, List<Guid> projectIds)
{
try
{
var response = await _employeeCache.AddProjectsToCache(employeeId, projectIds);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding projectIds for employee {EmployeeId} to Cache: {Error}", employeeId, ex.Message);
return false;
}
}
public async Task<List<Guid>?> GetProjects(Guid employeeId)
{
try
{
var response = await _employeeCache.GetProjectsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting projectIds for employee {EmployeeId} from Cache: {Error}", employeeId, ex.Message);
return null;
}
}
public async Task<List<Guid>?> GetPermissions(Guid employeeId)
{
try
{
var response = await _employeeCache.GetPermissionsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting permissionIds for employee {EmployeeId} from Cache: {Error}", employeeId, ex.Message);
return null;
}
}
public async Task ClearAllProjectIds(Guid employeeId)
{
try
{
var response = await _employeeCache.ClearAllProjectIdsFromCache(employeeId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting projectIds from Cache for employee {EmployeeId}: {Error}", employeeId, ex.Message);
}
}
public async Task ClearAllProjectIdsByRoleId(Guid roleId)
{
try
{
await _employeeCache.ClearAllProjectIdsByRoleIdFromCache(roleId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting projectIds from Cache for Application Role {RoleId}: {Error}", roleId, ex.Message);
}
}
public async Task ClearAllProjectIdsByPermissionId(Guid permissionId)
{
try
{
await _employeeCache.ClearAllProjectIdsByPermissionIdFromCache(permissionId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting projectIds from Cache for Permission {PermissionId}: {Error}", permissionId, ex.Message);
}
}
public async Task ClearAllPermissionIdsByEmployeeID(Guid employeeId)
{
try
{
var response = await _employeeCache.ClearAllPermissionIdsByEmployeeIDFromCache(employeeId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting permissionIds from Cache for employee {EmployeeId}: {Error}", employeeId, ex.Message);
}
}
public async Task ClearAllPermissionIdsByRoleId(Guid roleId)
{
try
{
var response = await _employeeCache.ClearAllPermissionIdsByRoleIdFromCache(roleId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting permissionIds from Cache for Application role {RoleId}: {Error}", roleId, ex.Message);
}
}
public async Task RemoveRoleId(Guid employeeId, Guid roleId)
{
try
{
var response = await _employeeCache.RemoveRoleIdFromCache(employeeId, roleId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting Application role {RoleId} from Cache for employee {EmployeeId}: {Error}", roleId, employeeId, ex.Message);
}
}
}
}

84
Marco.Pms.Services/Helpers/ProjectsHelper.cs
View File

@ -1,7 +1,9 @@
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using Marco.Pms.Services.Helpers;
using Microsoft.EntityFrameworkCore;
namespace MarcoBMS.Services.Helpers
@ -10,12 +12,14 @@ namespace MarcoBMS.Services.Helpers
{
private readonly ApplicationDbContext _context;
private readonly RolesHelper _rolesHelper;
private readonly CacheUpdateHelper _cache;
public ProjectsHelper(ApplicationDbContext context, RolesHelper rolesHelper)
public ProjectsHelper(ApplicationDbContext context, RolesHelper rolesHelper, CacheUpdateHelper cache)
{
_context = context;
_rolesHelper = rolesHelper;
_cache = cache;
}
public async Task<List<Project>> GetAllProjectByTanentID(Guid tanentID)
@ -49,40 +53,74 @@ namespace MarcoBMS.Services.Helpers
public async Task<List<Project>> GetMyProjects(Guid tenantId, Employee LoggedInEmployee)
{
List<FeaturePermission> featurePermission = await _rolesHelper.GetFeaturePermissionByEmployeeID(LoggedInEmployee.Id);
string[] projectsId = [];
List<Project> projects = new List<Project>();
// Define a common queryable base for projects
IQueryable<Project> projectQuery = _context.Projects.Where(c => c.TenantId == tenantId);
var projectIds = await _cache.GetProjects(LoggedInEmployee.Id);
// 2. Optimized Project Retrieval Logic
// User with permission 'manage project' can see all projects
if (featurePermission != null && featurePermission.Exists(c => c.Id.ToString() == "172fc9b6-755b-4f62-ab26-55c34a330614"))
if (projectIds != null)
{
// If GetAllProjectByTanentID is already optimized and directly returns IQueryable or
// directly executes with ToListAsync(), keep it.
// If it does more complex logic or extra trips, consider inlining here.
projects = await projectQuery.ToListAsync(); // Directly query the context
List<ProjectMongoDB> projectdetails = await _cache.GetProjectDetailsList(projectIds) ?? new List<ProjectMongoDB>();
projects = projectdetails.Select(p => new Project
{
Id = Guid.Parse(p.Id),
Name = p.Name,
ShortName = p.ShortName,
ProjectAddress = p.ProjectAddress,
ProjectStatusId = Guid.Parse(p.ProjectStatus?.Id ?? ""),
ContactPerson = p.ContactPerson,
StartDate = p.StartDate,
EndDate = p.EndDate,
TenantId = tenantId
}).ToList();
if (projects.Count != projectIds.Count)
{
projects = await _context.Projects.Where(p => projectIds.Contains(p.Id)).ToListAsync();
}
}
else
{
// 3. Efficiently get project allocations and then filter projects
// Load allocations only once
var allocation = await GetProjectByEmployeeID(LoggedInEmployee.Id);
// If there are no allocations, return an empty list early
if (allocation == null || !allocation.Any())
var featurePermissionIds = await _cache.GetPermissions(LoggedInEmployee.Id);
if (featurePermissionIds == null)
{
return new List<Project>();
List<FeaturePermission> featurePermission = await _rolesHelper.GetFeaturePermissionByEmployeeID(LoggedInEmployee.Id);
featurePermissionIds = featurePermission.Select(fp => fp.Id).ToList();
}
// Define a common queryable base for projects
IQueryable<Project> projectQuery = _context.Projects.Where(c => c.TenantId == tenantId);
// Use LINQ's Contains for efficient filtering by ProjectId
var projectIds = allocation.Select(c => c.ProjectId).Distinct().ToList(); // Get distinct Guids
// 2. Optimized Project Retrieval Logic
// User with permission 'manage project' can see all projects
if (featurePermissionIds != null && featurePermissionIds.Contains(Guid.Parse("172fc9b6-755b-4f62-ab26-55c34a330614")))
{
// If GetAllProjectByTanentID is already optimized and directly returns IQueryable or
// directly executes with ToListAsync(), keep it.
// If it does more complex logic or extra trips, consider inlining here.
projects = await projectQuery.ToListAsync(); // Directly query the context
}
else
{
// 3. Efficiently get project allocations and then filter projects
// Load allocations only once
var allocation = await GetProjectByEmployeeID(LoggedInEmployee.Id);
// Filter projects based on the retrieved ProjectIds
projects = await projectQuery.Where(c => projectIds.Contains(c.Id)).ToListAsync();
// If there are no allocations, return an empty list early
if (allocation == null || !allocation.Any())
{
return new List<Project>();
}
// Use LINQ's Contains for efficient filtering by ProjectId
projectIds = allocation.Select(c => c.ProjectId).Distinct().ToList(); // Get distinct Guids
// Filter projects based on the retrieved ProjectIds
projects = await projectQuery.Where(c => projectIds.Contains(c.Id)).ToListAsync();
}
projectIds = projects.Select(p => p.Id).ToList();
await _cache.AddProjects(LoggedInEmployee.Id, projectIds);
}
return projects;

274
Marco.Pms.Services/Helpers/ReportHelper.cs Normal file
View File

@ -0,0 +1,274 @@
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;
}
}
}

7
Marco.Pms.Services/Helpers/RolesHelper.cs
View File

@ -2,6 +2,7 @@
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Services.Helpers;
using Microsoft.EntityFrameworkCore;
namespace MarcoBMS.Services.Helpers
@ -9,15 +10,19 @@ namespace MarcoBMS.Services.Helpers
public class RolesHelper
{
private readonly ApplicationDbContext _context;
public RolesHelper(ApplicationDbContext context)
private readonly CacheUpdateHelper _cache;
public RolesHelper(ApplicationDbContext context, CacheUpdateHelper cache)
{
_context = context;
_cache = cache;
}
public async Task<List<FeaturePermission>> GetFeaturePermissionByEmployeeID(Guid EmployeeID)
{
List<Guid> roleMappings = await _context.EmployeeRoleMappings.Where(c => c.EmployeeId == EmployeeID && c.IsEnabled == true).Select(c => c.RoleId).ToListAsync();
await _cache.AddApplicationRole(EmployeeID, roleMappings);
// _context.RolePermissionMappings
var result = await (from rpm in _context.RolePermissionMappings

1
Marco.Pms.Services/Marco.Pms.Services.csproj
View File

@ -44,6 +44,7 @@
<ProjectReference Include="..\Marco.Pms.DataAccess\Marco.Pms.DataAccess.csproj" />
<ProjectReference Include="..\Marco.Pms.Model\Marco.Pms.Model.csproj" />
<ProjectReference Include="..\Marco.Pms.Utility\Marco.Pms.Utility.csproj" />
<ProjectReference Include="..\Marco.Pms.CacheHelper\Marco.Pms.CacheHelper.csproj" />
</ItemGroup>
<ItemGroup>
<Content Include="EmailTemplates\**\*.html">

4
Marco.Pms.Services/Middleware/LoggingMiddleware.cs
View File

@ -24,7 +24,7 @@ namespace MarcoBMS.Services.Middleware
var response = context.Response;
var request = context.Request;
var tenantId = context.User.FindFirst("TenantId")?.Value;
string origin = request.Headers["Origin"].FirstOrDefault() ?? "";
using (LogContext.PushProperty("TenantId", tenantId))
using (LogContext.PushProperty("TraceId", context.TraceIdentifier))
@ -33,6 +33,8 @@ namespace MarcoBMS.Services.Middleware
using (LogContext.PushProperty("Timestamp", DateTime.UtcNow))
using (LogContext.PushProperty("IpAddress", context.Connection.RemoteIpAddress?.ToString()))
using (LogContext.PushProperty("RequestPath", request.Path))
using (LogContext.PushProperty("Origin", origin))
try

7
Marco.Pms.Services/Program.cs
View File

@ -1,4 +1,5 @@
using System.Text;
using Marco.Pms.CacheHelper;
using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Authentication;
using Marco.Pms.Model.Entitlements;
@ -136,6 +137,10 @@ builder.Services.AddScoped<EmployeeHelper>();
builder.Services.AddScoped<ProjectsHelper>();
builder.Services.AddScoped<DirectoryHelper>();
builder.Services.AddScoped<MasterHelper>();
builder.Services.AddScoped<ReportHelper>();
builder.Services.AddScoped<CacheUpdateHelper>();
builder.Services.AddScoped<ProjectCache>();
builder.Services.AddScoped<EmployeeCache>();
builder.Services.AddSingleton<ILoggingService, LoggingService>();
@ -225,7 +230,7 @@ app.UseStaticFiles(); // Enables serving static files
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.MapHub<MarcoHub>("/hubs/marco");
app.MapControllers();

18
Marco.Pms.Services/Service/PermissionServices.cs
View File

@ -2,6 +2,7 @@
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Projects;
using Marco.Pms.Services.Helpers;
using MarcoBMS.Services.Helpers;
using Microsoft.EntityFrameworkCore;
@ -12,21 +13,24 @@ namespace Marco.Pms.Services.Service
private readonly ApplicationDbContext _context;
private readonly RolesHelper _rolesHelper;
private readonly ProjectsHelper _projectsHelper;
public PermissionServices(ApplicationDbContext context, RolesHelper rolesHelper, ProjectsHelper projectsHelper)
private readonly CacheUpdateHelper _cache;
public PermissionServices(ApplicationDbContext context, RolesHelper rolesHelper, ProjectsHelper projectsHelper, CacheUpdateHelper cache)
{
_context = context;
_rolesHelper = rolesHelper;
_projectsHelper = projectsHelper;
_cache = cache;
}
public async Task<bool> HasPermission(Guid featurePermissionId, Guid employeeId)
{
var hasPermission = await _context.EmployeeRoleMappings
.Where(er => er.EmployeeId == employeeId)
.Select(er => er.RoleId)
.Distinct()
.AnyAsync(roleId => _context.RolePermissionMappings
.Any(rp => rp.FeaturePermissionId == featurePermissionId && rp.ApplicationRoleId == roleId));
var featurePermissionIds = await _cache.GetPermissions(employeeId);
if (featurePermissionIds == null)
{
List<FeaturePermission> featurePermission = await _rolesHelper.GetFeaturePermissionByEmployeeID(employeeId);
featurePermissionIds = featurePermission.Select(fp => fp.Id).ToList();
}
var hasPermission = featurePermissionIds.Contains(featurePermissionId);
return hasPermission;
}
public async Task<bool> HasProjectPermission(Employee emp, string projectId)

2
Marco.Pms.Services/Service/RefreshTokenService.cs
View File

@ -218,7 +218,7 @@ namespace MarcoBMS.Services.Service
catch (Exception ex)
{
// Token is invalid
Console.WriteLine($"Token validation failed: {ex.Message}");
_logger.LogError($"Token validation failed: {ex.Message}");
return null;
}
}

3
Marco.Pms.Services/appsettings.Development.json
View File

@ -47,6 +47,7 @@
"BucketName": "testenv-marco-pms-documents"
},
"MongoDB": {
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs"
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs",
"ConnectionString": "mongodb://localhost:27017/MarcoBMS_Caches?socketTimeoutMS=500&serverSelectionTimeoutMS=500&connectTimeoutMS=500"
}
}

5
Marco.Pms.Services/appsettings.Production.json
View File

@ -6,7 +6,7 @@
},
"Environment": {
"Name": "Production",
"Title": ""
"Title": ""
},
"ConnectionStrings": {
"DefaultConnectionString": "Server=147.93.98.152;User ID=devuser;Password=AppUser@123$;Database=MarcoBMS1"
@ -40,6 +40,7 @@
"BucketName": "testenv-marco-pms-documents"
},
"MongoDB": {
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs"
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs",
"ConnectionString": "mongodb://localhost:27017/MarcoBMS_Caches"
}
}

6
marco.pms.api.sln
View File

@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Marco.Pms.Utility", "Marco.
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Marco.Pms.Services", "Marco.Pms.Services\Marco.Pms.Services.csproj", "{27A83653-5B7F-4135-9886-01594D54AFAE}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Marco.Pms.CacheHelper", "Marco.Pms.CacheHelper\Marco.Pms.CacheHelper.csproj", "{1A105C22-4ED7-4F54-8834-6923DDD96852}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -33,6 +35,10 @@ Global
{27A83653-5B7F-4135-9886-01594D54AFAE}.Debug|Any CPU.Build.0 = Debug|Any CPU
{27A83653-5B7F-4135-9886-01594D54AFAE}.Release|Any CPU.ActiveCfg = Release|Any CPU
{27A83653-5B7F-4135-9886-01594D54AFAE}.Release|Any CPU.Build.0 = Release|Any CPU
{1A105C22-4ED7-4F54-8834-6923DDD96852}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1A105C22-4ED7-4F54-8834-6923DDD96852}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1A105C22-4ED7-4F54-8834-6923DDD96852}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1A105C22-4ED7-4F54-8834-6923DDD96852}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE