TourIAm/TIAMWebApp/Server/Controllers/MessageAPIController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using System.Text.Json;
using AyCode.Core.Helpers;
using TIAMWebApp.Shared.Application.Models;
using TIAMWebApp.Shared.Application.Models.ClientSide.Messages;
using AyCode.Models.Enums;
using TIAM.Database.DataLayers.Admins;
using TIAM.Entities.Emails;
using AyCode.Services.SignalRs;
using TIAM.Services;
using AyCode.Core.Loggers;
using AyCode.Core.Extensions;
using TIAM.Entities.Products;
using AyCode.Core.Consts;
using AyCode.Core;
using TIAM.Core.Consts;
using TIAM.Entities.Users;
using TIAM.Services.Server;
using TIAMWebApp.Shared.Application.Models.ClientSide;

namespace TIAMWebApp.Server.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/v1/[controller]")]
    public class MessageAPIController : ControllerBase
    {
        private readonly AdminDal _adminDal;
        private readonly TIAM.Core.Loggers.ILogger _logger;
        private readonly IConfiguration _configuration;
        private readonly IWebHostEnvironment _webHostEnvironment;
        private readonly IMessageSenderService _messageSenderService;

        
        public MessageAPIController(IEnumerable<IAcLogWriterBase> logWriters, IConfiguration configuration, IWebHostEnvironment webHostEnvironment, IMessageSenderService messageSenderService, AdminDal adminDal)
        {
            _adminDal = adminDal;
            _logger = new TIAM.Core.Loggers.Logger<MessageAPIController>(logWriters.ToArray());
            _configuration = configuration;
            _webHostEnvironment = webHostEnvironment;

            _messageSenderService = messageSenderService;
        }

        [AllowAnonymous]
        [HttpPost]
        [Route(APIUrls.SendEmailRouteName)]
        public async Task<IActionResult> SendEmail([FromBody] JsonElement serializedMessageSenderModel)
        {
            _logger.Debug($"SendEmail called!");
            var message = JObject.Parse(serializedMessageSenderModel.GetRawText()).ToObject<MessageSenderModel<EmailMessage>>();
            var receiver = _adminDal.GetUserById(message.Message.Recipients[0].RecipientId);
            string receiverFullName = "";
            if (receiver != null) {
                if (receiver.FullName != null)
                {
                    receiverFullName = receiver.FullName;
                }
                else
                {
                    receiverFullName = "TourIam User";
                }
            }
            else
            {
                //wrong userId?
            }


            if (message == null) return BadRequest("Invalid request");

            if (message.MessageType == MessageTypesEnum.email)
            {
                _logger.Debug($"EmailMessage!!!");

                var messageElement = message.Message;
                _logger.Debug(message.Message.Subject);
                messageElement.EmailAddress = TiamConstClient.SystemEmailAddress;

                var htmlContent = EmailTemplateHelper.GenerateGeneralEmail(
                    receiverFullName,
                    messageElement.Text,
                    Setting.BaseUrl,
                    messageElement.Recipients[0].RecipientId.ToString()
                    );
                message.Message.Text = htmlContent;

                foreach (var admin in TiamConstClient.SysAdmins)
                {
                    var adminUser = _adminDal.GetUserById(admin, true);
                    message.Message.Recipients.Add(new EmailRecipient(Guid.NewGuid(), admin, message.Message.Id, adminUser.EmailAddress));
                }

                await _adminDal.AddEmailMessageAsync(messageElement);
                var result = await _messageSenderService.SendMessageAsync(messageElement, (int)message.MessageType);
                //_adminDal.AddEmailMessageAsync((TIAM.Entities.Emails.EmailMessage)SerializedMessageSenderModel.Message);

                
                _logger.Debug($"SendEmail result: {result}");

                return Ok(result);
            }
            else
            {
                return BadRequest("Invalid request");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="driverId">UserPropductMappingId</param>
        /// <returns></returns>
        [NonAction]
        [ApiExplorerSettings(IgnoreApi = true)]
        [SignalR(SignalRTags.GetTransfersMessagesByDriverId)]
        public async Task<List<EmailMessage>> GetTransfersMessagesByDriverId(Guid driverId)
        {
            _logger.Info($@"GetAllMessagesByDriverId called; driverId: {driverId}");

            return await _adminDal.GetTransfersMessagesByDriverIdAsync(driverId);
        }

        [NonAction]
        [ApiExplorerSettings(IgnoreApi = true)]
        [SignalR(SignalRTags.GetMessagesByUserId)]
        public async Task<List<EmailMessage>> GetMessagesByUserId(Guid userId)
        {
            _logger.Info($@"GetMessagesByUserId called with userId: {userId}");

            return await _adminDal.GetEmailMessagesByUserId(userId);
        }

        [AllowAnonymous]
        [HttpGet]
        [Route(APIUrls.GetMessagesByContextIdRouteName + "/{contextId}")]
        [Tags("Finished", "Messages")]
        [SignalR(SignalRTags.GetMessagesByContextId)]
        public async Task<string> GetMessagesByContextId(Guid contextId)
        {
            _logger.Info($@"GetMessagessByContextId called with ownerId: {contextId}");
            
            var messages = await _adminDal.GetEmailMessagesByContextIdAsync(contextId);

            return messages.ToJson();
        }

        [AllowAnonymous]
        [HttpGet]
        [Route(APIUrls.GetAllMessagesRouteName)]
        [Tags("Finished", "Messages")]
        [SignalR(SignalRTags.GetAllMessages)]
        public async Task<string> GetAllMessages()
        {
            _logger.Info($@"GetMessages called");

            var messages = await _adminDal.GetAllEmailMessagesAsync();

            return messages.ToJson();
        }

        [NonAction]
        [ApiExplorerSettings(IgnoreApi = true)]
        [SignalR(SignalRTags.UpdateMessage)]
        public async Task<EmailMessage?> UpdateMessages([FromBody] EmailMessage message)
        {
            _logger.Info($@"UpdateMessages called");

            if (await _adminDal.UpdateEmailMessageAsync(message)) return message;

            return null;
        }
    }
}