515 lines
25 KiB
C#
515 lines
25 KiB
C#
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(ProjectMongoDB projectDetails)
|
|
{
|
|
await _projetCollection.InsertOneAsync(projectDetails);
|
|
}
|
|
public async Task AddProjectDetailsListToCache(List<ProjectMongoDB> projectDetailsList)
|
|
{
|
|
await _projetCollection.InsertManyAsync(projectDetailsList);
|
|
//_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;
|
|
}
|
|
|
|
// ------------------------------------------------------- Project InfraStructure -------------------------------------------------------
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|