monorepo/LCU.WebApps.Indirect.ReserveManagementSystem/Api/ReserveManagementSystemApi/Controllers/ImportController.cs

using ReserveManagementSystemApi.Models;
using ReserveManagementSystemApi.Services;
using ReserveManagementSystemApi.Services.QueueServices;
using ReserveManagementSystemLib.Models;

namespace ReserveManagementSystemApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ImportController : ControllerBase
    {
        private readonly IImportReadService _importReadService;
        private readonly IImportService _importService;
        private readonly IQueueRmsActiveLoanService _queueRmsActiveLoanService;

        public ImportController(IImportReadService importReadService, IImportService importService, IQueueRmsActiveLoanService queueRmsActiveLoanService)
        {
            _importReadService = importReadService;
            _importService = importService;
            _queueRmsActiveLoanService = queueRmsActiveLoanService;
        }

        [HttpGet(Name = "GetAllImports")]
        [ProducesResponseType(typeof(IEnumerable<Import>), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> Get()
        {
            try
            {
                var result = await _importService.GetAllAsync();
                return Ok(result);
            }
            catch (Exception e)
            {
                Log.Error(e, "Failure returning Imports");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpGet("GetRecentImports/{numberOfImports}", Name = "GetRecentImports")]
        [ProducesResponseType(typeof(IEnumerable<Import>), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> GetRecent(int numberOfImports)
        {
            try
            {
                var result = await _importService.GetRecentAsync(numberOfImports);
                return Ok(result);
            }
            catch (Exception e)
            {
                Log.Error(e, "Failure returning Imports");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpGet("GetById/{importId}", Name = "GetImportById")]
        [ProducesResponseType(typeof(Loan), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> GetById(int importId)
        {
            try
            {
                var result = await _importService.GetByIdAsync(importId);
                return Ok(result);
            }
            catch (Exception e)
            {
                Log.Error(e, $"Failure returning loan with id {importId}");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost("ImportNewLoanFile", Name ="ImportNewLoanFile")]
        [ProducesResponseType(typeof(Import), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportNewLoanFile(IFormFile file)
        {
            try
            {
                var stream = new StreamReader(file.OpenReadStream());
                var import = await _importReadService.ReadNewLoanImportFile(stream, file.FileName, DateTime.Now);
                return Ok(import);
            }
            catch (Exception e)
            {
                Log.Error("Failure to import new loan file, message: {0} {1}", e.Message, e.StackTrace);
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost("ImportBoatLoanFile", Name = "ImportBoatLoanFile")]
        [ProducesResponseType(typeof(List<ImportBoatLoan>), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportBoatLoanFile(IFormFile file)
        {
            try
            {
                var stream = new StreamReader(file.OpenReadStream());
                var import = await _importReadService.ReadBoatLoanImportFile(stream);
                return Ok(import);
            }
            catch (Exception e)
            {
                Log.Error("Failure to import boat loan file, message: {0} {1}", e.Message, e.StackTrace);
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPost("ImportClosedLoanFile", Name = "ImportClosedLoanFile")]
        [ProducesResponseType(typeof(Import), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportClosedLoanFile(IFormFile file)
        {
            try
            {
                var stream = new StreamReader(file.OpenReadStream());
                var import = await _importReadService.ReadClosedLoanImportFile(stream, file.FileName, DateTime.Now);
                return Ok(import);
            }
            catch (Exception e)
            {
                Log.Error("Failure to import closed loan file, message: {0} {1}", e.Message, e.StackTrace);
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPut("ImportActiveLoans", Name = "ImportActiveLoans")]
        [ProducesResponseType(typeof(Import), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportActiveLoans(string? newerThanDateTime = "", bool skipExport = false)
        {
            try
            {
                var request = new RmsActiveImportRequest()
                {
                    ImportDateTime = newerThanDateTime,
                    SkipExport = skipExport
                };
               await _queueRmsActiveLoanService.QueueRmsActiveLoanServiceRequest(request);
               return Accepted();
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure importing Active Loans");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPut("ImportClosedLoans", Name = "ImportClosedLoans")]
        [ProducesResponseType(typeof(Import), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportClosedLoans(string? newerThanDateTime)
        {
            try
            {
                var import = await _importReadService.ImportClosedLoansFromDNA(newerThanDateTime);
                return Ok(import);
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failure importing Closed Loans");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }

        [HttpPut("ImportClosedLoansWithUpdates", Name = "ImportClosedLoansWithUpdates")]
        [ProducesResponseType(typeof(Import), 200)]
        [ProducesResponseType(500)]
        public async Task<IActionResult> ImportClosedLoansWithUpdates(string? newerThanDateTime, bool skipExport = false)
        {
            try
            {
                var import = await _importReadService.ImportClosedLoansWithUpdatesFromDNA(newerThanDateTime, skipExport);
                return Ok(import);
            }
            catch (Exception ex)
            {
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }
    }
}