public EmailResponseDto <string> DeleteEmailTemplate(string templateID)
{
var response = new EmailResponseDto <string>();
try
{
var emailTemplate = _context.EmailTemplates.Where(o => o.ID.ToLower().Equals(templateID.ToLower())).FirstOrDefault();
if (emailTemplate != null)
{
_context.EmailTemplates.Remove(emailTemplate);
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = $"Deleted Template";
}
else
{
response.Status = false;
response.Message = $"Failed to delete Template";
}
}
else
{
response.Status = false;
response.Message = $"Found no record";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> CheckIfEmailPoolIDNameValid(string poolID, string poolName)
{
var response = new EmailResponseDto <string>();
try
{
var emailPool = _context.EmailPools.Any(sp => sp.ID.ToLower().Equals(poolID.ToLower()) && sp.Name.ToLower().Equals(poolName.ToLower()));
if (emailPool)
{
response.Status = true;
response.Message = $"Valid Pool ID and Pool Name {poolName}.";
response.Result = "Email Pool Valid.";
}
else
{
response.Status = false;
response.Message = $"Invalid Pool ID and Pool Name {poolName}";
response.Result = "Email Pool Invalid.";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public ActionResult UpdateEmailPool(EmailPoolDto poolInput)
{
_logger.LogInformation("UpdateEmailPool action method.");
EmailResponseDto <EmailPoolDto> poolResponse = new EmailResponseDto <EmailPoolDto>();
try
{
if (!string.IsNullOrWhiteSpace(poolInput.Name))
{
poolResponse = _emailManagementInteractor.UpdateEmailPool(poolInput);
if (poolResponse.Status)
{
_logger.LogDebug("Status: " + poolResponse.Status + ", " + poolResponse.Message);
return(Ok(poolResponse));
}
else
{
_logger.LogError("Status: " + poolResponse.Status + ", " + poolResponse.Message);
return(StatusCode((int)HttpStatusCode.PreconditionFailed, poolResponse));
}
}
else
{
poolResponse.Status = false;
poolResponse.Message = "Pool Name cannot be empty or whitespace.";
_logger.LogError("Status: " + poolResponse.Status + ", " + poolResponse.Message);
return(StatusCode((int)HttpStatusCode.PreconditionFailed, poolResponse));
}
}
catch (Exception ex)
{
_logger.LogError("Internal server error: Error occurred while updating email pool: " + ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
public EmailResponseDto <EmailPoolTable> GetEmailPoolByName(string poolName)
{
var response = new EmailResponseDto <EmailPoolTable>();
try
{
var emailPool = _context.EmailPools.FirstOrDefault(sp => sp.Name.ToLower().Equals(poolName.ToLower()));
if (emailPool != null)
{
response.Status = true;
response.Message = $"Retrieved Email pool data for {poolName}";
}
else
{
response.Status = false;
response.Message = $"Email pool data for {poolName} is not available";
}
response.Result = emailPool;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailHistoryTable> AddEmailHistory(EmailHistoryTable historyInput)
{
var response = new EmailResponseDto <EmailHistoryTable>();
try
{
historyInput.ID = Guid.NewGuid().ToString();
historyInput = _context.EmailHistories.Add(historyInput).Entity;
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = "Added";
response.Result = historyInput;
}
else
{
response.Status = false;
response.Message = "Not Added";
response.Result = historyInput;
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailChannelTable> GetEmailChannelByKey(string channelKey)
{
var response = new EmailResponseDto <EmailChannelTable>();
try
{
var emailChannel = _context.EmailChannels.FirstOrDefault(sp => sp.Key.ToLower().Equals(channelKey.ToLower()));
if (emailChannel != null)
{
response.Status = true;
response.Message = $"Retrieved Email channel data for {channelKey}";
}
else
{
response.Status = false;
response.Message = $"Email Channel Data Unavailable for {channelKey}";
}
response.Result = emailChannel;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailProviderSettingsTable> GetEmailProviderByChannelKey(string channelKey)
{
_logger.LogInformation("GetEmailProviderByChannelKey");
var response = new EmailResponseDto <EmailProviderSettingsTable>();
try
{
var emailProvider = (from p in _context.EmailProviders
join c in _context.EmailChannels on new { PoolID = p.EmailPoolID, ProviderID = p.ID } equals new { PoolID = c.EmailPoolID, ProviderID = c.EmailProviderID }
where c.Key.ToLower().Equals(channelKey.ToLower())
select p).FirstOrDefault();
if (emailProvider != null)
{
response.Status = true;
response.Message = $"Retrieved Email provider data for channel {channelKey}";
}
else
{
response.Status = false;
response.Message = $"Email provider data for channel {channelKey} is not available.";
}
_logger.LogDebug($"Status : {response.Status}");
_logger.LogDebug($"Message : {response.Message}");
response.Result = emailProvider;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> CheckIfEmailChannelIDKeyValid(string channelID, string channelKey)
{
var response = new EmailResponseDto <string>();
try
{
var emailPool = _context.EmailChannels.Any(sp => sp.ID.ToLower().Equals(channelID.ToLower()) && sp.Key.ToLower().Equals(channelKey.ToLower()));
if (emailPool)
{
response.Status = true;
response.Message = $"Valid Channel ID and Channel Key {channelKey}.";
response.Result = "Email Channel Valid.";
}
else
{
response.Status = false;
response.Message = $"Invalid Channel ID and Channel Key {channelKey}";
response.Result = "Email Channel Invalid.";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> DeleteEmailChannel(string channelID)
{
var response = new EmailResponseDto <string>();
try
{
var emailChannel = _context.EmailChannels.Where(o => o.ID.ToLower().Equals(channelID.ToLower())).FirstOrDefault();
if (emailChannel != null)
{
_context.EmailChannels.Remove(emailChannel);
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = $"Deleted Successfully";
}
else
{
response.Status = false;
response.Message = $"Failed to delete";
}
}
else
{
response.Status = false;
response.Message = $"Email Channel Data not found";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <List <EmailChannelTable> > GetEmailChannels(string poolID)
{
var response = new EmailResponseDto <List <EmailChannelTable> >();
try
{
var emailChannels = (from p in _context.EmailPools
join c in _context.EmailChannels on p.ID equals c.EmailPoolID
join pr in _context.EmailProviders on c.EmailProviderID equals pr.ID
where p.ID.ToLower().Equals(poolID.ToLower())
select new EmailChannelTable
{
ID = c.ID,
Key = c.Key,
EmailPoolID = c.EmailPoolID,
EmailPoolName = p.Name,
EmailProviderID = c.EmailProviderID,
EmailProviderName = pr.Name
}).ToList();
response.Status = true;
response.Message = $"Retrieved {emailChannels.Count} Email channel data";
response.Result = emailChannels;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> CheckIfEmailPoolIDIsValid(string poolID)
{
var response = new EmailResponseDto <string>();
try
{
var emailPool = _context.EmailPools.Any(sp => sp.ID.ToLower().Equals(poolID.ToLower()));
if (emailPool)
{
response.Status = true;
response.Message = $"Email Pool ID is valid.";
response.Result = "Valid Email Pool.";
}
else
{
response.Status = false;
response.Message = $"Email pool data is not available";
response.Result = "Invalid Email Pool.";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> DeleteEmailPool(string poolID)
{
var response = new EmailResponseDto <string>();
try
{
var queryResult = _context.EmailPools.Where(sp => sp.ID.ToLower().Equals(poolID.ToLower())).FirstOrDefault();
if (queryResult != null)
{
_context.Remove(queryResult);
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = "Deleted";
}
else
{
response.Status = false;
response.Message = "Not Deleted";
}
}
else
{
response.Status = false;
response.Message = "No Record found.";
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <string> SendMail(EmailDto emailInputs)
{
_logger.LogInformation("SendMail interactor method.");
var response = new EmailResponseDto <string>();
try
{
if (string.IsNullOrEmpty(emailInputs.ChannelKey))
{
_logger.LogError("Channel key cannot be blank.");
response.Status = false;
response.Message = "Channel key cannot be blank.";
return(response);
}
else
{
var channelExist = _emailChannelInteractor.CheckIfChannelExist(emailInputs.ChannelKey).Result;
if (!channelExist)
{
_logger.LogError($"Invalid Channel key {emailInputs.ChannelKey}.");
response.Status = channelExist;
response.Message = $"Invalid Channel key {emailInputs.ChannelKey}.";
return(response);
}
}
if (string.IsNullOrEmpty(emailInputs.TemplateName))
{
_logger.LogError($"Template name cannot be blank.");
response.Status = false;
response.Message = "Template name cannot be blank.";
return(response);
}
else
{
var templateExist = _emailTemplateInteractor.CheckIfTemplateExist(emailInputs.ChannelKey, emailInputs.TemplateName).Result;
if (!templateExist)
{
_logger.LogError($"No template found for template name {emailInputs.TemplateName} and channel key {emailInputs.ChannelKey}.");
response.Status = templateExist;
response.Message = $"No template found for template name {emailInputs.TemplateName} and channel key {emailInputs.ChannelKey}.";
return(response);
}
}
_logger.LogInformation("Trying to send Email.");
_emailEventInteractor.SendMail(emailInputs);
response.Status = true;
response.Message = $"Email is sent successfully to {string.Join(",", emailInputs.Recipients)}.";
_logger.LogDebug("" + response.Message);
return(response);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while sending email: ", ex.Message);
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailTemplateDto> UpdateEmailTemplate(EmailTemplateDto templateInput)
{
var response = new EmailResponseDto <EmailTemplateDto>();
if (!string.IsNullOrEmpty(templateInput.EmailPoolName))
{
if (string.IsNullOrEmpty(templateInput.EmailPoolID))
{
var emailPool = _emailPoolRepository.GetEmailPoolByName(templateInput.EmailPoolName)?.Result;
if (emailPool != null)
{
templateInput.EmailPoolID = emailPool.ID;
}
else
{
response.Status = false;
response.Message = "Invalid Email pool.";
response.Result = templateInput;
return(response);
}
}
else
{
var emailPool = _emailPoolRepository.CheckIfEmailPoolIDNameValid(templateInput.EmailPoolID, templateInput.EmailPoolName);
if (!emailPool.Status)
{
response.Status = false;
response.Message = "Email Pool ID and Name do not match.";
response.Result = templateInput;
return(response);
}
}
}
else if (!string.IsNullOrEmpty(templateInput.EmailPoolID))
{
var emailPool = _emailPoolRepository.CheckIfEmailPoolIDIsValid(templateInput.EmailPoolID);
if (!emailPool.Status)
{
response.Status = false;
response.Message = "Invalid Email Pool ID.";
response.Result = templateInput;
return(response);
}
}
else
{
response.Status = false;
response.Message = "Email pool cannot be blank.";
response.Result = templateInput;
return(response);
}
var mappedInput = _mapper.Map <EmailTemplateTable>(templateInput);
var mappedResponse = _emailTemplateRepository.UpdateEmailTemplate(mappedInput);
response = _mapper.Map <EmailResponseDto <EmailTemplateDto> >(mappedResponse);
return(response);
}
public EmailResponseDto <EmailProviderSettingsDto> AddEmailProvider(EmailProviderSettingsDto providerInput)
{
var response = new EmailResponseDto <EmailProviderSettingsDto>();
if (!string.IsNullOrEmpty(providerInput.EmailPoolName))
{
if (string.IsNullOrEmpty(providerInput.EmailPoolID))
{
var emailPool = _emailPoolRepository.GetEmailPoolByName(providerInput.EmailPoolName)?.Result;
if (emailPool != null)
{
providerInput.EmailPoolID = emailPool.ID;
}
else
{
response.Status = false;
response.Message = "Invalid Email pool.";
response.Result = providerInput;
return(response);
}
}
else
{
var emailPool = _emailPoolRepository.CheckIfEmailPoolIDNameValid(providerInput.EmailPoolID, providerInput.EmailPoolName);
if (!emailPool.Status)
{
response.Status = false;
response.Message = "Email Pool ID and Name do not match.";
response.Result = providerInput;
return(response);
}
}
}
else if (!string.IsNullOrEmpty(providerInput.EmailPoolID))
{
var emailPool = _emailPoolRepository.CheckIfEmailPoolIDIsValid(providerInput.EmailPoolID);
if (!emailPool.Status)
{
response.Status = false;
response.Message = "Invalid Email Pool ID.";
response.Result = providerInput;
return(response);
}
}
else
{
response.Status = false;
response.Message = "Email pool cannot be blank.";
response.Result = providerInput;
return(response);
}
var mappedEmailInput = _mapper.Map <EmailProviderSettingsTable>(providerInput);
var mappedResponse = _emailProviderRepository.AddEmailProvider(mappedEmailInput);
response = _mapper.Map <EmailResponseDto <EmailProviderSettingsDto> >(mappedResponse);
return(response);
}
public EmailResponseDto <List <EmailHistoryDto> > GetEmailHistoriesByTag(string channelKey, string tag)
{
_logger.LogInformation("AddEmailHistory interactor method.");
EmailResponseDto <List <EmailHistoryDto> > responseDto = new EmailResponseDto <List <EmailHistoryDto> >();
try
{
var histories = _emailHistoryRepository.GetEmailHistoriesByTag(channelKey, tag);
_logger.LogDebug($"Status: {histories.Status},Message: {histories.Message}");
return(_mapper.Map <EmailResponseDto <List <EmailHistoryDto> > >(histories));
}
catch (Exception ex)
{
_logger.LogError("Error occurred while getting email history by tag:" + ex.Message);
responseDto.Message = "Failed to get histories by tag: " + ex.Message;
responseDto.Status = false;
return(responseDto);
}
}
public EmailResponseDto <List <EmailPoolTable> > GetEmailPoolNames()
{
var response = new EmailResponseDto <List <EmailPoolTable> >();
try
{
var emailPools = _context.EmailPools.ToList();
response.Status = true;
response.Message = $"Retrieved {emailPools.Count} Email pool data";
response.Result = emailPools;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <List <EmailHistoryTable> > GetEmailHistoriesByTag(string channelKey, string tag)
{
var response = new EmailResponseDto <List <EmailHistoryTable> >();
try
{
var emailHistories = new List <EmailHistoryTable>();
emailHistories = (from h in _context.EmailHistories
join c in _context.EmailChannels on h.EmailChannelID equals c.ID
join pr in _context.EmailProviders on h.EmailProviderID equals pr.ID
where c.Key.ToLower().Equals(channelKey.ToLower()) && (string.IsNullOrEmpty(tag) || h.Tags.ToLower().Equals(tag.ToLower()))
select new EmailHistoryTable {
ID = h.ID,
Sender = h.Sender,
SentOn = h.SentOn,
Recipients = h.Recipients,
Attempts = h.Attempts,
Tags = h.Tags,
Status = h.Status,
ChannelKey = c.Key,
ProviderName = pr.Name,
MessageSent = h.MessageSent,
EmailChannelID = h.EmailChannelID,
EmailProviderID = h.EmailProviderID,
TemplateName = h.TemplateName,
TemplateVariant = h.TemplateVariant
}).ToList();
response.Status = true;
response.Message = $"Retrieved {emailHistories.Count} Email histories data for pool";
response.Result = emailHistories;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailTemplateTable> AddEmailTemplate(EmailTemplateTable templateInput)
{
var response = new EmailResponseDto <EmailTemplateTable>();
try
{
var template = _context.EmailTemplates.FirstOrDefault(st => st.Name.ToLower().Equals(templateInput.Name.ToLower()) &&
st.EmailPoolID.Equals(templateInput.EmailPoolID) && (string.IsNullOrEmpty(templateInput.Variant) ||
st.Variant.ToLower().Equals(templateInput.Variant.ToLower())));
if (template != null)
{
response.Status = false;
response.Message = $"This template is already used.";
response.Result = templateInput;
}
else
{
templateInput.ID = Guid.NewGuid().ToString();
_context.EmailTemplates.Add(templateInput);
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = "Added";
response.Result = templateInput;
}
else
{
response.Status = false;
response.Message = "Not Added";
response.Result = templateInput;
}
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailTemplateTable> UpdateEmailTemplate(EmailTemplateTable templateInput)
{
var response = new EmailResponseDto <EmailTemplateTable>();
try
{
var template = _context.EmailTemplates.FirstOrDefault(st => st.Name.ToLower().Equals(templateInput.Name.ToLower()) &&
st.EmailPoolID.Equals(templateInput.EmailPoolID) && (string.IsNullOrEmpty(templateInput.Variant) ||
st.Variant.ToLower().Equals(templateInput.Variant.ToLower())));
if (template != null)
{
template.MessageTemplate = templateInput.MessageTemplate;
template.Sender = templateInput.Sender;
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = "Updated";
response.Result = templateInput;
}
else
{
response.Status = false;
response.Message = "Failed To Update";
response.Result = templateInput;
}
}
else
{
response.Status = false;
response.Message = $"Unable to find template with name {templateInput.Name} and variant {templateInput.Variant}";
response.Result = templateInput;
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <EmailChannelDto> AddEmailChannel(EmailChannelDto channelInput)
{
_logger.LogInformation("AddEmailChannel interactor method.");
EmailResponseDto <EmailChannelDto> channelResponse = new EmailResponseDto <EmailChannelDto>();
try
{
_logger.LogInformation("Trying to add EmailChannel.");
channelResponse = _emailChannelInteractor.AddEmailChannel(channelInput);
_logger.LogDebug("" + channelResponse.Message);
return(channelResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while adding email channel: ", ex.Message);
channelResponse.Message = "Error occurred while adding email channel: " + ex.Message;
channelResponse.Status = false;
return(channelResponse);
}
}
public EmailResponseDto <EmailProviderSettingsDto> UpdateEmailProvider(EmailProviderSettingsDto providerInput)
{
_logger.LogInformation("UpdateEmailProvider interactor method.");
EmailResponseDto <EmailProviderSettingsDto> providerResponse = new EmailResponseDto <EmailProviderSettingsDto>();
try
{
_logger.LogInformation("Trying to update EmailProvider.");
providerResponse = _emailProviderInteractor.UpdateEmailProvider(providerInput);
_logger.LogDebug("Status: " + providerResponse.Status + ", " + providerResponse.Message);
return(providerResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while updating email provider: ", ex.Message);
providerResponse.Message = "Error occurred while updating email provider: " + ex.Message;
providerResponse.Status = false;
return(providerResponse);
}
}
public EmailResponseDto <EmailPoolDto> AddEmailPool(EmailPoolDto poolInput)
{
_logger.LogInformation("AddEmailPool interactor method.");
EmailResponseDto <EmailPoolDto> poolResponse = new EmailResponseDto <EmailPoolDto>();
try
{
_logger.LogInformation("Trying to add EmailPool.");
poolResponse = _emailPoolInteractor.AddEmailPool(poolInput);
_logger.LogDebug("Status: " + poolResponse.Status + ", " + poolResponse.Message);
return(poolResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while adding email pool: ", ex.Message);
poolResponse.Message = "Error occurred while adding email pool: " + ex.Message;
poolResponse.Status = false;
return(poolResponse);
}
}
public EmailResponseDto <EmailQuotaDto> GetEmailQuota(string channelKey)
{
_logger.LogInformation("GetEmailQuota interactor method.");
var response = new EmailResponseDto <EmailQuotaDto>();
try
{
var emailQuotaResponse = _emailQuotaRepository.GetEmailQuota(channelKey);
_logger.LogDebug("Status: " + emailQuotaResponse.Status + ", Message: " + emailQuotaResponse.Message);
var mappedResponse = _mapper.Map <EmailResponseDto <EmailQuotaDto> >(emailQuotaResponse);
return(mappedResponse);
}
catch (Exception ex)
{
_logger.LogError("Failed to get Email Quota" + ex.Message);
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
public EmailResponseDto <List <EmailHistoryDto> > GetEmailHistoriesByTag(string channelKey, string tag)
{
_logger.LogInformation("GetEmailHistoriesByTag interactor method.");
EmailResponseDto <List <EmailHistoryDto> > poolResponse = new EmailResponseDto <List <EmailHistoryDto> >();
try
{
_logger.LogInformation($"Trying to get Email histories by tag for ChannelKey: {channelKey} and Tag: {tag}.");
poolResponse = _emailHistoryInteractor.GetEmailHistoriesByTag(channelKey, tag);
_logger.LogDebug("" + poolResponse.Message);
return(poolResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while getting email histories: ", ex.Message);
poolResponse.Message = "Error occurred while getting email histories: " + ex.Message;
poolResponse.Status = false;
return(poolResponse);
}
}
public EmailResponseDto <List <EmailProviderSettingsDto> > GetEmailProvidersByPool(string poolName, string providerName)
{
_logger.LogInformation("GetEmailProvidersByPool interactor method.");
EmailResponseDto <List <EmailProviderSettingsDto> > providerResponse = new EmailResponseDto <List <EmailProviderSettingsDto> >();
try
{
_logger.LogInformation($"Trying to get Email Provider By poolname for Pool: {poolName} and Provider: {providerName}.");
providerResponse = _emailProviderInteractor.GetEmailProvidersByPool(poolName, providerName);
_logger.LogDebug("" + providerResponse.Message);
return(providerResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while getting email provider by pool: ", ex.Message);
providerResponse.Message = "Error occurred while getting email provider by pool: " + ex.Message;
providerResponse.Status = false;
return(providerResponse);
}
}
public EmailResponseDto <EmailChannelDto> GetEmailChannelByKey(string channelKey)
{
_logger.LogInformation("GetEmailChannelByKey interactor method.");
EmailResponseDto <EmailChannelDto> channelResponse = new EmailResponseDto <EmailChannelDto>();
try
{
_logger.LogInformation($"Trying to get Email Channel By Key for Channel Key {channelKey}.");
channelResponse = _emailChannelInteractor.GetEmailChannelByKey(channelKey);
_logger.LogDebug("" + channelResponse.Message);
return(channelResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while getting email channel by key: ", ex.Message);
channelResponse.Message = "Error occurred while getting email channel by key: " + ex.Message;
channelResponse.Status = false;
return(channelResponse);
}
}
public EmailResponseDto <EmailTemplateDto> UpdateEmailTemplate(EmailTemplateDto templateInput)
{
_logger.LogInformation("UpdateEmailTemplate interactor method.");
EmailResponseDto <EmailTemplateDto> templateResponse = new EmailResponseDto <EmailTemplateDto>();
try
{
_logger.LogInformation("Trying to update EmailTemplate.");
templateResponse = _emailTemplateInteractor.UpdateEmailTemplate(templateInput);
_logger.LogDebug("" + templateResponse.Message);
return(templateResponse);
}
catch (Exception ex)
{
_logger.LogError("Error occurred in Email Interactor while updating email template: ", ex.Message);
templateResponse.Message = "Error occurred while updating email template: " + ex.Message;
templateResponse.Status = false;
return(templateResponse);
}
}
public EmailResponseDto <bool> CheckIfChannelExist(string channelKey)
{
var response = new EmailResponseDto <bool>();
try
{
var channelExist = _context.EmailChannels.Any(sp => sp.Key.ToLower().Equals(channelKey.ToLower()));
response.Status = channelExist;
response.Message = $"Is channel existing : {channelExist}";
response.Result = channelExist;
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
response.Result = false;
return(response);
}
}
public EmailResponseDto <EmailQuotaTable> UpdateEmailQuota(string channelID)
{
var response = new EmailResponseDto <EmailQuotaTable>();
try
{
var emailQuota = _context.EmailQuotas.FirstOrDefault(q => q.EmailChannelID == channelID);
if (emailQuota != null)
{
var countInt = Convert.ToInt32(emailQuota.TotalConsumption); // TODO Implement encryption
countInt += 1;
emailQuota.TotalConsumption = countInt;
_context.EmailQuotas.Update(emailQuota);
}
else
{
emailQuota = new EmailQuotaTable()
{
EmailChannelID = channelID,
MonthlyQuota = 100,
MonthlyConsumption = 1,
TotalConsumption = 1
};
_context.EmailQuotas.Add(emailQuota);
}
if (_context.SaveChanges() == 1)
{
response.Status = true;
response.Message = "Email Quota is updated";
response.Result = emailQuota;
}
return(response);
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
return(response);
}
}
