public async Task SendEmail_NoUpdates_ReturnNull()
{
var user = new UpdateUserEmailDto()
{
UserId = 0,
UserName = "******",
Language = new CultureInfo("he"),
ToEmailAddress = "some email"
};
var asyncCollector = new TestAsyncCollector <SendGridMessage>();
await EmailUpdateFunction.SendEmail(user,
asyncCollector,
_queryBusStub.Object,
null,
_dataProtectProviderStub.Object,
_hostUriService.Object,
CancellationToken.None);
var message = asyncCollector.Result.FirstOrDefault();
message.Should().BeNull();
}
public async Task <IActionResult> UpdateUserEmail(UpdateUserEmailDto item)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ModelStateResult(ModelState)));
}
var updateUserEmailResultDto = await _usersService.UpdateUserEmail(item, UserId);
return(Ok(updateUserEmailResultDto));
}
public void RunOrchestrator_UpdateUserEmailDto_SerializeOk()
{
var user = new UpdateUserEmailDto()
{
UserName = "******",
Language = new CultureInfo("he"),
ToEmailAddress = "some email"
};
var json = JsonConvert.SerializeObject(user);
var user2 = JsonConvert.DeserializeObject <UpdateUserEmailDto>(json);
user2.Should().BeEquivalentTo(user);
}
public async Task SendEmail_UserWithHebrew_EmailIsRtl()
{
var user = new UpdateUserEmailDto()
{
UserId = 159039,
UserName = "******",
Language = new CultureInfo("he"),
ToEmailAddress = "some email"
};
List <DocumentUpdateEmailDto> update = new List <DocumentUpdateEmailDto>();
update.Add(new DocumentUpdateEmailDto()
{
Id = 11,
Name = "Load Stress Testing Multimi2.docx",
Course = "Box Read for hotmail user",
UserId = 2641,
UserName = "******",
UserImage = null,
});
_queryBusStub.Setup(s => s.QueryAsync(It.IsAny <GetUpdatesEmailByUserQuery>(), default)).ReturnsAsync(update);
var asyncCollector = new TestAsyncCollector <SendGridMessage>();
await EmailUpdateFunction.SendEmail(user,
asyncCollector,
_queryBusStub.Object,
null,
_dataProtectProviderStub.Object,
_hostUriService.Object,
CancellationToken.None);
var message = asyncCollector.Result.First();
var firstObject = message.Personalizations.First();
var email = (UpdateEmail)firstObject.TemplateData;
message.TemplateId.Should().Be(EmailUpdateFunction.HebrewTemplateId);
email.Direction.Should().Be("rtl");
}
public async Task <IActionResult> UpdateEmail(UpdateUserEmailDto updateUserEmailDto)
{
var user = await userManager.FindByIdAsync(updateUserEmailDto.UserId);
if (user != null)
{
user.Email = updateUserEmailDto.Email;
var updateResult = await userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <UpdateUserEmailResultDto> UpdateUserEmail(UpdateUserEmailDto updateUserEmailDto, int userId)
{
var user = await _usersRepository.GetAsync(userId);
if (user == null)
{
throw new ValidationException(Messages.UserDoesNotExist, nameof(Messages.UserDoesNotExist));
}
if (await _usersRepository.GetAsync(filter: o => o.Email == updateUserEmailDto.Email) != null)
{
throw new ValidationException(Messages.EmailExists, nameof(Messages.EmailExists));
}
user.Email = updateUserEmailDto.Email;
await _usersRepository.UpdateAsync(user);
return(new UpdateUserEmailResultDto());
}
/// <summary>
/// 修改邮箱
/// </summary>
/// <param name="updateUserEmailDto"></param>
/// <returns></returns>
internal async Task <BaseResponse> UpdateEmailAsync(UpdateUserEmailDto updateUserEmailDto)
{
return(await HttpRequestWithValidate($"api/client/user/UpdateEmail", HttpMethod.Patch, updateUserEmailDto.BuildHttpContent()));
}
public static async Task SendEmail(
[ActivityTrigger] UpdateUserEmailDto user,
[SendGrid(ApiKey = "SendgridKey", From = "Spitball <*****@*****.**>")] IAsyncCollector <SendGridMessage> emailProvider,
[Inject] IQueryBus queryBus,
[Inject] IUrlBuilder urlBuilder,
[Inject] IDataProtectionService dataProtectService,
[Inject] IHostUriService hostUriService,
CancellationToken token)
{
var code = dataProtectService.ProtectData(user.UserId.ToString(), DateTimeOffset.UtcNow.AddDays(3));
var uri = hostUriService.GetHostUri();
var questionNvc = new NameValueCollection()
{
["width"] = "86",
["height"] = "96",
["mode"] = "crop"
};
var q = new GetUpdatesEmailByUserQuery(user.UserId, user.Since);
var result = (await queryBus.QueryAsync(q, token)).ToList();
if (result.Count == 0)
{
return;
}
var courses = result.GroupBy(g => g.Course).Take(3).Select(s =>
{
var emailUpdates = s.Take(4).ToList();
return(new Course()
{
Name = s.Key,
Url = urlBuilder.BuildCourseEndPoint(s.Key),
NeedMore = emailUpdates.Count == 4,
Documents = emailUpdates.OfType <DocumentUpdateEmailDto>().Select(document =>
{
var uriBuilder = new UriBuilder(uri)
{
Path = $"api/image/document/{document.Id}",
};
uriBuilder.AddQuery(questionNvc);
return new Document()
{
Url = urlBuilder.BuildDocumentEndPoint(document.Id, new { token = code }),
Name = document.Name,
UserName = document.UserName,
DocumentPreview = uriBuilder.ToString(),
UserImage = BuildUserImage(document.UserId, document.UserImage, document.UserName, hostUriService)
};
}),
Questions = emailUpdates.OfType <QuestionUpdateEmailDto>().Select(question => new Question()
{
QuestionUrl = urlBuilder.BuildQuestionEndPoint(question.QuestionId, new { token = code }),
QuestionText = question.QuestionText,
UserImage = BuildUserImage(question.UserId, question.UserImage, question.UserName, hostUriService),
UserName = question.UserName,
AnswerText = question.AnswerText
})
});
});
var templateData = new UpdateEmail(user.UserName, user.ToEmailAddress, user.Language.TextInfo.IsRightToLeft)
{
DocumentCountUpdate = result.OfType <DocumentUpdateEmailDto>().Count(),
QuestionCountUpdate = result.OfType <QuestionUpdateEmailDto>().Count(),
Courses = courses
};
var message = new SendGridMessage
{
Asm = new ASM {
GroupId = UnsubscribeGroup.Update
},
TemplateId = Equals(user.Language, Language.Hebrew.Info)
? HebrewTemplateId : EnglishTemplateId
};
templateData.To = user.ToEmailAddress;
var personalization = new Personalization
{
TemplateData = templateData
};
message.Personalizations = new List <Personalization>()
{
personalization
};
message.AddCategory("updates");
message.TrackingSettings = new TrackingSettings
{
Ganalytics = new Ganalytics
{
UtmCampaign = "updates",
UtmSource = "SendGrid",
UtmMedium = "Email",
Enable = true
}
};
message.AddTo(user.ToEmailAddress);
await emailProvider.AddAsync(message, token);
await emailProvider.FlushAsync(token);
}
public async Task <ActionResult <ResponseDto <UserResponseDto> > > UpdateEmail([FromBody] UpdateUserEmailDto updateUserEmailDto, [FromRoute] string id)
{
var user = await _userManager.FindUserByEmailAsyncFromClaimsPrincipal(HttpContext.User);
if (user == null)
{
return(NotFound(new ResponseDto <string>
{
Success = false,
Data = null,
Error = new ApiErrorResponse(404)
}));
}
if (user.Id != id)
{
return(StatusCode(403, new ResponseDto <string>
{
Success = false,
Data = null,
Error = new ApiErrorResponse(403)
}));
}
var changeEmailToken = await _userManager.GenerateChangeEmailTokenAsync(user, updateUserEmailDto.Email);
var result = await _userManager.ChangeEmailAsync(user, updateUserEmailDto.Email, changeEmailToken);
if (!result.Succeeded)
{
return(BadRequest(new ResponseDto <string>
{
Success = false,
Data = null,
Error = new ApiErrorResponse(400)
}));
}
return(new ResponseDto <UserResponseDto>
{
Success = true,
Data = new UserResponseDto
{
User = _mapper.Map <AppUser, UserDto>(user),
Token = new TokenDto {
Token = _tokenService.CreateToken(user)
},
},
Error = new ApiErrorResponse()
});
}
