public virtual void Update(EmailTemplateDto emailTemplateDto)
{
Guard.Hope(Id == emailTemplateDto.EmailTemplateId, "Invalid email template id");
emailTemplateDto.Parts.Each(part =>
{
switch (part.PartType)
{
case PartType.Html:
_setHtml(part.PartId, part.Html);
break;
case PartType.Variable:
_setVariableValue(part.PartId, part.VariableValue);
break;
default:
throw new EmailMakerException("Unknown email template part type: " + part.PartType);
}
});
Name = emailTemplateDto.Name;
void _setHtml(int htmlTemplatePartId, string html)
{
var htmlTemplatePart = _GetHtmlPart(htmlTemplatePartId);
htmlTemplatePart.SetHtml(html);
}
void _setVariableValue(int variablePartId, string value)
{
_GetVariablePart(variablePartId).SetValue(value);
}
}
public void Context()
{
_emailTemplate = A.Fake <EmailTemplate>();
const int emailTemplateId = 23;
var emailTemplateRepository = A.Fake <IRepository <EmailTemplate> >();
A.CallTo(() => emailTemplateRepository.GetAsync(emailTemplateId)).Returns(_emailTemplate);
_htmlTemplatePartId = 47;
_htmlStartIndex = 56;
_length = 65;
_emailTemplateDto = new EmailTemplateDto
{
EmailTemplateId = emailTemplateId,
};
var command = new CreateVariableCommand
{
EmailTemplate = _emailTemplateDto,
HtmlStartIndex = _htmlStartIndex,
HtmlTemplatePartId = _htmlTemplatePartId,
Length = _length
};
var handler = new CreateVariableCommandHandler(emailTemplateRepository);
handler.ExecuteAsync(command).Wait();
}
public EmailTemplateEntity BuildDto(EmailTemplateDto dto)
{
this.Body = dto.Body;
this.Id = dto.Id;
this.IsActive = dto.IsActive;
return(this);
}
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 async Task <IActionResult> PostEmailTemplate(string appId, [FromBody] CreateEmailTemplateDto request)
{
var update = request.ToUpdate();
var app = await appStore.UpsertAsync(appId, update, HttpContext.RequestAborted);
var response = EmailTemplateDto.FromDomainObject(app.EmailTemplates[request.Language]);
return(Ok(response));
}
public async Task <bool> CreateOrUpdate(EmailTemplateDto dto)
{
if (string.IsNullOrEmpty(dto.Id))
{
return(await Create(dto));
}
else
{
return(await Update(dto));
}
}
public async Task <ActionResult> Edit(EmailTemplateDto dto)
{
try
{
await this._emailTemplateService.CreateOrUpdate(dto);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public void Context()
{
var template = EmailTemplateBuilder.New
.WithId(45)
.WithInitialHtml("12345")
.Build();
var emailTemplateDto = new EmailTemplateDto
{
EmailTemplateId = 66,
};
_exception = Should.Throw <Exception>(() => template.Update(emailTemplateDto));
}
private async Task <bool> Create(EmailTemplateDto dto)
{
var result = true;
try
{
await this._emailTemplateRepository.Create(new EmailTemplateEntity().BuildDto(dto));
}
catch (Exception ex)
{
result = false;
}
return(result);
}
public void Context()
{
var template = EmailTemplateBuilder.New
.WithId(45)
.WithInitialHtml("12345")
.Build();
var emailTemplateDto = new EmailTemplateDto
{
EmailTemplateId = 45,
Parts = new[] { new EmailTemplatePartDto {
PartType = PartType.Html, PartId = 567
} }
};
_exception = Should.Throw <InvalidOperationException>(() => template.Update(emailTemplateDto));
}
public async Task <EmailTemplateDto> GetById(string id)
{
EmailTemplateDto result;
try
{
var entity = (await this._emailTemplateRepository.Get(x => x.Id.Equals(id))).FirstOrDefault();
result = new EmailTemplateDto(entity);
}
catch (Exception)
{
result = new EmailTemplateDto();
}
return(result);
}
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 void Context()
{
_emailTemplate = A.Fake <EmailTemplate>();
const int emailTemplateId = 23;
var emailTemplateRepository = A.Fake <IRepository <EmailTemplate> >();
A.CallTo(() => emailTemplateRepository.GetAsync(emailTemplateId)).Returns(_emailTemplate);
_emailTemplateDto = new EmailTemplateDto
{
EmailTemplateId = emailTemplateId,
};
var command = new SaveEmailTemplateCommand
{
EmailTemplate = _emailTemplateDto,
};
var handler = new SaveEmailTemplateCommandHandler(emailTemplateRepository);
handler.ExecuteAsync(command).Wait();
}
public void Context()
{
_templateId = 89;
_template = EmailTemplateBuilder.New
.WithId(_templateId)
.WithInitialHtml("12345")
.WithVariable(1, 1)
.WithVariable(1, 1)
.Build();
var emailTemplateDto = new EmailTemplateDto
{
EmailTemplateId = _templateId,
Parts = new[]
{
new EmailTemplatePartDto
{
PartId = _template.Parts.First().Id,
PartType = PartType.Html,
Html = "A"
},
new EmailTemplatePartDto
{
PartId = _template.Parts.ElementAt(3).Id,
PartType = PartType.Variable,
VariableValue = "B"
},
new EmailTemplatePartDto
{
PartId = _template.Parts.ElementAt(4).Id,
PartType = PartType.Html,
Html = "C"
},
},
Name = TemplateName
};
_template.Update(emailTemplateDto);
}
public ActionResult UpdateEmailTemplate(EmailTemplateDto templateInput)
{
_logger.LogInformation("UpdateEmailTemplate action method.");
_logger.LogDebug($"EmailPoolName: {templateInput.EmailPoolName}, TemplateName: {templateInput.Name}, Variant: {templateInput.Variant}, MessageTemplate: {templateInput.MessageTemplate}");
try
{
var templateResponse = _emailInteractor.UpdateEmailTemplate(templateInput);
if (templateResponse.Status)
{
_logger.LogDebug("Status: " + templateResponse.Status + ", " + templateResponse.Message);
return(Ok(templateResponse));
}
else
{
_logger.LogError("Status: " + templateResponse.Status + ", " + templateResponse.Message);
return(StatusCode((int)HttpStatusCode.PreconditionFailed, templateResponse));
}
}
catch (Exception ex)
{
_logger.LogError("Internal server error: Error occurred while updating email template: " + ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
public ActionResult AddEmailTemplate(EmailTemplateDto templateInput)
{
_logger.LogInformation("AddEmailTemplate action method.");
_logger.LogDebug($"EmailPoolName: {templateInput.EmailPoolName}, TemplateName: {templateInput.Name}, Variant: {templateInput.Variant}, MessageTemplate: {templateInput.MessageTemplate}");
EmailResponseDto <EmailTemplateDto> templateResponse = new EmailResponseDto <EmailTemplateDto>();
try
{
if (!string.IsNullOrWhiteSpace(templateInput.Name) && !string.IsNullOrWhiteSpace(templateInput.MessageTemplate))
{
templateResponse = _emailInteractor.AddEmailTemplate(templateInput);
if (templateResponse.Status)
{
_logger.LogDebug("Status: " + templateResponse.Status + ", " + templateResponse.Message);
return(Ok(templateResponse));
}
else
{
_logger.LogError("Status: " + templateResponse.Status + ", " + templateResponse.Message);
return(StatusCode((int)HttpStatusCode.PreconditionFailed, templateResponse));
}
}
else
{
templateResponse.Status = false;
templateResponse.Message = "Name and Message Template cannot be empty or whitespace.";
_logger.LogError("Status: " + templateResponse.Status + ", " + templateResponse.Message);
return(StatusCode((int)HttpStatusCode.PreconditionFailed, templateResponse));
}
}
catch (Exception ex)
{
_logger.LogError("Internal server error: Error occurred while adding email template: " + ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
public async Task UpdateAsync(EmailTemplateDto emailTemplate)
{
await _service.UpdateAsync(emailTemplate)
.ConfigureAwait(false);
}
public async Task <ActionResult <EmailTemplateDto> > InsertAsync(EmailTemplateDto emailTemplate)
{
return(await _service.AddAsync(emailTemplate)
.ConfigureAwait(false));
}
public async Task <IActionResult> PutEmailTemplate(string appId, string language, [FromBody] EmailTemplateDto request)
{
var update = request.ToUpdate(language);
await appStore.UpsertAsync(appId, update, HttpContext.RequestAborted);
return(NoContent());
}
