hrms-api-exam/Controllers/PeriodExamController.cs

using BMA.EHR.Recurit.Exam.Service.Core;
using BMA.EHR.Recurit.Exam.Service.Models;
using BMA.EHR.Recurit.Exam.Service.Request;
using BMA.EHR.Recurit.Exam.Service.Response;
using BMA.EHR.Recurit.Exam.Service.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using Swashbuckle.AspNetCore.Annotations;

namespace BMA.EHR.Recurit.Exam.Service.Controllers
{
    [Route("api/v{version:apiVersion}/candidate/period-exam")]
    [ApiVersion("1.0")]
    [ApiController]
    [Produces("application/json")]
    [AllowAnonymous]
    [Authorize]
    [SwaggerTag("จัดการข้อมูลรอบการสอบ เพื่อนำไปใช้งานในระบบ")]
    public class PeriodExamController : BaseController
    {
        #region " Fields "

        private readonly PeriodExamService _periodExamService;
        private readonly MinIOService _minioService;
        private readonly PermissionRepository _permission;

        #endregion

        #region " Constructor and Destructor "

        public PeriodExamController(PeriodExamService periodExamService, MinIOService minioService, PermissionRepository permission)
        {
            _periodExamService = periodExamService;
            _minioService = minioService;
            _permission = permission;
        }

        #endregion

        #region " Methods "

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบทั้งหมด
        /// </summary>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบทั้งหมดสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsync()
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("LIST", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.GetsAsync("all", showAll: false);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบทั้งหมด
        /// <param name="type">ประเกทประกาศสอบคัดเลือก</param>
        /// </summary>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบทั้งหมดสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("type/{type}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsByTypeAsync(string type)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("LIST", "SYS_EXAM_SELECT_LISTNAME");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.GetsAsync(type, showAll: false);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลสถานะจ่ายเงิน
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// </summary>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลสถานะจ่ายเงินสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("status-payment/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsStatusPaymentAsync(string examId)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("GET", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.GetsStatusPaymentAsync(examId);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsExamAndCandidateAsync(string examId)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("GET", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.GetsExamAndCandidateAsync(examId, showAll: false);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบ
        /// </summary>
        /// <param name="item">ข้อมูลรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPost]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> CreateAsync(RequestPeriodExam item)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("CREATE", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.CreateAsync(item);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <param name="item">ข้อมูลรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPut("{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> UpdateAsync(string examId, RequestPeriodExam item)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("UPDATE", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                await _periodExamService.UpdateAsync(examId, item);

                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบ
        /// </summary>
        /// <param name="type">ประเภทเอกสาร</param>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPut("{type}/{examId:length(36)}"), DisableRequestSizeLimit]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> UpdateDocAsync(string type, string examId)
        {
            try
            {
                if (Request.Form.Files == null || Request.Form.Files.Count == 0)
                {
                    return Error(GlobalMessages.NoFileToUpload);
                }

                var files = Request.Form.Files;
                if (type == "img")
                {
                    await _periodExamService.UpdateImgAsync(examId, files);
                }
                else if (type == "barcode")
                {
                    await _periodExamService.UpdateBarcodeAsync(examId, files);
                }
                else if (type == "qrcode")
                {
                    await _periodExamService.UpdateQrcodeAsync(examId, files);
                }
                else
                {
                    await _periodExamService.UpdateDocAsync(examId, files);
                }

                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลรอบการสมัครสอบ และ คนสมัครสอบในรอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpDelete("{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> DeleteAsync(string examId)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("DELETE", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                await _periodExamService.DeleteAsync(examId);

                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        // /// <summary>
        // /// รายชื่อผู้สมัครสอบรอ ตรวจสอบคุณสมบัติ
        // /// </summary>
        // /// <param name="examId">รหัสรอบสมัคร</param>
        // /// <returns></returns>
        // /// <response code="200">เมื่อทำการอ่านรายชื่อผู้สมัครสอบรอ ตรวจสอบคุณสมบัติสำเร็จ</response>
        // /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        // /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        // [HttpGet("register/{examId:length(36)}")]
        // [ProducesResponseType(StatusCodes.Status200OK)]
        // [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        // [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        // public async Task<ActionResult<ResponseObject>> GetsCandidateCheckRegisterAsync(string examId)
        // {
        //     try
        //     {
        //         var items = await _periodExamService.GetsCandidateByStatusAsync(examId, "checkRegister");

        //         return Success(items);
        //     }
        //     catch (Exception ex)
        //     {
        //         return Error(ex);
        //     }
        // }

        /// <summary>
        /// ข้อมูลชำระเงิน
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลชำระเงินสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("payment/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsPaymentExamAsync(string examId)
        {
            try
            {
                var items = await _periodExamService.GetsPaymentExamAsync(examId);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลเอกสารชำระเงิน
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลชำระเงินสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("payment-export/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> ExportsPaymentExamAsync(string examId)
        {
            try
            {
                var items = await _periodExamService.ExportsPaymentExamAsync(examId);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        // /// <summary>
        // /// รายชื่อผู้สมัครสอบรอ จัดการเลขที่นั่งสอบ
        // /// </summary>
        // /// <param name="examId">รหัสรอบสมัคร</param>
        // /// <returns></returns>
        // /// <response code="200">เมื่อทำการอ่านรายชื่อผู้สมัครสอบรอ จัดการเลขที่นั่งสอบสำเร็จ</response>
        // /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        // /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        // [HttpGet("seat/{examId:length(36)}")]
        // [ProducesResponseType(StatusCodes.Status200OK)]
        // [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        // [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        // public async Task<ActionResult<ResponseObject>> GetsCandidateCheckSeatAsync(string examId)
        // {
        //     try
        //     {
        //         var items = await _periodExamService.GetsCandidateByStatusAsync(examId, "checkSeat");

        //         return Success(items);
        //     }
        //     catch (Exception ex)
        //     {
        //         return Error(ex);
        //     }
        // }

        /// <summary>
        /// รายชื่อผู้สมัครสอบรอ ตรวจสอบคุณสมบัติ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านรายชื่อผู้สมัครสอบรอ ตรวจสอบคุณสมบัติสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("{status}/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsCandidateStatusAsync(string status, string examId, int page = 1, int pageSize = 25, string keyword = "")
        {
            try
            {
                var items = await _periodExamService.GetsCandidateByStatusAsync(examId, status, page, pageSize, keyword);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล ข้อมูลส่วนตัว ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล ข้อมูลส่วนตัว ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("information/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncInformation(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncInformation(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล ข้อมูลที่อยู่ ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล ข้อมูลที่อยู่ ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("address/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncAddress(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncAddress(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล ข้อมูลครอบครัว ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล ข้อมูลครอบครัว ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("family/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncFamily(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncFamily(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล อาชีพ ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล อาชีพ ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("occupation/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncOccupation(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncOccupation(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล บุคคลที่สามารถติดต่อได้
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล บุคคลที่สามารถติดต่อได้ สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("contact/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncContact(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncContact(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล ประวัติการทำงาน/ฝึกงาน ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล ประวัติการทำงาน/ฝึกงาน ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("career/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncCareer(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncCareer(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล ประวัติการศีกษา ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล ประวัติการศีกษา ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("education/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncEducation(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncEducation(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// get id รูปถ่าย
        /// </summary>
        /// <param name="candidate">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อ get id รูปถ่ายสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
		[HttpGet("profile-image/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncProfileImage(string candidate)
        {
            try
            {
                var path = await _periodExamService.GetsAsyncProfileImage(candidate);

                return Success(GlobalMessages.Success, path);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูล เอกสาร ผู้สมัคร
        /// </summary>
        /// <param name="candidate">รหัสผู้สมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการดึง ข้อมูล เอกสาร ผู้สมัคร สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("document/{candidate:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsAsyncDocument(string candidate)
        {
            try
            {
                var items = await _periodExamService.GetsAsyncDocument(candidate);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// อัพเดทข้อมูลที่นั่งสอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านอัพเดทข้อมูลที่นั่งสอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPut("upload-seat/{examId:length(36)}"), DisableRequestSizeLimit]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> UploadSeatCandidateAsync(string examId)
        {
            try
            {
                if (Request.Form.Files == null || Request.Form.Files.Count == 0)
                {
                    return Error(GlobalMessages.NoFileToUpload);
                }
                var file = Request.Form.Files[0];
                if (!Path.GetExtension(file.FileName).Equals(".xlsx", StringComparison.OrdinalIgnoreCase))
                {
                    return Error("นามสกุลไฟล์ต้องเป็น .xlsx!");
                }
                // return Success(file);
                await _periodExamService.UploadSeatCandidateAsync(examId, file);

                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// อัพเดทข้อมูลคะแนน
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านอัพเดทข้อมูลคะแนนสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPut("upload-point/{examId:length(36)}"), DisableRequestSizeLimit]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> UploadPointCandidateAsync(string examId)
        {
            try
            {
                if (Request.Form.Files == null || Request.Form.Files.Count == 0)
                {
                    return Error(GlobalMessages.NoFileToUpload);
                }
                var file = Request.Form.Files[0];
                if (!Path.GetExtension(file.FileName).Equals(".xlsx", StringComparison.OrdinalIgnoreCase))
                {
                    return Error("นามสกุลไฟล์ต้องเป็น .xlsx!");
                }
                // return Success(file);
                await _periodExamService.UploadPointCandidateAsync(examId, file);

                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// โหลดผู้สมัครสอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านโหลดผู้สมัครสอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("download/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> DownloadCandidateAsync(string examId)
        {
            try
            {
                //var stream = await _periodExamService.DownloadCandidateAsync(examId);

                //string excelName = $"Candidate_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.xlsx";
                //return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", excelName);

                var data = await _periodExamService.NewDownloadCandidateAsync(examId);
                return Success(data);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// โหลดผู้สมัครสอบ(รายละเอียด)
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านโหลดผู้สมัครสอบ(รายละเอียด)สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("download/detail/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> DownloadCandidateAllAsync(string examId)
        {
            try
            {
                //var stream = await _periodExamService.DownloadCandidateAllAsync(examId);

                //string excelName = $"Candidate_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.xlsx";
                //return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", excelName);

                var data = await _periodExamService.NewDownloadCandidateAllAsync(examId);
                return Success(data);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// โหลดสรุปการสอบ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านโหลดสรุปการสอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpPut("download/dashboard/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsDashboardExamAsync(string examId, RequestCandidateDashboard item)
        {
            try
            {
                //var stream = await _periodExamService.GetsDashboardExamAsync(item, examId);

                //string excelName = $"Candidate_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.xlsx";
                //return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", excelName);

                var data = await _periodExamService.NewGetsDashboardExamAsync(item, examId);
                return Success(data);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ข้อมูลตำแหน่งสมัครสอบ
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <param name="positionId">รหัสตำแหน่ง</param>
        /// </summary>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านข้อมูลตำแหน่งสมัครสอบสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("position/{examId:length(36)}/{positionId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsNamePositionAsync(string examId, string positionId)
        {
            try
            {
                var items = await _periodExamService.GetsNamePositionAsync(examId, positionId);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// ลบเอกไฟล์
        /// </summary>
        /// <param name="documentId">รหัสไฟล์เอกสาร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อลบเอกไฟล์สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
		[HttpDelete("doc/{examId:length(36)}"), DisableRequestSizeLimit]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> DeleteFileCandidateService(string examId, string documentId)
        {
            try
            {
                await _periodExamService.DeleteAsyncDocument(examId, documentId);
                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// สรุปข้อมูลผู้สมัคร
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านสรุปข้อมูลผู้สมัครสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("dashboard/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> GetsDashboardPaymentExamAsync(string examId)
        {
            try
            {
                var getPermission = await _permission.GetPermissionAPIAsync("GET", "SYS_EXAM_SELECT_PERIOD");
                var jsonData = JsonConvert.DeserializeObject<JObject>(getPermission);
                if (jsonData["status"]?.ToString() != "200")
                {
                    return Error(jsonData["message"]?.ToString(), StatusCodes.Status403Forbidden);
                }
                var items = await _periodExamService.GetsDashboardPaymentExamAsync(examId);

                return Success(items);
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// โหลดผู้สมัครสอบ(รายละเอียดชำระเงิน)
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อทำการอ่านโหลดผู้สมัครสอบ(รายละเอียดชำระเงิน)สำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("download/payment/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> DownloadCandidatePaymentAllAsync(string examId)
        {
            try
            {
                var stream = await _periodExamService.DownloadCandidatePaymentAllAsync(examId);

                string excelName = $"Candidate_Payment_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.xlsx";
                return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", excelName);
                // return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }

        /// <summary>
        /// โอนคนสรรหาไปบรรจุ
        /// </summary>
        /// <param name="examId">รหัสรอบสมัคร</param>
        /// <returns></returns>
        /// <response code="200">เมื่อโอนคนสรรหาไปบรรจุสำเร็จ</response>
        /// <response code="401">ไม่ได้ Login เข้าระบบ</response>
        /// <response code="500">เมื่อเกิดข้อผิดพลาดในการทำงาน</response>
        [HttpGet("placement/{examId:length(36)}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<ResponseObject>> UpdateAsyncCandidateToPlacement(Guid examId)
        {
            try
            {
                await _periodExamService.UpdateAsyncCandidateToPlacement(examId);
                return Success();
            }
            catch (Exception ex)
            {
                return Error(ex);
            }
        }
        #endregion
    }
}