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

Activity_Hierarchy #94

Open
ashutosh.nehete wants to merge 15 commits from Activity_Hierarchy into main
pull from: Activity_Hierarchy
merge into: admin:main
Conversation 0 Commits 15 Files Changed 19 +74 -135
1 changed files with 74 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit f6fa0bee1e - Show all commits

207
Marco.Pms.Services/Controllers/MasterController.cs
View File

@ -1,12 +1,10 @@
using Marco.Pms.DataAccess.Data; using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Dtos.Activities; using Marco.Pms.Model.Dtos.Activities;
using Marco.Pms.Model.Dtos.Master; using Marco.Pms.Model.Dtos.Master;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Forum; using Marco.Pms.Model.Forum;
using Marco.Pms.Model.Mapper; using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Master; using Marco.Pms.Model.Master;
using Marco.Pms.Model.Utilities; using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Activities;
using Marco.Pms.Model.ViewModels.Forum; using Marco.Pms.Model.ViewModels.Forum;
using Marco.Pms.Model.ViewModels.Master; using Marco.Pms.Model.ViewModels.Master;
using Marco.Pms.Services.Helpers; using Marco.Pms.Services.Helpers;
@ -35,155 +33,96 @@ namespace Marco.Pms.Services.Controllers
_masterHelper = masterHelper; _masterHelper = masterHelper;
} }
// -------------------------------- Activity -------------------------------- // -------------------------------- Services --------------------------------
[HttpGet]
[Route("activities")] [HttpGet("services")]
public async Task<IActionResult> GetActivitiesMaster() public async Task<IActionResult> GetServices()
{ {
Guid tenantId = _userHelper.GetTenantId(); var response = await _masterHelper.GetServices();
var activities = await _context.ActivityMasters.Where(c => c.TenantId == tenantId && c.IsActive == true).ToListAsync(); return StatusCode(response.StatusCode, response);
List<ActivityVM> activitiesVM = new List<ActivityVM>();
foreach (var activity in activities)
{
var checkList = await _context.ActivityCheckLists.Where(c => c.TenantId == tenantId && c.ActivityId == activity.Id).ToListAsync();
List<CheckListVM> checkListVM = new List<CheckListVM>();
if (checkList != null)
{
foreach (ActivityCheckList check in checkList)
{
var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
checkListVM.Add(checkVM);
}
} }
ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM); [HttpPost("service")]
activitiesVM.Add(activityVM); public async Task<IActionResult> CreateService([FromBody] ServiceMasterDto serviceMasterDto)
{
var response = await _masterHelper.CreateService(serviceMasterDto);
return StatusCode(response.StatusCode, response);
} }
_logger.LogInfo("{count} activity records fetched successfully from tenant {tenantId}", activitiesVM.Count, tenantId);
return Ok(ApiResponse<object>.SuccessResponse(activitiesVM, System.String.Format("{0} activity records fetched successfully", activitiesVM.Count), 200)); [HttpPut("service/{id}")]
public async Task<IActionResult> UpdateService(Guid id, [FromBody] ServiceMasterDto serviceMasterDto)
{
var response = await _masterHelper.UpdateService(id, serviceMasterDto);
return StatusCode(response.StatusCode, response);
}
[HttpDelete("service/{id}")]
public async Task<IActionResult> DeleteService(Guid id, [FromQuery] bool? isActive)
{
var response = await _masterHelper.DeleteService(id, isActive ?? false);
return StatusCode(response.StatusCode, response);
}
// -------------------------------- Activity Group --------------------------------
[HttpGet("activity-groups")]
public async Task<IActionResult> GetActivityGroups()
{
var response = await _masterHelper.GetActivityGroups();
return StatusCode(response.StatusCode, response);
}
[HttpPost("activity-group")]
public async Task<IActionResult> CreateActivityGroup([FromBody] ActivityGroupDto activityGroupDto)
{
var response = await _masterHelper.CreateActivityGroup(activityGroupDto);
return StatusCode(response.StatusCode, response);
}
[HttpPut("activity-group/{id}")]
public async Task<IActionResult> UpdateActivityGroup(Guid id, [FromBody] ActivityGroupDto activityGroupDto)
{
var response = await _masterHelper.UpdateActivityGroup(id, activityGroupDto);
return StatusCode(response.StatusCode, response);
}
[HttpDelete("activity-group/{id}")]
public async Task<IActionResult> DeleteActivityGroup(Guid id, [FromQuery] bool? isActive)
{
var response = await _masterHelper.DeleteActivityGroup(id, isActive ?? false);
return StatusCode(response.StatusCode, response);
}
// -------------------------------- Activity --------------------------------
[HttpGet("activities")]
public async Task<IActionResult> GetActivitiesMaster()
{
var response = await _masterHelper.GetActivitiesMaster();
return StatusCode(response.StatusCode, response);
} }
[HttpPost("activity")] [HttpPost("activity")]
public async Task<IActionResult> CreateActivity([FromBody] CreateActivityMasterDto createActivity) public async Task<IActionResult> CreateActivity([FromBody] CreateActivityMasterDto createActivity)
{ {
Guid tenantId = _userHelper.GetTenantId(); var response = await _masterHelper.CreateActivity(createActivity);
var employee = await _userHelper.GetCurrentEmployeeAsync(); return StatusCode(response.StatusCode, response);
if (employee.TenantId != tenantId)
{
_logger.LogWarning("User from tenant {employeeTenantId} tries to access data from tenant {tenantId}", employee.TenantId, tenantId);
return Unauthorized(ApiResponse<object>.ErrorResponse("Current tenant did not match with user's tenant", "Current tenant did not match with user's tenant", 401));
}
var activityMaster = createActivity.ToActivityMasterFromCreateActivityMasterDto(tenantId);
_context.ActivityMasters.Add(activityMaster);
await _context.SaveChangesAsync();
List<CheckListVM> checkListVM = new List<CheckListVM>();
if (createActivity.CheckList != null)
{
List<ActivityCheckList> activityCheckList = new List<ActivityCheckList>();
foreach (var check in createActivity.CheckList)
{
ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activityMaster.Id);
activityCheckList.Add(checkList);
}
_context.ActivityCheckLists.AddRange(activityCheckList);
await _context.SaveChangesAsync();
foreach (ActivityCheckList check in activityCheckList)
{
var checkVM = check.ToCheckListVMFromActivityCheckList(activityMaster.Id, false);
checkListVM.Add(checkVM);
}
}
ActivityVM activityVM = activityMaster.ToActivityVMFromActivityMaster(checkListVM);
_logger.LogInfo("activity created successfully from tenant {tenantId}", tenantId);
return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity created successfully", 200));
} }
[HttpPost("activity/edit/{id}")] [HttpPut("activity/{id}")]
public async Task<IActionResult> UpdateActivity(Guid id, [FromBody] CreateActivityMasterDto createActivity) public async Task<IActionResult> UpdateActivity(Guid id, [FromBody] CreateActivityMasterDto createActivity)
{ {
Guid tenantId = _userHelper.GetTenantId(); var response = await _masterHelper.UpdateActivity(id, createActivity);
var employee = await _userHelper.GetCurrentEmployeeAsync(); return StatusCode(response.StatusCode, response);
ActivityMaster? activity = await _context.ActivityMasters.FirstOrDefaultAsync(x => x.Id == id && x.IsActive == true && x.TenantId == tenantId);
if (activity != null && createActivity.UnitOfMeasurement != null && createActivity.ActivityName != null)
{
activity.ActivityName = createActivity.ActivityName;
activity.UnitOfMeasurement = createActivity.UnitOfMeasurement;
List<ActivityCheckList> activityCheckLists = await _context.ActivityCheckLists.AsNoTracking().Where(c => c.ActivityId == activity.Id).ToListAsync();
List<CheckListVM> checkListVM = new List<CheckListVM>();
if (createActivity.CheckList != null)
{
var newCheckIds = createActivity.CheckList.Select(c => c.Id);
List<ActivityCheckList> updateCheckList = new List<ActivityCheckList>();
List<ActivityCheckList> deleteCheckList = new List<ActivityCheckList>();
if (newCheckIds.Contains(null))
{
foreach (var check in createActivity.CheckList)
{
if (check.Id == null)
{
ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id);
updateCheckList.Add(checkList);
}
}
}
foreach (var check in activityCheckLists)
{
if (newCheckIds.Contains(check.Id))
{
var updatedCheck = createActivity.CheckList.Find(c => c.Id == check.Id);
ActivityCheckList checkList = updatedCheck != null ? updatedCheck.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id) : new ActivityCheckList();
updateCheckList.Add(checkList);
}
else
{
deleteCheckList.Add(check);
}
}
_context.ActivityCheckLists.UpdateRange(updateCheckList);
if (deleteCheckList != null)
{
_context.ActivityCheckLists.RemoveRange(deleteCheckList);
}
await _context.SaveChangesAsync();
foreach (ActivityCheckList check in updateCheckList)
{
var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
checkListVM.Add(checkVM);
}
}
else if (activityCheckLists != null)
{
_context.ActivityCheckLists.RemoveRange(activityCheckLists);
await _context.SaveChangesAsync();
}
ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
_logger.LogInfo("activity updated successfully from tenant {tenantId}", tenantId);
return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity updated successfully", 200));
}
_logger.LogError("Activity {ActivityId} not found", id);
return NotFound(ApiResponse<object>.ErrorResponse("Activity not found", "Activity not found", 404));
} }
[HttpDelete("activity/delete/{id}")] [HttpDelete("activity/{id}")]
public async Task<IActionResult> DeleteActivity(Guid Id) public async Task<IActionResult> DeleteActivity(Guid id, [FromQuery] bool? isActive)
{ {
Guid tenantId = _userHelper.GetTenantId(); var response = await _masterHelper.DeleteActivity(id, isActive ?? false);
var activity = await _context.ActivityMasters.FirstOrDefaultAsync(a => a.Id == Id && a.TenantId == tenantId); return StatusCode(response.StatusCode, response);
if (activity != null)
{
activity.IsActive = false;
}
await _context.SaveChangesAsync();
_logger.LogInfo("Activity Deleted Successfully from tenant {tenantId}", tenantId);
return Ok(ApiResponse<object>.SuccessResponse(new { }, "Activity Deleted Successfully", 200));
} }
// -------------------------------- Industry -------------------------------- // -------------------------------- Industry --------------------------------