EnvelopeGenerator/EnvelopeGenerator.Web/Controllers/HomeController.cs

using EnvelopeGenerator.Application.Contracts;
using EnvelopeGenerator.Common;
using EnvelopeGenerator.Web.Services;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
using DigitalData.Core.API;
using EnvelopeGenerator.Application;
using Microsoft.Extensions.Localization;
using DigitalData.Core.DTO;
using Microsoft.AspNetCore.Localization;
using System.Text.Encodings.Web;
using EnvelopeGenerator.Web.Models;
using EnvelopeGenerator.Application.Resources;
using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;

namespace EnvelopeGenerator.Web.Controllers
{
    public class HomeController : Controller
	{
		private readonly ILogger<HomeController> _logger;
		private readonly EnvelopeOldService envelopeOldService;
        private readonly IEnvelopeReceiverService _envRcvService;
        private readonly IEnvelopeHistoryService _historyService;
        private readonly IStringLocalizer<Resource> _localizer;
        private readonly IConfiguration _configuration;
        private readonly UrlEncoder _urlEncoder;
        private readonly Cultures _cultures;
        private readonly IEnvelopeMailService _mailService;
        
        public HomeController(EnvelopeOldService envelopeOldService, ILogger<HomeController> logger, IEnvelopeReceiverService envelopeReceiverService, IEnvelopeHistoryService historyService, IStringLocalizer<Resource> localizer, IConfiguration configuration, UrlEncoder urlEncoder, Cultures cultures, IEnvelopeMailService envelopeMailService)
        {
            this.envelopeOldService = envelopeOldService;
            _envRcvService = envelopeReceiverService;
            _historyService = historyService;
            _localizer = localizer;
            _configuration = configuration;
            _urlEncoder = urlEncoder;
            _cultures = cultures;
            _mailService = envelopeMailService;
            _logger = logger;
		}
        
        [HttpGet("EnvelopeKey/{envelopeReceiverId}")]
        public async Task<IActionResult> SendAccessCode([FromRoute] string envelopeReceiverId)
        {
            try
            {
                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);
                ViewData["EnvelopeKey"] = envelopeReceiverId;

                return await _envRcvService.ReadByEnvelopeReceiverIdAsync(envelopeReceiverId: envelopeReceiverId).ThenAsync<EnvelopeReceiverDto, IActionResult>(
                    SuccessAsync: async er =>
                    {
                        EnvelopeResponse response = await envelopeOldService.LoadEnvelope(envelopeReceiverId);

                        bool accessCodeAlreadyRequested = await _historyService.AccessCodeAlreadyRequested(envelopeId: er.Envelope!.Id, userReference: er.Receiver!.EmailAddress);
                        if (!accessCodeAlreadyRequested)
                        {
                            await _historyService.RecordAsync(er.EnvelopeId, er.Receiver.EmailAddress, Constants.EnvelopeStatus.AccessCodeRequested);

                            var mailRes = await _mailService.SendAccessCodeAsync(envelopeReceiverDto: er);
                            if (mailRes.IsFailed)
                            {
                                _logger.LogNotice(mailRes);
                                return this.ViewAccessCodeNotSent();
                            }
                        }

                        return Redirect($"{envelopeReceiverId}/Locked");
                    },
                    Fail: (messages, notices) =>
                    {
                        _logger.LogNotice(notices);
                        return this.ViewEnvelopeNotFound();
                    });
            }
            catch(Exception ex)
            {
                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception:ex, message: _localizer[WebKey.UnexpectedError]);
                return this.ViewInnerServiceError();
            }
        }

        [HttpGet("EnvelopeKey/{envelopeReceiverId}/Locked")]
        public async Task<IActionResult> EnvelopeLocked([FromRoute] string envelopeReceiverId, [FromQuery] string? culture = null)
        {
            try
            {
                culture = culture is not null ? _urlEncoder.Encode(culture) : null;
                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);

                if (UserLanguage is null && culture is null)
                {
                    UserLanguage = _cultures.Default.Language;
                    return Redirect($"{Request.Headers["Referer"]}?culture={_cultures.Default.Language}");
                }
                else if (UserLanguage is not null && culture is not null)
                    return Redirect($"Locked");

                ViewData["UserCulture"] = _cultures[UserLanguage ?? culture];

                return await _envRcvService.IsExisting(envelopeReceiverId: envelopeReceiverId).ThenAsync(
                    Success: isExisting => isExisting ? View().WithData("EnvelopeKey", envelopeReceiverId) : this.ViewEnvelopeNotFound(),
                    Fail: IActionResult (messages,notices) =>
                    {
                        _logger.LogNotice(notices);
                        Response.StatusCode = StatusCodes.Status401Unauthorized;
                        return this.ViewEnvelopeNotFound();
                    });
            }
            catch(Exception ex)
            {
                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception: ex);
                return this.ViewInnerServiceError();
            }
        }

        [HttpPost("EnvelopeKey/{envelopeReceiverId}/Locked")]
        public async Task<IActionResult> LogInEnvelope([FromRoute] string envelopeReceiverId, [FromForm] string access_code)
        {
            try
            {
                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);
                (string? uuid, string? signature) = envelopeReceiverId.DecodeEnvelopeReceiverId();

                if (uuid is null || signature is null)
                {
                    _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: _localizer[WebKey.WrongEnvelopeReceiverId]);
                    return Unauthorized();
                }

                _logger.LogInformation($"Envelope UUID: [{uuid}]\nReceiver Signature: [{signature}]");

                //check access code
                EnvelopeResponse response = await envelopeOldService.LoadEnvelope(envelopeReceiverId);
                var verification = await _envRcvService.VerifyAccessCodeAsync(uuid: uuid, signature: signature, accessCode: access_code);
                if (verification.IsFailed)
                {
                    _logger.LogNotice(verification.Notices);
                    Response.StatusCode = StatusCodes.Status401Unauthorized;
                    return View("EnvelopeLocked")
                            .WithData("UserLanguage", UserLanguage ?? _cultures.Default.Language)
                            .WithData("ErrorMessage", _localizer[WebKey.WrongAccessCode].Value);
                }

                return await _envRcvService.ReadByUuidSignatureAsync(uuid: uuid, signature: signature).ThenAsync<EnvelopeReceiverDto, IActionResult>(
                        SuccessAsync: async er =>
                        {
                            //check the access code verification
                            if (verification.IsWrong())
							{
								//Constants.EnvelopeStatus.AccessCodeIncorrect
								await _historyService.RecordAsync(er.EnvelopeId, er.Receiver!.EmailAddress, Constants.EnvelopeStatus.AccessCodeIncorrect);
								Response.StatusCode = StatusCodes.Status401Unauthorized;
								return View("EnvelopeLocked")
										.WithData("UserLanguage", UserLanguage ?? _cultures.Default.Language)
										.WithData("ErrorMessage", _localizer[WebKey.WrongAccessCode].Value);
							}

							await _historyService.RecordAsync(er.EnvelopeId, er.Receiver!.EmailAddress, Constants.EnvelopeStatus.AccessCodeCorrect);

							ViewData["EnvelopeKey"] = envelopeReceiverId;
							//check rejection
							var rejRcvrs = await _historyService.ReadRejectingReceivers(er.Envelope!.Id);
                            if(rejRcvrs.Any())
                            {
                                ViewBag.IsExt = !rejRcvrs.Contains(er.Receiver);    //external if the current user is not rejected
                                return View("EnvelopeRejected", er);
							}                               

                            //check if it has already signed
                            if (await _historyService.IsSigned(envelopeId: er.Envelope!.Id, userReference: er.Receiver!.EmailAddress))
                                return View("EnvelopeSigned");

                            if (response.Envelope.Documents.Count > 0)
                            {
                                var document = await envelopeOldService.GetDocument(response.Envelope.Documents[0].Id, envelopeReceiverId);
                                byte[] bytes = await envelopeOldService.GetDocumentContents(document);
                                ViewData["DocumentBytes"] = bytes;
                            }
                            else
                            {
                                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, message: "No document was found.");
								return this.ViewDocumentNotFound();
							}                                

                            var claims = new List<Claim> {
                                            new(ClaimTypes.NameIdentifier, uuid),
                                            new(ClaimTypes.Hash, signature),
                                            new(ClaimTypes.Name, er.Name ?? string.Empty),
                                            new(ClaimTypes.Email, er.Receiver.EmailAddress),
                                            new(EnvelopeClaimTypes.Title, er.Envelope.Title)
                            };

                            var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
                            var authProperties = new AuthenticationProperties
                            {
                                AllowRefresh = false,
                                IsPersistent = false
                            };

                            await HttpContext.SignInAsync(
                                CookieAuthenticationDefaults.AuthenticationScheme,
                                new ClaimsPrincipal(claimsIdentity),
                                authProperties);

                            //add PSPDFKit licence key
                            ViewData["PSPDFKitLicenseKey"] = _configuration["PSPDFKitLicenseKey"];
                            ViewData["UserCulture"] = _cultures[UserLanguage];

                            return View("ShowEnvelope", er);
                        },
                        Fail: (messages, notices) =>
                        {
                            _logger.LogNotice(notices);
                            return this.ViewEnvelopeNotFound();
                        }
                    );
            }
            catch (Exception ex)
            {
                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception: ex);
                return this.ViewInnerServiceError();
            }
        }

        [Authorize]
        [HttpGet("EnvelopeKey/{envelopeReceiverId}/Success")]
        public async Task<IActionResult> EnvelopeSigned(string envelopeReceiverId)
        {
            try
            {
                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);
                return await _envRcvService.IsExisting(envelopeReceiverId: envelopeReceiverId).ThenAsync(
                    SuccessAsync: async isExisting =>
                    {
                        if(!isExisting)
                            return this.ViewEnvelopeNotFound();

                        EnvelopeResponse response = await envelopeOldService.LoadEnvelope(envelopeReceiverId);
                        if (!envelopeOldService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id))
                            return Redirect($"/EnvelopeKey/{envelopeReceiverId}/Locked");

                        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
                        ViewData["EnvelopeKey"] = envelopeReceiverId;
                        return View();
                    },
                    Fail: IActionResult (messages, notices) =>
                    {
                        _logger.LogNotice(notices);
                        return this.ViewEnvelopeNotFound();
                    });
            }
            catch (Exception ex)
            {
                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception: ex);
                return this.ViewInnerServiceError();
            }
        }

        [Authorize]
        [HttpGet("EnvelopeKey/{envelopeReceiverId}/Rejected")]
        public async Task<IActionResult> EnvelopeRejected(string envelopeReceiverId)
        {
            try
            {
                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);

                await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
                return await _envRcvService.ReadByEnvelopeReceiverIdAsync(envelopeReceiverId).ThenAsync(
                    SuccessAsync: async (er) =>
                    {
                        ViewData["UserCulture"] = _cultures[UserLanguage];
                        return await _historyService.IsRejected(envelopeId: er.EnvelopeId)
                            ? View(er)
                            : Redirect($"/EnvelopeKey/{envelopeReceiverId}/Locked");

                    },
                    Fail: IActionResult (messages, notices) =>
                    {
                        _logger.LogNotice(notices);
                        return this.ViewEnvelopeNotFound();
                    });
            }
            catch (Exception ex)
            {
                _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception: ex);
                return this.ViewInnerServiceError();
            }
        }
        
        [Authorize]
        [HttpGet("IsAuthenticated")]
        public IActionResult IsAuthenticated()
        {
            var envelopeUuid = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            var receiverSignature = User.FindFirst(ClaimTypes.Hash)?.Value;
            return Ok(new { EnvelopeUuid = envelopeUuid, ReceiverSignature = receiverSignature });
        }

        [HttpPost("lang/{language}")]
        public IActionResult SetLanguage([FromRoute] string language)
        {
            try
            {
                language = _urlEncoder.Encode(language);
                if (!_cultures.Languages.Contains(language))
                    return BadRequest();

                UserLanguage = language;

                return Redirect(Request.Headers["Referer"].ToString());
            }
            catch(Exception ex)
            {
                _logger.LogError(ex, "{Message}", ex.Message);
                return StatusCode(statusCode: StatusCodes.Status500InternalServerError);
            }
        }

        [HttpGet("lang")]
        public IActionResult GetLanguages() => Ok(_cultures.Languages);

        private string? UserLanguage
        {
            get
            {
                var cookieValue = Request.Cookies[CookieRequestCultureProvider.DefaultCookieName];

                if (string.IsNullOrEmpty(cookieValue))
                    return null;    

                var culture = CookieRequestCultureProvider.ParseCookieValue(cookieValue)?.Cultures[0];
                return culture?.Value ?? null;
            }
            set
            {
                if(value is null)
                    Response.Cookies.Delete(CookieRequestCultureProvider.DefaultCookieName);
                else
                {
                    var cookieOptions = new CookieOptions()
                    {
                        Expires = DateTimeOffset.UtcNow.AddYears(1),
                        Secure = false,
                        SameSite = SameSiteMode.Strict,
                        HttpOnly = true
                    };

                    Response.Cookies.Append(
                        CookieRequestCultureProvider.DefaultCookieName,
                        CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(value)),
                        cookieOptions);
                }
            }
        }

        public IActionResult Error404() => this.ViewError404();
    }
}