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

ProjectDetails_Split_API #103

Merged
admin merged 47 commits from ProjectDetails_Split_API into main 2025-07-11 11:32:34 +00:00
Conversation 0 Commits 47 Files Changed 33 +1090 -91
25 changed files with 1090 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit cd4ad6f4ac - Show all commits

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

@ -0,0 +1,158 @@
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)
{
var newRoleIds = roleIds.Select(r => r.ToString()).ToList();
var newPermissionIds = await _context.RolePermissionMappings
.Where(rp => roleIds.Contains(rp.ApplicationRoleId))
.Select(p => p.FeaturePermissionId.ToString())
.Distinct()
.ToListAsync();
var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.EmployeeId, employeeId.ToString());
var update = Builders<EmployeePermissionMongoDB>.Update
.AddToSetEach(e => e.ApplicationRoleIds, newRoleIds)
.AddToSetEach(e => e.PermissionIds, newPermissionIds);
var result = await _collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
if (result.MatchedCount == 0)
{
return false;
}
return true;
}
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.EmployeeId, 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.EmployeeId, 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.EmployeeId, 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.EmployeeId, 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> RemoveRoleIdFromCache(Guid employeeId, Guid roleId)
{
var filter = Builders<EmployeePermissionMongoDB>.Filter
.Eq(e => e.EmployeeId, 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.EmployeeId, 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>

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

@ -0,0 +1,434 @@
using Marco.Pms.DataAccess.Data;
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 IMongoDatabase _mongoDB;
//private readonly ILoggingService _logger;
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
_mongoDB = client.GetDatabase(mongoUrl.DatabaseName); // Your MongoDB Database name
}
public async Task AddProjectDetailsToCache(Project project)
{
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
//_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(),
AreaName = wa.AreaName,
PlannedWork = waPlanned,
CompletedWork = waCompleted
});
floorPlanned += waPlanned;
floorCompleted += waCompleted;
}
floorMongoList.Add(new FloorMongoDB
{
Id = floor.Id.ToString(),
FloorName = floor.FloorName,
PlannedWork = floorPlanned,
CompletedWork = floorCompleted,
WorkAreas = workAreaMongoList
});
buildingPlanned += floorPlanned;
buildingCompleted += floorCompleted;
}
buildingMongoList.Add(new BuildingMongoDB
{
Id = building.Id.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 projectCollection.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);
}
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
// 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 projectCollection.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)
{
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
// 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 projectCollection
.Find(filter)
.Project<ProjectMongoDB>(projection)
.FirstOrDefaultAsync();
if (project == null)
{
//_logger.LogWarning("No project found in MongoDB for ProjectId: {ProjectId}", projectId);
return null;
}
//// Deserialize the result manually
//var project = BsonSerializer.Deserialize<ProjectMongoDB>(result);
//_logger.LogInfo("Successfully fetched project details (excluding Buildings) for ProjectId: {ProjectId}", projectId);
return project;
}
public async Task AddBuildngInfraToCache(Guid projectId, Building? building, Floor? floor, WorkArea? workArea, Guid? buildingId)
{
var stringProjectId = projectId.ToString();
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
// 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 projectCollection.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 projectCollection.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 projectCollection.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();
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
// 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 projectCollection.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 projectCollection.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 projectCollection.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)
{
var projectCollection = _mongoDB.GetCollection<ProjectMongoDB>("ProjectDetails");
// 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 projectCollection
.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;
}
}
}

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; }
public string? ActivityName { get; set; }
public string? UnitOfMeasurement { get; set; }
}
}

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

@ -0,0 +1,18 @@
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 List<FloorMongoDB>? Floors { get; set; }
}
public class BuildingMongoDBVM
{
public string Id { get; set; } = string.Empty;
public string? Name { get; set; }
public string? Description { get; set; }
}
}

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 EmployeeId { get; set; } = string.Empty;
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>();
}
}

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

@ -0,0 +1,17 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class FloorMongoDB
{
public string Id { 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; }
}
public class FloorMongoDBVM
{
public string Id { get; set; } = string.Empty;
public string? FloorName { 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; }
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; }
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; }
}
}

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

@ -0,0 +1,15 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkAreaMongoDB
{
public string Id { 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; }
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
}
}

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

@ -0,0 +1,15 @@
namespace Marco.Pms.Model.MongoDBModels
{
public class WorkItemMongoDB
{
public string? Id { get; set; }
public string? WorkAreaId { get; set; }
public ActivityMasterMongoDB? ActivityMaster { get; set; }
public WorkCategoryMasterMongoDB? WorkCategoryMaster { get; set; }
public string? ParentTaskId { get; set; }
public double PlannedWork { get; set; }
public double CompletedWork { get; set; }
public string? Description { get; set; }
public DateTime TaskDate { get; set; }
}
}

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

@ -2,10 +2,13 @@
using Marco.Pms.Model.Dtos.Project;
using Marco.Pms.Model.Employees;
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;
@ -14,6 +17,7 @@ using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using MongoDB.Driver;
namespace MarcoBMS.Services.Controllers
{
@ -29,6 +33,7 @@ namespace MarcoBMS.Services.Controllers
private readonly ProjectsHelper _projectsHelper;
private readonly IHubContext<MarcoHub> _signalR;
private readonly PermissionServices _permission;
private readonly CacheUpdateHelper _cache;
private readonly Guid ViewProjects;
private readonly Guid ManageProject;
private readonly Guid ViewInfra;
@ -37,7 +42,7 @@ namespace MarcoBMS.Services.Controllers
public ProjectController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger, RolesHelper rolesHelper, ProjectsHelper projectHelper,
IHubContext<MarcoHub> signalR, PermissionServices permission)
IHubContext<MarcoHub> signalR, PermissionServices permission, CacheUpdateHelper cache)
{
_context = context;
_userHelper = userHelper;
@ -45,13 +50,13 @@ namespace MarcoBMS.Services.Controllers
_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();
}
[HttpGet("list/basic")]
@ -222,24 +227,54 @@ namespace MarcoBMS.Services.Controllers
}
// Step 5: Fetch project with status
var project = await _context.Projects
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);
}
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 (project == null)
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: Map and return result
var projectVM = GetProjectViewModel(project);
// 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)
private ProjectVM? GetProjectViewModel(Project? project)
{
if (project == null)
{
return null;
}
return new ProjectVM
{
Id = project.Id,
@ -280,6 +315,9 @@ namespace MarcoBMS.Services.Controllers
_context.Projects.Add(project);
await _context.SaveChangesAsync();
await _cache.AddProjectDetails(project);
var notification = new { LoggedInUserId = LoggedInEmployee.Id, Keyword = "Create_Project", Response = project.ToProjectDto() };
await _signalR.Clients.All.SendAsync("NotificationEventHandler", notification);
@ -310,6 +348,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);
@ -524,6 +569,7 @@ namespace MarcoBMS.Services.Controllers
employeeIds.Add(projectAllocation.EmployeeId);
projectIds.Add(projectAllocation.ProjectId);
}
await _cache.ClearAllProjectIds(item.EmpID);
}
catch (Exception ex)
@ -565,53 +611,102 @@ namespace MarcoBMS.Services.Controllers
_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));
}
// 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();
// Step 7: Build the infra hierarchy (Building > Floors > Work Areas)
var infraVM = buildings.Select(b =>
var result = await _cache.GetBuildingInfra(projectId);
if (result == null)
{
var selectedFloors = floors
.Where(f => f.BuildingId == b.Id)
.Select(f => new
{
Id = f.Id,
FloorName = f.FloorName,
WorkAreas = workAreas
.Where(wa => wa.FloorId == f.Id)
.Select(wa => new { wa.Id, wa.AreaName })
.ToList()
}).ToList();
return new
// 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)
{
Id = b.Id,
BuildingName = b.Name,
Floors = selectedFloors
};
}).ToList();
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, infraVM.Count);
projectId, loggedInEmployee.Id, result.Count);
return Ok(ApiResponse<object>.SuccessResponse(infraVM, "Infra details fetched successfully", 200));
return Ok(ApiResponse<object>.SuccessResponse(result, "Infra details fetched successfully", 200));
}
[HttpGet("tasks/{workAreaId}")]
@ -807,6 +902,7 @@ namespace MarcoBMS.Services.Controllers
responseData.building = building;
responseMessage = "Buliding Added Successfully";
message = "Building Added";
await _cache.AddBuildngInfra(building.ProjectId, building);
}
else
{
@ -816,7 +912,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);
}
@ -824,6 +920,7 @@ namespace MarcoBMS.Services.Controllers
{
Floor floor = item.Floor.ToFloorFromFloorDto(tenantId);
floor.TenantId = GetTenantId();
bool isCreated = false;
if (item.Floor.Id == null)
{
@ -833,6 +930,7 @@ namespace MarcoBMS.Services.Controllers
responseData.floor = floor;
responseMessage = "Floor Added Successfully";
message = "Floor Added";
isCreated = true;
}
else
{
@ -844,13 +942,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)
{
@ -860,6 +968,7 @@ namespace MarcoBMS.Services.Controllers
responseData.workArea = workArea;
responseMessage = "Work Area Added Successfully";
message = "Work Area Added";
isCreated = true;
}
else
{
@ -871,8 +980,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}";
@ -996,6 +1114,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);

12
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()
@ -292,6 +296,8 @@ namespace MarcoBMS.Services.Controllers
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 +430,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();

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.Utility/Marco.Pms.CacheHelper.csproj", "Marco.Pms.CacheHelper/"]
RUN dotnet restore "./Marco.Pms.Services/Marco.Pms.Services.csproj"
COPY . .
WORKDIR "/src/Marco.Pms.Services"

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

@ -0,0 +1,98 @@
using Marco.Pms.CacheHelper;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using Project = Marco.Pms.Model.Projects.Project;
namespace Marco.Pms.Services.Helpers
{
public class CacheUpdateHelper
{
private readonly ProjectCache _projectCache;
private readonly EmployeeCache _employeeCache;
public CacheUpdateHelper(ProjectCache projectCache, EmployeeCache employeeCache)
{
_projectCache = projectCache;
_employeeCache = employeeCache;
}
// ------------------------------------ Project Details and Infrastructure Cache ---------------------------------------
public async Task AddProjectDetails(Project project)
{
await _projectCache.AddProjectDetailsToCache(project);
}
public async Task<bool> UpdateProjectDetailsOnly(Project project)
{
bool response = await _projectCache.UpdateProjectDetailsOnlyToCache(project);
return response;
}
public async Task<ProjectMongoDB?> GetProjectDetails(Guid projectId)
{
var response = await _projectCache.GetProjectDetailsFromCache(projectId);
return response;
}
public async Task AddBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
public async Task UpdateBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
var response = await _projectCache.UpdateBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
if (!response)
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
}
public async Task<List<BuildingMongoDB>?> GetBuildingInfra(Guid projectId)
{
var response = await _projectCache.GetBuildingInfraFromCache(projectId);
return response;
}
// ------------------------------------ Employee Profile Cache ---------------------------------------
public async Task AddApplicationRole(Guid employeeId, List<Guid> roleIds)
{
var response = await _employeeCache.AddApplicationRoleToCache(employeeId, roleIds);
}
public async Task<bool> AddProjects(Guid employeeId, List<Guid> projectIds)
{
var response = await _employeeCache.AddProjectsToCache(employeeId, projectIds);
return response;
}
public async Task<List<Guid>?> GetProjects(Guid employeeId)
{
var response = await _employeeCache.GetProjectsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
public async Task<List<Guid>?> GetPermissions(Guid employeeId)
{
var response = await _employeeCache.GetPermissionsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
public async Task ClearAllProjectIds(Guid employeeId)
{
var response = await _employeeCache.ClearAllProjectIdsFromCache(employeeId);
}
public async Task ClearAllPermissionIdsByEmployeeID(Guid employeeId)
{
var response = await _employeeCache.ClearAllPermissionIdsByEmployeeIDFromCache(employeeId);
}
public async Task ClearAllPermissionIdsByRoleId(Guid roleId)
{
var response = await _employeeCache.ClearAllPermissionIdsByRoleIdFromCache(roleId);
}
public async Task RemoveRoleId(Guid employeeId, Guid roleId)
{
var response = await _employeeCache.RemoveRoleIdFromCache(employeeId, roleId);
}
}
}

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

@ -2,11 +2,8 @@
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Projects;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Projects;
using Microsoft.AspNetCore.Mvc;
using Marco.Pms.Services.Helpers;
using Microsoft.EntityFrameworkCore;
using ModelServices.Helpers;
namespace MarcoBMS.Services.Helpers
{
@ -14,12 +11,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)
@ -53,40 +52,56 @@ 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
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;

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">

6
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,9 @@ builder.Services.AddScoped<EmployeeHelper>();
builder.Services.AddScoped<ProjectsHelper>();
builder.Services.AddScoped<DirectoryHelper>();
builder.Services.AddScoped<MasterHelper>();
builder.Services.AddScoped<CacheUpdateHelper>();
builder.Services.AddScoped<ProjectCache>();
builder.Services.AddScoped<EmployeeCache>();
builder.Services.AddSingleton<ILoggingService, LoggingService>();
@ -225,7 +229,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)

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

@ -47,6 +47,8 @@
"BucketName": "testenv-marco-pms-documents"
},
"MongoDB": {
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs"
"SerilogDatabaseUrl": "mongodb://localhost:27017/DotNetLogs",
"ConnectionString": "mongodb://localhost:27017/MarcoBMS_Caches"
//"DatabaseName": ""
}
}

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