657 lines
29 KiB
C#
657 lines
29 KiB
C#
using Marco.Pms.DataAccess.Data;
|
|
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.Projects;
|
|
using Marco.Pms.Model.Utilities;
|
|
using Marco.Pms.Model.ViewModels.Employee;
|
|
using Marco.Pms.Model.ViewModels.Projects;
|
|
using MarcoBMS.Services.Helpers;
|
|
using MarcoBMS.Services.Service;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace MarcoBMS.Services.Controllers
|
|
{
|
|
[Route("api/[controller]")]
|
|
[ApiController]
|
|
[Authorize]
|
|
public class ProjectController : ControllerBase
|
|
{
|
|
private readonly ApplicationDbContext _context;
|
|
private readonly UserHelper _userHelper;
|
|
private readonly ILoggingService _logger;
|
|
|
|
|
|
public ProjectController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger)
|
|
{
|
|
_context = context;
|
|
_userHelper = userHelper;
|
|
_logger = logger;
|
|
}
|
|
[HttpGet("list")]
|
|
public async Task<IActionResult> GetAll()
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var errors = ModelState.Values
|
|
.SelectMany(v => v.Errors)
|
|
.Select(e => e.ErrorMessage)
|
|
.ToList();
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
|
|
|
|
}
|
|
Guid tenantId = _userHelper.GetTenantId();
|
|
List<Project> projects = await _context.Projects.Where(c => c.TenantId == tenantId).ToListAsync();
|
|
|
|
|
|
List<ProjectListVM> response = new List<ProjectListVM>();
|
|
foreach (var project in projects)
|
|
{
|
|
var result = project.ToProjectListVMFromProject();
|
|
var team = await _context.ProjectAllocations.Where(p => p.TenantId == tenantId && p.ProjectId == project.Id && p.IsActive == true).ToListAsync();
|
|
|
|
result.TeamSize = team.Count();
|
|
|
|
List<Building> buildings = await _context.Buildings.Where(b => b.ProjectId == project.Id && b.TenantId == tenantId).ToListAsync();
|
|
List<Guid> idList = buildings.Select(b => b.Id).ToList();
|
|
|
|
List<Floor> floors = await _context.Floor.Where(f => idList.Contains(f.BuildingId) && f.TenantId == tenantId).ToListAsync();
|
|
idList = floors.Select(f => f.Id).ToList();
|
|
|
|
List<WorkArea> workAreas = await _context.WorkAreas.Where(a => idList.Contains(a.FloorId) && a.TenantId == tenantId).ToListAsync();
|
|
idList = workAreas.Select(a => a.Id).ToList();
|
|
|
|
List<WorkItem> workItems = await _context.WorkItems.Where(i => idList.Contains(i.WorkAreaId) && i.TenantId == tenantId).Include(i => i.ActivityMaster).ToListAsync();
|
|
double completedTask = 0;
|
|
double plannedTask = 0;
|
|
foreach (var workItem in workItems)
|
|
{
|
|
completedTask += workItem.CompletedWork;
|
|
plannedTask += workItem.PlannedWork;
|
|
}
|
|
result.PlannedWork = plannedTask;
|
|
result.CompletedWork = completedTask;
|
|
response.Add(result);
|
|
}
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(response, "Success.", 200));
|
|
}
|
|
|
|
[HttpGet("get/{id}")]
|
|
public async Task<IActionResult> Get([FromRoute] Guid id)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var errors = ModelState.Values
|
|
.SelectMany(v => v.Errors)
|
|
.Select(e => e.ErrorMessage)
|
|
.ToList();
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
|
|
|
|
}
|
|
|
|
var project = await _context.Projects.Where(c => c.TenantId == _userHelper.GetTenantId() && c.Id == id).SingleOrDefaultAsync();
|
|
if (project == null) return NotFound(ApiResponse<object>.ErrorResponse("Project not found", "Project not found", 404));
|
|
return Ok(ApiResponse<object>.SuccessResponse(project, "Success.", 200));
|
|
}
|
|
|
|
[HttpGet("details/{id}")]
|
|
public async Task<IActionResult> Details([FromRoute] Guid id)
|
|
{
|
|
// ProjectDetailsVM vm = new ProjectDetailsVM();
|
|
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var errors = ModelState.Values
|
|
.SelectMany(v => v.Errors)
|
|
.Select(e => e.ErrorMessage)
|
|
.ToList();
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
|
|
|
|
}
|
|
|
|
var project = await _context.Projects.Where(c => c.TenantId == _userHelper.GetTenantId() && c.Id == id).Include(c => c.ProjectStatus).SingleOrDefaultAsync(); // includeProperties: "ProjectStatus,Tenant"); //_context.Stock.FindAsync(id);
|
|
|
|
if (project == null)
|
|
{
|
|
return NotFound(ApiResponse<object>.ErrorResponse("Project not found", "Project not found", 404));
|
|
|
|
}
|
|
else
|
|
{
|
|
//var project = projects.Where(c => c.Id == id).SingleOrDefault();
|
|
ProjectDetailsVM vm = await GetProjectViewModel(id, project);
|
|
|
|
ProjectVM projectVM = new ProjectVM();
|
|
if (vm.project != null)
|
|
{
|
|
projectVM.Id = vm.project.Id;
|
|
projectVM.Name = vm.project.Name;
|
|
projectVM.ProjectAddress = vm.project.ProjectAddress;
|
|
projectVM.ContactPerson = vm.project.ContactPerson;
|
|
projectVM.StartDate = vm.project.StartDate;
|
|
projectVM.EndDate = vm.project.EndDate;
|
|
projectVM.ProjectStatusId = vm.project.ProjectStatusId;
|
|
}
|
|
projectVM.Buildings = new List<BuildingVM>();
|
|
if (vm.buildings != null)
|
|
{
|
|
foreach (Building build in vm.buildings)
|
|
{
|
|
BuildingVM buildVM = new BuildingVM() { Id = build.Id, Description = build.Description, Name = build.Name };
|
|
buildVM.Floors = new List<FloorsVM>();
|
|
if (vm.floors != null)
|
|
{
|
|
foreach (Floor floorDto in vm.floors.Where(c => c.BuildingId == build.Id).ToList())
|
|
{
|
|
FloorsVM floorVM = new FloorsVM() { FloorName = floorDto.FloorName, Id = floorDto.Id };
|
|
floorVM.WorkAreas = new List<WorkAreaVM>();
|
|
|
|
if (vm.workAreas != null)
|
|
{
|
|
foreach (WorkArea workAreaDto in vm.workAreas.Where(c => c.FloorId == floorVM.Id).ToList())
|
|
{
|
|
WorkAreaVM workAreaVM = new WorkAreaVM() { Id = workAreaDto.Id, AreaName = workAreaDto.AreaName, WorkItems = new List<WorkItemVM>() };
|
|
|
|
if (vm.workItems != null)
|
|
{
|
|
foreach (WorkItem workItemDto in vm.workItems.Where(c => c.WorkAreaId == workAreaDto.Id).ToList())
|
|
{
|
|
WorkItemVM workItemVM = new WorkItemVM() { WorkItemId = workItemDto.Id, WorkItem = workItemDto };
|
|
//workItemVM.WorkItem.WorkArea = null
|
|
workItemVM.WorkItem.WorkArea = new WorkArea();
|
|
//workItemVM.WorkItem.ActivityMaster.Tenant = null;
|
|
if (workItemVM.WorkItem.ActivityMaster != null)
|
|
{
|
|
workItemVM.WorkItem.ActivityMaster.Tenant = new Tenant();
|
|
}
|
|
//workItemVM.WorkItem.Tenant = null;
|
|
workItemVM.WorkItem.Tenant = new Tenant();
|
|
|
|
|
|
|
|
workAreaVM.WorkItems.Add(workItemVM);
|
|
}
|
|
}
|
|
|
|
floorVM.WorkAreas.Add(workAreaVM);
|
|
}
|
|
}
|
|
|
|
buildVM.Floors.Add(floorVM);
|
|
}
|
|
}
|
|
projectVM.Buildings.Add(buildVM);
|
|
}
|
|
}
|
|
return Ok(ApiResponse<object>.SuccessResponse(projectVM, "Success.", 200));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
private async Task<ProjectDetailsVM> GetProjectViewModel(Guid? id, Project project)
|
|
{
|
|
ProjectDetailsVM vm = new ProjectDetailsVM();
|
|
|
|
// List<Building> buildings = _unitOfWork.Building.GetAll(c => c.ProjectId == id).ToList();
|
|
List<Building> buildings = await _context.Buildings.Where(c => c.ProjectId == id).ToListAsync();
|
|
List<Guid> idList = buildings.Select(o => o.Id).ToList();
|
|
// List<Floor> floors = _unitOfWork.Floor.GetAll(c => idList.Contains(c.Id)).ToList();
|
|
List<Floor> floors = await _context.Floor.Where(c => idList.Contains(c.BuildingId)).ToListAsync();
|
|
idList = floors.Select(o => o.Id).ToList();
|
|
//List<WorkArea> workAreas = _unitOfWork.WorkArea.GetAll(c => idList.Contains(c.Id), includeProperties: "WorkItems,WorkItems.ActivityMaster").ToList();
|
|
|
|
List<WorkArea> workAreas = await _context.WorkAreas.Where(c => idList.Contains(c.FloorId)).ToListAsync();
|
|
|
|
idList = workAreas.Select(o => o.Id).ToList();
|
|
List<WorkItem> workItems = await _context.WorkItems.Include(c => c.WorkCategoryMaster).Where(c => idList.Contains(c.WorkAreaId)).Include(c => c.ActivityMaster).ToListAsync();
|
|
// List <WorkItem> workItems = _unitOfWork.WorkItem.GetAll(c => idList.Contains(c.WorkAreaId), includeProperties: "ActivityMaster").ToList();
|
|
|
|
vm.project = project;
|
|
vm.buildings = buildings;
|
|
vm.floors = floors;
|
|
vm.workAreas = workAreas;
|
|
vm.workItems = workItems;
|
|
|
|
return vm;
|
|
}
|
|
|
|
private Guid GetTenantId()
|
|
{
|
|
return _userHelper.GetTenantId();
|
|
//var tenant = User.FindFirst("TenantId")?.Value;
|
|
//return (tenant != null ? Convert.ToInt32(tenant) : 1);
|
|
}
|
|
|
|
[HttpPost]
|
|
public async Task<IActionResult> Create([FromBody] CreateProjectDto projectDto)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
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);
|
|
|
|
_context.Projects.Add(project);
|
|
|
|
await _context.SaveChangesAsync();
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(project.ToProjectDto(), "Success.", 200));
|
|
}
|
|
|
|
[HttpPut]
|
|
[Route("update/{id}")]
|
|
public async Task<IActionResult> Update([FromRoute] Guid id, [FromBody] UpdateProjectDto updateProjectDto)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
var errors = ModelState.Values
|
|
.SelectMany(v => v.Errors)
|
|
.Select(e => e.ErrorMessage)
|
|
.ToList();
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
|
|
|
|
}
|
|
try
|
|
{
|
|
Guid TenantId = GetTenantId();
|
|
|
|
Project project = updateProjectDto.ToProjectFromUpdateProjectDto(TenantId, id);
|
|
_context.Projects.Update(project);
|
|
|
|
await _context.SaveChangesAsync();
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(project.ToProjectDto(), "Success.", 200));
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ApiResponse<object>.ErrorResponse(ex.Message, ex, 400));
|
|
}
|
|
}
|
|
|
|
|
|
//[HttpPost("assign-employee")]
|
|
//public async Task<IActionResult> AssignEmployee(int? allocationid, int employeeId, int projectId)
|
|
//{
|
|
// var employee = await _context.Employees.FindAsync(employeeId);
|
|
// var project = _projectrepo.Get(c => c.Id == projectId);
|
|
// if (employee == null || project == null)
|
|
// {
|
|
// return NotFound();
|
|
// }
|
|
|
|
// // Logic to add the product to a new table (e.g., selected products)
|
|
|
|
// if (allocationid == null)
|
|
// {
|
|
// // Add allocation
|
|
// ProjectAllocation allocation = new ProjectAllocation()
|
|
// {
|
|
// EmployeeId = employeeId,
|
|
// ProjectId = project.Id,
|
|
// AllocationDate = DateTime.UtcNow,
|
|
// //EmployeeRole = employee.Rol
|
|
// TenantId = project.TenantId
|
|
// };
|
|
|
|
// _unitOfWork.ProjectAllocation.CreateAsync(allocation);
|
|
// }
|
|
// else
|
|
// {
|
|
// //remove allocation
|
|
// var allocation = await _context.ProjectAllocations.FindAsync(allocationid);
|
|
// if (allocation != null)
|
|
// {
|
|
// allocation.ReAllocationDate = DateTime.UtcNow;
|
|
|
|
// _unitOfWork.ProjectAllocation.UpdateAsync(allocation.Id, allocation);
|
|
// }
|
|
// else
|
|
// {
|
|
// return NotFound();
|
|
// }
|
|
// }
|
|
|
|
// return Ok();
|
|
//}
|
|
|
|
[HttpGet]
|
|
[Route("employees/get/{projectid?}/{includeInactive?}")]
|
|
public async Task<IActionResult> GetEmployeeByProjectID(Guid? projectid, bool includeInactive = false)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
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();
|
|
|
|
if (projectid != null)
|
|
{
|
|
// Fetch assigned project
|
|
List<Employee> result = new List<Employee>();
|
|
|
|
if ((bool)includeInactive)
|
|
{
|
|
|
|
result = await (from rpm in _context.Employees.Include(c => c.JobRole)
|
|
join fp in _context.ProjectAllocations.Where(c => c.TenantId == TenantId && c.ProjectId == projectid)
|
|
on rpm.Id equals fp.EmployeeId
|
|
select rpm).ToListAsync();
|
|
}
|
|
else
|
|
{
|
|
result = await (from rpm in _context.Employees.Include(c => c.JobRole)
|
|
join fp in _context.ProjectAllocations.Where(c => c.TenantId == TenantId && c.ProjectId == projectid && c.IsActive == true)
|
|
on rpm.Id equals fp.EmployeeId
|
|
select rpm).ToListAsync();
|
|
}
|
|
|
|
List<EmployeeVM> resultVM = new List<EmployeeVM>();
|
|
foreach (Employee employee in result)
|
|
{
|
|
EmployeeVM vm = employee.ToEmployeeVMFromEmployee();
|
|
resultVM.Add(vm);
|
|
}
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(resultVM, "Success.", 200));
|
|
}
|
|
else
|
|
{
|
|
return NotFound(ApiResponse<object>.ErrorResponse("Invalid Input Parameter", 404));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
[HttpGet]
|
|
[Route("allocation/{projectId}")]
|
|
public async Task<IActionResult> GetProjectAllocation(Guid? projectId)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
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 employees = await _context.ProjectAllocations
|
|
.Where(c => c.TenantId == TenantId && c.ProjectId == projectId && c.Employee != null)
|
|
.Include(e => e.Employee)
|
|
.Select(e => new
|
|
{
|
|
ID = e.Id,
|
|
EmployeeId = e.EmployeeId,
|
|
ProjectId = e.ProjectId,
|
|
AllocationDate = e.AllocationDate,
|
|
ReAllocationDate = e.ReAllocationDate,
|
|
FirstName = e.Employee != null ? e.Employee.FirstName : string.Empty,
|
|
LastName = e.Employee != null ? e.Employee.LastName : string.Empty,
|
|
MiddleName = e.Employee != null ? e.Employee.MiddleName : string.Empty,
|
|
IsActive = e.IsActive,
|
|
JobRoleId = (e.JobRoleId != null ? e.JobRoleId : e.Employee != null ? e.Employee.JobRoleId : null)
|
|
}).ToListAsync();
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(employees, "Success.", 200));
|
|
}
|
|
|
|
[HttpPost("allocation")]
|
|
public async Task<IActionResult> ManageAllocation(List<ProjectAllocationDot> projectAllocationDot)
|
|
{
|
|
if (projectAllocationDot != null)
|
|
{
|
|
Guid TenentID = GetTenantId();
|
|
List<object>? result = new List<object>();
|
|
|
|
foreach (var item in projectAllocationDot)
|
|
{
|
|
try
|
|
{
|
|
ProjectAllocation projectAllocation = item.ToProjectAllocationFromProjectAllocationDto(TenentID);
|
|
ProjectAllocation? projectAllocationFromDb = await _context.ProjectAllocations.Where(c => c.EmployeeId == projectAllocation.EmployeeId
|
|
&& c.ProjectId == projectAllocation.ProjectId
|
|
&& c.ReAllocationDate == null
|
|
&& c.TenantId == TenentID).SingleOrDefaultAsync();
|
|
|
|
if (projectAllocationFromDb != null)
|
|
{
|
|
_context.ProjectAllocations.Attach(projectAllocationFromDb);
|
|
|
|
if (item.Status)
|
|
{
|
|
projectAllocationFromDb.JobRoleId = projectAllocation.JobRoleId; ;
|
|
projectAllocationFromDb.IsActive = true;
|
|
_context.Entry(projectAllocationFromDb).Property(e => e.JobRoleId).IsModified = true;
|
|
_context.Entry(projectAllocationFromDb).Property(e => e.IsActive).IsModified = true;
|
|
}
|
|
else
|
|
{
|
|
projectAllocationFromDb.ReAllocationDate = DateTime.Now;
|
|
projectAllocationFromDb.IsActive = false;
|
|
_context.Entry(projectAllocationFromDb).Property(e => e.ReAllocationDate).IsModified = true;
|
|
_context.Entry(projectAllocationFromDb).Property(e => e.IsActive).IsModified = true;
|
|
}
|
|
await _context.SaveChangesAsync();
|
|
var result1 = new
|
|
{
|
|
Id = projectAllocationFromDb.Id,
|
|
EmployeeId = projectAllocation.EmployeeId,
|
|
JobRoleId = projectAllocation.JobRoleId,
|
|
IsActive = projectAllocation.IsActive,
|
|
ProjectId = projectAllocation.ProjectId,
|
|
AllocationDate = projectAllocation.AllocationDate,
|
|
ReAllocationDate = projectAllocation.ReAllocationDate,
|
|
TenantId = projectAllocation.TenantId
|
|
};
|
|
result.Add(result1);
|
|
}
|
|
else
|
|
{
|
|
projectAllocation.AllocationDate = DateTime.Now;
|
|
projectAllocation.IsActive = true;
|
|
_context.ProjectAllocations.Add(projectAllocation);
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return Ok(ApiResponse<object>.ErrorResponse(ex.Message, ex, 400));
|
|
}
|
|
}
|
|
|
|
return Ok(ApiResponse<object>.SuccessResponse(result, "Data saved successfully", 200));
|
|
|
|
}
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid details.", "Work Item Details are not valid.", 400));
|
|
|
|
}
|
|
|
|
[HttpPost("task")]
|
|
public async Task<IActionResult> CreateProjectTask(List<WorkItemDot> workItemDot)
|
|
{
|
|
Guid tenantId = GetTenantId();
|
|
List<WorkItemVM> workItems = new List<WorkItemVM> { };
|
|
string responseMessage = "";
|
|
if (workItemDot != null)
|
|
{
|
|
foreach (var item in workItemDot)
|
|
{
|
|
WorkItem workItem = item.ToWorkItemFromWorkItemDto(tenantId);
|
|
|
|
if (item.Id != null)
|
|
{
|
|
//update
|
|
_context.WorkItems.Update(workItem);
|
|
await _context.SaveChangesAsync();
|
|
responseMessage = "Task Added Successfully";
|
|
}
|
|
else
|
|
{
|
|
//create
|
|
_context.WorkItems.Add(workItem);
|
|
await _context.SaveChangesAsync();
|
|
responseMessage = "Task Updated Successfully";
|
|
}
|
|
var result = new WorkItemVM
|
|
{
|
|
WorkItemId = workItem.Id,
|
|
WorkItem = workItem
|
|
};
|
|
workItems.Add(result);
|
|
}
|
|
var activity = await _context.ActivityMasters.ToListAsync();
|
|
var category = await _context.WorkCategoryMasters.ToListAsync();
|
|
return Ok(ApiResponse<object>.SuccessResponse(workItems, responseMessage, 200));
|
|
}
|
|
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid details.", "Work Item Details are not valid.", 400));
|
|
|
|
}
|
|
|
|
[HttpDelete("task/{id}")]
|
|
public async Task<IActionResult> DeleteProjectTask(Guid id)
|
|
{
|
|
Guid tenantId = _userHelper.GetTenantId();
|
|
WorkItem? task = await _context.WorkItems.AsNoTracking().FirstOrDefaultAsync(t => t.Id == id && t.TenantId == tenantId);
|
|
if (task != null)
|
|
{
|
|
if (task.CompletedWork == 0)
|
|
{
|
|
var assignedTask = await _context.TaskAllocations.Where(t => t.WorkItemId == id).ToListAsync();
|
|
if (assignedTask.Count == 0)
|
|
{
|
|
_context.WorkItems.Remove(task);
|
|
await _context.SaveChangesAsync();
|
|
_logger.LogInfo("Task with ID {WorkItemId} has been successfully deleted.", task.Id);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("Task with ID {WorkItemId} is currently assigned and cannot be deleted.", task.Id);
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Task is currently assigned and cannot be deleted.", "Task is currently assigned and cannot be deleted.", 400));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double percentage = (task.CompletedWork / task.PlannedWork) * 100;
|
|
percentage = Math.Round(percentage, 2);
|
|
_logger.LogWarning("Task with ID {WorkItemId} is {CompletionPercentage}% complete and cannot be deleted", task.Id, percentage);
|
|
return BadRequest(ApiResponse<object>.ErrorResponse(System.String.Format("Task is {0}% complete and cannot be deleted", percentage), System.String.Format("Task is {0}% complete and cannot be deleted", percentage), 400));
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogError("Task with ID {WorkItemId} not found ID database", id);
|
|
}
|
|
return Ok(ApiResponse<object>.SuccessResponse(new { }, "Task deleted successfully", 200));
|
|
}
|
|
|
|
[HttpPost("manage-infra")]
|
|
public async Task<IActionResult> ManageProjectInfra(List<InfraDot> infraDots)
|
|
{
|
|
Guid tenantId = GetTenantId();
|
|
var responseData = new InfraVM { };
|
|
string responseMessage = "";
|
|
if (infraDots != null)
|
|
{
|
|
foreach (var item in infraDots)
|
|
{
|
|
if (item.Building != null)
|
|
{
|
|
|
|
Building building = item.Building.ToBuildingFromBuildingDto(tenantId);
|
|
building.TenantId = GetTenantId();
|
|
|
|
if (item.Building.Id == null)
|
|
{
|
|
//create
|
|
_context.Buildings.Add(building);
|
|
await _context.SaveChangesAsync();
|
|
responseData.building = building;
|
|
responseMessage = "Buliding Added Successfully";
|
|
}
|
|
else
|
|
{
|
|
//update
|
|
_context.Buildings.Update(building);
|
|
await _context.SaveChangesAsync();
|
|
responseData.building = building;
|
|
responseMessage = "Buliding Updated Successfully";
|
|
|
|
}
|
|
}
|
|
if (item.Floor != null)
|
|
{
|
|
Floor floor = item.Floor.ToFloorFromFloorDto(tenantId);
|
|
floor.TenantId = GetTenantId();
|
|
|
|
if (item.Floor.Id == null)
|
|
{
|
|
//create
|
|
_context.Floor.Add(floor);
|
|
await _context.SaveChangesAsync();
|
|
responseData.floor = floor;
|
|
responseMessage = "Floor Added Successfully";
|
|
}
|
|
else
|
|
{
|
|
//update
|
|
_context.Floor.Update(floor);
|
|
await _context.SaveChangesAsync();
|
|
responseData.floor = floor;
|
|
responseMessage = "Floor Updated Successfully";
|
|
}
|
|
}
|
|
if (item.WorkArea != null)
|
|
{
|
|
WorkArea workArea = item.WorkArea.ToWorkAreaFromWorkAreaDto(tenantId);
|
|
workArea.TenantId = GetTenantId();
|
|
|
|
if (item.WorkArea.Id == null)
|
|
{
|
|
//create
|
|
_context.WorkAreas.Add(workArea);
|
|
await _context.SaveChangesAsync();
|
|
responseData.workArea = workArea;
|
|
responseMessage = "Work Area Added Successfully";
|
|
}
|
|
else
|
|
{
|
|
//update
|
|
_context.WorkAreas.Update(workArea);
|
|
await _context.SaveChangesAsync();
|
|
responseData.workArea = workArea;
|
|
responseMessage = "Work Area Updated Successfully";
|
|
}
|
|
}
|
|
}
|
|
return Ok(ApiResponse<object>.SuccessResponse(responseData, responseMessage, 200));
|
|
}
|
|
return BadRequest(ApiResponse<object>.ErrorResponse("Invalid details.", "Infra Details are not valid.", 400));
|
|
|
|
}
|
|
|
|
}
|
|
} |