public async Task ShouldUpdateSecurityUser()
{
var usertId = Guid.NewGuid();
var securityUser = new SecurityUser();
var expected = new UserSettingsDTO();
var userSettingsDTO = new UserSettingsDTO();
_mock.Mock <ISecurityUserProvider>()
.Setup(provider => provider.GetByUserIdAsync(usertId))
.ReturnsAsync(securityUser);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map(userSettingsDTO, securityUser))
.Returns(securityUser);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map <UserSettingsDTO>(securityUser))
.Returns(expected);
var actual = await _service.UpdateAsync(userSettingsDTO, usertId);
_mock.Mock <IInventContext>()
.Verify(context => context.Update(securityUser));
_mock.Mock <IInventContext>()
.Verify(context => context.SaveChangesAsync(default(CancellationToken)));
ContentAssert.AreEqual(expected, actual);
}
public async Task ShouldReturnUserSettingsDTOOnGetAction()
{
Guid userId = Guid.NewGuid();
Guid securityUserId = Guid.NewGuid();
var securityUser = new SecurityUser
{
Id = securityUserId
};
var expected = new UserSettingsDTO();
var controller = _mock.Create <UserSettingsController>();
_mock.Mock <IUserManager>()
.Setup(manager => manager.GetUserId(controller.User))
.Returns(userId);
_mock.Mock <ISecurityUserProvider>()
.Setup(provider => provider.GetByUserIdAsync(userId))
.ReturnsAsync(securityUser);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map <UserSettingsDTO>(securityUser))
.Returns(expected);
var actual = await controller.Get();
ContentAssert.AreEqual(expected, actual);
}
public async Task ShouldDeleteUserPicture()
{
var claimsPrincipal = new ClaimsPrincipal();
var controllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = claimsPrincipal
}
};
var userId = Guid.NewGuid();
var expected = new UserSettingsDTO();
var controller = _mock.Create <UserPictureController>();
controller.ControllerContext = controllerContext;
_mock.Mock <IUserManager>()
.Setup(manager => manager.GetUserId(controller.User))
.Returns(userId);
_mock.Mock <IUserPictureService>()
.Setup(service => service.DeleteUserPictureAsync(userId))
.ReturnsAsync(expected);
var actual = await controller.DeleteUserPicture();
ContentAssert.AreEqual(expected, actual);
}
public async Task <ChangingSettingsResult> ChangeUserSettings(UserSettingsDTO settingsData, Func <string, string> pathResolver)
{
var me = db.Users.FindById(settingsData.Id);
var result = new ChangingSettingsResult();
result.Settings = settingsData;
var isPassValid = db.Users.CheckPassword(me, settingsData.Password);
if (!isPassValid)
{
result.Errors.Add("Invalid password");
result.Succeeded = false;
settingsData.Password = "";
return(result);
}
if (!string.IsNullOrEmpty(settingsData.NewPassword))
{
if (settingsData.NewPassword != settingsData.NewPasswordConfirmation)
{
settingsData.NewPassword = "";
settingsData.NewPasswordConfirmation = "";
settingsData.Password = "";
result.Errors.Add("Passwords don't match");
result.Succeeded = false;
return(result);
}
await db.Users.ChangePasswordAsync(me.Id, settingsData.Password, settingsData.NewPassword);
}
me.UserInfo.FirstName = settingsData.FirstName;
me.UserInfo.LastName = settingsData.LastName;
me.UserInfo.Phone = settingsData.Phone;
me.UserInfo.Skype = settingsData.Skype;
me.Email = settingsData.Email;
me.UserInfo.AboutMe = settingsData.AboutMe;
if (settingsData.Avatar != null)
{
var extension = settingsData.Avatar.FileName.Split('.').Last();
var filename = $"{me.Id}.{extension}";
var savePath = Path.Combine(ConfigurationManager.AppSettings["avatarPath"].ToString(),
filename);
settingsData.Avatar.SaveAs(pathResolver(savePath));
me.UserInfo.AvatarFilename = filename;
me.UserInfo.AvatarMimeType = settingsData.Avatar.ContentType;
}
await db.Users.UpdateAsync(me);
await db.SaveChangesAsync();
result.Succeeded = true;
return(result);
}
public async Task <UserSettingsDTO> UpdateUserSettings([FromBody] UserSettingsDTO userSettings)
{
var currentUserId = this.GetCurrentUserClaim("Id");
var result = await this.usersService.UpdateUserSettings(currentUserId, userSettings.ToEntity());
return(result.ToDto());
}
public async Task <UserSettingsDTO> Update([FromBody] UserSettingsDTO userSettings)
{
using (var userManager = _userManagerFactory())
{
var userId = userManager.GetUserId(User);
return(await _userSettingsService.UpdateAsync(userSettings, userId));
}
}
public async Task <IActionResult> Settings(UserSettingsDTO model)
{
var userProfile = new UserProfileDTO();
var user = await GetCurrentUserAsync();
userProfile.FirsName = user.FirstName;
userProfile.LastName = user.LastName;
userProfile.ProfilePhoto = user.ProfilePhoto;
userProfile.Email = user.Email;
return(View(userProfile));
}
public static UserSettings ToEntity(this UserSettingsDTO settings)
{
return(new UserSettings
{
IsProfileVisible = settings.IsProfileVisible,
IsActivityVisible = settings.IsActivityVisible,
IsNargilesVisible = settings.IsNargilesVisible,
AllowNotifications = settings.AllowNotifications,
Language = settings.Language
});
}
public async Task <IActionResult> Settings()
{
var userSetting = new UserSettingsDTO();
//get currentuser
var user = await GetCurrentUserAsync();
//get user settings
var userSet = uow.UserSettings.Find(i => i.ApplicationUser == user).First();
//add viewmodel
userSetting.Compare = userSet.Compare;
userSetting.Fill = userSet.Fill;
userSetting.Random = userSet.Random;
userSetting.TestWordCount = userSet.TestWordCount;
return(View(userSetting));
}
public UserSettingsDTO GetUserSettings(string userId)
{
var me = db.Users.FindById(userId);
var data = new UserSettingsDTO {
Id = me.Id,
Email = me.Email,
FirstName = me.UserInfo.FirstName,
LastName = me.UserInfo.LastName,
AboutMe = me.UserInfo.AboutMe,
AvatarFilename = me.UserInfo.AvatarFilename,
Phone = me.UserInfo.Phone,
Skype = me.UserInfo.Skype
};
return(data);
}
public async Task <UserSettingsDTO> UpdateAsync(UserSettingsDTO userSettings, Guid userId)
{
using (var context = _contextFactory())
using (var securityUserProvider = _securityUserProviderFactory(context))
{
var securityUser = await securityUserProvider.GetByUserIdAsync(userId);
securityUser = _mapper.Map(userSettings, securityUser);
context.Update(securityUser);
await context.SaveChangesAsync();
return(_mapper.Map <UserSettingsDTO>(securityUser));
}
}
public async Task ShouldUpdateUserSettings()
{
Guid userId = Guid.NewGuid();
var userSettings = new UserSettingsDTO();
var expected = new UserSettingsDTO();
var controller = _mock.Create <UserSettingsController>();
_mock.Mock <IUserManager>()
.Setup(manager => manager.GetUserId(controller.User))
.Returns(userId);
_mock.Mock <IUserSettingsService>()
.Setup(service => service.UpdateAsync(userSettings, userId))
.ReturnsAsync(expected);
var actual = await controller.Update(userSettings);
ContentAssert.AreEqual(expected, actual);
}
public async Task ActivateReturnsSuccessResponse()
{
var credentials = new OtpActivationRequest();
var activationParams = new OtpActivationRequestParams();
var userSettings = new UserSettingsDTO();
_mock.Mock <IOtpActivationRequestParamProvider>()
.Setup(instance => instance.Get(credentials))
.Returns(activationParams);
_mock.Mock <IOtpActivationRequestValidationService>()
.Setup(instance => instance.ValidateAsync(activationParams))
.ReturnsAsync("VALID");
_mock.Mock <IOtpActivationService>()
.Setup(instance => instance.ActivateAsync(activationParams))
.ReturnsAsync(userSettings);
var controller = _mock.Create <AuthOtpController>();
var actual = await controller.Activate(credentials);
ContentAssert.AreEqual(userSettings, actual);
}
