994 lines
46 KiB
C#
994 lines
46 KiB
C#
using System.Security.Claims;
|
|
using System.Text.Json;
|
|
using BMA.EHR.Recurit.Exam.Service.Core;
|
|
using BMA.EHR.Recurit.Exam.Service.Data;
|
|
using BMA.EHR.Recurit.Exam.Service.Models;
|
|
using BMA.EHR.Recurit.Exam.Service.Models.Documents;
|
|
using BMA.EHR.Recurit.Exam.Service.Request;
|
|
using BMA.EHR.Recurit.Exam.Service.Response;
|
|
using BMA.EHR.Recurit.Exam.Service.Responses.Document;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Newtonsoft.Json.Linq;
|
|
using OfficeOpenXml;
|
|
|
|
namespace BMA.EHR.Recurit.Exam.Service.Services
|
|
{
|
|
public class PeriodExamService
|
|
{
|
|
#region " Fields "
|
|
|
|
private readonly ApplicationDbContext _context;
|
|
private readonly MetadataDbContext _contextMetadata;
|
|
private readonly IHttpContextAccessor _httpContextAccessor;
|
|
private readonly MinIOService _minioService;
|
|
|
|
#endregion
|
|
|
|
#region " Constructor and Destructor "
|
|
|
|
public PeriodExamService(ApplicationDbContext context,
|
|
MetadataDbContext contextMetadata,
|
|
IHttpContextAccessor httpContextAccessor,
|
|
MinIOService minioService)
|
|
{
|
|
_context = context;
|
|
_contextMetadata = contextMetadata;
|
|
_httpContextAccessor = httpContextAccessor;
|
|
_minioService = minioService;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region " Properties "
|
|
|
|
private string? UserId => _httpContextAccessor?.HttpContext?.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
|
|
|
|
private string? FullName => _httpContextAccessor?.HttpContext?.User?.FindFirst("name")?.Value;
|
|
|
|
#endregion
|
|
|
|
#region " Methods "
|
|
|
|
public async Task<IEnumerable<PeriodExamCandidateResponseItem>> GetsAsync(string type, bool showAll = true)
|
|
{
|
|
return await _context.PeriodExams.AsQueryable()
|
|
.Where(p => p.IsActive)
|
|
.Where(p => type.ToUpper() == "ALL" ? (p.AnnouncementExam == true || p.AnnouncementExam == false) : (type.ToUpper() == "EXAM" ? p.AnnouncementExam == true : p.AnnouncementExam == false))
|
|
.OrderByDescending(d => d.CreatedAt)
|
|
.Select(x => new PeriodExamCandidateResponseItem
|
|
{
|
|
ExamDate = x.ExamDate,
|
|
AnnouncementEndDate = x.AnnouncementEndDate,
|
|
AnnouncementStartDate = x.AnnouncementStartDate,
|
|
CheckDisability = x.CheckDisability,
|
|
CheckDocument = x.CheckDocument,
|
|
Detail = x.Detail,
|
|
Fee = x.Fee,
|
|
Id = x.Id,
|
|
IsActive = x.IsActive,
|
|
Name = x.Name,
|
|
Note = x.Note,
|
|
OrganizationCodeId = x.OrganizationCodeId,
|
|
OrganizationCodeName = x.OrganizationCodeName,
|
|
OrganizationId = x.OrganizationId,
|
|
OrganizationName = x.OrganizationName,
|
|
PaymentEndDate = x.PaymentEndDate,
|
|
PaymentKrungThai = x.PaymentKrungThai,
|
|
AnnouncementExam = x.AnnouncementExam,
|
|
Category = x.Category,
|
|
PaymentStartDate = x.PaymentStartDate,
|
|
RegisterEndDate = x.RegisterEndDate,
|
|
RegisterStartDate = x.RegisterStartDate,
|
|
Round = x.Round,
|
|
SetSeat = x.SetSeat,
|
|
Year = x.Year,
|
|
})
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task<PeriodExamCandidateResponseItem?> GetsExamAndCandidateAsync(string examId, bool showAll = true)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.PositionExam)
|
|
.Include(x => x.BankExam)
|
|
.Include(x => x.PeriodExamDocuments)
|
|
.Select(x => new PeriodExamCandidateResponseItem
|
|
{
|
|
ExamDate = x.ExamDate,
|
|
AnnouncementEndDate = x.AnnouncementEndDate,
|
|
AnnouncementStartDate = x.AnnouncementStartDate,
|
|
CheckDisability = x.CheckDisability,
|
|
CheckDocument = x.CheckDocument,
|
|
Detail = x.Detail,
|
|
Fee = x.Fee,
|
|
Id = x.Id,
|
|
IsActive = x.IsActive,
|
|
Name = x.Name,
|
|
Note = x.Note,
|
|
OrganizationCodeId = x.OrganizationCodeId,
|
|
OrganizationCodeName = x.OrganizationCodeName,
|
|
OrganizationId = x.OrganizationId,
|
|
OrganizationName = x.OrganizationName,
|
|
PaymentEndDate = x.PaymentEndDate,
|
|
PaymentKrungThai = x.PaymentKrungThai,
|
|
AnnouncementExam = x.AnnouncementExam,
|
|
Category = x.Category,
|
|
PaymentStartDate = x.PaymentStartDate,
|
|
RegisterEndDate = x.RegisterEndDate,
|
|
RegisterStartDate = x.RegisterStartDate,
|
|
Round = x.Round,
|
|
SetSeat = x.SetSeat,
|
|
Year = x.Year,
|
|
BankExam = x.BankExam.OrderBy(o => o.CreatedAt).Select(b => new BankExam
|
|
{
|
|
Id = b.Id,
|
|
AccountName = b.AccountName,
|
|
AccountNumber = b.AccountNumber,
|
|
BankName = b.BankName,
|
|
}).ToList(),
|
|
PositionExam = x.PositionExam.OrderBy(o => o.CreatedAt).Select(b => new PositionExam
|
|
{
|
|
Id = b.Id,
|
|
TypeId = b.TypeId,
|
|
TypeName = b.TypeName,
|
|
PositionId = b.PositionId,
|
|
PositionName = b.PositionName,
|
|
}).ToList(),
|
|
Documents = x.PeriodExamDocuments.OrderBy(o => o.CreatedAt).Select(b => new FileListResponse
|
|
{
|
|
Id = b.Document == null ? "" : b.Document.Id.ToString(),
|
|
FileName = b.Document == null ? "" : b.Document.FileName,
|
|
FileSize = b.Document == null ? 0 : b.Document.FileSize,
|
|
FileType = b.Document == null ? "" : b.Document.FileType,
|
|
Detail = b.Document == null ? "" : b.Document.Id.ToString(),
|
|
}).ToList(),
|
|
Images = x.PeriodExamImages.OrderBy(o => o.CreatedAt).Select(b => new FileListResponse
|
|
{
|
|
Id = b.Document == null ? "" : b.Document.Id.ToString(),
|
|
FileName = b.Document == null ? "" : b.Document.FileName,
|
|
FileSize = b.Document == null ? 0 : b.Document.FileSize,
|
|
FileType = b.Document == null ? "" : b.Document.FileType,
|
|
Detail = b.Document == null ? "" : b.Document.Id.ToString(),
|
|
}).ToList(),
|
|
})
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
var i = 0;
|
|
foreach (var item in periodExam.Images)
|
|
{
|
|
if (periodExam.Images[i].Detail != null && periodExam.Images[i].Detail != "")
|
|
periodExam.Images[i].Detail = _minioService.ImagesPath(Guid.Parse(periodExam.Images[i].Detail)).Result;
|
|
i++;
|
|
}
|
|
i = 0;
|
|
foreach (var item in periodExam.Documents)
|
|
{
|
|
if (periodExam.Documents[i].Detail != null && periodExam.Documents[i].Detail != "")
|
|
periodExam.Documents[i].Detail = _minioService.ImagesPath(Guid.Parse(periodExam.Documents[i].Detail)).Result;
|
|
i++;
|
|
}
|
|
|
|
return periodExam;
|
|
}
|
|
|
|
public async Task<RequestStatusExam?> GetsStatusPaymentAsync(string examId, bool showAll = true)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
return new RequestStatusExam
|
|
{
|
|
Name = periodExam.Name,
|
|
Status = DateTime.Now > periodExam.PaymentEndDate,
|
|
SetSeat = periodExam.SetSeat,
|
|
};
|
|
}
|
|
|
|
public async Task<RequestPositionName?> GetsNamePositionAsync(string examId, string positionId)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.PositionExam)
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
if (positionId != "00000000-0000-0000-0000-000000000000")
|
|
{
|
|
return new RequestPositionName
|
|
{
|
|
Name = periodExam.Name,
|
|
Posiiton = periodExam.PositionExam.FirstOrDefault(x => x.Id == Guid.Parse(positionId) && x.PeriodExam == periodExam),
|
|
};
|
|
}
|
|
else
|
|
{
|
|
return new RequestPositionName
|
|
{
|
|
Name = periodExam.Name,
|
|
Posiiton = null,
|
|
};
|
|
}
|
|
}
|
|
|
|
public async Task<Guid> CreateAsync(RequestPeriodExam inserted)
|
|
{
|
|
var periodExam = new PeriodExam
|
|
{
|
|
Name = inserted.Name,
|
|
CheckDocument = inserted.CheckDocument,
|
|
CheckDisability = inserted.CheckDisability,
|
|
Round = inserted.Round,
|
|
Year = inserted.Year,
|
|
Fee = inserted.Fee,
|
|
RegisterStartDate = inserted.RegisterStartDate,
|
|
RegisterEndDate = inserted.RegisterEndDate,
|
|
PaymentStartDate = inserted.PaymentStartDate,
|
|
PaymentEndDate = inserted.PaymentEndDate,
|
|
AnnouncementStartDate = inserted.AnnouncementStartDate,
|
|
ExamDate = inserted.ExamDate,
|
|
AnnouncementEndDate = inserted.AnnouncementEndDate,
|
|
OrganizationCodeId = inserted.OrganizationCodeId,
|
|
OrganizationCodeName = inserted.OrganizationCodeName,
|
|
OrganizationId = inserted.OrganizationId,
|
|
OrganizationName = inserted.OrganizationName,
|
|
PaymentKrungThai = inserted.PaymentKrungThai,
|
|
AnnouncementExam = inserted.AnnouncementExam,
|
|
Category = inserted.Category,
|
|
Detail = inserted.Detail,
|
|
Note = inserted.Note,
|
|
CreatedAt = DateTime.Now,
|
|
CreatedUserId = UserId ?? "",
|
|
LastUpdatedAt = DateTime.Now,
|
|
LastUpdateUserId = UserId ?? "",
|
|
CreatedFullName = FullName ?? "",
|
|
LastUpdateFullName = FullName ?? "",
|
|
};
|
|
|
|
if (inserted.PaymentKrungThai == "payment2")
|
|
{
|
|
foreach (var bank in inserted.BankExam)
|
|
{
|
|
var bankExam = new BankExam
|
|
{
|
|
PeriodExam = periodExam,
|
|
AccountName = bank.AccountName,
|
|
AccountNumber = bank.AccountNumber,
|
|
BankName = bank.BankName,
|
|
CreatedAt = DateTime.Now,
|
|
CreatedUserId = UserId ?? "",
|
|
LastUpdatedAt = DateTime.Now,
|
|
LastUpdateUserId = UserId ?? "",
|
|
CreatedFullName = FullName ?? "",
|
|
LastUpdateFullName = FullName ?? "",
|
|
};
|
|
await _context.BankExams.AddAsync(bankExam);
|
|
}
|
|
}
|
|
|
|
foreach (var position in inserted.PositionExam)
|
|
{
|
|
var positionExam = new PositionExam
|
|
{
|
|
PeriodExam = periodExam,
|
|
PositionId = position.PositionId,
|
|
PositionName = position.PositionName,
|
|
TypeId = position.TypeId,
|
|
TypeName = position.TypeName,
|
|
CreatedAt = DateTime.Now,
|
|
CreatedUserId = UserId ?? "",
|
|
LastUpdatedAt = DateTime.Now,
|
|
LastUpdateUserId = UserId ?? "",
|
|
CreatedFullName = FullName ?? "",
|
|
LastUpdateFullName = FullName ?? "",
|
|
};
|
|
await _context.PositionExams.AddAsync(positionExam);
|
|
}
|
|
|
|
await _context.PeriodExams.AddAsync(periodExam);
|
|
await _context.SaveChangesAsync();
|
|
|
|
return periodExam.Id;
|
|
}
|
|
|
|
public async Task UpdateAsync(string examId, RequestPeriodExam updated)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.BankExam)
|
|
.Include(x => x.PositionExam)
|
|
.Include(x => x.Candidate)
|
|
.Include(x => x.PeriodExamDocuments)
|
|
.ThenInclude(x => x.Document)
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
periodExam.Name = updated.Name;
|
|
periodExam.CheckDocument = updated.CheckDocument;
|
|
periodExam.CheckDisability = updated.CheckDisability;
|
|
periodExam.Round = updated.Round;
|
|
periodExam.Year = updated.Year;
|
|
periodExam.Fee = updated.Fee;
|
|
periodExam.RegisterStartDate = updated.RegisterStartDate;
|
|
periodExam.RegisterEndDate = updated.RegisterEndDate;
|
|
periodExam.PaymentStartDate = updated.PaymentStartDate;
|
|
periodExam.PaymentEndDate = updated.PaymentEndDate;
|
|
periodExam.AnnouncementStartDate = updated.AnnouncementStartDate;
|
|
periodExam.ExamDate = updated.ExamDate;
|
|
periodExam.AnnouncementEndDate = updated.AnnouncementEndDate;
|
|
periodExam.OrganizationCodeId = updated.OrganizationCodeId;
|
|
periodExam.OrganizationCodeName = updated.OrganizationCodeName;
|
|
periodExam.OrganizationId = updated.OrganizationId;
|
|
periodExam.OrganizationName = updated.OrganizationName;
|
|
periodExam.PaymentKrungThai = updated.PaymentKrungThai;
|
|
// periodExam.AnnouncementExam = updated.AnnouncementExam;
|
|
periodExam.Category = updated.Category;
|
|
periodExam.Detail = updated.Detail;
|
|
periodExam.Note = updated.Note;
|
|
periodExam.LastUpdatedAt = DateTime.Now;
|
|
periodExam.LastUpdateUserId = UserId ?? "";
|
|
periodExam.LastUpdateFullName = FullName ?? "";
|
|
|
|
if (updated.PaymentKrungThai == "payment2")
|
|
{
|
|
foreach (var bank in periodExam.BankExam)
|
|
{
|
|
var bankData = updated.BankExam
|
|
.FirstOrDefault(x => x.Id == bank.Id);
|
|
if (bankData != null)
|
|
{
|
|
bank.AccountName = bankData.AccountName;
|
|
bank.AccountNumber = bankData.AccountNumber;
|
|
bank.BankName = bankData.BankName;
|
|
bank.LastUpdatedAt = DateTime.Now;
|
|
bank.LastUpdateUserId = UserId ?? "";
|
|
bank.LastUpdateFullName = FullName ?? "";
|
|
}
|
|
else
|
|
{
|
|
var bankDelete = await _context.BankExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == bank.Id);
|
|
|
|
if (bankDelete != null)
|
|
_context.BankExams.Remove(bankDelete);
|
|
}
|
|
}
|
|
var bankAdd = updated.BankExam
|
|
.Where(x => x.Id == Guid.Parse("00000000-0000-0000-0000-000000000000"))
|
|
.ToList();
|
|
foreach (var bank in bankAdd)
|
|
{
|
|
var bankExam = new BankExam
|
|
{
|
|
PeriodExam = periodExam,
|
|
AccountName = bank.AccountName,
|
|
AccountNumber = bank.AccountNumber,
|
|
BankName = bank.BankName,
|
|
CreatedAt = DateTime.Now,
|
|
CreatedUserId = UserId ?? "",
|
|
LastUpdatedAt = DateTime.Now,
|
|
LastUpdateUserId = UserId ?? "",
|
|
CreatedFullName = FullName ?? "",
|
|
LastUpdateFullName = FullName ?? "",
|
|
};
|
|
await _context.BankExams.AddAsync(bankExam);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var bank in periodExam.BankExam)
|
|
{
|
|
var bankDelete = await _context.BankExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == bank.Id);
|
|
|
|
if (bankDelete != null)
|
|
_context.BankExams.Remove(bankDelete);
|
|
}
|
|
}
|
|
|
|
foreach (var position in periodExam.PositionExam)
|
|
{
|
|
var positionData = updated.PositionExam
|
|
.FirstOrDefault(x => x.Id == position.Id);
|
|
if (positionData != null)
|
|
{
|
|
position.PositionId = positionData.PositionId;
|
|
position.PositionName = positionData.PositionName;
|
|
position.TypeId = positionData.TypeId;
|
|
position.TypeName = positionData.TypeName;
|
|
position.LastUpdatedAt = DateTime.Now;
|
|
position.LastUpdateUserId = UserId ?? "";
|
|
position.LastUpdateFullName = FullName ?? "";
|
|
}
|
|
else
|
|
{
|
|
var positionDelete = await _context.PositionExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == position.Id);
|
|
|
|
if (positionDelete != null)
|
|
{
|
|
if (periodExam.Candidate.Count() > 0)
|
|
throw new Exception("รอบนี้มีการสมัครแล้วไม่สามารถลบตำแหน่งได้");
|
|
_context.PositionExams.Remove(positionDelete);
|
|
}
|
|
}
|
|
}
|
|
|
|
var positionAdd = updated.PositionExam
|
|
.Where(x => x.Id == Guid.Parse("00000000-0000-0000-0000-000000000000"))
|
|
.ToList();
|
|
foreach (var position in positionAdd)
|
|
{
|
|
var positionExam = new PositionExam
|
|
{
|
|
PeriodExam = periodExam,
|
|
PositionId = position.PositionId,
|
|
PositionName = position.PositionName,
|
|
TypeId = position.TypeId,
|
|
TypeName = position.TypeName,
|
|
CreatedAt = DateTime.Now,
|
|
CreatedUserId = UserId ?? "",
|
|
LastUpdatedAt = DateTime.Now,
|
|
LastUpdateUserId = UserId ?? "",
|
|
CreatedFullName = FullName ?? "",
|
|
LastUpdateFullName = FullName ?? "",
|
|
};
|
|
await _context.PositionExams.AddAsync(positionExam);
|
|
}
|
|
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task UpdateDocAsync(string examId, IFormFileCollection files)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
foreach (var file in files)
|
|
{
|
|
var doc = await _minioService.UploadFileAsync(file);
|
|
|
|
var document = await _context.Documents.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == doc.Id);
|
|
|
|
if (document == null)
|
|
throw new Exception(GlobalMessages.NoFileToUpload);
|
|
|
|
var periodExamDocument = new PeriodExamDocument
|
|
{
|
|
PeriodExam = periodExam,
|
|
Document = document,
|
|
};
|
|
|
|
await _context.PeriodExamDocuments.AddAsync(periodExamDocument);
|
|
}
|
|
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task UpdateImgAsync(string examId, IFormFileCollection files)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
foreach (var file in files)
|
|
{
|
|
var doc = await _minioService.UploadFileAsync(file);
|
|
|
|
var document = await _context.Documents.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == doc.Id);
|
|
|
|
if (document == null)
|
|
throw new Exception(GlobalMessages.NoFileToUpload);
|
|
|
|
var periodExamImage = new PeriodExamImage
|
|
{
|
|
PeriodExam = periodExam,
|
|
Document = document,
|
|
};
|
|
|
|
await _context.PeriodExamImages.AddAsync(periodExamImage);
|
|
}
|
|
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task DeleteDocument(string documentId)
|
|
{
|
|
await _minioService.DeleteFileAsync(Guid.Parse(documentId));
|
|
}
|
|
|
|
public async Task DeleteAsyncDocument(string examId, string documentId)
|
|
{
|
|
var exam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.PositionExam)
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (exam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
await _minioService.DeleteFileAsync(Guid.Parse(documentId));
|
|
}
|
|
|
|
public async Task DeleteAsync(string examId)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
_context.PeriodExams.Remove(periodExam);
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task<IEnumerable<Candidate?>> GetsCandidateByStatusAsync(string examId, string status)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
if (status == "all")
|
|
{
|
|
var candidate = await _context.Candidates.AsQueryable()
|
|
.Include(x => x.ProfileImg)
|
|
.OrderByDescending(d => d.CreatedAt)
|
|
.Where(x => x.PeriodExam == periodExam && x.Status != "register" && x.Status != "rejectRegister")
|
|
.ToListAsync();
|
|
var i = 0;
|
|
foreach (var item in candidate)
|
|
{
|
|
if (candidate[i].ProfileImg != null)
|
|
candidate[i].ProfileImg.Detail = _minioService.ImagesPath(candidate[i].ProfileImg.Id).Result;
|
|
i++;
|
|
}
|
|
return candidate;
|
|
}
|
|
else
|
|
{
|
|
var candidate = await _context.Candidates.AsQueryable()
|
|
.Include(x => x.ProfileImg)
|
|
.OrderByDescending(d => d.CreatedAt)
|
|
.Where(x => x.PeriodExam == periodExam && x.Status == status)
|
|
.ToListAsync();
|
|
var i = 0;
|
|
foreach (var item in candidate)
|
|
{
|
|
if (candidate[i].ProfileImg != null)
|
|
candidate[i].ProfileImg.Detail = _minioService.ImagesPath(candidate[i].ProfileImg.Id).Result;
|
|
i++;
|
|
}
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
public async Task<CandidateInformationResponseItem?> GetsAsyncInformation(string candidateId)
|
|
{
|
|
var candidate = await _context.Candidates.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.Select(x => new CandidateInformationResponseItem
|
|
{
|
|
Prefix = x.PrefixName,
|
|
PrefixId = x.PrefixId != null ? x.PrefixId.ToString() : null,
|
|
FirstName = x.FirstName,
|
|
LastName = x.LastName,
|
|
Nationality = x.Nationality,
|
|
DateOfBirth = x.DateOfBirth,
|
|
Relationship = x.RelationshipName,
|
|
RelationshipId = x.RelationshipId != null ? x.RelationshipId.ToString() : null,
|
|
CitizenProvince = x.CitizenProvinceName,
|
|
CitizenProvinceId = x.CitizenProvinceId != null ? x.CitizenProvinceId.ToString() : null,
|
|
CitizenDistrict = x.CitizenDistrictName,
|
|
CitizenDistrictId = x.CitizenDistrictId != null ? x.CitizenDistrictId.ToString() : null,
|
|
CitizenDate = x.CitizenDate,
|
|
Email = x.Email,
|
|
CitizenId = x.CitizenId,
|
|
Telephone = x.Telephone,
|
|
MobilePhone = x.MobilePhone,
|
|
Knowledge = x.Knowledge,
|
|
ProfileImg = x.ProfileImg == null ? "" : x.ProfileImg.Id.ToString(),
|
|
})
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (candidate == null)
|
|
return candidate;
|
|
|
|
if (candidate.ProfileImg != null && candidate.ProfileImg != "")
|
|
candidate.ProfileImg = _minioService.ImagesPath(Guid.Parse(candidate.ProfileImg)).Result;
|
|
|
|
return candidate;
|
|
}
|
|
|
|
public async Task<CandidateOccupationResponseItem?> GetsAsyncOccupation(string candidateId)
|
|
{
|
|
return await _context.Candidates.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.Select(x => new CandidateOccupationResponseItem
|
|
{
|
|
OccupationType = x.OccupationType,
|
|
OccupationCompany = x.OccupationCompany,
|
|
OccupationDepartment = x.OccupationDepartment,
|
|
OccupationEmail = x.OccupationEmail,
|
|
OccupationTelephone = x.OccupationTelephone,
|
|
OccupationPosition = x.OccupationPosition,
|
|
})
|
|
.FirstOrDefaultAsync();
|
|
}
|
|
|
|
public async Task<CandidateAddressResponseItem?> GetsAsyncAddress(string candidateId)
|
|
{
|
|
return await _context.Candidates.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.Select(x => new CandidateAddressResponseItem
|
|
{
|
|
RegistAddress = x.RegistAddress,
|
|
RegistProvince = x.RegistProvinceName,
|
|
RegistProvinceId = x.RegistProvinceId != null ? x.RegistProvinceId.ToString() : null,
|
|
RegistDistrict = x.RegistDistrictName,
|
|
RegistDistrictId = x.RegistDistrictId != null ? x.RegistDistrictId.ToString() : null,
|
|
RegistSubDistrict = x.RegistSubDistrictName,
|
|
RegistSubDistrictId = x.RegistSubDistrictId != null ? x.RegistSubDistrictId.ToString() : null,
|
|
RegistZipCode = x.RegistZipCode,
|
|
RegistSame = x.RegistSame,
|
|
CurrentAddress = x.CurrentAddress,
|
|
CurrentProvince = x.CurrentProvinceName,
|
|
CurrentProvinceId = x.CurrentProvinceId != null ? x.CurrentProvinceId.ToString() : null,
|
|
CurrentDistrict = x.CurrentDistrictName,
|
|
CurrentDistrictId = x.CurrentDistrictId != null ? x.CurrentDistrictId.ToString() : null,
|
|
CurrentSubDistrict = x.CurrentSubDistrictName,
|
|
CurrentSubDistrictId = x.CurrentSubDistrictId != null ? x.CurrentSubDistrictId.ToString() : null,
|
|
CurrentZipCode = x.CurrentZipCode,
|
|
})
|
|
.FirstOrDefaultAsync();
|
|
}
|
|
|
|
public async Task<CandidateFamilyResponseItem?> GetsAsyncFamily(string candidateId)
|
|
{
|
|
return await _context.Candidates.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.Select(x => new CandidateFamilyResponseItem
|
|
{
|
|
Marry = x.Marry,
|
|
MarryPrefix = x.MarryPrefixName,
|
|
MarryPrefixId = x.MarryPrefixId != null ? x.MarryPrefixId.ToString() : null,
|
|
MarryFirstName = x.MarryFirstName,
|
|
MarryLastName = x.MarryLastName,
|
|
MarryOccupation = x.MarryOccupation,
|
|
MarryNationality = x.MarryNationality,
|
|
FatherPrefix = x.FatherPrefixName,
|
|
FatherPrefixId = x.FatherPrefixId != null ? x.FatherPrefixId.ToString() : null,
|
|
FatherFirstName = x.FatherFirstName,
|
|
FatherLastName = x.FatherLastName,
|
|
FatherOccupation = x.FatherOccupation,
|
|
FatherNationality = x.FatherNationality,
|
|
MotherPrefix = x.MotherPrefixName,
|
|
MotherPrefixId = x.MotherPrefixId != null ? x.MotherPrefixId.ToString() : null,
|
|
MotherFirstName = x.MotherFirstName,
|
|
MotherLastName = x.MotherLastName,
|
|
MotherOccupation = x.MotherOccupation,
|
|
MotherNationality = x.MotherNationality,
|
|
})
|
|
.FirstOrDefaultAsync();
|
|
}
|
|
|
|
public async Task<IEnumerable<Education?>> GetsAsyncEducation(string candidateId)
|
|
{
|
|
return await _context.Educations.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.OrderBy(d => d.DurationStart)
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task<IEnumerable<Career?>> GetsAsyncCareer(string candidateId)
|
|
{
|
|
return await _context.Careers.AsQueryable()
|
|
.Where(x => x.Id == Guid.Parse(candidateId))
|
|
.OrderBy(d => d.DurationStart)
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task<IEnumerable<FileListResponse?>> GetsAsyncDocument(string candidateId)
|
|
{
|
|
var candidate = await _context.Candidates.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(candidateId));
|
|
|
|
if (candidate == null)
|
|
throw new Exception(GlobalMessages.CandidateNotFound);
|
|
|
|
var document = await _context.CandidateDocuments.AsQueryable()
|
|
.Where(x => x.Candidate == candidate)
|
|
.OrderBy(d => d.CreatedAt)
|
|
.Select(x => new FileListResponse
|
|
{
|
|
Id = x.Document == null ? "" : x.Document.Id.ToString(),
|
|
FileName = x.Document == null ? "" : x.Document.FileName,
|
|
FileType = x.Document == null ? "" : x.Document.FileType,
|
|
FileSize = x.Document == null ? 0 : x.Document.FileSize,
|
|
Detail = x.Document == null ? "" : x.Document.Id.ToString(),
|
|
})
|
|
.ToListAsync();
|
|
|
|
var i = 0;
|
|
foreach (var item in document)
|
|
{
|
|
if (document[i].Detail != null && document[i].Detail != "")
|
|
document[i].Detail = _minioService.ImagesPath(Guid.Parse(document[i].Detail)).Result;
|
|
i++;
|
|
}
|
|
|
|
return document;
|
|
}
|
|
|
|
private async Task<List<RequestImportSeat>> ReadExcelCandidate(IFormFile formFile)
|
|
{
|
|
var list = new List<RequestImportSeat>();
|
|
using (var stream = new MemoryStream())
|
|
{
|
|
await formFile.CopyToAsync(stream);
|
|
using (var package = new ExcelPackage(stream))
|
|
{
|
|
for (int i = 0; i < package.Workbook.Worksheets.Count(); i++)
|
|
{
|
|
ExcelWorksheet worksheet = package.Workbook.Worksheets[i];
|
|
var rowCount = worksheet.Dimension.Rows;
|
|
for (int row = 2; row <= rowCount; row++)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine(worksheet);
|
|
if (worksheet.Cells[row, 1].Value != null)
|
|
{
|
|
list.Add(new RequestImportSeat
|
|
{
|
|
CitizenId = worksheet.Cells[row, 1].Value != null ? worksheet.Cells[row, 1].Value.ToString() : "-",
|
|
ExamIdenNumber = worksheet.Cells[row, 2].Value != null ? worksheet.Cells[row, 2].Value.ToString() : "-",
|
|
SeatNumber = worksheet.Cells[row, 3].Value != null ? worksheet.Cells[row, 3].Value.ToString() : "-",
|
|
Point = worksheet.Cells[row, 4].Value != null ? worksheet.Cells[row, 4].Value.ToString() : "-",
|
|
Pass = worksheet.Cells[row, 4].Value != null ? (worksheet.Cells[row, 4].Value.ToString() == "1" ? true : false) : null,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public async Task UploadSeatCandidateAsync(string examId, IFormFile excels)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
var candidates = await _context.Candidates
|
|
.AsQueryable()
|
|
.Where(x => x.PeriodExam == periodExam)
|
|
.ToListAsync();
|
|
|
|
var items = await ReadExcelCandidate(excels);
|
|
|
|
foreach (var candidate in candidates)
|
|
{
|
|
var item = items.FirstOrDefault(x => x.CitizenId == candidate.CitizenId && x.ExamIdenNumber == candidate.ExamIdenNumber);
|
|
|
|
if (item != null)
|
|
{
|
|
if (candidate.Status == "checkSeat")
|
|
{
|
|
candidate.SeatNumber = item.SeatNumber;
|
|
candidate.Status = "checkPoint";
|
|
}
|
|
else
|
|
{
|
|
candidate.Status = "waiver";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
candidate.Status = "waiver";
|
|
}
|
|
periodExam.SetSeat = true;
|
|
}
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task UploadPointCandidateAsync(string examId, IFormFile excels)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
var candidates = await _context.Candidates
|
|
.AsQueryable()
|
|
.Where(x => x.PeriodExam == periodExam)
|
|
.ToListAsync();
|
|
|
|
var items = await ReadExcelCandidate(excels);
|
|
|
|
foreach (var candidate in candidates)
|
|
{
|
|
var item = items.FirstOrDefault(x => x.CitizenId == candidate.CitizenId && x.ExamIdenNumber == candidate.ExamIdenNumber);
|
|
|
|
if (item != null)
|
|
{
|
|
if (candidate.Status == "checkPoint" || candidate.Status == "done")
|
|
{
|
|
candidate.Point = item.Point;
|
|
candidate.Pass = item.Pass;
|
|
candidate.Status = "done";
|
|
}
|
|
else
|
|
{
|
|
candidate.Status = "waiver";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
candidate.Status = "waiver";
|
|
}
|
|
periodExam.SetSeat = true;
|
|
}
|
|
await _context.SaveChangesAsync();
|
|
}
|
|
|
|
public async Task<MemoryStream> DownloadCandidateAsync(string examId)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(examId));
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
var candidates = new List<Candidate>();
|
|
if (periodExam.SetSeat == true)
|
|
{
|
|
candidates = await _context.Candidates
|
|
.AsQueryable()
|
|
.OrderBy(x => x.ExamIdenNumber)
|
|
.Where(x => x.PeriodExam == periodExam)
|
|
.Where(x => x.Status != "waiver")
|
|
.ToListAsync();
|
|
}
|
|
else
|
|
{
|
|
candidates = await _context.Candidates
|
|
.AsQueryable()
|
|
.OrderBy(x => x.ExamIdenNumber)
|
|
.Where(x => x.PeriodExam == periodExam)
|
|
.ToListAsync();
|
|
}
|
|
|
|
var stream = new MemoryStream();
|
|
using (var package = new ExcelPackage(stream))
|
|
{
|
|
var summarySheet = package.Workbook.Worksheets.Add("Candidate");
|
|
summarySheet.TabColor = System.Drawing.Color.Black;
|
|
// summarySheet.DefaultRowHeight = 17;
|
|
summarySheet.Row(1).Style.Font.Bold = true;
|
|
summarySheet.Cells[1, 1].Value = "เลขบัตรประชาชน";
|
|
summarySheet.Cells[1, 2].Value = "เลขประจำตัวสอบ";
|
|
summarySheet.Cells[1, 3].Value = "เลขที่นั่งสอบ";
|
|
summarySheet.Cells[1, 4].Value = "คะแนน";
|
|
summarySheet.Cells[1, 5].Value = "ผลการสอบ";
|
|
int row = 2;
|
|
|
|
foreach (var item in candidates)
|
|
{
|
|
summarySheet.Cells[row, 1].Value = item.CitizenId;
|
|
summarySheet.Cells[row, 2].Value = item.ExamIdenNumber;
|
|
summarySheet.Cells[row, 3].Value = item.SeatNumber;
|
|
summarySheet.Cells[row, 4].Value = item.Point;
|
|
summarySheet.Cells[row, 5].Value = item.Pass;
|
|
row++;
|
|
}
|
|
summarySheet.Cells[summarySheet.Dimension.Address].AutoFitColumns();
|
|
package.Save();
|
|
}
|
|
|
|
stream.Position = 0;
|
|
return stream;
|
|
}
|
|
|
|
public async Task<PeriodExam> GetsPaymentExamAsync(string examId)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.BankExam)
|
|
.Where(x => x.Id == Guid.Parse(examId))
|
|
.Select(x => new PeriodExam
|
|
{
|
|
BankExam = x.BankExam,
|
|
Fee = x.Fee,
|
|
})
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
return periodExam;
|
|
}
|
|
|
|
public async Task<List<DashboardResponseItem>> GetsDashboardPaymentExamAsync(string examId)
|
|
{
|
|
var periodExam = await _context.PeriodExams.AsQueryable()
|
|
.Include(x => x.Candidate)
|
|
.ThenInclude(x => x.PaymentImg)
|
|
.Where(x => x.Id == Guid.Parse(examId))
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (periodExam == null)
|
|
throw new Exception(GlobalMessages.ExamNotFound);
|
|
|
|
var dashboard = new List<DashboardResponseItem>
|
|
{
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 1,
|
|
Name = "จำนวนผู้สมัครคัดเลือกทั้งหมด",
|
|
Count = periodExam.Candidate.Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 2,
|
|
Name = "จำนวนผู้มีสิทธิ์เข้ารับคัดเลือกทั้งหมด",
|
|
Count = periodExam.Candidate.Where(x=>x.ExamIdenNumber != null).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 3,
|
|
Name = "จำนวนผู้เข้ารับการคัดเลือกทั้งหมด",
|
|
Count = periodExam.Candidate.Where(x=>x.PaymentImg!=null).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 4,
|
|
Name = "ผ่านการสอบ",
|
|
Count = periodExam.Candidate.Where(x=>x.Pass == true).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 5,
|
|
Name = "ไม่ผ่านการสอบ",
|
|
Count = periodExam.Candidate.Where(x=>x.Pass == false).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 6,
|
|
Name = "เพศชาย",
|
|
Count = periodExam.Candidate.Where(x=>x.PrefixName != null && x.PrefixName.Contains("ชาย")).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 7,
|
|
Name = "เพศหญิง",
|
|
Count = periodExam.Candidate.Where(x=>x.PrefixName != null && x.PrefixName.Contains("หญิง")).Count()
|
|
},
|
|
new DashboardResponseItem
|
|
{
|
|
Id = 8,
|
|
Name = "เพศอื่นๆ",
|
|
Count = periodExam.Candidate.Count() -periodExam.Candidate.Where(x=>x.PrefixName != null && x.PrefixName.Contains("ชาย")).Count()-periodExam.Candidate.Where(x=>x.PrefixName != null && x.PrefixName.Contains("หญิง")).Count()
|
|
},
|
|
};
|
|
|
|
return dashboard;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|