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()); }