EnvelopeGenerator/EnvelopeGenerator.Application/Services/EnvelopeMailService.cs

using AutoMapper;
using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
using DigitalData.EmailProfilerDispatcher.Abstraction.DTOs.EmailOut;
using DigitalData.EmailProfilerDispatcher.Abstraction.Services;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using DigitalData.Core.Abstraction.Application.DTO;
using EnvelopeGenerator.Domain.Constants;
using EnvelopeGenerator.Application.Common.Configurations;
using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
using EnvelopeGenerator.Application.Common.Extensions;
using EnvelopeGenerator.Application.Common.Interfaces.Services;
using MediatR;

namespace EnvelopeGenerator.Application.Services;

/// <summary>
/// 
/// </summary>
[Obsolete("Use MediatR")]
public class EnvelopeMailService : EmailOutService, IEnvelopeMailService
{
	private readonly IEmailTemplateService _tempService;
	private readonly IEnvelopeReceiverService _envRcvService;
	private readonly DispatcherParams _dConfig;
	private readonly IConfigService _configService;
	private readonly Dictionary<string, string> _placeholders;
    private readonly ISender _sender;

	/// <summary>
	/// 
	/// </summary>
	/// <param name="repository"></param>
	/// <param name="mapper"></param>
	/// <param name="tempService"></param>
	/// <param name="envelopeReceiverService"></param>
	/// <param name="dispatcherConfigOptions"></param>
	/// <param name="configService"></param>
	/// <param name="mailConfig"></param>
	/// <param name="sender"></param>
    public EnvelopeMailService(IEmailOutRepository repository, IMapper mapper, IEmailTemplateService tempService, IEnvelopeReceiverService envelopeReceiverService, IOptions<DispatcherParams> dispatcherConfigOptions, IConfigService configService, IOptions<MailParams> mailConfig, ISender sender) : base(repository, mapper)
	{
		_tempService = tempService;
		_envRcvService = envelopeReceiverService;
		_dConfig = dispatcherConfigOptions.Value;
		_configService = configService;
		_placeholders = new Dictionary<string, string>(mailConfig.Value.Placeholders);
		_sender = sender;
    }

	private async Task<Dictionary<string, string>> CreatePlaceholders(string? accessCode = null, EnvelopeReceiverDto? envelopeReceiverDto = null)
	{
		if (accessCode is not null)
			_placeholders["[DOCUMENT_ACCESS_CODE]"] = accessCode;

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

		return _placeholders;
	}

	private async Task<Dictionary<string, string>> CreatePlaceholders(EnvelopeReceiverReadOnlyDto? readOnlyDto = null)
	{
		if (readOnlyDto?.Envelope is not null && readOnlyDto.Receiver is not null)
		{
			_placeholders["[NAME_RECEIVER]"] = await _envRcvService.ReadLastUsedReceiverNameByMailAsync(readOnlyDto.AddedWho).ThenAsync(res => res, (msg, ntc) => string.Empty) ?? string.Empty;
			var erReadOnlyId = (readOnlyDto.Id).ToEnvelopeKey();
			var sigHost = await _configService.ReadDefaultSignatureHost();
			var linkToDoc = $"{sigHost}/EnvelopeKey/{erReadOnlyId}";
			_placeholders["[LINK_TO_DOCUMENT]"] = linkToDoc;
			_placeholders["[LINK_TO_DOCUMENT_TEXT]"] = linkToDoc[..Math.Min(40, linkToDoc.Length)] + "..";
		}

		return _placeholders;
	}

	/// <summary>
	/// 
	/// </summary>
	/// <param name="dto"></param>
	/// <param name="tempType"></param>
	/// <param name="optionalPlaceholders"></param>
	/// <returns></returns>
	public async Task<DataResult<int>> SendAsync(EnvelopeReceiverDto dto, EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null)
	{
		var tempSerResult = await _tempService.ReadByNameAsync(tempType);
		if (tempSerResult.IsFailed)
			return tempSerResult.ToFail<int>().Notice(LogLevel.Error, DigitalData.Core.Abstraction.Application.DTO.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);

		// Add optional place holders.
		if (optionalPlaceholders is not null)
			foreach (var oph in optionalPlaceholders)
				placeholders[oph.Key] = oph.Value.ToString() ?? "NULL";

		//TODO: remove the requirement to add the models using reflections
		return await CreateWithTemplateAsync(createDto: mail, placeholders: placeholders,
			dto, dto.Envelope.User!, dto.Envelope);
	}

	/// <summary>
	/// 
	/// </summary>
	/// <param name="dto"></param>
	/// <param name="optionalPlaceholders"></param>
	/// <returns></returns>
	public async Task<DataResult<int>> SendAsync(EnvelopeReceiverReadOnlyDto dto, Dictionary<string, object>? optionalPlaceholders = null)
	{
		var tempSerResult = await _tempService.ReadByNameAsync(EmailTemplateType.DocumentShared);
		if (tempSerResult.IsFailed)
			return tempSerResult.ToFail<int>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"The email cannot send because '{EmailTemplateType.DocumentShared}' template cannot found.");
		var temp = tempSerResult.Data;

		var mail = new EmailOutCreateDto()
		{
			EmailAddress = dto.ReceiverMail,
			EmailSubj = temp.Subject,
			EmailBody = temp.Body,
			//TODO: remove int casting when all 
			ReferenceId = (int)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.EnvelopeShared,
			WfReference = null,
			AddedWho = _dConfig.AddedWho,
			EmailAttmt1 = _dConfig.EmailAttmt1
		};

		var placeholders = await CreatePlaceholders(readOnlyDto: dto);

		// Add optional place holders.
		if (optionalPlaceholders is not null)
			foreach (var oph in optionalPlaceholders)
				placeholders[oph.Key] = oph.Value.ToString() ?? "NULL";

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

	/// <summary>
	/// 
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	public async Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto dto) => await SendAsync(dto: dto, tempType: EmailTemplateType.DocumentAccessCodeReceived);
}