EnvelopeGenerator/EnvelopeGenerator.Web/Controllers/ReadOnlyController.cs

using DigitalData.Core.Abstraction.Application.DTO;
using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using static EnvelopeGenerator.Domain.Constants;

namespace EnvelopeGenerator.Web.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ReadOnlyController : ControllerBase
    {
        private readonly ILogger<ReadOnlyController> _logger;

        [Obsolete("Use MediatR")]
        private readonly IEnvelopeReceiverReadOnlyService _erroService;

        [Obsolete("Use MediatR")]
        private readonly IEnvelopeMailService _mailService;

        [Obsolete("Use MediatR")]
        private readonly IEnvelopeHistoryService _histService;

        [Obsolete("Use MediatR")]
        public ReadOnlyController(ILogger<ReadOnlyController> logger, IEnvelopeReceiverReadOnlyService erroService, IEnvelopeMailService mailService, IEnvelopeHistoryService histService)
        {
            _logger = logger;
            _erroService = erroService;
            _mailService = mailService;
            _histService = histService;
        }

        [HttpPost]
        [Authorize(Roles = ReceiverRole.FullyAuth)]
        [Obsolete("Use MediatR")]
        public async Task<IActionResult> CreateAsync([FromBody] EnvelopeReceiverReadOnlyCreateDto createDto)
        {
            try
            {
                //set AddedWho
                var authReceiverMail = this.GetAuthReceiverMail();
                if (authReceiverMail is null)
                {
                    _logger.LogError("EmailAddress clam is not found in envelope-receiver-read-only creation process. Create DTO is:\n {dto}", JsonConvert.SerializeObject(createDto));
                    return Unauthorized();
                }

                var envelopeId = this.GetAuthEnvelopeId();
                if (envelopeId is null)
                {
                    _logger.LogError("Envelope Id clam is not found in envelope-receiver-read-only creation process. Create DTO is:\n {dto}", JsonConvert.SerializeObject(createDto));
                    return Unauthorized();
                }

                createDto.AddedWho = authReceiverMail;
                createDto.EnvelopeId = envelopeId;

                // create entity
                var creation_res = await _erroService.CreateAsync(createDto: createDto);

                if (creation_res.IsFailed)
                {
                    _logger.LogNotice(creation_res);
                    return StatusCode(StatusCodes.Status500InternalServerError);
                }

                //read new entity
                var read_res = await _erroService.ReadByIdAsync(creation_res.Data.Id);
                if (read_res.IsFailed)
                {
                    _logger.LogNotice(creation_res);
                    return StatusCode(StatusCodes.Status500InternalServerError);
                }

                var new_erro = read_res.Data;

                //send email two receiver
                return await _mailService.SendAsync(new_erro).ThenAsync<int, IActionResult>(SuccessAsync: async res =>
                {
                    //TODO: implement multi-threading to history process (Task)
                    //TODO: remove casting after change the id type
                    var hist_res = await _histService.RecordAsync((int)createDto.EnvelopeId, createDto.AddedWho, EnvelopeStatus.EnvelopeShared);
                    if (hist_res.IsFailed)
                    {
                        _logger.LogError("Although the envelope was sent as read-only, the EnvelopeShared hisotry could not be saved. Create DTO:\n{createDto}", JsonConvert.SerializeObject(createDto));
                        _logger.LogNotice(hist_res.Notices);
                    }

                    return Ok();
                },

                Fail: (msg, ntc) =>
                {
                    _logger.LogNotice(ntc);
                    return StatusCode(StatusCodes.Status500InternalServerError);
                });
            }
            catch(Exception ex)
            {
                _logger.LogError(ex, "{Message}", ex.Message);
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }
    }
}