1649 lines
62 KiB
C#
1649 lines
62 KiB
C#
using Azure.Core;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Identity;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Mono.TextTemplating;
|
|
using Newtonsoft.Json;
|
|
using PSTW_CentralSystem.Areas.OTcalculate.Models;
|
|
using PSTW_CentralSystem.Controllers.API;
|
|
using PSTW_CentralSystem.Controllers.API.Inventory;
|
|
using PSTW_CentralSystem.DBContext;
|
|
using PSTW_CentralSystem.Models;
|
|
using System.ComponentModel.Design;
|
|
using System.Data;
|
|
using System;
|
|
using System.Threading.Tasks;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using static System.Collections.Specialized.BitVector32;
|
|
using System.Security.Claims;
|
|
using Microsoft.VisualStudio.Web.CodeGenerators.Mvc.Templates.BlazorIdentity.Pages;
|
|
using Microsoft.AspNetCore.Mvc.Rendering;
|
|
using QuestPDF.Fluent;
|
|
using QuestPDF.Helpers;
|
|
using QuestPDF.Infrastructure;
|
|
using PSTW_CentralSystem.Areas.OTcalculate.Services;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using DocumentFormat.OpenXml.InkML;
|
|
|
|
|
|
namespace PSTW_CentralSystem.Controllers.API
|
|
{
|
|
[ApiController]
|
|
[Route("[controller]")]
|
|
public class OvertimeAPI : Controller
|
|
{
|
|
private readonly ILogger<OvertimeAPI> _logger;
|
|
private readonly CentralSystemContext _centralDbContext;
|
|
private readonly UserManager<UserModel> _userManager;
|
|
private readonly OvertimePdfService _pdfService;
|
|
private readonly IWebHostEnvironment _env;
|
|
private readonly OvertimeExcelService _excelService;
|
|
|
|
public OvertimeAPI(ILogger<OvertimeAPI> logger, CentralSystemContext centralDbContext, UserManager<UserModel> userManager, OvertimePdfService pdfService, IWebHostEnvironment env, OvertimeExcelService excelService)
|
|
{
|
|
_logger = logger;
|
|
_centralDbContext = centralDbContext;
|
|
_userManager = userManager;
|
|
_pdfService = pdfService;
|
|
_env = env;
|
|
_excelService = excelService;
|
|
}
|
|
|
|
#region Settings
|
|
[HttpGet("GetUpdateDates")]
|
|
public IActionResult GetUpdateDates()
|
|
{
|
|
try
|
|
{
|
|
|
|
var latestRateUpdate = _centralDbContext.Rates.OrderByDescending(r => r.LastUpdated).FirstOrDefault()?.LastUpdated;
|
|
var latestCalendarUpdate = _centralDbContext.Holidays.OrderByDescending(c => c.LastUpdated).FirstOrDefault()?.LastUpdated;
|
|
var latestFlexiHourUpdate = _centralDbContext.Hrusersetting.OrderByDescending(r => r.FlexiHourUpdate).FirstOrDefault()?.FlexiHourUpdate;
|
|
var latestRegionUpdate = _centralDbContext.Hrusersetting.OrderByDescending(c => c.StateUpdate).FirstOrDefault()?.StateUpdate;
|
|
var latestApprovalFlowUpdate = _centralDbContext.Hrusersetting.OrderByDescending(c => c.ApprovalUpdate).FirstOrDefault()?.ApprovalUpdate;
|
|
|
|
var updateDates = new
|
|
{
|
|
rateUpdateDate = latestRateUpdate.HasValue ? latestRateUpdate.Value.ToString("dd MMMM yyyy") : null,
|
|
calendarUpdateDate = latestCalendarUpdate.HasValue ? latestCalendarUpdate.Value.ToString("dd MMMM yyyy") : null,
|
|
flexiHourUpdateDate = latestFlexiHourUpdate.HasValue ? latestFlexiHourUpdate.Value.ToString("dd MMMM yyyy") : null,
|
|
regionUpdateDate = latestRegionUpdate.HasValue ? latestRegionUpdate.Value.ToString("dd MMMM yyyy") : null,
|
|
approvalFlowUpdateDate = latestApprovalFlowUpdate.HasValue ? latestApprovalFlowUpdate.Value.ToString("dd MMMM yyyy") : null
|
|
};
|
|
|
|
return Json(updateDates);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Rate
|
|
[HttpPost("UpdateRates")]
|
|
public async Task<IActionResult> UpdateRate([FromBody] List<RateModel> rates)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (var rate in rates)
|
|
{
|
|
var existingRate = await _centralDbContext.Rates
|
|
.FirstOrDefaultAsync(r => r.UserId == rate.UserId);
|
|
|
|
if (existingRate != null)
|
|
{
|
|
existingRate.RateValue = rate.RateValue;
|
|
existingRate.LastUpdated = DateTime.Now;
|
|
_centralDbContext.Rates.Update(existingRate);
|
|
}
|
|
else
|
|
{
|
|
_centralDbContext.Rates.Add(new RateModel
|
|
{
|
|
UserId = rate.UserId,
|
|
RateValue = rate.RateValue,
|
|
LastUpdated = DateTime.Now
|
|
});
|
|
}
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
var updatedRates = await _centralDbContext.Rates
|
|
.Include(r => r.Users)
|
|
.Select(r => new
|
|
{
|
|
r.RateId,
|
|
r.RateValue,
|
|
r.UserId,
|
|
FullName = r.Users.FullName,
|
|
DepartmentName = r.Users.Department.DepartmentName
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(updatedRates);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost("GetUserRates")]
|
|
public async Task<IActionResult> GetUserRates()
|
|
{
|
|
try
|
|
{
|
|
var userRates = await _centralDbContext.Rates
|
|
.Include(rates => rates.Users)
|
|
.ThenInclude(user => user.Department)
|
|
.Select(rates => new
|
|
{
|
|
rates.RateId,
|
|
rates.RateValue,
|
|
rates.UserId,
|
|
rates.Users.FullName,
|
|
rates.Users.Department.DepartmentName
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(userRates);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region FlexiHour State Approval
|
|
private async Task UpdateOrInsertUserSettingAsync(int userId, int? flexiHourId = null, int? stateId = null, int? approvalFlowId = null)
|
|
{
|
|
var setting = await _centralDbContext.Hrusersetting
|
|
.FirstOrDefaultAsync(h => h.UserId == userId);
|
|
|
|
if (setting != null)
|
|
{
|
|
if (flexiHourId.HasValue)
|
|
{
|
|
setting.FlexiHourId = flexiHourId;
|
|
setting.FlexiHourUpdate = DateTime.Now;
|
|
}
|
|
|
|
if (stateId.HasValue)
|
|
{
|
|
setting.StateId = stateId;
|
|
setting.StateUpdate = DateTime.Now;
|
|
}
|
|
|
|
if (approvalFlowId.HasValue)
|
|
{
|
|
setting.ApprovalFlowId = approvalFlowId;
|
|
setting.ApprovalUpdate = DateTime.Now;
|
|
}
|
|
|
|
_centralDbContext.Hrusersetting.Update(setting);
|
|
}
|
|
else
|
|
{
|
|
var newSetting = new HrUserSettingModel
|
|
{
|
|
UserId = userId,
|
|
FlexiHourId = flexiHourId,
|
|
FlexiHourUpdate = flexiHourId.HasValue ? DateTime.Now : null,
|
|
StateId = stateId,
|
|
StateUpdate = stateId.HasValue ? DateTime.Now : null,
|
|
ApprovalFlowId = approvalFlowId,
|
|
ApprovalUpdate = approvalFlowId.HasValue ? DateTime.Now : null
|
|
};
|
|
_centralDbContext.Hrusersetting.Add(newSetting);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region FlexiHour
|
|
[HttpGet("GetFlexiHours")]
|
|
public IActionResult GetAllFlexiHours()
|
|
{
|
|
var flexiHours = _centralDbContext.Flexihour
|
|
.Select(f => new { f.FlexiHourId, f.FlexiHour })
|
|
.ToList();
|
|
return Ok(flexiHours);
|
|
}
|
|
|
|
[HttpGet("GetUserFlexiHours")]
|
|
public async Task<IActionResult> GetUserFlexiHours()
|
|
{
|
|
try
|
|
{
|
|
var users = await _centralDbContext.Users
|
|
.Include(u => u.Department)
|
|
.ToListAsync();
|
|
|
|
var hrUserSettings = await _centralDbContext.Hrusersetting
|
|
.Include(hr => hr.FlexiHour)
|
|
.ToListAsync();
|
|
|
|
var result = users.Select(u => new
|
|
{
|
|
UserId = u.Id,
|
|
FullName = u.FullName,
|
|
DepartmentName = u.Department != null ? u.Department.DepartmentName : "N/A",
|
|
FlexiHour = hrUserSettings
|
|
.Where(hr => hr.UserId == u.Id)
|
|
.Select(hr => hr.FlexiHour != null ? hr.FlexiHour.FlexiHour : "N/A")
|
|
.FirstOrDefault() ?? "N/A",
|
|
State = hrUserSettings
|
|
.Where(hr => hr.UserId == u.Id)
|
|
.Select(hr => hr.State != null ? hr.State.StateName : "N/A")
|
|
.FirstOrDefault() ?? "N/A"
|
|
}).ToList();
|
|
|
|
// Log this data to inspect the response
|
|
Console.WriteLine(JsonConvert.SerializeObject(result)); // Debugging log
|
|
return Ok(result);
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(new { message = ex.Message });
|
|
}
|
|
}
|
|
|
|
|
|
[HttpPost("UpdateUserFlexiHours")]
|
|
public async Task<IActionResult> UpdateUserFlexiHours([FromBody] List<HrUserSettingModel> updates)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
|
|
try
|
|
{
|
|
foreach (var update in updates)
|
|
{
|
|
await UpdateOrInsertUserSettingAsync(update.UserId, flexiHourId: update.FlexiHourId);
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(new { message = ex.Message });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region State
|
|
[HttpGet("GetUserStates")]
|
|
public async Task<IActionResult> GetUserStates()
|
|
{
|
|
try
|
|
{
|
|
var users = await _centralDbContext.Users
|
|
.Include(u => u.Department)
|
|
.ToListAsync();
|
|
|
|
var hrUserSettings = await _centralDbContext.Hrusersetting
|
|
.Include(h => h.State)
|
|
.Include(h => h.Approvalflow)
|
|
.ToListAsync();
|
|
|
|
var result = users.Select(u =>
|
|
{
|
|
var hrSetting = hrUserSettings.FirstOrDefault(h => h.UserId == u.Id);
|
|
return new
|
|
{
|
|
u.Id,
|
|
u.FullName,
|
|
DepartmentName = u.Department != null ? u.Department.DepartmentName : "N/A",
|
|
State = hrSetting != null && hrSetting.State != null ? hrSetting.State.StateName : "N/A",
|
|
approvalName = hrSetting?.Approvalflow?.ApprovalName ?? "N/A"
|
|
};
|
|
}).ToList();
|
|
|
|
return Ok(result);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost("UpdateUserStates")]
|
|
public async Task<IActionResult> UpdateUserStates([FromBody] List<HrUserSettingModel> updates)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
|
|
try
|
|
{
|
|
foreach (var update in updates)
|
|
{
|
|
var existingSetting = await _centralDbContext.Hrusersetting.FirstOrDefaultAsync(h => h.UserId == update.UserId);
|
|
|
|
if (existingSetting != null)
|
|
{
|
|
existingSetting.StateId = update.StateId;
|
|
}
|
|
else
|
|
{
|
|
// Handle the case where a user setting doesn't exist.
|
|
// You might want to create a new one with a default ApprovalFlowId or return an error.
|
|
_centralDbContext.Hrusersetting.Add(new HrUserSettingModel
|
|
{
|
|
UserId = update.UserId,
|
|
StateId = update.StateId,
|
|
// Consider setting a default ApprovalFlowId here if needed
|
|
});
|
|
}
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(new { message = ex.Message });
|
|
}
|
|
}
|
|
|
|
[HttpPost("UpdateUserApprovalFlow")]
|
|
public async Task<IActionResult> UpdateUserApprovalFlow([FromBody] List<HrUserSettingModel> updates)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
|
|
try
|
|
{
|
|
foreach (var update in updates)
|
|
{
|
|
var existingSetting = await _centralDbContext.Hrusersetting.FirstOrDefaultAsync(h => h.UserId == update.UserId);
|
|
|
|
if (existingSetting != null)
|
|
{
|
|
existingSetting.ApprovalFlowId = update.ApprovalFlowId;
|
|
existingSetting.ApprovalUpdate = DateTime.Now;
|
|
}
|
|
else
|
|
{
|
|
_centralDbContext.Hrusersetting.Add(new HrUserSettingModel
|
|
{
|
|
UserId = update.UserId,
|
|
ApprovalFlowId = update.ApprovalFlowId,
|
|
ApprovalUpdate = DateTime.Now
|
|
});
|
|
}
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(new { message = ex.Message });
|
|
}
|
|
}
|
|
|
|
[HttpPost("UpdateApprovalFlow")]
|
|
public async Task<IActionResult> UpdateApprovalFlow([FromBody] ApprovalFlowModel model)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest("Invalid data");
|
|
|
|
var existing = await _centralDbContext.Approvalflow.FindAsync(model.ApprovalFlowId);
|
|
if (existing == null)
|
|
return NotFound("Approval flow not found");
|
|
|
|
existing.ApprovalName = model.ApprovalName;
|
|
existing.HoU = model.HoU;
|
|
existing.HoD = model.HoD;
|
|
existing.Manager = model.Manager;
|
|
existing.HR = model.HR;
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok();
|
|
}
|
|
|
|
[HttpGet("GetApprovalFlowList")]
|
|
public async Task<IActionResult> GetApprovalFlowList()
|
|
{
|
|
try
|
|
{
|
|
var flows = await _centralDbContext.Approvalflow
|
|
.Select(af => new
|
|
{
|
|
af.ApprovalFlowId,
|
|
af.ApprovalName,
|
|
hou = af.HoU,
|
|
hod = af.HoD,
|
|
manager = af.Manager,
|
|
hr = af.HR
|
|
})
|
|
.ToListAsync();
|
|
return Ok(flows);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, new { message = ex.Message });
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Approval Flow
|
|
|
|
[HttpPost("CreateApprovalFlow")]
|
|
public async Task<IActionResult> CreateApprovalFlow([FromBody] ApprovalFlowModel model)
|
|
{
|
|
if (string.IsNullOrEmpty(model.ApprovalName))
|
|
return BadRequest(new { message = "Approval Name is required." });
|
|
|
|
if (!model.HR.HasValue)
|
|
return BadRequest(new { message = "HR approver is required." });
|
|
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new { message = "Invalid approval flow data." });
|
|
|
|
try
|
|
{
|
|
_centralDbContext.Approvalflow.Add(model);
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok(new { message = "Approval flow created successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, new { message = $"Error saving approval flow: {ex.InnerException?.Message ?? ex.Message}" });
|
|
}
|
|
}
|
|
|
|
|
|
[HttpGet("GetApprovalFlowRecord")]
|
|
public async Task<IActionResult> GetApprovalFlowRecord()
|
|
{
|
|
try
|
|
{
|
|
var approvalFlows = await _centralDbContext.Approvalflow
|
|
.Select(af => new { af.ApprovalFlowId, af.ApprovalName })
|
|
.ToListAsync();
|
|
return Ok(approvalFlows);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, new { message = $"Error fetching approval flows: {ex.Message}" });
|
|
}
|
|
}
|
|
|
|
[HttpPut("EditApprovalFlow")]
|
|
public async Task<IActionResult> EditApprovalFlow([FromBody] ApprovalFlowModel model)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest("Invalid data.");
|
|
}
|
|
|
|
var existingFlow = await _centralDbContext.Approvalflow.FindAsync(model.ApprovalFlowId);
|
|
if (existingFlow == null)
|
|
{
|
|
return NotFound("Approval flow not found.");
|
|
}
|
|
|
|
// Update fields
|
|
existingFlow.ApprovalName = model.ApprovalName;
|
|
existingFlow.HoU = model.HoU;
|
|
existingFlow.HoD = model.HoD;
|
|
existingFlow.Manager = model.Manager;
|
|
existingFlow.HR = model.HR;
|
|
|
|
try
|
|
{
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok(new { message = "Approval flow updated successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log the exception
|
|
return StatusCode(500, new { message = "Failed to update approval flow.", detail = ex.Message });
|
|
}
|
|
}
|
|
|
|
[HttpDelete("DeleteApprovalFlow/{id}")]
|
|
public async Task<IActionResult> DeleteApprovalFlow(int id)
|
|
{
|
|
try
|
|
{
|
|
var approvalFlow = await _centralDbContext.Approvalflow.FindAsync(id);
|
|
if (approvalFlow == null)
|
|
{
|
|
return NotFound(new { message = "Approval flow not found." });
|
|
}
|
|
|
|
_centralDbContext.Approvalflow.Remove(approvalFlow);
|
|
await _centralDbContext.SaveChangesAsync();
|
|
return Ok(new { message = "Approval flow deleted successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, new { message = $"Error deleting approval flow: {ex.Message}" });
|
|
}
|
|
}
|
|
|
|
[HttpGet("GetAllUsers")]
|
|
public async Task<IActionResult> GetAllUsers()
|
|
{
|
|
try
|
|
{
|
|
var users = await _centralDbContext.Users
|
|
.Select(u => new { u.Id, u.FullName })
|
|
.ToListAsync();
|
|
return Ok(users);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return StatusCode(500, new { message = ex.Message });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Calendar
|
|
[HttpGet("GetStatesName")]
|
|
public async Task<IActionResult> GetStatesName()
|
|
{
|
|
try
|
|
{
|
|
var states = await _centralDbContext.States
|
|
.Select(s => new
|
|
{
|
|
s.StateId,
|
|
s.StateName
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(states);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpPost("UpdateHoliday")]
|
|
public async Task<IActionResult> UpdateHoliday([FromBody] List<CalendarModel> holidays)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (var calendar in holidays)
|
|
{
|
|
var existingCalendar = await _centralDbContext.Holidays
|
|
.FirstOrDefaultAsync(h => h.StateId == calendar.StateId && h.HolidayDate == calendar.HolidayDate);
|
|
|
|
if (existingCalendar != null)
|
|
{
|
|
existingCalendar.HolidayName = calendar.HolidayName;
|
|
existingCalendar.LastUpdated = DateTime.Now;
|
|
_centralDbContext.Holidays.Update(existingCalendar);
|
|
}
|
|
else
|
|
{
|
|
_centralDbContext.Holidays.Add(new CalendarModel
|
|
{
|
|
HolidayName = calendar.HolidayName,
|
|
HolidayDate = calendar.HolidayDate,
|
|
StateId = calendar.StateId,
|
|
LastUpdated = DateTime.Now
|
|
});
|
|
}
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
var updatedHoliday = await _centralDbContext.Holidays
|
|
.Include(h => h.States)
|
|
.Select(h => new
|
|
{
|
|
h.HolidayId,
|
|
h.HolidayName,
|
|
h.HolidayDate,
|
|
h.StateId,
|
|
StateName = h.States.StateName
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(updatedHoliday);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpGet("GetAllHolidays")]
|
|
public IActionResult GetAllHolidays()
|
|
{
|
|
var holidays = _centralDbContext.Holidays.ToList();
|
|
return Ok(holidays);
|
|
}
|
|
|
|
[HttpDelete("DeleteHoliday/{id}")]
|
|
public async Task<IActionResult> DeleteHoliday(int id)
|
|
{
|
|
try
|
|
{
|
|
var holiday = await _centralDbContext.Holidays.FindAsync(id);
|
|
if (holiday == null)
|
|
{
|
|
return NotFound("Holiday not found.");
|
|
}
|
|
|
|
_centralDbContext.Holidays.Remove(holiday);
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
return Ok(new { message = "Holiday deleted successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Weekend
|
|
[HttpGet("GetWeekendDay")]
|
|
public async Task<IActionResult> GetWeekendDay()
|
|
{
|
|
try
|
|
{
|
|
var weekends = await _centralDbContext.Weekends
|
|
.Select(w => new
|
|
{
|
|
w.WeekendId,
|
|
w.Day
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(weekends);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost("UpdateWeekend")]
|
|
public async Task<IActionResult> UpdateWeekend([FromBody] List<StateModel> states)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (var state in states)
|
|
{
|
|
var existingState = await _centralDbContext.States
|
|
.FirstOrDefaultAsync(s => s.StateId == state.StateId);
|
|
|
|
if (existingState != null)
|
|
{
|
|
// Corrected: Updating WeekendId
|
|
existingState.WeekendId = state.WeekendId;
|
|
_centralDbContext.States.Update(existingState);
|
|
}
|
|
else
|
|
{
|
|
// Ensure new states are added correctly
|
|
_centralDbContext.States.Add(new StateModel
|
|
{
|
|
StateId = state.StateId,
|
|
StateName = state.StateName,
|
|
WeekendId = state.WeekendId
|
|
});
|
|
}
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
var updatedWeekend = await _centralDbContext.States
|
|
.Include(w => w.Weekends)
|
|
.Select(w => new
|
|
{
|
|
w.StateId,
|
|
w.StateName,
|
|
w.WeekendId,
|
|
Day = w.Weekends.Day
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(updatedWeekend);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpGet("GetAllWeekends")]
|
|
public IActionResult GetAllWeekends()
|
|
{
|
|
var weekends = _centralDbContext.Weekends.ToList();
|
|
return Ok(weekends);
|
|
}
|
|
|
|
[HttpGet("GetStateWeekends")]
|
|
public async Task<IActionResult> GetStateWeekends()
|
|
{
|
|
try
|
|
{
|
|
var stateWeekends = await _centralDbContext.States
|
|
.Include(s => s.Weekends)
|
|
.Where(s => s.WeekendId != null)
|
|
.Select(s => new
|
|
{
|
|
s.StateId,
|
|
s.StateName,
|
|
Day = s.Weekends.Day
|
|
})
|
|
.ToListAsync();
|
|
|
|
return Json(stateWeekends);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OtRegister
|
|
[HttpGet("GetStationsByDepartment")]
|
|
public IActionResult GetStationsByDepartment()
|
|
{
|
|
var stations = _centralDbContext.Stations
|
|
.Where(s => s.DepartmentId == 2)
|
|
.Select(s => new
|
|
{
|
|
s.StationId,
|
|
StationName = s.StationName ?? "Unnamed Station"
|
|
})
|
|
.ToList();
|
|
|
|
return Ok(stations);
|
|
}
|
|
|
|
|
|
[HttpPost("AddOvertime")]
|
|
public async Task<IActionResult> AddOvertimeAsync([FromBody] OvertimeRequestDto request)
|
|
{
|
|
_logger.LogInformation("AddOvertimeAsync called.");
|
|
_logger.LogInformation("Received request: {@Request}", request);
|
|
|
|
if (request == null)
|
|
{
|
|
_logger.LogError("Request is null.");
|
|
return BadRequest("Invalid data.");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (request.UserId == 0)
|
|
{
|
|
_logger.LogWarning("No user ID provided.");
|
|
return BadRequest("User ID is required.");
|
|
}
|
|
|
|
// Parse times (make them optional)
|
|
TimeSpan? officeFrom = string.IsNullOrEmpty(request.OfficeFrom) ? (TimeSpan?)null : TimeSpan.Parse(request.OfficeFrom);
|
|
TimeSpan? officeTo = string.IsNullOrEmpty(request.OfficeTo) ? (TimeSpan?)null : TimeSpan.Parse(request.OfficeTo);
|
|
TimeSpan? afterFrom = string.IsNullOrEmpty(request.AfterFrom) ? (TimeSpan?)null : TimeSpan.Parse(request.AfterFrom);
|
|
TimeSpan? afterTo = string.IsNullOrEmpty(request.AfterTo) ? (TimeSpan?)null : TimeSpan.Parse(request.AfterTo);
|
|
|
|
// Office time validation: if officeFrom is set, officeTo must be set too, and vice versa
|
|
if ((officeFrom != null && officeTo == null) || (officeFrom == null && officeTo != null))
|
|
{
|
|
return BadRequest("Both Office From and To must be filled if one is provided.");
|
|
}
|
|
|
|
// No need for specific validation for AfterFrom and AfterTo being both present
|
|
// If one is null and the other isn't, that's acceptable now.
|
|
|
|
// Map to DB model (continue using null for optional fields)
|
|
var newRecord = new OtRegisterModel
|
|
{
|
|
OtDate = request.OtDate,
|
|
OfficeFrom = officeFrom,
|
|
OfficeTo = officeTo,
|
|
OfficeBreak = request.OfficeBreak ?? null, // Make OfficeBreak optional
|
|
AfterFrom = afterFrom,
|
|
AfterTo = afterTo,
|
|
AfterBreak = request.AfterBreak ?? null, // Make AfterBreak optional
|
|
StationId = request.StationId,
|
|
OtDescription = request.OtDescription,
|
|
OtDays = request.OtDays,
|
|
UserId = request.UserId,
|
|
StatusId = request.StatusId // Pass StatusId as it is, which can be null
|
|
};
|
|
|
|
_centralDbContext.Otregisters.Add(newRecord);
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
return Ok(new { message = "Overtime registered successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error registering overtime.");
|
|
return StatusCode(500, $"An error occurred while saving overtime: {ex.InnerException?.Message ?? ex.Message}");
|
|
}
|
|
}
|
|
|
|
|
|
[HttpGet("GetUserStateAndHolidays/{userId}")]
|
|
public async Task<IActionResult> GetUserStateAndHolidaysAsync(int userId)
|
|
{
|
|
try
|
|
{
|
|
var hrSettings = await _centralDbContext.Hrusersetting
|
|
.Include(h => h.State)
|
|
.ThenInclude(s => s.Weekends)
|
|
.Where(h => h.UserId == userId)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (hrSettings?.State == null)
|
|
{
|
|
return Ok(new { state = (object)null, publicHolidays = new List<object>() }); // Or handle no state differently
|
|
}
|
|
|
|
// Fetch public holidays for the user's state and the current year (example)
|
|
var publicHolidays = await _centralDbContext.Holidays
|
|
.Where(ph => ph.StateId == hrSettings.StateId && ph.HolidayDate.Year == DateTime.Now.Year)
|
|
.Select(ph => new { Date = ph.HolidayDate.ToString("yyyy-MM-dd") })
|
|
.ToListAsync();
|
|
|
|
return Ok(new
|
|
{
|
|
state = new
|
|
{
|
|
stateId = hrSettings.StateId,
|
|
stateName = hrSettings.State?.StateName,
|
|
weekendDay = hrSettings.State?.Weekends?.Day,
|
|
weekendId = hrSettings.State?.WeekendId
|
|
},
|
|
publicHolidays
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error fetching user state and public holidays.");
|
|
return StatusCode(500, "An error occurred while fetching user state and public holidays.");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Ot Records
|
|
|
|
[HttpGet("GetUserOvertimeRecords/{userId}")]
|
|
public IActionResult GetUserOvertimeRecords(int userId)
|
|
{
|
|
try
|
|
{
|
|
var records = _centralDbContext.Otregisters
|
|
.Where(o => o.UserId == userId)
|
|
.OrderByDescending(o => o.OtDate)
|
|
.Select(o => new
|
|
{
|
|
o.OvertimeId,
|
|
o.OtDate,
|
|
o.OfficeFrom,
|
|
o.OfficeTo,
|
|
o.OfficeBreak,
|
|
o.AfterFrom,
|
|
o.AfterTo,
|
|
o.AfterBreak,
|
|
o.StationId,
|
|
StationName = o.Stations != null ? o.Stations.StationName : "N/A",
|
|
o.OtDescription,
|
|
o.OtDays,
|
|
o.UserId
|
|
})
|
|
.ToList();
|
|
|
|
return Ok(records);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to fetch OT records.");
|
|
return StatusCode(500, "Error retrieving OT records.");
|
|
}
|
|
}
|
|
|
|
[HttpDelete("DeleteOvertimeRecord/{id}")]
|
|
public IActionResult DeleteOvertimeRecord(int id)
|
|
{
|
|
try
|
|
{
|
|
var record = _centralDbContext.Otregisters.FirstOrDefault(o => o.OvertimeId == id);
|
|
if (record == null)
|
|
{
|
|
_logger.LogWarning("Overtime record not found for Id: {OvertimeId}", id);
|
|
return NotFound("Overtime record not found.");
|
|
}
|
|
|
|
_centralDbContext.Otregisters.Remove(record);
|
|
_centralDbContext.SaveChanges();
|
|
|
|
_logger.LogInformation("Overtime record deleted successfully for Id: {OvertimeId}", id);
|
|
return Ok(new { message = "Record deleted successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to delete OT record.");
|
|
return StatusCode(500, "Error deleting OT record.");
|
|
}
|
|
}
|
|
|
|
[HttpGet("GenerateOvertimePdf")]
|
|
public IActionResult GenerateOvertimePdf(int month, int year)
|
|
{
|
|
var userIdStr = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
|
|
if (string.IsNullOrEmpty(userIdStr) || !int.TryParse(userIdStr, out int userId))
|
|
return Unauthorized();
|
|
|
|
var user = _centralDbContext.Users
|
|
.Include(u => u.Department)
|
|
.FirstOrDefault(u => u.Id == userId);
|
|
|
|
if (user == null)
|
|
return NotFound("User not found.");
|
|
|
|
var fullName = user.FullName;
|
|
var departmentId = user.departmentId ?? 0;
|
|
var departmentName = user.Department?.DepartmentName ?? "N/A";
|
|
|
|
var records = _centralDbContext.Otregisters
|
|
.Include(o => o.Stations)
|
|
.Where(o => o.UserId == userId && o.OtDate.Month == month && o.OtDate.Year == year)
|
|
.ToList();
|
|
|
|
var hrUserSetting = _centralDbContext.Hrusersetting.FirstOrDefault(h => h.UserId == userId);
|
|
|
|
// StateId
|
|
var userStateId = hrUserSetting?.StateId ?? 0;
|
|
|
|
// WeekendId
|
|
var weekendId = _centralDbContext.States
|
|
.Where(s => s.StateId == userStateId)
|
|
.Select(s => s.WeekendId)
|
|
.FirstOrDefault() ?? 2; // Default Sat-Sun if null
|
|
|
|
// Public Holidays
|
|
var publicHolidays = _centralDbContext.Holidays
|
|
.Where(c => c.StateId == userStateId)
|
|
.ToList();
|
|
|
|
// Step 1: Generate all days of the month
|
|
var daysInMonth = DateTime.DaysInMonth(year, month);
|
|
var allDays = Enumerable.Range(1, daysInMonth)
|
|
.Select(day => new DateTime(year, month, day))
|
|
.ToList();
|
|
|
|
// Step 2: Merge records with missing days
|
|
var mergedRecords = new List<OtRegisterModel>();
|
|
|
|
foreach (var date in allDays)
|
|
{
|
|
var dayRecords = records
|
|
.Where(r => r.OtDate.Date == date.Date)
|
|
.OrderBy(r => r.OfficeFrom)
|
|
.ToList();
|
|
|
|
if (dayRecords.Any())
|
|
{
|
|
mergedRecords.AddRange(dayRecords);
|
|
}
|
|
else
|
|
{
|
|
mergedRecords.Add(new OtRegisterModel
|
|
{
|
|
OtDate = date,
|
|
OtDays = date.DayOfWeek.ToString(),
|
|
OtDescription = "",
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
byte[]? logoImage = null;
|
|
var logoPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images", "logo.jpg");
|
|
|
|
logoImage = System.IO.File.Exists(logoPath) ? System.IO.File.ReadAllBytes(logoPath) : null;
|
|
|
|
var stream = _pdfService.GenerateOvertimeTablePdf(
|
|
mergedRecords,
|
|
departmentId,
|
|
fullName,
|
|
departmentName,
|
|
userStateId,
|
|
weekendId,
|
|
publicHolidays,
|
|
isAdminUser: IsAdmin(userId),
|
|
logoImage
|
|
);
|
|
|
|
|
|
return File(stream, "application/pdf", $"OvertimeRecords_{year}_{month}.pdf");
|
|
}
|
|
|
|
private bool IsAdmin(int userId)
|
|
{
|
|
var userRoles = _centralDbContext.UserRoles
|
|
.Where(ur => ur.UserId == userId)
|
|
.Join(_centralDbContext.Roles, ur => ur.RoleId, r => r.Id, (ur, r) => r.Name)
|
|
.ToList();
|
|
|
|
return userRoles.Any(role => role.Contains("SuperAdmin") || role.Contains("SystemAdmin"));
|
|
}
|
|
|
|
[HttpGet("GenerateOvertimeExcel")]
|
|
public IActionResult GenerateOvertimeExcel(int month, int year)
|
|
{
|
|
var userIdStr = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
|
|
if (string.IsNullOrEmpty(userIdStr) || !int.TryParse(userIdStr, out int userId))
|
|
return Unauthorized();
|
|
|
|
var user = _centralDbContext.Users
|
|
.Include(u => u.Department)
|
|
.FirstOrDefault(u => u.Id == userId);
|
|
|
|
if (user == null)
|
|
return NotFound("User not found.");
|
|
|
|
var fullName = user.FullName;
|
|
var departmentId = user.departmentId ?? 0;
|
|
var departmentName = user.Department?.DepartmentName ?? "N/A";
|
|
|
|
var records = _centralDbContext.Otregisters
|
|
.Include(o => o.Stations)
|
|
.Where(o => o.UserId == userId && o.OtDate.Month == month && o.OtDate.Year == year)
|
|
.ToList();
|
|
|
|
var hrUserSetting = _centralDbContext.Hrusersetting.FirstOrDefault(h => h.UserId == userId);
|
|
var userStateId = hrUserSetting?.StateId ?? 0;
|
|
|
|
var weekendId = _centralDbContext.States
|
|
.Where(s => s.StateId == userStateId)
|
|
.Select(s => s.WeekendId)
|
|
.FirstOrDefault() ?? 2;
|
|
|
|
var publicHolidays = _centralDbContext.Holidays
|
|
.Where(c => c.StateId == userStateId)
|
|
.ToList();
|
|
|
|
var daysInMonth = DateTime.DaysInMonth(year, month);
|
|
var allDays = Enumerable.Range(1, daysInMonth)
|
|
.Select(day => new DateTime(year, month, day))
|
|
.ToList();
|
|
|
|
var mergedRecords = new List<OtRegisterModel>();
|
|
foreach (var date in allDays)
|
|
{
|
|
var dayRecords = records
|
|
.Where(r => r.OtDate.Date == date.Date)
|
|
.OrderBy(r => r.OfficeFrom)
|
|
.ToList();
|
|
|
|
if (dayRecords.Any())
|
|
{
|
|
mergedRecords.AddRange(dayRecords);
|
|
}
|
|
else
|
|
{
|
|
mergedRecords.Add(new OtRegisterModel
|
|
{
|
|
OtDate = date,
|
|
OtDays = date.DayOfWeek.ToString(),
|
|
OtDescription = "",
|
|
});
|
|
}
|
|
}
|
|
|
|
var logoPath = Path.Combine(_env.WebRootPath, "images", "logo.jpg");
|
|
byte[]? logoImage = System.IO.File.Exists(logoPath) ? System.IO.File.ReadAllBytes(logoPath) : null;
|
|
|
|
var stream = _excelService.GenerateOvertimeExcel(
|
|
mergedRecords,
|
|
departmentId,
|
|
fullName,
|
|
departmentName,
|
|
userStateId,
|
|
weekendId,
|
|
publicHolidays,
|
|
isAdminUser: IsAdmin(userId),
|
|
logoImage: logoImage
|
|
);
|
|
|
|
|
|
return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
|
$"OvertimeRecords_{year}_{month}.xlsx");
|
|
}
|
|
|
|
[HttpPost("SubmitOvertime")]
|
|
public async Task<IActionResult> SubmitOvertime([FromForm] OvertimeSubmissionModel model)
|
|
{
|
|
if (model.File == null || model.File.Length == 0)
|
|
return BadRequest("No file uploaded.");
|
|
|
|
var userIdStr = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
|
|
if (string.IsNullOrEmpty(userIdStr) || !int.TryParse(userIdStr, out int userId))
|
|
return Unauthorized();
|
|
|
|
try
|
|
{
|
|
var uploadsFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Media", "Overtime");
|
|
if (!Directory.Exists(uploadsFolder))
|
|
Directory.CreateDirectory(uploadsFolder);
|
|
|
|
var uniqueFileName = $"{Guid.NewGuid()}_{model.File.FileName}";
|
|
var filePath = Path.Combine(uploadsFolder, uniqueFileName);
|
|
|
|
using (var fileStream = new FileStream(filePath, FileMode.Create))
|
|
{
|
|
await model.File.CopyToAsync(fileStream);
|
|
}
|
|
|
|
var relativePath = Path.Combine("Media", "Overtime", uniqueFileName).Replace("\\", "/");
|
|
|
|
// Create a NEW OtStatusModel for the resubmission
|
|
var statusModel = new OtStatusModel
|
|
{
|
|
UserId = userId,
|
|
Month = model.Month,
|
|
Year = model.Year,
|
|
FilePath = relativePath,
|
|
SubmitDate = DateTime.Now,
|
|
HouStatus = "Pending",
|
|
HodStatus = "Pending",
|
|
ManagerStatus = "Pending",
|
|
HrStatus = "Pending"
|
|
};
|
|
|
|
_centralDbContext.Otstatus.Add(statusModel);
|
|
await _centralDbContext.SaveChangesAsync(); // Save the new OtStatus record to get its StatusId
|
|
|
|
// Update StatusId in OtRegister records for the current month/year
|
|
var monthStart = new DateTime(model.Year, model.Month, 1);
|
|
var monthEnd = monthStart.AddMonths(1);
|
|
|
|
var otRecords = _centralDbContext.Otregisters
|
|
.Where(r => r.UserId == userId && r.OtDate >= monthStart && r.OtDate < monthEnd)
|
|
.ToList();
|
|
|
|
foreach (var record in otRecords)
|
|
{
|
|
record.StatusId = statusModel.StatusId;
|
|
}
|
|
|
|
_centralDbContext.Otregisters.UpdateRange(otRecords);
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
// Update HrUserSetting with the NEW StatusId
|
|
var userSetting = _centralDbContext.Hrusersetting.FirstOrDefault(s => s.UserId == userId);
|
|
if (userSetting != null)
|
|
{
|
|
userSetting.ApprovalUpdate = DateTime.Now;
|
|
_centralDbContext.Hrusersetting.Update(userSetting);
|
|
}
|
|
|
|
await _centralDbContext.SaveChangesAsync();
|
|
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to submit overtime.");
|
|
return StatusCode(500, "An error occurred while submitting overtime.");
|
|
}
|
|
}
|
|
|
|
[HttpGet("CheckOvertimeSubmitted/{userId}/{month}/{year}")]
|
|
public IActionResult CheckOvertimeSubmitted(int userId, int month, int year)
|
|
{
|
|
try
|
|
{
|
|
// Get the latest OtStatus record for the user, month, and year
|
|
var latestStatus = _centralDbContext.Otstatus
|
|
.Where(s => s.UserId == userId && s.Month == month && s.Year == year)
|
|
.OrderByDescending(s => s.SubmitDate)
|
|
.FirstOrDefault();
|
|
|
|
if (latestStatus == null)
|
|
{
|
|
return Ok(false); // Not submitted yet
|
|
}
|
|
|
|
// Check if the latest submission has been rejected at any level
|
|
if (latestStatus.HouStatus?.ToLower() == "rejected" ||
|
|
latestStatus.HodStatus?.ToLower() == "rejected" ||
|
|
latestStatus.ManagerStatus?.ToLower() == "rejected" ||
|
|
latestStatus.HrStatus?.ToLower() == "rejected")
|
|
{
|
|
return Ok(false); // Latest submission was rejected, enable submit
|
|
}
|
|
|
|
// If not rejected, check if it's in a pending state (new submission)
|
|
if (latestStatus.HouStatus?.ToLower() == "pending" ||
|
|
latestStatus.HodStatus?.ToLower() == "pending" ||
|
|
latestStatus.ManagerStatus?.ToLower() == "pending" ||
|
|
latestStatus.HrStatus?.ToLower() == "pending")
|
|
{
|
|
return Ok(true); // Newly submitted or resubmitted, disable submit
|
|
}
|
|
|
|
// If not pending and not rejected, it implies it's fully approved or in a final rejected state
|
|
return Ok(true); // Disable submit
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error while checking overtime submission status.");
|
|
return StatusCode(500, new { error = "Internal server error occurred." });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Ot Edit
|
|
[HttpGet("GetOvertimeRecordById/{id}")]
|
|
public async Task<IActionResult> GetOvertimeRecordById(int id)
|
|
{
|
|
var record = await _centralDbContext.Otregisters.FindAsync(id);
|
|
if (record == null)
|
|
return NotFound();
|
|
|
|
return Ok(record);
|
|
}
|
|
|
|
[HttpPost]
|
|
[Route("UpdateOvertimeRecord")]
|
|
public IActionResult UpdateOvertimeRecord([FromForm] OtRegisterModel model)
|
|
{
|
|
_logger.LogInformation("UpdateOvertimeRecord called. Model: {@Model}", model);
|
|
|
|
try
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
_logger.LogWarning("ModelState is invalid. Errors: {@ModelStateErrors}", ModelState.Values.SelectMany(v => v.Errors));
|
|
return BadRequest(ModelState);
|
|
}
|
|
|
|
var existing = _centralDbContext.Otregisters.FirstOrDefault(o => o.OvertimeId == model.OvertimeId);
|
|
if (existing == null)
|
|
{
|
|
_logger.LogWarning("Overtime record not found for Id: {OvertimeId}", model.OvertimeId);
|
|
return NotFound("Overtime record not found.");
|
|
}
|
|
|
|
_logger.LogInformation("Existing record found: {@ExistingRecord}", existing);
|
|
|
|
existing.OtDate = model.OtDate;
|
|
existing.OfficeFrom = model.OfficeFrom;
|
|
existing.OfficeTo = model.OfficeTo;
|
|
existing.OfficeBreak = model.OfficeBreak;
|
|
existing.AfterFrom = model.AfterFrom;
|
|
existing.AfterTo = model.AfterTo;
|
|
existing.AfterBreak = model.AfterBreak;
|
|
existing.StationId = model.StationId;
|
|
existing.OtDescription = model.OtDescription;
|
|
existing.OtDays = model.OtDays;
|
|
existing.UserId = model.UserId;
|
|
|
|
_centralDbContext.SaveChanges();
|
|
_logger.LogInformation("Overtime record updated successfully for Id: {OvertimeId}", model.OvertimeId);
|
|
|
|
return Ok(new { message = "Record updated successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error updating overtime record. Stack Trace: {StackTrace}", ex.StackTrace);
|
|
return StatusCode(500, "Failed to update record.");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Ot Status
|
|
[HttpGet("GetUserOtStatus")]
|
|
public IActionResult GetUserOtStatus()
|
|
{
|
|
var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
|
|
|
|
if (string.IsNullOrEmpty(userIdClaim))
|
|
return BadRequest("User ID is not available.");
|
|
|
|
if (!int.TryParse(userIdClaim, out int userId))
|
|
return BadRequest("Invalid User ID.");
|
|
|
|
var approvalFlowId = _centralDbContext.Hrusersetting
|
|
.Where(x => x.UserId == userId)
|
|
.Select(x => x.ApprovalFlowId)
|
|
.FirstOrDefault();
|
|
|
|
var flow = _centralDbContext.Approvalflow
|
|
.FirstOrDefault(f => f.ApprovalFlowId == approvalFlowId);
|
|
|
|
if (flow == null)
|
|
return BadRequest("Approval flow not found.");
|
|
|
|
bool includeHou = flow.HoU.HasValue;
|
|
bool includeHod = flow.HoD.HasValue;
|
|
bool includeManager = flow.Manager.HasValue;
|
|
bool includeHr = flow.HR.HasValue;
|
|
|
|
var otStatuses = _centralDbContext.Otstatus
|
|
.Where(o => o.UserId == userId)
|
|
.Select(o => new
|
|
{
|
|
o.Month,
|
|
o.Year,
|
|
o.SubmitDate,
|
|
HouStatus = includeHou ? o.HouStatus : null,
|
|
HodStatus = includeHod ? o.HodStatus : null,
|
|
ManagerStatus = includeManager ? o.ManagerStatus : null,
|
|
HrStatus = includeHr ? o.HrStatus : null,
|
|
o.FilePath,
|
|
Updated = o.HouUpdate != null || o.HodUpdate != null || o.ManagerUpdate != null || o.HrUpdate != null
|
|
})
|
|
.ToList();
|
|
|
|
return Ok(new
|
|
{
|
|
includeHou,
|
|
includeHod,
|
|
includeManager,
|
|
includeHr,
|
|
otStatuses
|
|
});
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OT Approval
|
|
[HttpGet("GetPendingApproval")]
|
|
public IActionResult GetPendingApproval(int month, int year)
|
|
{
|
|
var userIdStr = _userManager.GetUserId(User);
|
|
if (string.IsNullOrEmpty(userIdStr) || !int.TryParse(userIdStr, out int currentUserId))
|
|
return Unauthorized("Invalid or missing user ID");
|
|
|
|
// Get all flows where the user is an approver
|
|
var flows = _centralDbContext.Approvalflow
|
|
.Where(f => f.HoU == currentUserId || f.HoD == currentUserId || f.Manager == currentUserId || f.HR == currentUserId)
|
|
.ToList();
|
|
|
|
if (!flows.Any())
|
|
return Unauthorized("You are not assigned to any approval flow.");
|
|
|
|
// Map flow ID to role (the role user is in for that flow)
|
|
var flowRoleMap = new Dictionary<int, string>();
|
|
foreach (var flow in flows)
|
|
{
|
|
if (flow.HoU == currentUserId) flowRoleMap[flow.ApprovalFlowId] = "HoU";
|
|
if (flow.HoD == currentUserId) flowRoleMap[flow.ApprovalFlowId] = "HoD";
|
|
if (flow.Manager == currentUserId) flowRoleMap[flow.ApprovalFlowId] = "Manager";
|
|
if (flow.HR == currentUserId) flowRoleMap[flow.ApprovalFlowId] = "HR";
|
|
}
|
|
|
|
// Load all OT status entries and their associated approval flow IDs
|
|
var otEntriesWithFlow = (from status in _centralDbContext.Otstatus
|
|
join user in _centralDbContext.Users on status.UserId equals user.Id
|
|
join setting in _centralDbContext.Hrusersetting on status.UserId equals setting.UserId
|
|
where status.Month == month && status.Year == year && setting.ApprovalFlowId.HasValue
|
|
select new
|
|
{
|
|
status.StatusId,
|
|
status.SubmitDate,
|
|
status.HouStatus,
|
|
status.HodStatus,
|
|
status.ManagerStatus,
|
|
status.HrStatus,
|
|
setting.ApprovalFlowId,
|
|
fullName = user.FullName
|
|
}).ToList();
|
|
|
|
var filteredList = new List<object>();
|
|
var distinctRoles = new HashSet<string>();
|
|
|
|
foreach (var entry in otEntriesWithFlow)
|
|
{
|
|
if (!flowRoleMap.ContainsKey(entry.ApprovalFlowId.Value))
|
|
continue; // User is not an approver for this flow
|
|
|
|
var role = flowRoleMap[entry.ApprovalFlowId.Value];
|
|
distinctRoles.Add(role);
|
|
|
|
var flow = _centralDbContext.Approvalflow.FirstOrDefault(f => f.ApprovalFlowId == entry.ApprovalFlowId);
|
|
if (flow == null) continue;
|
|
|
|
// If any earlier status is rejected, do not allow further approvals
|
|
if (entry.HouStatus == "Rejected" || entry.HodStatus == "Rejected" || entry.ManagerStatus == "Rejected" || entry.HrStatus == "Rejected")
|
|
continue;
|
|
|
|
|
|
bool shouldShow = false;
|
|
|
|
// Show if the current user still needs to act
|
|
if ((role == "HoU" && entry.HouStatus == "Pending") ||
|
|
(role == "HoD" && (!flow.HoU.HasValue || entry.HouStatus == "Approved") && entry.HodStatus == "Pending") ||
|
|
(role == "Manager" && (!flow.HoU.HasValue || entry.HouStatus == "Approved") && (!flow.HoD.HasValue || entry.HodStatus == "Approved") && entry.ManagerStatus == "Pending") ||
|
|
(role == "HR" && (!flow.HoU.HasValue || entry.HouStatus == "Approved") && (!flow.HoD.HasValue || entry.HodStatus == "Approved") && (!flow.Manager.HasValue || entry.ManagerStatus == "Approved") && entry.HrStatus == "Pending"))
|
|
{
|
|
shouldShow = true;
|
|
}
|
|
// Also show if the current user has already acted (approved or rejected)
|
|
else if ((role == "HoU" && (entry.HouStatus == "Approved" || entry.HouStatus == "Rejected")) ||
|
|
(role == "HoD" && (entry.HodStatus == "Approved" || entry.HodStatus == "Rejected")) ||
|
|
(role == "Manager" && (entry.ManagerStatus == "Approved" || entry.ManagerStatus == "Rejected")) ||
|
|
(role == "HR" && (entry.HrStatus == "Approved" || entry.HrStatus == "Rejected")))
|
|
{
|
|
shouldShow = true;
|
|
}
|
|
|
|
if (shouldShow)
|
|
{
|
|
filteredList.Add(entry);
|
|
}
|
|
}
|
|
|
|
return Json(new
|
|
{
|
|
Roles = distinctRoles.ToList(),
|
|
Data = filteredList
|
|
});
|
|
}
|
|
[HttpPost("UpdateApprovalStatus")]
|
|
public IActionResult UpdateApprovalStatus([FromBody] UpdateStatusDto dto)
|
|
{
|
|
if (dto == null)
|
|
return BadRequest("DTO is null or improperly formatted.");
|
|
|
|
if (dto.StatusId == 0 || string.IsNullOrWhiteSpace(dto.Decision))
|
|
return BadRequest("Missing StatusId or Decision.");
|
|
|
|
var userIdStr = _userManager.GetUserId(User);
|
|
if (string.IsNullOrEmpty(userIdStr) || !int.TryParse(userIdStr, out int currentUserId))
|
|
return Unauthorized("Invalid user");
|
|
|
|
var status = _centralDbContext.Otstatus.FirstOrDefault(s => s.StatusId == dto.StatusId);
|
|
if (status == null) return NotFound("OT Status not found");
|
|
|
|
var setting = _centralDbContext.Hrusersetting.FirstOrDefault(s => s.UserId == status.UserId);
|
|
if (setting == null) return BadRequest("User setting not found");
|
|
|
|
var flow = _centralDbContext.Approvalflow.FirstOrDefault(f => f.ApprovalFlowId == setting.ApprovalFlowId);
|
|
if (flow == null) return BadRequest("Approval flow not found");
|
|
|
|
var now = DateTime.Now;
|
|
|
|
if (dto.Decision.ToLower() == "rejected")
|
|
{
|
|
if (flow.HoU == currentUserId && status.HouStatus == "Pending")
|
|
{
|
|
status.HouStatus = "Rejected";
|
|
status.HouSubmitDate = now;
|
|
}
|
|
else if (flow.HoD == currentUserId && status.HodStatus == "Pending" && (!flow.HoU.HasValue || status.HouStatus == "Approved"))
|
|
{
|
|
status.HodStatus = "Rejected";
|
|
status.HodSubmitDate = now;
|
|
}
|
|
else if (flow.Manager == currentUserId && status.ManagerStatus == "Pending" &&
|
|
(!flow.HoU.HasValue || status.HouStatus == "Approved") &&
|
|
(!flow.HoD.HasValue || status.HodStatus == "Approved"))
|
|
{
|
|
status.ManagerStatus = "Rejected";
|
|
status.ManagerSubmitDate = now;
|
|
}
|
|
else if (flow.HR == currentUserId && status.HrStatus == "Pending" &&
|
|
(!flow.HoU.HasValue || status.HouStatus == "Approved") &&
|
|
(!flow.HoD.HasValue || status.HodStatus == "Approved") &&
|
|
(!flow.Manager.HasValue || status.ManagerStatus == "Approved"))
|
|
{
|
|
status.HrStatus = "Rejected";
|
|
status.HrSubmitDate = now;
|
|
}
|
|
else
|
|
{
|
|
return BadRequest("Not authorized to reject this request or already decided based on the flow.");
|
|
}
|
|
}
|
|
else if (dto.Decision.ToLower() == "approved")
|
|
{
|
|
if (flow.HoU == currentUserId && status.HouStatus == "Pending")
|
|
{
|
|
status.HouStatus = "Approved";
|
|
status.HouSubmitDate = now;
|
|
}
|
|
else if (flow.HoD == currentUserId && status.HodStatus == "Pending" && (!flow.HoU.HasValue || status.HouStatus == "Approved"))
|
|
{
|
|
status.HodStatus = "Approved";
|
|
status.HodSubmitDate = now;
|
|
}
|
|
else if (flow.Manager == currentUserId && status.ManagerStatus == "Pending" &&
|
|
(!flow.HoU.HasValue || status.HouStatus == "Approved") &&
|
|
(!flow.HoD.HasValue || status.HodStatus == "Approved"))
|
|
{
|
|
status.ManagerStatus = "Approved";
|
|
status.ManagerSubmitDate = now;
|
|
}
|
|
else if (flow.HR == currentUserId && status.HrStatus == "Pending" &&
|
|
(!flow.HoU.HasValue || status.HouStatus == "Approved") &&
|
|
(!flow.HoD.HasValue || status.HodStatus == "Approved") &&
|
|
(!flow.Manager.HasValue || status.ManagerStatus == "Approved"))
|
|
{
|
|
status.HrStatus = "Approved";
|
|
status.HrSubmitDate = now;
|
|
}
|
|
else
|
|
{
|
|
return BadRequest("Not authorized to approve this request or already decided based on the flow.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return BadRequest("Invalid decision value.");
|
|
}
|
|
|
|
_centralDbContext.SaveChanges();
|
|
return Ok(new { message = "Status updated successfully." });
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region OT Review
|
|
[HttpGet("GetOtRecordsByStatusId/{statusId}")]
|
|
public IActionResult GetOtRecordsByStatusId(int statusId)
|
|
{
|
|
var otStatus = _centralDbContext.Otstatus.FirstOrDefault(s => s.StatusId == statusId);
|
|
if (otStatus == null)
|
|
return NotFound("OT status not found.");
|
|
|
|
var user = _centralDbContext.Users.FirstOrDefault(u => u.Id == otStatus.UserId);
|
|
if (user == null)
|
|
return NotFound("User not found.");
|
|
|
|
var department = _centralDbContext.Departments
|
|
.Where(d => d.DepartmentId == user.departmentId)
|
|
.Select(d => d.DepartmentName)
|
|
.FirstOrDefault();
|
|
|
|
var otRecords = _centralDbContext.Otregisters
|
|
.Include(o => o.Stations)
|
|
.Where(o => o.StatusId == statusId)
|
|
.Select(o => new
|
|
{
|
|
o.OvertimeId,
|
|
o.OtDate,
|
|
o.OfficeFrom,
|
|
o.OfficeTo,
|
|
o.OfficeBreak,
|
|
o.AfterFrom,
|
|
o.AfterTo,
|
|
o.AfterBreak,
|
|
o.StationId,
|
|
StationName = o.Stations != null ? o.Stations.StationName : "N/A",
|
|
o.OtDescription,
|
|
o.OtDays,
|
|
o.UserId
|
|
})
|
|
.ToList();
|
|
|
|
|
|
var result = new
|
|
{
|
|
userInfo = new
|
|
{
|
|
fullName = user.FullName,
|
|
departmentName = department,
|
|
filePath = otStatus.FilePath
|
|
},
|
|
records = otRecords
|
|
};
|
|
|
|
|
|
return Ok(result);
|
|
}
|
|
|
|
[HttpDelete("DeleteOvertimeInOtReview/{id}")]
|
|
public IActionResult DeleteOvertimeInOtReview(int id)
|
|
{
|
|
var record = _centralDbContext.Otregisters.FirstOrDefault(o => o.OvertimeId == id);
|
|
if (record == null)
|
|
return NotFound(new { message = "Overtime record not found." });
|
|
|
|
_centralDbContext.Otregisters.Remove(record);
|
|
_centralDbContext.SaveChanges();
|
|
|
|
return Ok(new { message = "Overtime record deleted successfully." });
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|
|
} |