public async Task <IActionResult> Login([FromBody] LoginInfo loginInfo)
{
UserRead user = await usersService.GetUserByEmailAsync(loginInfo.Email, loginInfo.Password);
if (user.LoginSuccess == (int)LoginType.passwordOrEmailInvalid)
{
return(BadRequest("Email or password is incorrect."));
}
else if (user.LoginSuccess == (int)LoginType.accountLocked)
{
return(BadRequest("The account has been locked."));
}
else if (user.LoginSuccess == (int)LoginType.accountLockedFor5Min)
{
return(BadRequest("The account has been locked for 5 minutes."));
}
else if (user.LoginSuccess == (int)LoginType.correctLoginInfo)
{
TokenProvider tokenProvider = new TokenProvider();
return(Ok(tokenProvider.CreateJWT(user.EmailUser)));
}
else
{
return(BadRequest("There was an unknown error"));
}
}
private async Task <bool> ValidateUserPassword(UserRead userRead, string inputPassword)
{
if (ValidatePassword(inputPassword, userRead.EmailUser.Password))
{
userRead.LoginSuccess = (int)LoginType.correctLoginInfo;
return(true);
}
else
{
userRead.LoginSuccess = (int)LoginType.passwordOrEmailInvalid;
if (userRead.EmailUser.LoginAttempts > 4)
{
userRead.EmailUser.UnlockedDateUTC = DateTime.UtcNow.AddMinutes(5);
userRead.EmailUser.LoginAttempts = 0;
}
else
{
userRead.EmailUser.LoginAttempts += 1;
}
await usersRepo.UpdateUserAsync(userRead.EmailUser);
return(false);
}
}
public Window CreateUserDeleteView(UserRead user)
{
return(new ConfirmDeleteWindow
{
DataContext = _viewModelFactory.CreateUserConfirmDeleteViewModel(user),
FontFamily = _fontFamily
});
}
public object CreateUserConfirmDeleteViewModel(UserRead user)
{
return(new ConfirmDeleteWindowViewModel
{
MessageDetail = string.Format("User: {0}", user.DisplayName),
DeleteCommand = _commandFactory.DeleteUserCommand(user),
CancelCommand = _commandFactory.CloseWindowCommand(),
DeletingItem = user
});
}
public async Task <ServiceCallResult <UserRead> > GetUserProfile()
{
var response = await RequestGet <UserRead>(ProfilesUrl);
if (response != null && response.CallStatusCode == HttpStatusCode.OK)
{
_user = response.Results;
}
return(response);
}
public void CreateAuctionCommand_handled_and_readmodel_is_created()
{
var services = TestDepedencies.Instance.Value;
var sem = new SemaphoreSlim(0, 1);
var command = GetCreateCommand();
string idFromHandler = "";
CorrelationId correlationIdFromHandler = null;
var eventHandler = new TestAuctionCreatedHandler(services.AppEventBuilder, services.DbContext, Mock.Of <IRequestStatusService>());
eventHandler.OnConsumeCalled = ev =>
{
Assert.True(VerifyEvent(ev.Event, command));
idFromHandler = ev.Event.AuctionId.ToString();
correlationIdFromHandler = ev.CorrelationId;
sem.Release();
};
services.SetupEventBus(eventHandler);
SetUpCommandHandler();
//act
commandHandler.Handle(command, CancellationToken.None);
if (!sem.Wait(TimeSpan.FromSeconds(60)))
{
Assert.Fail();
}
;
var auctionReadModel = services.DbContext.AuctionsReadModel.Find(a => a.AuctionId == idFromHandler)
.FirstOrDefault();
UserRead userRead = services.DbContext.UsersReadModel
.Find(f => f.UserIdentity.UserId == user.UserIdentity.UserId.ToString())
.FirstOrDefault();
auctionReadModel.Should()
.NotBeNull();
auctionReadModel.Product.Should()
.BeEquivalentTo(product);
auctionReadModel.Creator.UserId.Should()
.Be(userRead.UserIdentity.UserId);
services.AuctionImageRepository.Find("img1-1")
.Metadata.IsAssignedToAuction.Should()
.BeTrue();
correlationIdFromHandler.Value.Should().NotBeEmpty();
}
public async Task <UserRead> GetUserByEmailAsync(string email, string password)
{
User user = await usersRepo.GetUserByEmailAsync(email);
UserRead userRead = new UserRead();
userRead.EmailUser = user;
if (user.Id != 0)
{
if (user.UnlockedDateUTC.HasValue)
{
if (user.UnlockedDateUTC > DateTime.UtcNow)
{
userRead.LoginSuccess = (int)LoginType.accountLockedFor5Min;
}
else
{
if (await ValidateUserPassword(userRead, password))
{
userRead.LoginSuccess = (int)LoginType.correctLoginInfo;
}
else
{
userRead.LoginSuccess = (int)LoginType.passwordOrEmailInvalid;
}
}
}
else
{
if (await ValidateUserPassword(userRead, password))
{
userRead.LoginSuccess = (int)LoginType.correctLoginInfo;
}
else
{
userRead.LoginSuccess = (int)LoginType.passwordOrEmailInvalid;
}
}
if (user.AccountLocked == true)
{
userRead.LoginSuccess = (int)LoginType.accountLocked;
}
}
return(userRead);
}
internal async Task <bool> DeleteUser(UserRead userRead)
{
LogWarning(Localized.Resources.StatusConnecting);
var successful = await _membershipService.DeleteUser(userRead);
if (successful)
{
_users.Remove(userRead);
LogSuccess(Localized.Resources.StatusItemDeleted);
return(true);
}
LogFailure(Localized.Resources.StatusFailedToDeleteItem);
return(false);
}
public override void Consume(IAppEvent <UserRegistered> message)
{
UserRegistered ev = message.Event;
var userReadModel = new UserRead();
userReadModel.UserIdentity = new UserIdentityRead(ev.UserIdentity);
try
{
_dbContext.UsersReadModel.InsertOne(userReadModel);
}
catch (Exception)
{
throw;
}
}
public void MarkRead(int userid, int messageid)
{
try
{
if (!HasRead(userid, messageid))
{
BBSDataDataContext bbs = GetDataContext();
UserRead ur = new UserRead()
{
UserId = userid, MessageHeaderId = messageid
};
bbs.UserReads.InsertOnSubmit(ur);
bbs.SubmitChanges();
}
}
catch (Exception e)
{
LoggingAPI.LogEntry("Exception in DataInterface.MarkRead(" + userid.ToString() + "," + messageid.ToString() + "):" + e.ToString());
}
}
public DeleteUserCommand(MembershipRepository repository, UserRead user)
{
_repository = repository;
_user = user;
}
public async Task <bool> DeleteUser(UserRead user)
{
return(await RequestDelete(UsersUrl + string.Format("/{0}", user.UserId)));
}
internal ICommand DeleteUserCommand(UserRead user)
{
return(new DeleteUserCommand(_membershipRepository, user));
}
public void RequestPermissionToDelete(UserRead user)
{
_viewFactory.CreateUserDeleteView(user).Show();
}
