protected void CreateUserAndApplication(IAdoNetUnitOfWork uow, out int accountId, out int applicationId)
{
var accountRepos = new AccountRepository(uow);
var account = new Account(TestUser.Username, TestUser.Password)
{
Email = TestUser.Email
};
account.Activate();
accountRepos.Create(account);
var userRepos = new UserRepository(uow);
var user = new User(account.Id, TestUser.Username)
{
EmailAddress = TestUser.Email
};
userRepos.CreateAsync(user).GetAwaiter().GetResult();
var appRepos = new ApplicationRepository(uow);
var app = new Application(account.Id, "MyTestApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
appRepos.CreateAsync(app).GetAwaiter().GetResult();
var member = new ApplicationTeamMember(app.Id, account.Id, "Admin");
appRepos.CreateAsync(member).GetAwaiter().GetResult();
accountId = user.AccountId;
applicationId = app.Id;
}
public JsonResult UpdateUserRole(int appId, int memberId, string roleToUpdate)
{
if (!Repository.Managers.ApplicationBuildMgr.IsUserAnAppTeamMember(User.Identity.GetUserName(), appId, Constants.APPLICATION_MEMBER_ROLE_ADMINISTRATOR))
{
return(Json(new {
Status = "Error",
Msg = "You are not a administrator of this app"
}));
}
using (var context = new Repository.BetaDepotContext())
{
ApplicationTeamMember membership = context.ApplicationTeamMembers
.Where(w => w.TeamMemberId == memberId &&
w.ApplicationId == appId)
.FirstOrDefault();
if (membership != null)
{
membership.MemberRole = roleToUpdate.ToUpper();
}
context.SaveChanges();
}
return(Json(new
{
Status = "OK",
Msg = ""
}));
}
public async Task HandleAsync(IMessageContext context, AddTeamMember message)
{
var member = new ApplicationTeamMember(message.ApplicationId, message.UserToAdd,
context.Principal.Identity.Name);
await _applicationRepository.CreateAsync(member);
}
public void CreateUser(TestUser testUser, int applicationId)
{
using (var uow = CreateUnitOfWork())
{
var accountRepos = new AccountRepository(uow);
var account = new Account(testUser.Username, testUser.Password)
{
Email = testUser.Email
};
account.Activate();
accountRepos.Create(account);
var userRepos = new UserRepository(uow);
var user = new User(account.Id, testUser.Username)
{
EmailAddress = testUser.Email
};
userRepos.CreateAsync(user).GetAwaiter().GetResult();
var appRepos = new ApplicationRepository(uow);
var member = new ApplicationTeamMember(applicationId, account.Id, "Admin");
appRepos.CreateAsync(member).GetAwaiter().GetResult();
uow.SaveChanges();
}
}
public async Task ExecuteAsync(InviteUser command)
{
var inviter = await _userRepository.GetUserAsync(command.UserId);
var invitedUser = await _userRepository.FindByEmailAsync(command.EmailAddress);
if (invitedUser != null)
{
var member = new ApplicationTeamMember(command.ApplicationId, invitedUser.AccountId)
{
AddedByName = inviter.UserName,
Roles = new[] { ApplicationRole.Member }
};
await _applicationRepository.CreateAsync(member);
await _eventBus.PublishAsync(new UserAddedToApplication(command.ApplicationId, member.AccountId));
return;
}
var invitedMember = new ApplicationTeamMember(command.ApplicationId, command.EmailAddress)
{
AddedByName = inviter.UserName,
Roles = new[] { ApplicationRole.Member }
};
await _applicationRepository.CreateAsync(invitedMember);
var invitation = await _invitationRepository.FindByEmailAsync(command.EmailAddress);
if (invitation == null)
{
invitation = new Invitation(command.EmailAddress, inviter.UserName);
await _invitationRepository.CreateAsync(invitation);
await SendInvitationEmailAsync(invitation, command.Text);
}
invitation.Add(command.ApplicationId, inviter.UserName);
await _invitationRepository.UpdateAsync(invitation);
var app = await _applicationRepository.GetByIdAsync(command.ApplicationId);
var evt = new UserInvitedToApplication(
invitation.InvitationKey,
command.ApplicationId,
app.Name,
command.EmailAddress,
inviter.UserName);
await _eventBus.PublishAsync(evt);
}
public ActionResult AcceptInvite(string uHash, string rHash, int appId, string userName)
{
string platform = string.Empty;
if (uHash != null &&
rHash != null &&
appId > 0 &&
userName != null)
{
using (var context = new Repository.BetaDepotContext())
{
Application app = context.Applications.Where(w => w.Id == appId).FirstOrDefault();
platform = app.Platform;
TeamMember member = context.TeamMembers.Where(w => w.UserName == userName).FirstOrDefault();
if (app != null && member != null)
{
if (isUserInviteTokenValid(app.ApplicationIdentifier, userName, uHash))
{
if (Repository.Managers.ApplicationBuildMgr.IsUserAnAppTeamMember(userName, appId))
{
throw new HttpException(400, "Your invite is invalid.");
}
string role = getRoleFromRoleInviteToken(app.ApplicationIdentifier, rHash);
if (role != null)
{
ApplicationTeamMember membership = new ApplicationTeamMember()
{
TeamMember = member,
MemberRole = role
};
app.AssignedMembers.Add(membership);
context.SaveChanges();
}
else
{
throw new HttpException(400, "Your invite is invalid.");
}
}
}
else
{
throw new HttpException(400, "Your invite is invalid.");
}
}
}
return(RedirectToAction("Index", "Platform", new { id = platform }));
}
public int CreateApplication(string name, int accountId)
{
using (var uow = CreateUnitOfWork())
{
var appRepos = new ApplicationRepository(uow);
var app = new Application(accountId, "MyTestApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
appRepos.CreateAsync(app).GetAwaiter().GetResult();
var member = new ApplicationTeamMember(app.Id, accountId, "Admin");
appRepos.CreateAsync(member).GetAwaiter().GetResult();
uow.SaveChanges();
return(app.Id);
}
}
public async Task should_send_an_invitation_email()
{
var cmd = new InviteUser(1, "*****@*****.**")
{
UserId = 1
};
var members = new[] { new ApplicationTeamMember(1, 3) };
ApplicationTeamMember actual = null;
_applicationRepository.GetTeamMembersAsync(1).Returns(members);
_applicationRepository.WhenForAnyArgs(x => x.CreateAsync(Arg.Any <ApplicationTeamMember>()))
.Do(x => actual = x.Arg <ApplicationTeamMember>());
await _sut.ExecuteAsync(cmd);
_commandBus.Received().ExecuteAsync(Arg.Any <SendEmail>());
}
public async Task should_notify_the_system_of_the_invite()
{
var cmd = new InviteUser(1, "*****@*****.**")
{
UserId = 1
};
var members = new[] { new ApplicationTeamMember(1, 3) };
ApplicationTeamMember actual = null;
_applicationRepository.GetTeamMembersAsync(1).Returns(members);
_applicationRepository.WhenForAnyArgs(x => x.CreateAsync(Arg.Any <ApplicationTeamMember>()))
.Do(x => actual = x.Arg <ApplicationTeamMember>());
await _sut.ExecuteAsync(cmd);
_applicationRepository.Received().CreateAsync(Arg.Any <ApplicationTeamMember>());
_eventBus.Received().PublishAsync(Arg.Any <UserInvitedToApplication>());
}
public async Task Should_send_an_invitation_email()
{
var cmd = new InviteUser(1, "*****@*****.**")
{
UserId = 1
};
var members = new[] { new ApplicationTeamMember(1, 3, "karl") };
ApplicationTeamMember actual = null;
_applicationRepository.GetTeamMembersAsync(1).Returns(members);
_applicationRepository.WhenForAnyArgs(x => x.CreateAsync(Arg.Any <ApplicationTeamMember>()))
.Do(x => actual = x.Arg <ApplicationTeamMember>());
_context.Principal.Returns(CreateAdminPrincipal());
await _sut.HandleAsync(_context, cmd);
await _context.Received().SendAsync(Arg.Any <SendEmail>());
}
public void CreateUserAndApp()
{
using (var uow = CreateUnitOfWork())
{
var accountRepos = new AccountRepository(uow);
var account = new Account("arne", "123456")
{
Email = "*****@*****.**"
};
accountRepos.Create(account);
var userRepos = new UserRepository(uow);
var user = new User(account.Id, "arne")
{
EmailAddress = "*****@*****.**"
};
userRepos.CreateAsync(user).GetAwaiter().GetResult();
var appRepos = new ApplicationRepository(uow);
var app = new Application(account.Id, "MinApp");
appRepos.CreateAsync(app).GetAwaiter().GetResult();
var member = new ApplicationTeamMember(app.Id, account.Id, "Admin");
appRepos.CreateAsync(member).GetAwaiter().GetResult();
var report = new ErrorReportEntity(app.Id, Guid.NewGuid().ToString("N"), DateTime.UtcNow,
new ErrorReportException(new Exception("mofo")),
new List <ErrorReportContext> {
new ErrorReportContext("Maps", new Dictionary <string, string>())
});
report.Title = "Missing here";
report.Init(report.GenerateHashCodeIdentifier());
var incident = new ReportAnalyzer.Domain.Incidents.IncidentBeingAnalyzed(report);
var incRepos = new AnalyticsRepository(new AnalysisDbContext(uow), ConfigStore);
incRepos.CreateIncident(incident);
report.IncidentId = incident.Id;
incRepos.CreateReport(report);
uow.SaveChanges();
}
}
public async Task should_create_an_invite_for_a_new_user()
{
var cmd = new InviteUser(1, "*****@*****.**")
{
UserId = 1
};
var members = new[] { new ApplicationTeamMember(1, 3) };
ApplicationTeamMember actual = null;
_applicationRepository.GetTeamMembersAsync(1).Returns(members);
_applicationRepository.WhenForAnyArgs(x => x.CreateAsync(Arg.Any <ApplicationTeamMember>()))
.Do(x => actual = x.Arg <ApplicationTeamMember>());
await _sut.ExecuteAsync(cmd);
_applicationRepository.Received().CreateAsync(Arg.Any <ApplicationTeamMember>());
actual.EmailAddress.Should().Be(cmd.EmailAddress);
actual.ApplicationId.Should().Be(cmd.ApplicationId);
actual.AddedAtUtc.Should().BeCloseTo(DateTime.UtcNow, 1000);
actual.AddedByName.Should().Be("First");
}
public async Task <ActionResult> Admin(AccountViewModel model)
{
SetStateFlag();
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var account = new Account(model.UserName, model.Password);
account.Activate();
account.IsSysAdmin = true;
var con = SetupTools.DbTools.OpenConnection();
var uow = new AdoNetUnitOfWork(con);
var repos = new AccountRepository(uow);
if (await repos.IsUserNameTakenAsync(model.UserName))
{
return(Redirect(Url.GetNextWizardStep()));
}
account.SetVerifiedEmail(model.EmailAddress);
await repos.CreateAsync(account);
var user = new User(account.Id, account.UserName)
{
EmailAddress = account.Email
};
var userRepos = new UserRepository(uow);
await userRepos.CreateAsync(user);
var repos2 = new ApplicationRepository(uow);
var app = new Application(user.AccountId, "DemoApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
await repos2.CreateAsync(app);
var tm = new ApplicationTeamMember(app.Id, account.Id, "System")
{
Roles = new[] { ApplicationRole.Admin, ApplicationRole.Member },
UserName = account.UserName
};
await repos2.CreateAsync(tm);
uow.SaveChanges();
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, account.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(ClaimTypes.Name, account.UserName, ClaimValueTypes.String),
new Claim(ClaimTypes.Email, account.Email, ClaimValueTypes.String),
new Claim(CoderrClaims.Application, app.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(CoderrClaims.ApplicationAdmin, app.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(ClaimTypes.Role, CoderrClaims.RoleSysAdmin, ClaimValueTypes.String)
};
var identity = new ClaimsIdentity(claims, "Cookie", ClaimTypes.Name, ClaimTypes.Role);
var properties = new AuthenticationProperties {
IsPersistent = false
};
HttpContext.GetOwinContext().Authentication.SignIn(properties, identity);
return(Redirect(Url.GetNextWizardStep()));
}
catch (Exception ex)
{
ViewBag.Exception = ex;
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
public async Task UpdateAsync(ApplicationTeamMember member)
{
await _uow.UpdateAsync(member);
}
public async Task CreateAsync(ApplicationTeamMember member)
{
await _uow.InsertAsync(member);
}
public async Task <ActionResult> Admin(AccountViewModel model)
{
SetStateFlag();
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var account = new Account(model.UserName, model.Password);
account.Activate();
var con = SetupTools.DbTools.OpenConnection();
var uow = new AdoNetUnitOfWork(con);
var repos = new AccountRepository(uow);
if (await repos.IsUserNameTakenAsync(model.UserName))
{
return(Redirect(Url.GetNextWizardStep()));
}
account.SetVerifiedEmail(model.EmailAddress);
await repos.CreateAsync(account);
var user = new User(account.Id, account.UserName)
{
EmailAddress = account.Email
};
var userRepos = new UserRepository(uow);
await userRepos.CreateAsync(user);
var repos2 = new ApplicationRepository(uow);
var app = new Application(user.AccountId, "DemoApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
await repos2.CreateAsync(app);
/*insert into ApplicationMembers (AccountId, ApplicationId, EmailAddress, AddedAtUtc, AddedByName, Roles) SELECT 1, 1, (SELECT TOP 1 email FROM accounts), GetUtcDate(), 'admin', 'Admin,Member';
*/
var tm = new ApplicationTeamMember(app.Id, account.Email)
{
AccountId = account.Id,
AddedByName = "system",
Roles = new[] { "Admin, Member" },
UserName = account.UserName
};
await repos2.CreateAsync(tm);
uow.SaveChanges();
SessionUser.Current = new SessionUser(account.Id, model.UserName);
return(Redirect(Url.GetNextWizardStep()));
}
catch (Exception ex)
{
ViewBag.Exception = ex;
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
/// <inheritdoc />
public async Task ExecuteAsync(InviteUser command)
{
var inviter = await _userRepository.GetUserAsync(command.UserId);
if (!ClaimsPrincipal.Current.IsSysAdmin() &&
!ClaimsPrincipal.Current.IsApplicationAdmin(command.ApplicationId))
{
_logger.Warn($"User {command.UserId} attempted to do an invite for an application: {command.ApplicationId}.");
throw new SecurityException("You are not an admin of that application.");
}
var invitedUser = await _userRepository.FindByEmailAsync(command.EmailAddress);
if (invitedUser != null)
{
//correction of issue #21, verify that the person isn't already a member.
var members = await _applicationRepository.GetTeamMembersAsync(command.ApplicationId);
if (members.Any(x => x.AccountId == invitedUser.AccountId))
{
_logger.Warn("User " + invitedUser.AccountId + " is already a member.");
return;
}
var member = new ApplicationTeamMember(command.ApplicationId, invitedUser.AccountId)
{
AddedByName = inviter.UserName,
Roles = new[] { ApplicationRole.Member }
};
await _applicationRepository.CreateAsync(member);
await _eventBus.PublishAsync(new UserAddedToApplication(command.ApplicationId, member.AccountId));
return;
}
else
{
//correction of issue #21, verify that the person isn't already a member.
var members = await _applicationRepository.GetTeamMembersAsync(command.ApplicationId);
if (members.Any(x => x.EmailAddress == command.EmailAddress))
{
_logger.Warn("User " + command.EmailAddress + " is already invited.");
return;
}
}
var invitedMember = new ApplicationTeamMember(command.ApplicationId, command.EmailAddress)
{
AddedByName = inviter.UserName,
Roles = new[] { ApplicationRole.Member }
};
await _applicationRepository.CreateAsync(invitedMember);
var invitation = await _invitationRepository.FindByEmailAsync(command.EmailAddress);
if (invitation == null)
{
invitation = new Invitation(command.EmailAddress, inviter.UserName);
await _invitationRepository.CreateAsync(invitation);
await SendInvitationEmailAsync(invitation, command.Text);
}
invitation.Add(command.ApplicationId, inviter.UserName);
await _invitationRepository.UpdateAsync(invitation);
var app = await _applicationRepository.GetByIdAsync(command.ApplicationId);
var evt = new UserInvitedToApplication(
invitation.InvitationKey,
command.ApplicationId,
app.Name,
command.EmailAddress,
inviter.UserName);
await _eventBus.PublishAsync(evt);
}
