public void SetUp()
{
dataContextMock = MockRepository.GenerateMock<NemeStatsDataContext>();
retriever = new PendingGamingGroupInvitationRetriever(dataContextMock);
currentUser = new ApplicationUser()
{
Id = "application user id"
};
expectedApplicationUser = new ApplicationUser()
{
Id = currentUser.Id,
Email = "*****@*****.**"
};
dataContextMock.Expect(mock => mock.FindById<ApplicationUser>(currentUser.Id))
.Return(expectedApplicationUser);
expectedGamingGroupInvitations = new List<GamingGroupInvitation>();
expectedGamingGroupInvitation = new GamingGroupInvitation() { InviteeEmail = expectedApplicationUser.Email };
expectedGamingGroupInvitations.Add(expectedGamingGroupInvitation);
expectedGamingGroupInvitations.Add(new GamingGroupInvitation() { InviteeEmail = "some other email that shouldnt be included" });
dataContextMock.Expect(mock => mock.GetQueryable<GamingGroupInvitation>())
.Return(expectedGamingGroupInvitations.AsQueryable());
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock <NemeStatsDataContext>();
retriever = new PendingGamingGroupInvitationRetriever(dataContextMock);
currentUser = new ApplicationUser()
{
Id = "application user id"
};
expectedApplicationUser = new ApplicationUser()
{
Id = currentUser.Id,
Email = "*****@*****.**"
};
dataContextMock.Expect(mock => mock.FindById <ApplicationUser>(currentUser.Id))
.Return(expectedApplicationUser);
expectedGamingGroupInvitations = new List <GamingGroupInvitation>();
expectedGamingGroupInvitation = new GamingGroupInvitation()
{
InviteeEmail = expectedApplicationUser.Email
};
expectedGamingGroupInvitations.Add(expectedGamingGroupInvitation);
expectedGamingGroupInvitations.Add(new GamingGroupInvitation()
{
InviteeEmail = "some other email that shouldnt be included"
});
dataContextMock.Expect(mock => mock.GetQueryable <GamingGroupInvitation>())
.Return(expectedGamingGroupInvitations.AsQueryable());
}
public NewlyRegisteredUser AddNewUserToGamingGroup(string applicationUserId, Guid gamingGroupInvitationId)
{
ApplicationUser userFromDatabase = dataContext.FindById <ApplicationUser>(applicationUserId);
ValidateApplicationUser(userFromDatabase, applicationUserId);
GamingGroupInvitation invitation = dataContext.FindById <GamingGroupInvitation>(gamingGroupInvitationId);
ValidateInvitation(gamingGroupInvitationId, invitation);
this.AssociateUserWithNewGamingGroup(invitation.GamingGroupId, userFromDatabase);
this.UpdateGamingGroupInvitation(invitation, userFromDatabase);
Player player = this.AssociatePlayerWithApplicationUser(invitation, userFromDatabase);
dataContext.CommitAllChanges();
var gamingGroup = dataContext.FindById <GamingGroup>(invitation.GamingGroupId);
return(new NewlyRegisteredUser
{
GamingGroupId = gamingGroup.Id,
GamingGroupName = gamingGroup.Name,
PlayerId = player.Id,
PlayerName = player.Name,
UserId = applicationUserId
});
}
private static void ValidateInvitation(Guid guid, GamingGroupInvitation invitation)
{
if (invitation == null)
{
throw new EntityDoesNotExistException(typeof(GamingGroupInvitation), guid);
}
}
private static void ValidatePlayer(Player player, GamingGroupInvitation invitation)
{
if (player == null)
{
throw new EntityDoesNotExistException(typeof(Player), invitation.PlayerId);
}
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock <IDataContext>();
emailServiceMock = MockRepository.GenerateMock <IIdentityMessageService>();
configurationManagerMock = MockRepository.GenerateMock <IConfigurationManager>();
playerInvitation = new PlayerInvitation
{
CustomEmailMessage = "custom message",
EmailSubject = "email subject",
InvitedPlayerEmail = "player email",
InvitedPlayerId = 1
};
currentUser = new ApplicationUser
{
CurrentGamingGroupId = 15,
UserName = "******"
};
player = new Player
{
Id = playerInvitation.InvitedPlayerId,
GamingGroupId = 135
};
gamingGroup = new GamingGroup
{
Id = currentUser.CurrentGamingGroupId,
Name = "jake's Gaming Group"
};
gamingGroupInvitation = new GamingGroupInvitation
{
Id = Guid.NewGuid()
};
dataContextMock.Expect(mock => mock.FindById <GamingGroup>(currentUser.CurrentGamingGroupId))
.Return(gamingGroup);
List <ApplicationUser> applicationUsers = new List <ApplicationUser>
{
new ApplicationUser
{
Email = playerInvitation.InvitedPlayerEmail,
Id = existingUserId
}
};
dataContextMock.Expect(mock => mock.GetQueryable <ApplicationUser>())
.Return(applicationUsers.AsQueryable());
dataContextMock.Expect(mock => mock.Save <GamingGroupInvitation>(Arg <GamingGroupInvitation> .Is.Anything, Arg <ApplicationUser> .Is.Anything))
.Return(gamingGroupInvitation);
configurationManagerMock.Expect(mock => mock.AppSettings[PlayerInviter.APP_SETTING_URL_ROOT])
.Return(rootUrl);
emailServiceMock.Expect(mock => mock.SendAsync(Arg <IdentityMessage> .Is.Anything))
.Return(Task.FromResult <object>(null));
playerInviter = new PlayerInviter(dataContextMock, emailServiceMock, configurationManagerMock);
}
public void SetUp()
{
dataContextMock = MockRepository.GenerateMock<IDataContext>();
emailServiceMock = MockRepository.GenerateMock<IIdentityMessageService>();
configurationManagerMock = MockRepository.GenerateMock<IConfigurationManager>();
playerInvitation = new PlayerInvitation
{
CustomEmailMessage = "custom message",
EmailSubject = "email subject",
InvitedPlayerEmail = "player email",
InvitedPlayerId = 1
};
currentUser = new ApplicationUser
{
CurrentGamingGroupId = 15,
UserName = "******"
};
player = new Player
{
Id = playerInvitation.InvitedPlayerId,
GamingGroupId = 135
};
gamingGroup = new GamingGroup
{
Id = currentUser.CurrentGamingGroupId,
Name = "jake's Gaming Group"
};
gamingGroupInvitation = new GamingGroupInvitation
{
Id = Guid.NewGuid()
};
dataContextMock.Expect(mock => mock.FindById<GamingGroup>(currentUser.CurrentGamingGroupId))
.Return(gamingGroup);
List<ApplicationUser> applicationUsers = new List<ApplicationUser>
{
new ApplicationUser
{
Email = playerInvitation.InvitedPlayerEmail,
Id = existingUserId
}
};
dataContextMock.Expect(mock => mock.GetQueryable<ApplicationUser>())
.Return(applicationUsers.AsQueryable());
dataContextMock.Expect(mock => mock.Save<GamingGroupInvitation>(Arg<GamingGroupInvitation>.Is.Anything, Arg<ApplicationUser>.Is.Anything))
.Return(gamingGroupInvitation);
configurationManagerMock.Expect(mock => mock.AppSettings[PlayerInviter.APP_SETTING_URL_ROOT])
.Return(rootUrl);
emailServiceMock.Expect(mock => mock.SendAsync(Arg<IdentityMessage>.Is.Anything))
.Return(Task.FromResult<object>(null));
playerInviter = new PlayerInviter(dataContextMock, emailServiceMock, configurationManagerMock);
}
public void ItReturnsTheGamingGroupInvitation()
{
GamingGroupInvitation returnedInvitation = gamingGroupAccessGranter.CreateInvitation(inviteeEmail, currentUser);
IList <object[]> objectsPassedToAddMethod = dataContextMock.GetArgumentsForCallsMadeOn(
mock => mock.Save <GamingGroupInvitation>(Arg <GamingGroupInvitation> .Is.Anything, Arg <ApplicationUser> .Is.Anything));
GamingGroupInvitation savedInvitation = (GamingGroupInvitation)objectsPassedToAddMethod[0][0];
Assert.AreSame(savedInvitation, returnedInvitation);
}
private ApplicationUser ValidateExistingUser(GamingGroupInvitation invitation)
{
var existingUser = this.dataContext.FindById <ApplicationUser>(invitation.RegisteredUserId);
if (existingUser == null)
{
throw new EntityDoesNotExistException(typeof(GamingGroupInvitation), invitation.RegisteredUserId);
}
return(existingUser);
}
public void ItSetsTheRegisteredUserId()
{
GamingGroupInvitation invitation = new GamingGroupInvitation();
gamingGroupAccessGranter.ConsumeInvitation(invitation, currentUser);
dataContextMock.AssertWasCalled(mock => mock.Save(
Arg <GamingGroupInvitation> .Matches(invite => invite.RegisteredUserId == currentUser.Id),
Arg <ApplicationUser> .Is.Same(currentUser)));
}
private Player AssociatePlayerWithApplicationUser(GamingGroupInvitation invitation, ApplicationUser userFromDatabase)
{
Player player = this.dataContext.FindById <Player>(invitation.PlayerId);
ValidatePlayer(player, invitation);
player.ApplicationUserId = userFromDatabase.Id;
this.dataContext.Save(player, userFromDatabase);
return(player);
}
public void SetUp()
{
transformation = new GamingGroupInvitationViewModelBuilder();
gamingGroupInvitation = new GamingGroupInvitation()
{
InviteeEmail = "*****@*****.**",
DateRegistered = DateTime.UtcNow,
RegisteredUser = new ApplicationUser() { UserName = "******" }
};
invitationViewModel = transformation.Build(gamingGroupInvitation);
}
public GamingGroupInvitation CreateInvitation(string email, ApplicationUser currentUser)
{
GamingGroupInvitation invitation = new GamingGroupInvitation()
{
InviteeEmail = email,
GamingGroupId = currentUser.CurrentGamingGroupId,
InvitingUserId = currentUser.Id,
DateSent = DateTime.UtcNow.Date
};
dataContext.Save <GamingGroupInvitation>(invitation, currentUser);
return(invitation);
}
private void SaveGamingGroupInvitations(NemeStatsDbContext nemeStatsDbContext, IDataContext dataContext)
{
EntityFrameworkGamingGroupAccessGranter accessGranter = new EntityFrameworkGamingGroupAccessGranter(dataContext);
testUnredeemedGamingGroupInvitation = accessGranter.CreateInvitation(testUserWithDefaultGamingGroup.Email, testUserWithDefaultGamingGroup);
dataContext.CommitAllChanges();
testAlreadyRedeemedGamingGroupInvitation = accessGranter.CreateInvitation(testUserWithOtherGamingGroup.Email, testUserWithDefaultGamingGroup);
//TODO simulating registration. Will need a separate method for this soon so this logic can be replaced
testAlreadyRedeemedGamingGroupInvitation.DateRegistered = DateTime.UtcNow.AddDays(1);
testAlreadyRedeemedGamingGroupInvitation.RegisteredUserId = testUserWithOtherGamingGroup.Id;
nemeStatsDbContext.GamingGroupInvitations.Add(testAlreadyRedeemedGamingGroupInvitation);
nemeStatsDbContext.SaveChanges();
}
public void LocalSetUp()
{
expectedInvitation = new GamingGroupInvitation
{
GamingGroupId = 1,
PlayerId = 2
};
expectedGamingGroup = new GamingGroup
{
Id = expectedInvitation.GamingGroupId,
Name = "some awesome gaming group name"
};
dataContextMock.Expect(mock => mock.FindById<GamingGroup>(expectedInvitation.GamingGroupId)).Return(expectedGamingGroup);
expectedPlayer = new Player();
}
public void SetUp()
{
transformation = new GamingGroupInvitationViewModelBuilder();
gamingGroupInvitation = new GamingGroupInvitation()
{
InviteeEmail = "*****@*****.**",
DateRegistered = DateTime.UtcNow,
RegisteredUser = new ApplicationUser()
{
UserName = "******"
}
};
invitationViewModel = transformation.Build(gamingGroupInvitation);
}
public void LocalSetUp()
{
expectedInvitation = new GamingGroupInvitation
{
GamingGroupId = 1,
PlayerId = 2
};
expectedGamingGroup = new GamingGroup
{
Id = expectedInvitation.GamingGroupId,
Name = "some awesome gaming group name"
};
dataContextMock.Expect(mock => mock.FindById <GamingGroup>(expectedInvitation.GamingGroupId)).Return(expectedGamingGroup);
expectedPlayer = new Player();
}
private void CleanUpGamingGroupInvitation(string inviteeEmail)
{
GamingGroupInvitation invitation = (from gamingGroupInvitation in _nemeStatsDbContext.GamingGroupInvitations
where gamingGroupInvitation.InviteeEmail == inviteeEmail
select gamingGroupInvitation).FirstOrDefault();
if (invitation != null)
{
try
{
_nemeStatsDbContext.GamingGroupInvitations.Remove(invitation);
}
catch (Exception) { }
}
}
public void InvitePlayer(PlayerInvitation playerInvitation, ApplicationUser currentUser)
{
var gamingGroup = _dataContext.FindById <GamingGroup>(playerInvitation.GamingGroupId);
var existingUserId = (from ApplicationUser user in _dataContext.GetQueryable <ApplicationUser>()
where user.Email == playerInvitation.InvitedPlayerEmail
select user.Id).FirstOrDefault();
var gamingGroupInvitation = new GamingGroupInvitation
{
DateSent = DateTime.UtcNow,
GamingGroupId = playerInvitation.GamingGroupId,
InviteeEmail = playerInvitation.InvitedPlayerEmail,
InvitingUserId = currentUser.Id,
PlayerId = playerInvitation.InvitedPlayerId,
RegisteredUserId = existingUserId
};
var savedGamingGroupInvitation = _dataContext.Save(gamingGroupInvitation, currentUser);
//commit so we can get the Id back
_dataContext.CommitAllChanges();
var urlRoot = _configurationManager.AppSettings[APP_SETTING_URL_ROOT];
var customMessage = string.Empty;
if (!string.IsNullOrWhiteSpace(playerInvitation.CustomEmailMessage))
{
customMessage = $"{currentUser.UserName} says: {playerInvitation.CustomEmailMessage}";
}
var messageBody = $@"Well hello there! You've been invited by '{currentUser.UserName}' to join the NemeStats Gaming Group called '{gamingGroup.Name}'!
To join this Gaming Group, click on the following link: {urlRoot}/Account/ConsumeInvitation/{savedGamingGroupInvitation.Id} <br/><br/>
{customMessage} <br/><br/>
If you believe you've received this in error just disregard the email.";
var message = new IdentityMessage
{
Body = messageBody,
Destination = playerInvitation.InvitedPlayerEmail,
Subject = playerInvitation.EmailSubject
};
_emailService.SendAsync(message);
}
public void InvitePlayer(PlayerInvitation playerInvitation, ApplicationUser currentUser)
{
if (!currentUser.CurrentGamingGroupId.HasValue)
{
throw new UserHasNoGamingGroupException(currentUser.Id);
}
GamingGroup gamingGroup = dataContext.FindById <GamingGroup>(currentUser.CurrentGamingGroupId);
string existingUserId = (from ApplicationUser user in dataContext.GetQueryable <ApplicationUser>()
where user.Email == playerInvitation.InvitedPlayerEmail
select user.Id).FirstOrDefault();
GamingGroupInvitation gamingGroupInvitation = new GamingGroupInvitation
{
DateSent = DateTime.UtcNow,
GamingGroupId = currentUser.CurrentGamingGroupId.Value,
InviteeEmail = playerInvitation.InvitedPlayerEmail,
InvitingUserId = currentUser.Id,
PlayerId = playerInvitation.InvitedPlayerId,
RegisteredUserId = existingUserId
};
GamingGroupInvitation savedGamingGroupInvitation = dataContext.Save <GamingGroupInvitation>(gamingGroupInvitation, currentUser);
//commit so we can get the Id back
dataContext.CommitAllChanges();
string urlRoot = configurationManager.AppSettings[APP_SETTING_URL_ROOT];
string messageBody = string.Format(PlayerInviter.EMAIL_MESSAGE_INVITE_PLAYER,
currentUser.UserName,
gamingGroup.Name,
urlRoot,
playerInvitation.CustomEmailMessage,
savedGamingGroupInvitation.Id,
"<br/><br/>");
var message = new IdentityMessage
{
Body = messageBody,
Destination = playerInvitation.InvitedPlayerEmail,
Subject = playerInvitation.EmailSubject
};
emailService.SendAsync(message);
}
public InvitationViewModel Build(GamingGroupInvitation invitation)
{
InvitationViewModel viewModel = new InvitationViewModel()
{
InviteeEmail = invitation.InviteeEmail,
DateRegistered = invitation.DateRegistered
};
if(invitation.RegisteredUser == null)
{
viewModel.RegisteredUserName = string.Empty;
}else
{
viewModel.RegisteredUserName = invitation.RegisteredUser.UserName;
}
return viewModel;
}
private void AddNewGamingGroupAssociation(GamingGroupInvitation invitation)
{
UserGamingGroup userGamingGroup = dataContext.GetQueryable <UserGamingGroup>()
.FirstOrDefault(
ugg => ugg.ApplicationUserId == invitation.RegisteredUserId &&
ugg.GamingGroupId == invitation.GamingGroupId);
if (userGamingGroup == null)
{
var newGamingGroupAssociation = new UserGamingGroup
{
ApplicationUserId = invitation.RegisteredUserId,
GamingGroupId = invitation.GamingGroupId
};
//ApplicationUser is not used when saving new entities -- just has to be not-null
this.dataContext.Save(newGamingGroupAssociation, new ApplicationUser());
}
}
public InvitationViewModel Build(GamingGroupInvitation invitation)
{
InvitationViewModel viewModel = new InvitationViewModel()
{
InviteeEmail = invitation.InviteeEmail,
DateRegistered = invitation.DateRegistered
};
if (invitation.RegisteredUser == null)
{
viewModel.RegisteredUserName = string.Empty;
}
else
{
viewModel.RegisteredUserName = invitation.RegisteredUser.UserName;
}
return(viewModel);
}
public async Task <int?> ConsumeGamingGroupInvitation(ApplicationUser currentUser)
{
IList <GamingGroupInvitation> gamingGroupInvitations
= pendingGamingGroupRetriever.GetPendingGamingGroupInvitations(currentUser);
if (gamingGroupInvitations.Count == 0)
{
return(null);
}
ApplicationUser user = await userManager.FindByIdAsync(currentUser.Id);
GamingGroupInvitation oldestInvite = gamingGroupInvitations.OrderBy(invite => invite.DateSent).First();
user.CurrentGamingGroupId = oldestInvite.GamingGroupId;
userManager.Update(user);
gamingGroupAccessGranter.ConsumeInvitation(oldestInvite, currentUser);
return(user.CurrentGamingGroupId);
}
public void InvitePlayer(PlayerInvitation playerInvitation, ApplicationUser currentUser)
{
GamingGroup gamingGroup = dataContext.FindById<GamingGroup>(currentUser.CurrentGamingGroupId);
string existingUserId = (from ApplicationUser user in dataContext.GetQueryable<ApplicationUser>()
where user.Email == playerInvitation.InvitedPlayerEmail
select user.Id).FirstOrDefault();
GamingGroupInvitation gamingGroupInvitation = new GamingGroupInvitation
{
DateSent = DateTime.UtcNow,
GamingGroupId = currentUser.CurrentGamingGroupId,
InviteeEmail = playerInvitation.InvitedPlayerEmail,
InvitingUserId = currentUser.Id,
PlayerId = playerInvitation.InvitedPlayerId,
RegisteredUserId = existingUserId
};
GamingGroupInvitation savedGamingGroupInvitation = dataContext.Save<GamingGroupInvitation>(gamingGroupInvitation, currentUser);
//commit so we can get the Id back
dataContext.CommitAllChanges();
string urlRoot = configurationManager.AppSettings[APP_SETTING_URL_ROOT];
string messageBody = string.Format(PlayerInviter.EMAIL_MESSAGE_INVITE_PLAYER,
currentUser.UserName,
gamingGroup.Name,
urlRoot,
playerInvitation.CustomEmailMessage,
savedGamingGroupInvitation.Id,
"<br/><br/>");
var message = new IdentityMessage
{
Body = messageBody,
Destination = playerInvitation.InvitedPlayerEmail,
Subject = playerInvitation.EmailSubject
};
emailService.SendAsync(message);
}
public override void SetUp()
{
base.SetUp();
invitation = new GamingGroupInvitation
{
Id = gamingGroupInvitationId
};
userGamingGroups = new List <UserGamingGroup>
{
new UserGamingGroup
{
ApplicationUserId = currentUser.Id,
GamingGroupId = gamingGroupId
}
};
player = new Player();
dataContextMock.Expect(mock => mock.FindById <Player>(invitation.PlayerId))
.Return(player);
}
public override void SetUp()
{
base.SetUp();
invitation = new GamingGroupInvitation
{
Id = gamingGroupInvitationId
};
userGamingGroups = new List<UserGamingGroup>
{
new UserGamingGroup
{
ApplicationUserId = currentUser.Id,
GamingGroupId = gamingGroupId
}
};
player = new Player();
dataContextMock.Expect(mock => mock.FindById<Player>(invitation.PlayerId))
.Return(player);
}
public void SetUp()
{
firstTimeUserAuthenticatorMock = MockRepository.GenerateMock <IFirstTimeAuthenticator>();
userStoreMock = MockRepository.GenerateMock <IUserStore <ApplicationUser> >();
var dataProtector = MockRepository.GenerateMock <IDataProtector>();
dataProtectionProviderMock = MockRepository.GenerateMock <IDataProtectionProvider>();
dataProtectionProviderMock.Expect(mock => mock.Create(Arg <string> .Is.Anything)).Return(dataProtector);
applicationUserManagerMock = MockRepository.GenerateMock <ApplicationUserManager>(userStoreMock, dataProtectionProviderMock);
authenticationManagerMock = MockRepository.GenerateMock <IAuthenticationManager>();
signInManagerMock = MockRepository.GenerateMock <ApplicationSignInManager>(applicationUserManagerMock, authenticationManagerMock);
dataContextMock = MockRepository.GenerateMock <IDataContext>();
eventTrackerMock = MockRepository.GenerateMock <INemeStatsEventTracker>();
gamingGroupInviteConsumerMock = MockRepository.GenerateMock <IGamingGroupInviteConsumer>();
userRegisterer = new UserRegisterer(
applicationUserManagerMock,
firstTimeUserAuthenticatorMock,
dataContextMock,
signInManagerMock,
eventTrackerMock,
gamingGroupInviteConsumerMock);
Guid invitationId = Guid.NewGuid();
const int PLAYER_ID = 1938;
GamingGroupInvitation invitation = new GamingGroupInvitation
{
Id = invitationId,
PlayerId = PLAYER_ID,
GamingGroupId = 10
};
newUser = new NewUser()
{
UserName = "******",
EmailAddress = "the email",
GamingGroupInvitationId = invitationId,
Source = TransactionSource.WebApplication
};
expectedNewlyRegisteredUser = new NewlyRegisteredUser
{
GamingGroupId = invitation.GamingGroupId,
GamingGroupName = "some awesome gaming group name",
PlayerId = PLAYER_ID,
PlayerName = "some awesome player name",
UserId = applicationUserIdAfterSaving
};
IdentityResult result = IdentityResult.Success;
dataContextMock.Expect(mock => mock.FindById <GamingGroupInvitation>(invitationId))
.Return(invitation);
applicationUserManagerMock.Expect(mock => mock.CreateAsync(Arg <ApplicationUser> .Is.Anything, Arg <string> .Is.Anything))
.Return(Task.FromResult(result))
.WhenCalled(invocation => ((ApplicationUser)invocation.Arguments[0]).Id = applicationUserIdAfterSaving);
signInManagerMock.Expect(mock => mock.SignInAsync(
Arg <ApplicationUser> .Is.Anything,
Arg <bool> .Is.Anything,
Arg <bool> .Is.Anything))
.Return(Task.FromResult(-1));
gamingGroupInviteConsumerMock.Expect(mock => mock.AddNewUserToGamingGroup(Arg <string> .Is.Anything, Arg <Guid> .Is.Anything))
.Return(expectedNewlyRegisteredUser);
firstTimeUserAuthenticatorMock.Expect(mock => mock.CreateGamingGroupAndSendEmailConfirmation(
Arg <ApplicationUser> .Is.Anything,
Arg <TransactionSource> .Is.Anything))
.Return(Task.FromResult(expectedNewlyRegisteredUser));
}
private void AddNewGamingGroupAssociation(GamingGroupInvitation invitation)
{
var userGamingGroup = dataContext.GetQueryable<UserGamingGroup>()
.FirstOrDefault(
ugg => ugg.ApplicationUserId == invitation.RegisteredUserId
&& ugg.GamingGroupId == invitation.GamingGroupId);
if (userGamingGroup == null)
{
var newGamingGroupAssociation = new UserGamingGroup
{
ApplicationUserId = invitation.RegisteredUserId,
GamingGroupId = invitation.GamingGroupId
};
//ApplicationUser is not used when saving new entities -- just has to be not-null
dataContext.Save(newGamingGroupAssociation, new ApplicationUser());
}
}
private ApplicationUser ValidateExistingUser(GamingGroupInvitation invitation)
{
var existingUser = dataContext.FindById<ApplicationUser>(invitation.RegisteredUserId);
if (existingUser == null)
{
throw new EntityDoesNotExistException(typeof(GamingGroupInvitation), invitation.RegisteredUserId);
}
return existingUser;
}
private static void ValidatePlayer(Player player, GamingGroupInvitation invitation)
{
if (player == null)
{
throw new EntityDoesNotExistException(typeof(Player), invitation.PlayerId);
}
}
private void UpdateGamingGroupInvitation(GamingGroupInvitation invitation, ApplicationUser userFromDatabase)
{
invitation.RegisteredUserId = userFromDatabase.Id;
invitation.DateRegistered = DateTime.UtcNow;
dataContext.Save(invitation, userFromDatabase);
}
private static void ValidateInvitation(Guid guid, GamingGroupInvitation invitation)
{
if (invitation == null)
{
throw new EntityDoesNotExistException(typeof(GamingGroupInvitation), guid);
}
}
private Player AssociatePlayerWithApplicationUser(GamingGroupInvitation invitation, ApplicationUser userFromDatabase)
{
var player = dataContext.FindById<Player>(invitation.PlayerId);
ValidatePlayer(player, invitation);
player.ApplicationUserId = userFromDatabase.Id;
dataContext.Save(player, userFromDatabase);
return player;
}
private void SwitchCurrentGamingGroup(ApplicationUser existingUser, GamingGroupInvitation invitation)
{
existingUser.CurrentGamingGroupId = invitation.GamingGroupId;
dataContext.Save(existingUser, new ApplicationUser());
}
public void SetUp()
{
playerWithNemesisViewModelBuilderMock = MockRepository.GenerateMock <IPlayerWithNemesisViewModelBuilder>();
playedGameDetailsViewModelBuilderMock = MockRepository.GenerateMock <IPlayedGameDetailsViewModelBuilder>();
gameDefinitionSummaryViewModelBuilderMock = MockRepository.GenerateMock <IGameDefinitionSummaryViewModelBuilder>();
transformer = new GamingGroupViewModelBuilder(
playedGameDetailsViewModelBuilderMock,
playerWithNemesisViewModelBuilderMock,
gameDefinitionSummaryViewModelBuilderMock);
players = new List <PlayerWithNemesis>()
{
new PlayerWithNemesis()
{
PlayerId = 1
},
new PlayerWithNemesis()
{
PlayerId = 2
}
};
gameDefinitionSummaries = new List <GameDefinitionSummary>
{
new GameDefinitionSummary {
Id = 1
},
new GameDefinitionSummary {
Id = 2
}
};
playedGames = new List <PlayedGame>();
ApplicationUser owningUser = new ApplicationUser()
{
Id = "owning user user Id",
Email = "*****@*****.**",
UserName = "******"
};
ApplicationUser registeredUser = new ApplicationUser()
{
Email = "*****@*****.**",
Id = "registered user id",
UserName = "******"
};
GamingGroupInvitation invitation = new GamingGroupInvitation()
{
DateRegistered = DateTime.UtcNow,
RegisteredUserId = "registered user id",
RegisteredUser = registeredUser
};
gamingGroupSummary = new GamingGroupSummary()
{
Id = 1,
Name = "gaming group",
OwningUserId = owningUser.Id,
OwningUser = owningUser,
GamingGroupInvitations = new List <GamingGroupInvitation>()
{
invitation
},
Players = players,
GameDefinitionSummaries = gameDefinitionSummaries,
PlayedGames = playedGames
};
playedGameDetailsViewModelBuilderMock.Expect(mock => mock.Build(
Arg <PlayedGame> .Is.Anything,
Arg <ApplicationUser> .Is.Anything))
.Return(new PlayedGameDetailsViewModel());
currentUser = new ApplicationUser();
foreach (PlayerWithNemesis playerWithNemesis in players)
{
playerWithNemesisViewModelBuilderMock.Expect(mock => mock.Build(playerWithNemesis, this.currentUser))
.Return(new PlayerWithNemesisViewModel()
{
PlayerId = playerWithNemesis.PlayerId
});
}
foreach (GameDefinitionSummary summary in gameDefinitionSummaries)
{
gameDefinitionSummaryViewModelBuilderMock.Expect(mock => mock.Build(summary, currentUser))
.Return(new GameDefinitionSummaryViewModel {
Id = summary.Id
});
}
viewModel = transformer.Build(gamingGroupSummary, currentUser);
}
public void SetUp()
{
playerWithNemesisViewModelBuilderMock = MockRepository.GenerateMock<IPlayerWithNemesisViewModelBuilder>();
playedGameDetailsViewModelBuilderMock = MockRepository.GenerateMock<IPlayedGameDetailsViewModelBuilder>();
gameDefinitionSummaryViewModelBuilderMock = MockRepository.GenerateMock<IGameDefinitionSummaryViewModelBuilder>();
transformer = new GamingGroupViewModelBuilder(
playedGameDetailsViewModelBuilderMock,
playerWithNemesisViewModelBuilderMock,
gameDefinitionSummaryViewModelBuilderMock);
players = new List<PlayerWithNemesis>()
{
new PlayerWithNemesis(){ PlayerId = 1 },
new PlayerWithNemesis(){ PlayerId = 2 }
};
gameDefinitionSummaries = new List<GameDefinitionSummary>
{
new GameDefinitionSummary{ Id = 1 },
new GameDefinitionSummary{ Id = 2 }
};
playedGames = new List<PlayedGame>();
ApplicationUser owningUser = new ApplicationUser()
{
Id = "owning user user Id",
Email = "*****@*****.**",
UserName = "******"
};
ApplicationUser registeredUser = new ApplicationUser()
{
Email = "*****@*****.**",
Id = "registered user id",
UserName = "******"
};
GamingGroupInvitation invitation = new GamingGroupInvitation()
{
DateRegistered = DateTime.UtcNow,
RegisteredUserId = "registered user id",
RegisteredUser = registeredUser
};
gamingGroupSummary = new GamingGroupSummary()
{
Id = 1,
Name = "gaming group",
OwningUserId = owningUser.Id,
OwningUser = owningUser,
GamingGroupInvitations = new List<GamingGroupInvitation>() { invitation },
Players = players,
GameDefinitionSummaries = gameDefinitionSummaries,
PlayedGames = playedGames
};
playedGameDetailsViewModelBuilderMock.Expect(mock => mock.Build(
Arg<PlayedGame>.Is.Anything,
Arg<ApplicationUser>.Is.Anything,
Arg<bool>.Is.Anything))
.Return(new PlayedGameDetailsViewModel());
currentUser = new ApplicationUser();
foreach(PlayerWithNemesis playerWithNemesis in players)
{
playerWithNemesisViewModelBuilderMock.Expect(mock => mock.Build(playerWithNemesis, this.currentUser))
.Return(new PlayerWithNemesisViewModel() { PlayerId = playerWithNemesis.PlayerId });
}
foreach (GameDefinitionSummary summary in gameDefinitionSummaries)
{
gameDefinitionSummaryViewModelBuilderMock.Expect(mock => mock.Build(summary, currentUser))
.Return(new GameDefinitionSummaryViewModel { Id = summary.Id });
}
viewModel = transformer.Build(gamingGroupSummary, currentUser);
}
private void UpdateGamingGroupInvitation(GamingGroupInvitation invitation, ApplicationUser userFromDatabase)
{
invitation.RegisteredUserId = userFromDatabase.Id;
invitation.DateRegistered = DateTime.UtcNow;
this.dataContext.Save(invitation, userFromDatabase);
}
public void SetUp()
{
firstTimeUserAuthenticatorMock = MockRepository.GenerateMock<IFirstTimeAuthenticator>();
userStoreMock = MockRepository.GenerateMock<IUserStore<ApplicationUser>>();
var dataProtector = MockRepository.GenerateMock<IDataProtector>();
dataProtectionProviderMock = MockRepository.GenerateMock<IDataProtectionProvider>();
dataProtectionProviderMock.Expect(mock => mock.Create(Arg<string>.Is.Anything)).Return(dataProtector);
applicationUserManagerMock = MockRepository.GenerateMock<ApplicationUserManager>(userStoreMock, dataProtectionProviderMock);
authenticationManagerMock = MockRepository.GenerateMock<IAuthenticationManager>();
signInManagerMock = MockRepository.GenerateMock<ApplicationSignInManager>(applicationUserManagerMock, authenticationManagerMock);
dataContextMock = MockRepository.GenerateMock<IDataContext>();
eventTrackerMock = MockRepository.GenerateMock<INemeStatsEventTracker>();
gamingGroupInviteConsumerMock = MockRepository.GenerateMock<IGamingGroupInviteConsumer>();
userRegisterer = new UserRegisterer(
applicationUserManagerMock,
firstTimeUserAuthenticatorMock,
dataContextMock,
signInManagerMock,
eventTrackerMock,
gamingGroupInviteConsumerMock);
Guid invitationId = Guid.NewGuid();
const int PLAYER_ID = 1938;
GamingGroupInvitation invitation = new GamingGroupInvitation
{
Id = invitationId,
PlayerId = PLAYER_ID,
GamingGroupId = 10
};
newUser = new NewUser()
{
UserName = "******",
EmailAddress = "the email",
GamingGroupInvitationId = invitationId,
Source = TransactionSource.WebApplication
};
expectedNewlyRegisteredUser = new NewlyRegisteredUser
{
GamingGroupId = invitation.GamingGroupId,
GamingGroupName = "some awesome gaming group name",
PlayerId = PLAYER_ID,
PlayerName = "some awesome player name",
UserId = applicationUserIdAfterSaving
};
IdentityResult result = IdentityResult.Success;
dataContextMock.Expect(mock => mock.FindById<GamingGroupInvitation>(invitationId))
.Return(invitation);
applicationUserManagerMock.Expect(mock => mock.CreateAsync(Arg<ApplicationUser>.Is.Anything, Arg<string>.Is.Anything))
.Return(Task.FromResult(result))
.WhenCalled(invocation => ((ApplicationUser)invocation.Arguments[0]).Id = applicationUserIdAfterSaving);
signInManagerMock.Expect(mock => mock.SignInAsync(
Arg<ApplicationUser>.Is.Anything,
Arg<bool>.Is.Anything,
Arg<bool>.Is.Anything))
.Return(Task.FromResult(-1));
gamingGroupInviteConsumerMock.Expect(mock => mock.AddNewUserToGamingGroup(Arg<string>.Is.Anything, Arg<Guid>.Is.Anything))
.Return(expectedNewlyRegisteredUser);
firstTimeUserAuthenticatorMock.Expect(mock => mock.CreateGamingGroupAndSendEmailConfirmation(
Arg<ApplicationUser>.Is.Anything,
Arg<TransactionSource>.Is.Anything))
.Return(Task.FromResult(expectedNewlyRegisteredUser));
}
public GamingGroupInvitation ConsumeInvitation(GamingGroupInvitation gamingGroupInvitation, ApplicationUser currentUser)
{
gamingGroupInvitation.DateRegistered = DateTime.UtcNow;
gamingGroupInvitation.RegisteredUserId = currentUser.Id;
return(dataContext.Save <GamingGroupInvitation>(gamingGroupInvitation, currentUser));
}
private void SwitchCurrentGamingGroup(ApplicationUser existingUser, GamingGroupInvitation invitation)
{
existingUser.CurrentGamingGroupId = invitation.GamingGroupId;
this.dataContext.Save(existingUser, new ApplicationUser());
}
