819 lines
29 KiB
C#
819 lines
29 KiB
C#
using BMA.EHR.Application.Common.Interfaces;
|
|
using BMA.EHR.Application.Requests.Commands;
|
|
using BMA.EHR.Application.Responses;
|
|
using BMA.EHR.Domain.Extensions;
|
|
using BMA.EHR.Domain.Models.Commands.Core;
|
|
using BMA.EHR.Domain.Models.MetaData;
|
|
using BMA.EHR.Domain.Models.Organizations;
|
|
using BMA.EHR.Domain.Models.Placement;
|
|
using BMA.EHR.Domain.Shared;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Command = BMA.EHR.Domain.Models.Commands.Core.Command;
|
|
|
|
namespace BMA.EHR.Application.Repositories.Commands
|
|
{
|
|
public class CommandRepository : GenericRepository<Guid, Command>
|
|
{
|
|
#region " Fields "
|
|
|
|
private readonly IApplicationDBContext _dbContext;
|
|
private readonly IHttpContextAccessor _httpContextAccessor;
|
|
|
|
#endregion
|
|
|
|
#region " Constructor and Destuctor "
|
|
|
|
public CommandRepository(IApplicationDBContext dbContext,
|
|
IHttpContextAccessor httpContextAccessor) : base(dbContext, httpContextAccessor)
|
|
{
|
|
_dbContext = dbContext;
|
|
_httpContextAccessor = httpContextAccessor;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Methods "
|
|
|
|
#region " Private "
|
|
|
|
#region " List Receiver "
|
|
|
|
private async Task<List<CommandReceiver>> GetReceiverForByCommndTypeAsync(Command command)
|
|
{
|
|
var result = new List<CommandReceiver>();
|
|
|
|
switch (command.CommandType.CommandCode.Trim().ToUpper())
|
|
{
|
|
case "C-PM-01":
|
|
case "C-PM-02":
|
|
case "C-PM-03":
|
|
result = await GetReceiver01(command);
|
|
break;
|
|
default: throw new Exception(GlobalMessages.MethodForCommandTypeNotImplement);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// C-PM-01
|
|
/// </summary>
|
|
/// <param name="command"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<CommandReceiver>> GetReceiver01(Command command)
|
|
{
|
|
try
|
|
{
|
|
var result = new List<CommandReceiver>();
|
|
|
|
|
|
// 1. หารายชื่อที่ถูกเลือกไปแล้ว ในประเภทเดียวกัน
|
|
var otherCommandReceivers = await _dbContext.Set<CommandReceiver>()
|
|
.Include(x => x.Command)
|
|
.ThenInclude(x => x.CommandType)
|
|
.Where(x => x.Command.CommandType.CommandCode.Trim().ToUpper() == "C-PM-01")
|
|
.Where(x => x.Id != command.Id)
|
|
.Select(x => x.CitizenId)
|
|
.ToListAsync();
|
|
|
|
// 2. Query
|
|
var appointPeople = await _dbContext.Set<PlacementProfile>()
|
|
.Include(x => x.Prefix)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.Organization)
|
|
//.Where(x => x.OrganizationPosition!.Organization!.Id == command.OwnerGovId)
|
|
.Where(x => !otherCommandReceivers.Contains(x.CitizenId!))
|
|
.Where(x => x.PlacementStatus.Trim().ToUpper() == "PREPARE-CONTAIN")
|
|
.Where(x => x.Draft! == true)
|
|
.OrderBy(x => x.ExamNumber)
|
|
.ToListAsync();
|
|
|
|
// 3. Create new Record
|
|
var seq = 1;
|
|
foreach (var item in appointPeople)
|
|
{
|
|
|
|
var receiver = new CommandReceiver
|
|
{
|
|
Sequence = seq,
|
|
CitizenId = item.CitizenId!,
|
|
Prefix = item.Prefix!.Name,
|
|
FirstName = item.Firstname!,
|
|
LastName = item.Lastname!,
|
|
RefPlacementProfileId = item.Id
|
|
};
|
|
seq++;
|
|
|
|
result.Add(receiver);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Execute and Deploy "
|
|
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region " Override "
|
|
|
|
public override async Task<Command?> GetByIdAsync(Guid id)
|
|
{
|
|
return await _dbContext.Set<Command>()
|
|
.Include(x => x.Placement)
|
|
.Include(x => x.CommandType)
|
|
.Include(x => x.Documents)
|
|
.Include(x => x.Receivers)
|
|
.Include(x => x.CommandStatus)
|
|
.FirstOrDefaultAsync(x => x.Id == id);
|
|
}
|
|
|
|
public override async Task<IReadOnlyList<Command>> GetAllAsync()
|
|
{
|
|
return await _dbContext.Set<Command>()
|
|
.Include(x => x.Placement)
|
|
.Include(x => x.CommandType)
|
|
.Include(x => x.CommandStatus)
|
|
.ToListAsync();
|
|
}
|
|
|
|
public override async Task<Command> AddAsync(Command command)
|
|
{
|
|
var status = await _dbContext.Set<CommandStatus>().FirstOrDefaultAsync(c => c.Sequence == 1);
|
|
command.CommandStatus = status!;
|
|
_dbContext.Attatch(status!);
|
|
|
|
return await base.AddAsync(command);
|
|
}
|
|
|
|
public override async Task<Command> UpdateAsync(Command entity)
|
|
{
|
|
// attatch
|
|
_dbContext.Attatch(entity.CommandStatus);
|
|
_dbContext.Attatch(entity.CommandType);
|
|
_dbContext.Attatch(entity.Placement);
|
|
|
|
return await base.UpdateAsync(entity);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Command Receiver "
|
|
|
|
public async Task SaveSelectedReceiverAsync(Guid id, List<Guid> selected)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Receivers)
|
|
.Include(x => x.CommandType)
|
|
.FirstOrDefaultAsync(x => x.Id == id);
|
|
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
var appointPeople = await _dbContext.Set<PlacementProfile>()
|
|
.Include(x => x.Prefix)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.Organization)
|
|
//.Where(x => x.OrganizationPosition!.Organization!.Id == command.OwnerGovId)
|
|
.Where(x => selected.Contains(x.Id))
|
|
.OrderBy(x => x.ExamNumber)
|
|
.ToListAsync();
|
|
|
|
_dbContext.Set<CommandReceiver>().RemoveRange(command.Receivers);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
var seq = 1;
|
|
foreach (var item in appointPeople)
|
|
{
|
|
|
|
var receiver = new CommandReceiver
|
|
{
|
|
Sequence = seq,
|
|
CitizenId = item.CitizenId!,
|
|
Prefix = item.Prefix!.Name,
|
|
FirstName = item.Firstname!,
|
|
LastName = item.Lastname!,
|
|
RefPlacementProfileId = item.Id
|
|
};
|
|
seq++;
|
|
|
|
command.Receivers.Add(receiver);
|
|
}
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<List<CommandReceiver>> GetReceiverForCommandAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Receivers)
|
|
.Include(x => x.CommandType)
|
|
.FirstOrDefaultAsync(x => x.Id == id);
|
|
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
else
|
|
return await GetReceiverForByCommndTypeAsync(command);
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<List<CommandReceiver>> GetReceiverByCommmandIdAsync(Guid Id)
|
|
{
|
|
try
|
|
{
|
|
// ปรับใหม่ให้อ่านจาก database ล้วนๆ
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Receivers)
|
|
.Include(x => x.CommandType)
|
|
.FirstOrDefaultAsync(x => x.Id == Id);
|
|
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
else
|
|
{
|
|
if (command.Receivers != null && command!.Receivers!.Count > 0)
|
|
{
|
|
return command.Receivers;
|
|
}
|
|
else
|
|
{
|
|
// returrn empty list
|
|
return new List<CommandReceiver>();
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<CommandReceiver> DeleteCommandReceiverAsync(Guid personalId)
|
|
{
|
|
try
|
|
{
|
|
var deleted = await _dbContext.Set<CommandReceiver>()
|
|
.FirstOrDefaultAsync(x => x.Id == personalId);
|
|
|
|
if (deleted == null)
|
|
throw new Exception(GlobalMessages.DataNotFound);
|
|
|
|
_dbContext.Set<CommandReceiver>().Remove(deleted);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
return deleted;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<CommandReceiver?> GetCommandReceiverAsync(Guid personalId)
|
|
{
|
|
try
|
|
{
|
|
var receiver = await _dbContext.Set<CommandReceiver>()
|
|
.FirstOrDefaultAsync(x => x.Id == personalId);
|
|
|
|
if (receiver == null)
|
|
throw new Exception(GlobalMessages.DataNotFound);
|
|
|
|
return receiver;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public async Task SwapReceiverOrderAsync(Guid personalId, string direction)
|
|
{
|
|
try
|
|
{
|
|
var current = await _dbContext.Set<CommandReceiver>()
|
|
.FirstOrDefaultAsync(x => x.Id == personalId);
|
|
|
|
if (current == null)
|
|
throw new Exception(GlobalMessages.DataNotFound);
|
|
|
|
var currentSeq = current.Sequence;
|
|
|
|
switch (direction.Trim().ToLower())
|
|
{
|
|
case "up":
|
|
{
|
|
// get prev record
|
|
var prev = await _dbContext.Set<CommandReceiver>()
|
|
.OrderByDescending(x => x.Sequence)
|
|
.Where(x => x.Sequence < currentSeq)
|
|
.Take(1)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (prev != null)
|
|
{
|
|
var prevSeq = prev.Sequence;
|
|
|
|
current.Sequence = prevSeq;
|
|
prev.Sequence = currentSeq;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
break;
|
|
}
|
|
case "down":
|
|
{
|
|
// get next record
|
|
var next = await _dbContext.Set<CommandReceiver>()
|
|
.OrderBy(x => x.Sequence)
|
|
.Where(x => x.Sequence > currentSeq)
|
|
.Take(1)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (next != null)
|
|
{
|
|
var nextSeq = next.Sequence;
|
|
|
|
current.Sequence = nextSeq;
|
|
next.Sequence = currentSeq;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
break;
|
|
}
|
|
default: throw new Exception("Invalid swap direction!");
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public async Task<List<CommandDeployment>> GetDeploymentByCommandIdAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Deployments)
|
|
.FirstOrDefaultAsync(x => x.Id == id);
|
|
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
else
|
|
{
|
|
if (command.Deployments != null || command!.Deployments!.Count > 0)
|
|
{
|
|
return command.Deployments;
|
|
}
|
|
else
|
|
{
|
|
var orgPos = await _dbContext.Set<ProfilePosition>()
|
|
.Include(x => x.Profile)
|
|
.ThenInclude(x => x!.Prefix)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.Organization)
|
|
.ThenInclude(x => x!.OrganizationOrganization)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.PositionMaster)
|
|
.ThenInclude(x => x!.PositionPath)
|
|
.Where(x => x.OrganizationPosition!.IsDirector! == true)
|
|
.Where(x => x.OrganizationPosition!.Organization!.Id == command.OwnerGovId)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (orgPos != null)
|
|
{
|
|
if (orgPos.Profile != null)
|
|
{
|
|
var dp = new CommandDeployment
|
|
{
|
|
Sequence = 1,
|
|
ReceiveUserId = orgPos!.Profile!.Id!.ToString("D"),
|
|
CitizenId = orgPos!.Profile!.CitizenId!,
|
|
Prefix = orgPos!.Profile!.Prefix!.Name,
|
|
FirstName = orgPos!.Profile!.FirstName!,
|
|
LastName = orgPos!.Profile!.LastName!,
|
|
IsSendInbox = true,
|
|
IsSendMail = true,
|
|
IsSendNotification = true,
|
|
OrganizationName = orgPos!.OrganizationPosition!.Organization!.OrganizationOrganization!.Name,
|
|
PositionName = orgPos!.OrganizationPosition!.PositionMaster!.PositionPath!.Name
|
|
};
|
|
|
|
command.Deployments.Add(dp);
|
|
}
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
}
|
|
// query for new list
|
|
return command.Deployments;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<List<ProfilePosition>> GetProfileByOrganizationIdAsync(Guid orgId)
|
|
{
|
|
try
|
|
{
|
|
var orgProfiles = await _dbContext.Set<ProfilePosition>()
|
|
.Include(x => x.Profile)
|
|
.ThenInclude(x => x!.Prefix)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.Organization)
|
|
.ThenInclude(x => x!.OrganizationOrganization)
|
|
.Include(x => x.OrganizationPosition)
|
|
.ThenInclude(x => x!.PositionMaster)
|
|
.ThenInclude(x => x!.PositionPath)
|
|
.Where(x => x.OrganizationPosition!.Organization!.Id == orgId)
|
|
.ToListAsync();
|
|
|
|
return orgProfiles;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task CreateCommandDeploymentAsync(Guid commandId, List<CommandDeployment> deploy)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Deployments)
|
|
.FirstOrDefaultAsync(x => x.Id == commandId);
|
|
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
else
|
|
{
|
|
var lastSeq = 0;
|
|
var dep = command.Deployments.OrderByDescending(x => x.Sequence).FirstOrDefault();
|
|
if (dep == null) lastSeq = 1;
|
|
else lastSeq = dep.Sequence;
|
|
|
|
foreach (var dep2 in deploy)
|
|
{
|
|
dep2.Sequence = lastSeq;
|
|
lastSeq++;
|
|
}
|
|
|
|
command.Deployments.AddRange(deploy);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task UpdatCommandDeploymentAsync(List<CommandDeployment> deploys)
|
|
{
|
|
try
|
|
{
|
|
foreach (var dp in deploys)
|
|
{
|
|
var updated = await _dbContext.Set<CommandDeployment>().FirstOrDefaultAsync(x => x.Id == dp.Id);
|
|
if (updated != null)
|
|
{
|
|
updated.IsSendMail = dp.IsSendMail;
|
|
updated.IsSendInbox = dp.IsSendInbox;
|
|
}
|
|
}
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task DeleteCommandDeploymentAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var deleted = await _dbContext.Set<CommandDeployment>().FirstOrDefaultAsync(x => x.Id == id);
|
|
if (deleted == null)
|
|
throw new Exception(GlobalMessages.DataNotFound);
|
|
|
|
_dbContext.Set<CommandDeployment>().Remove(deleted);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<CommandDeployment?> GetCommandDeploymentById(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var data = await _dbContext.Set<CommandDeployment>().FirstOrDefaultAsync(x => x.Id == id);
|
|
|
|
return data;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#region " Documents "
|
|
|
|
public async Task<List<CommandDocument>> GetExistDocument(Guid id, string category)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>()
|
|
.Include(x => x.Documents)
|
|
.ThenInclude(x => x.Document)
|
|
.FirstOrDefaultAsync(c => c.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
// insert new record to comand Document
|
|
var exist = command.Documents.Where(x => x.Category == category).ToList();
|
|
|
|
return exist;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task UploadDocument(Guid id, string category, CommandDocument document)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>().Include(x => x.Documents).FirstOrDefaultAsync(c => c.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
// insert new record to comand Document
|
|
var exist = command.Documents.Where(x => x.Category == category).ToList();
|
|
if (exist.Any())
|
|
{
|
|
_dbContext.Set<CommandDocument>().RemoveRange(exist);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
|
|
// insert new Record
|
|
command.Documents.Add(document);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<List<CommandDocument>> GetCommandDocumentAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var docs = await _dbContext.Set<CommandDocument>()
|
|
.Include(x => x.Command)
|
|
.Include(x => x.Document)
|
|
.Where(x => x.Command.Id == id)
|
|
.ToListAsync();
|
|
|
|
return docs;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Change Command Status "
|
|
|
|
public async Task GotoNextStateAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>().Include(c => c.CommandStatus).FirstOrDefaultAsync(x => x.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
var notProcess = new int[] { 4, 5 };
|
|
|
|
if (!notProcess.Contains(command.CommandStatus.Sequence))
|
|
{
|
|
var nextStatus = await _dbContext.Set<CommandStatus>().FirstOrDefaultAsync(c => c.Sequence == command.CommandStatus.Sequence + 1);
|
|
command.CommandStatus = nextStatus!;
|
|
_dbContext.Attatch(nextStatus!);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task GotoPrevStateAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>().Include(c => c.CommandStatus).FirstOrDefaultAsync(x => x.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
var notProcess = new int[] { 1, 5 };
|
|
|
|
if (!notProcess.Contains(command.CommandStatus.Sequence))
|
|
{
|
|
var nextStatus = await _dbContext.Set<CommandStatus>().FirstOrDefaultAsync(c => c.Sequence == command.CommandStatus.Sequence - 1);
|
|
command.CommandStatus = nextStatus!;
|
|
_dbContext.Attatch(nextStatus!);
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Change Detail Sequence "
|
|
|
|
|
|
#endregion
|
|
|
|
#region " Placement "
|
|
|
|
public async Task<PlacementSalaryResponse> GetPlacementSalaryAsync(Guid placementProfileId)
|
|
{
|
|
try
|
|
{
|
|
var placementProfile = await _dbContext.Set<PlacementProfile>()
|
|
.FirstOrDefaultAsync(p => p.Id == placementProfileId);
|
|
|
|
if (placementProfile == null)
|
|
throw new Exception($"Invalid placement profile: {placementProfileId}");
|
|
|
|
return new PlacementSalaryResponse
|
|
{
|
|
SalaryAmount = placementProfile.Amount ?? 0,
|
|
PositionSalaryAmount = placementProfile.PositionSalaryAmount ?? 0,
|
|
MonthSalaryAmount = placementProfile.MouthSalaryAmount ?? 0
|
|
};
|
|
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task UpdatePlacementSalaryAsync(Guid placementProfileId, UpdatePlacementSalaryRequest req)
|
|
{
|
|
try
|
|
{
|
|
var placementProfile = await _dbContext.Set<PlacementProfile>()
|
|
.FirstOrDefaultAsync(p => p.Id == placementProfileId);
|
|
|
|
if (placementProfile == null)
|
|
throw new Exception($"Invalid placement profile: {placementProfileId}");
|
|
|
|
placementProfile.Amount = req.SalaryAmount;
|
|
placementProfile.PositionSalaryAmount = req.PositionSalaryAmount;
|
|
placementProfile.MouthSalaryAmount = req.MonthSalaryAmount;
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task<List<PositionPath>> GetPlacementPositionPath(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var data = await _dbContext.Set<PlacementProfile>()
|
|
.Include(x => x.PositionPath)
|
|
.Include(x => x.Placement)
|
|
.Where(x => x.Placement!.Id == id)
|
|
.Where(x => x.PositionPath != null)
|
|
.Select(x => x.PositionPath)
|
|
.Distinct()
|
|
.ToListAsync();
|
|
|
|
return data!;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Command Info "
|
|
|
|
public async Task<CommandInfoResponse> GetCommandInfoAsync(Guid id)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>().FirstOrDefaultAsync(x => x.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
return new CommandInfoResponse
|
|
{
|
|
SignDate = command.CommandExcecuteDate.Value,
|
|
OrderNo = command.CommandNo,
|
|
OrderYear = command.CommandYear,
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public async Task UpdateCommandInfoAsync(Guid id, string orderNo, string orderYear, DateTime signDate)
|
|
{
|
|
try
|
|
{
|
|
var command = await _dbContext.Set<Command>().FirstOrDefaultAsync(x => x.Id == id);
|
|
if (command == null)
|
|
throw new Exception(GlobalMessages.CommandNotFound);
|
|
|
|
command.CommandExcecuteDate = signDate;
|
|
command.CommandNo = orderNo;
|
|
command.CommandYear = orderYear;
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public async Task<Guid> GetRootOcIdAsync(Guid ocId)
|
|
{
|
|
try
|
|
{
|
|
var data = await _dbContext.Set<OrganizationEntity>().AsQueryable()
|
|
//.Include(x => x.OrganizationAgency)
|
|
//.Include(x => x.OrganizationGovernmentAgency)
|
|
.FirstOrDefaultAsync(o => o.Id == ocId);
|
|
|
|
if (data == null)
|
|
throw new Exception(GlobalMessages.OrganizationNotFound);
|
|
|
|
return data.OrganizationAgencyId!.Value;
|
|
}
|
|
catch
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|