EnvelopeGenerator/EnvelopeGenerator.Application/Services/EnvelopeMailService.cs

using AutoMapper;
using DigitalData.Core.DTO;
using DigitalData.EmailProfilerDispatcher.Application.DTOs.EmailOut;
using DigitalData.EmailProfilerDispatcher.Application.Services;
using DigitalData.EmailProfilerDispatcher.Infrastructure.Contracts;
using DigitalData.UserManager.Application;
using EnvelopeGenerator.Application.Contracts;
using EnvelopeGenerator.Application.DTOs;
using EnvelopeGenerator.Common;
using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using static EnvelopeGenerator.Common.Constants;

namespace EnvelopeGenerator.Application.Services
{
	public class EnvelopeMailService : EmailOutService, IEnvelopeMailService
    {
		private readonly IEmailTemplateService _tempService;
		private readonly IEnvelopeReceiverService _envRcvService;
		private readonly DispatcherConfig _dConfig;
		private readonly IConfigService _configService;

        public EnvelopeMailService(IEmailOutRepository repository, IStringLocalizer<Resource> localizer, IMapper mapper, IEmailTemplateService tempService, IEnvelopeReceiverService envelopeReceiverService, IOptions<DispatcherConfig> dispatcherConfigOptions, IConfigService configService) : base(repository, mapper)
        {
            _tempService = tempService;
			_envRcvService = envelopeReceiverService;
			_dConfig = dispatcherConfigOptions.Value;
			_configService = configService;
        }

		//TODO: create ioptions and implement TemplatePlaceHolderAttribute instead of this method
		private async Task<Dictionary<string, string>> CreatePlaceholders(string? accessCode = null, EnvelopeReceiverDto? envelopeReceiverDto = null)
		{
			Dictionary<string, string> placeholders = new() {
				{ "[NAME_PORTAL]", "signFlow" },
				{ "[SIGNATURE_TYPE]" , "signieren"},
				{ "[REASON]", string.Empty } };

			if (accessCode is not null)
				placeholders["[DOCUMENT_ACCESS_CODE]"] = accessCode;

			if(envelopeReceiverDto is not null && envelopeReceiverDto.Envelope is not null && envelopeReceiverDto.Receiver is not null)
			{
				var erId = (envelopeReceiverDto.Envelope.Uuid, envelopeReceiverDto.Receiver.Signature).EncodeEnvelopeReceiverId();
				var sigHost = await _configService.ReadDefaultSignatureHost();
				var linkToDoc = $"{sigHost}/envelope/{erId}";
				placeholders["[LINK_TO_DOCUMENT]"] = linkToDoc;
				placeholders["[LINK_TO_DOCUMENT_TEXT]"] = linkToDoc[..Math.Min(40, linkToDoc.Length)];
			}

			return placeholders;
		}

		public async Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto dto) => await SendAsync(dto: dto, tempType: Constants.EmailTemplateType.DocumentAccessCodeReceived);

        public async Task<DataResult<int>> SendAsync(EnvelopeReceiverDto dto, Constants.EmailTemplateType tempType)
        {
			var tempSerResult = await _tempService.ReadByNameAsync(tempType);
			if (tempSerResult.IsFailed)
				return tempSerResult.ToFail<int>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"The email cannot send because '{tempType}' template cannot found.");
			var temp = tempSerResult.Data;

			var mail = new EmailOutCreateDto()
			{
				EmailAddress = dto.Receiver!.EmailAddress,
				EmailSubj = temp.Subject,
				EmailBody = temp.Body,
				//email_type = envelope_status,
				//message = envelope_message,
				ReferenceId = dto.EnvelopeId,               //REFERENCE_ID = ENVELOPE_ID
				ReferenceString = dto!.Envelope!.Uuid,		//REFERENCE_STRING = ENVELOPE_UUID
				//receiver_name = receiver.name,
				//receiver_access_code = receiver.access_code,
				//sender_adress = envelope.user.email,
				//sender_name = envelope.user.full_name,
				//envelope_title = envelope.title,
				ReminderTypeId = _dConfig.ReminderTypeId,
				SendingProfile = _dConfig.SendingProfile,
				EntityId = null,
				WfId = (int) EnvelopeStatus.MessageAccessCodeSent,
				WfReference = null,
				AddedWho = _dConfig.AddedWho,
				EmailAttmt1 = _dConfig.EmailAttmt1
			};

			//get acccess code
			var acResult = await _envRcvService.ReadAccessCodeByIdAsync(envelopeId: dto.EnvelopeId, receiverId: dto.ReceiverId);
			if (acResult.IsFailed)
				return acResult.ToFail<int>().Notice(LogLevel.Error, "Therefore, access code cannot be sent");
			var accessCode = acResult.Data;
			
			var placeholders = await CreatePlaceholders(accessCode: accessCode, envelopeReceiverDto: dto);

			return await CreateWithTemplateAsync(createDto: mail,placeholders: placeholders,
				dto, dto.Envelope.User!, dto.Envelope);
		}
	}
}