public async Task <ActionResult> AddMember(int teamId, string email)
{
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
var getTeamResult = await this.GetTeamManagedByUser(teamId, telimenaUser.Id);
if (getTeamResult.ErrorResult != null)
{
return(getTeamResult.ErrorResult);
}
TelimenaUser newUser = this.unitOfWork.Users.FirstOrDefault(x => x.Email == email);
if (newUser == null)
{
return(this.HttpNotFound($"User with email [{email}] does not exist"));
}
getTeamResult.Team.AssociateUser(newUser);
await this.unitOfWork.CompleteAsync().ConfigureAwait(false);
return(new HttpStatusCodeResult(HttpStatusCode.OK, $"Added user [{newUser.Email}] to [{getTeamResult.Team.Name}]"));
}
public void TestSetUserAsMainForSecondDeveloper()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
GetTwoUsers(unit);
TelimenaUser jim = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
TelimenaUser jack = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
DeveloperTeam jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jack.Id);
DeveloperTeam jimDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jim.Id);
Assert.AreEqual(jackDev.Id, jack.GetDeveloperAccountsLedByUser().Single().Id);
Assert.AreEqual(jimDev.Id, jim.GetDeveloperAccountsLedByUser().Single().Id);
jimDev.SetMainUser(jack);
unit.Complete();
Assert.IsNotNull(jimDev.AssociatedUsers.Single(x => x.Id == jim.Id));
Assert.IsNotNull(jimDev.AssociatedUsers.Single(x => x.Id == jack.Id));
Assert.AreEqual(1, jim.AssociatedDeveloperAccounts.Count());
Assert.AreEqual(jack, jimDev.MainUser);
Assert.AreEqual(0, jim.GetDeveloperAccountsLedByUser().Count());
Assert.AreEqual(2, jack.GetDeveloperAccountsLedByUser().Count());
Assert.IsNotNull(jack.GetDeveloperAccountsLedByUser().Single(x => x.Id == jackDev.Id));
Assert.IsNotNull(jack.GetDeveloperAccountsLedByUser().Single(x => x.Id == jimDev.Id));
}
/// <summary>
/// Indexes this instance.
/// </summary>
/// <returns>ActionResult.</returns>
public async Task <ActionResult> Index(int id)
{
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
var getTeamResult = await this.GetTeam(id, telimenaUser.Id);
if (getTeamResult.ErrorResult != null)
{
return(getTeamResult.ErrorResult);
}
var model = new TeamViewModel()
{
Name = getTeamResult.Team.Name, TeamId = getTeamResult.Team.Id
};
foreach (TelimenaUser user in getTeamResult.Team.AssociatedUsers)
{
model.TeamMembers.Add(new SelectListItem()
{
Value = user.Email, Text = user.DisplayName
});
}
return(this.View("Index", model));
}
public PartialViewResult ProgramsList()
{
TelimenaUser user = this.work.Users.GetByPrincipal(this.User);
var programs = this.work.Programs.GetProgramsVisibleToUser(user, this.User);
ProgramsListViewModel model = new ProgramsListViewModel();
var list = new List <ProgramMenuEntry>();
foreach (Program program in programs)
{
var entry = new ProgramMenuEntry()
{
ProgramName = program.Name
, TelemetryKey = program.TelemetryKey
, DeveloperTeamId = program.DeveloperTeam.Id
, DeveloperTeamName = program.DeveloperTeam.Name
,
};
list.Add(entry);
}
model.Programs = list.GroupBy(x => x.DeveloperTeamId);
return(this.PartialView("_ProgramsList", model));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (this.ModelState.IsValid)
{
TelimenaUser user = await this.unitOfWork.UserManager.FindAsync(model.Email, model.Password).ConfigureAwait(false);
if (user != null)
{
if (user.IsActivated)
{
user.LastLoginDate = DateTime.UtcNow;
await this.unitOfWork.UserManager.UpdateAsync(user).ConfigureAwait(false);
ClaimsIdentity ident = await this.unitOfWork.UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie).ConfigureAwait(false);
this.unitOfWork.AuthManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, ident);
if (user.MustChangePassword)
{
return(this.RedirectToAction("ChangePassword"));
}
return(this.Redirect(returnUrl ?? this.Url.Action("Index", "Home")));
}
return(this.View("WaitForActivationInfo"));
}
}
this.ModelState.AddModelError("", "Invalid username or password");
return(this.View(model));
}
public async Task <ActionResult> RenameTeam(int teamId, string newName)
{
if (!newName.IsUrlFriendly())
{
var properName = newName.MakeUrlFriendly();
var properNameHint = "";
if (properName != null)
{
properNameHint = $" Proposed name: {properName}";
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, $"Team name should only contain letters and numbers or hyphens. " +
$"Also it needs to begin and end with a letter or digit.{properNameHint}"));
}
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
var getTeamResult = await this.GetTeam(teamId, telimenaUser.Id);
if (getTeamResult.ErrorResult != null)
{
return(getTeamResult.ErrorResult);
}
var existingTeam = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.Name == newName).ConfigureAwait(false);
if (existingTeam != null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Conflict, $"A [{existingTeam.Name}] team already exists"));
}
getTeamResult.Team.Name = newName;
await this.unitOfWork.CompleteAsync().ConfigureAwait(false);
return(new HttpStatusCodeResult(HttpStatusCode.OK, $"Renamed team to [{getTeamResult.Team.Name}]"));
}
public async Task <ActionResult> ToggleRoleActivation(string userId, bool activateRole, string roleName)
{
TelimenaUser user = await this.userManager.FindByIdAsync(userId).ConfigureAwait(false);
try
{
if (activateRole)
{
await this.userManager.AddToRoleAsync(user.Id, roleName).ConfigureAwait(false);
}
else
{
await this.userManager.RemoveFromRoleAsync(user.Id, roleName).ConfigureAwait(false);
}
bool isInRole = await this.userManager.IsInRoleAsync(user.Id, roleName).ConfigureAwait(false);
this.telemetryClient.TrackTrace($"User [{user.UserName}] role [{roleName}] status changed. Is in role: [{isInRole}].");
return(this.Json(isInRole));
}
catch (Exception ex)
{
this.telemetryClient.TrackException(new InvalidOperationException($"Error while toggling role activation to [{activateRole}]. Role: [{roleName}]. User [{user.UserName}]", ex));
return(null);
}
}
public void RegisterTest()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
AccountController sut = new AccountController(unit, new Mock <ILog>().Object);
RegisterViewModel model = new RegisterViewModel
{
Name = "Jim Beam"
, ConfirmPassword = "******"
, Password = "******"
, Email = "*****@*****.**"
, Role = TelimenaRoles.Developer
};
ViewResult result = sut.Register(model).GetAwaiter().GetResult() as ViewResult;
Assert.AreEqual("WaitForActivationInfo", result.ViewName);
TelimenaUser user = unit.UserManager.FindByNameAsync(model.Email).GetAwaiter().GetResult();
Assert.AreEqual("Jim Beam", user.DisplayName);
Assert.IsTrue(user.RegisteredDate.Date == DateTime.UtcNow.Date);
//Assert.IsFalse(user.IsActivated);
Assert.IsTrue(unit.UserManager.IsInRoleAsync(user.Id, TelimenaRoles.Developer).GetAwaiter().GetResult());
Assert.IsTrue(unit.UserManager.IsInRoleAsync(user.Id, TelimenaRoles.Viewer).GetAwaiter().GetResult());
DeveloperTeam developerTeam = unit.DeveloperRepository.SingleOrDefault(x => x.MainUser.Id == user.Id);
Assert.AreEqual(user.DisplayName, developerTeam.MainUser.DisplayName);
Assert.AreEqual(user.Email, developerTeam.MainEmail);
Assert.AreEqual(developerTeam, user.GetDeveloperAccountsLedByUser().Single());
}
public Updater Add(string fileName, string internalName, TelimenaUser user)
{
var updater = new Updater(fileName, internalName);
this.TelimenaPortalContext.Updaters.Add(updater);
updater.DeveloperTeam = user.AssociatedDeveloperAccounts.FirstOrDefault(x => x.MainUserId == user.Id);
return(updater);
}
private IQueryable <Program> GetProgramsVisibleToUserImpl(TelimenaUser user, IPrincipal principal)
{
if (principal != null && principal.IsInRole(TelimenaRoles.Admin))
{
return(this.portalContext.Programs);
}
return(this.portalContext.Programs.Where(x => x.DeveloperTeam != null && (x.DeveloperTeam.MainUserId == user.Id || x.DeveloperTeam.AssociatedUsers.Any(a => a.Id == user.Id))));
}
/// <summary>
/// Gets all programs summary counts.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>Task<AllProgramsSummaryData>.</returns>
public async Task <AllProgramsSummaryData> GetAllProgramsSummaryCounts(IPrincipal user)
{
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == user.Identity.Name);
List <Program> programs = await this.unitOfWork.Programs.GetProgramsVisibleToUserAsync(telimenaUser, user).ConfigureAwait(false);
AllProgramsSummaryData summary = await this.unitOfWork.GetAllProgramsSummaryCounts(programs).ConfigureAwait(false);
return(summary);
}
/// <summary>
/// Gets all programs.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>Task<List<ProgramSummary>>.</returns>
public async Task <List <AppUsersSummaryData> > GetAppUsersSummary(IPrincipal user)
{
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == user.Identity.Name);
List <Program> programs = await this.unitOfWork.Programs.GetProgramsVisibleToUserAsync(telimenaUser, user).ConfigureAwait(false);
var summary = (await this.unitOfWork.GetAppUsersSummary(programs, null, null).ConfigureAwait(false)).ToList();
return(summary);
}
public async Task <ActionResult> ToggleUserActivation(string userId, bool isActive)
{
TelimenaUser user = await this.userManager.FindByIdAsync(userId).ConfigureAwait(false);
user.IsActivated = !isActive;
await this.userManager.UpdateAsync(user).ConfigureAwait(false);
this.telemetryClient.TrackTrace($"User [{user.UserName}] activation status changed to [{user.IsActivated}]");
return(this.Json(user.IsActivated));
}
public void TestRemoveUserFromDeveloper()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
GetTwoUsers(unit);
TelimenaUser jim = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
TelimenaUser jack = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
DeveloperTeam jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jack.Id);
}
public PartialViewResult TeamsList()
{
TelimenaUser user = this.work.Users.GetByPrincipal(this.User);
var teams = user.AssociatedDeveloperAccounts;
var model = new TeamsListViewModel();
model.Teams = teams.Select(x => new TeamsMenuEntry()
{
TeamId = x.Id, TeamName = x.Name
});
return(this.PartialView("_TeamsList", model));
}
public static async Task <TelimenaUser> CreateTelimenaUser(TelimenaPortalContext context, string email, string displayName = null, [CallerMemberName] string caller = "")
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, context);
TelimenaUser user = new TelimenaUser(caller + "_" + email, caller + "_" + (displayName ?? email.ToUpper()));
await unit.RegisterUserAsync(user, "P@ssword", TelimenaRoles.Developer).ConfigureAwait(false);
unit.Complete();
return(user);
}
public async Task <RegisterProgramResponse> Register(RegisterProgramRequest request)
{
try
{
if (!ApiRequestsValidator.IsRequestValid(request, out List <string> errors))
{
return(new RegisterProgramResponse(new BadRequestException(string.Join(", ", errors))));
}
if (await this.Work.Programs.GetByTelemetryKey(request.TelemetryKey).ConfigureAwait(false) != null)
{
return(new RegisterProgramResponse(new BadRequestException($"Use different telemetry key")));
}
TelimenaUser user = await this.Work.Users.FirstOrDefaultAsync(x => x.UserName == this.User.Identity.Name).ConfigureAwait(false);
if (user == null)
{
return(new RegisterProgramResponse(new BadRequestException($"Cannot find user [{this.User.Identity.Name}]")));
}
DeveloperTeam developerTeam = user.GetDeveloperAccountsLedByUser().FirstOrDefault();
if (developerTeam == null)
{
return(new RegisterProgramResponse(new BadRequestException($"Cannot find developer account associated with user [{user.UserName}]")));
}
Program program = new Program(request.Name, request.TelemetryKey)
{
Description = request.Description
};
ProgramAssembly primaryAss = new ProgramAssembly()
{
Name = Path.GetFileNameWithoutExtension(request.PrimaryAssemblyFileName),
Extension = Path.GetExtension(request.PrimaryAssemblyFileName)
};
await this.Work.RegisterProgram(developerTeam, program, primaryAss).ConfigureAwait(false);
program = await this.Work.Programs.GetByTelemetryKey(request.TelemetryKey).ConfigureAwait(false);
var url = this.Url?.Link("Default", new { Controller = "ProgramManagement", Action = "Index", telemetryKey = program.TelemetryKey });
return(new RegisterProgramResponse(program.TelemetryKey, program.DeveloperTeam.PublicId, url));
}
catch (Exception ex)
{
return(new RegisterProgramResponse(ex));
}
}
public async Task <Tuple <IdentityResult, IdentityResult> > RegisterUserAsync(TelimenaUser user, string password, params string[] roles)
{
IdentityResult registerResult = await this.UserManager.CreateAsync(user, password).ConfigureAwait(false);
if (registerResult.Succeeded)
{
TelimenaUser addedUser = await this.UserManager.FindByIdAsync(user.Id).ConfigureAwait(false);
addedUser.IsActivated = true;
IdentityResult roleResult = await this.HandleRoleRegistrationAsync(roles, addedUser).ConfigureAwait(false);
return(new Tuple <IdentityResult, IdentityResult>(registerResult, roleResult));
}
return(new Tuple <IdentityResult, IdentityResult>(registerResult, null));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (this.ModelState.IsValid)
{
if (!this.ValidateRegistrationModel(model))
{
return(this.View(model));
}
TelimenaUser user = new TelimenaUser(model.Email, model.Name);
Tuple <IdentityResult, IdentityResult> results = await this.unitOfWork.RegisterUserAsync(user, model.Password, TelimenaRoles.Viewer, model.Role).ConfigureAwait(false);
await this.unitOfWork.CompleteAsync().ConfigureAwait(false);
if (results.Item1.Succeeded)
{
if (results.Item2 != null && results.Item2.Succeeded || results.Item2 == null)
{
this.logger.Info($"User [{user.GetNameAndIdString()}] user registered and added to proper roles");
return(this.View("WaitForActivationInfo"));
}
this.logger.Info(
$"User [{user.GetNameAndIdString()}] user registered but errors occurred while adding to roles: [{string.Join(",", results.Item2.Errors)}");
foreach (string resultError in results.Item2.Errors)
{
this.ModelState.AddModelError("", resultError);
}
}
else
{
foreach (string resultError in results.Item1.Errors)
{
this.ModelState.AddModelError("", resultError);
}
}
}
else
{
this.ModelState.AddModelError("", "Something went wrong during registration");
}
// If we got this far, something failed, redisplay form
return(this.View(model));
}
public PartialViewResult ProgramsList()
{
TelimenaUser user = this.work.Users.GetByPrincipal(this.User);
IEnumerable <Program> programs = this.work.Programs.GetProgramsVisibleToUser(user, this.User);
ProgramsListViewModel model = new ProgramsListViewModel();
foreach (Program program in programs)
{
if (!model.Programs.ContainsKey(program.TelemetryKey))
{
model.Programs.Add(program.TelemetryKey, program.Name);
}
}
return(this.PartialView("_ProgramsList", model));
}
public async Task <IHttpActionResult> Upload()
{
try
{
string reqString = HttpContext.Current.Request.Form["Model"];
UploadUpdaterRequest request = JsonConvert.DeserializeObject <UploadUpdaterRequest>(reqString);
HttpPostedFile uploadedFile = HttpContext.Current.Request.Files.Count > 0 ? HttpContext.Current.Request.Files[0] : null;
if (uploadedFile != null && uploadedFile.ContentLength > 0)
{
TelimenaUser user = await this.work.Users.GetByPrincipalAsync(this.User).ConfigureAwait(false);
Updater updater = await this.work.UpdaterRepository.GetUpdater(request.UpdaterInternalName).ConfigureAwait(false);
if (updater == null)
{
updater = this.work.UpdaterRepository.Add(uploadedFile.FileName, request.UpdaterInternalName, user);
}
if (user.AssociatedDeveloperAccounts.All(x => x.Id != updater.DeveloperTeam.Id))
{
return(this.BadRequest(
$"Updater '{updater.InternalName}' is managed by a team that you don't belong to - '{updater.DeveloperTeam.Name}'"));
}
if (uploadedFile.FileName != updater.FileName && !uploadedFile.FileName.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase))
{
return(this.BadRequest(
$"Incorrect file. Expected {updater.FileName} or a zip package with it"));
}
UpdaterPackageInfo pkg =
await this.work.UpdaterRepository.StorePackageAsync(updater, request.MinimumCompatibleToolkitVersion, uploadedFile.InputStream, this.fileSaver).ConfigureAwait(false);
await this.work.CompleteAsync().ConfigureAwait(false);
return(this.Ok($"Uploaded package {pkg.Version} with ID {pkg.Id}"));
}
return(this.BadRequest("Empty attachment"));
}
catch (Exception ex)
{
return(this.BadRequest(ex.Message));
}
}
public async Task <ActionResult> RenameTeam(string newName)
{
var existingTeam = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.Name == newName).ConfigureAwait(false);
if (existingTeam != null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Conflict, $"A [{existingTeam.Name}] team already exists"));
}
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
DeveloperTeam team = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.MainUser.Id == telimenaUser.Id).ConfigureAwait(false);
team.Name = newName;
await this.unitOfWork.CompleteAsync().ConfigureAwait(false);
return(new HttpStatusCodeResult(HttpStatusCode.OK, $"Renamed team to [{team.Name}]"));
}
public async Task <ActionResult> RemoveMember(string email)
{
TelimenaUser userToBeRemoved = this.unitOfWork.Users.FirstOrDefault(x => x.Email == email);
if (userToBeRemoved == null)
{
return(this.HttpNotFound($"User with email [{email}] does not exist"));
}
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
DeveloperTeam team = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.MainUser.Id == telimenaUser.Id).ConfigureAwait(false);
team.RemoveAssociatedUser(userToBeRemoved);
await this.unitOfWork.CompleteAsync().ConfigureAwait(false);
return(new HttpStatusCodeResult(HttpStatusCode.OK, $"Removed user [{userToBeRemoved.Email}] from [{team.Name}]"));
}
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
if (this.ModelState.IsValid)
{
if (model.NewPasswordRepeated != model.NewPassword)
{
this.ModelState.AddModelError("", "Provided new password does not match the repeated password");
}
else if (model.OldPassword == model.NewPassword)
{
this.ModelState.AddModelError("", "New password must be different from the old one");
}
else
{
TelimenaUser user = await this.unitOfWork.UserManager.FindAsync(this.User.Identity.Name, model.OldPassword).ConfigureAwait(false);
if (user != null)
{
IdentityResult result =
await this.unitOfWork.UserManager.ChangePasswordAsync(this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword).ConfigureAwait(false);
if (result.Succeeded)
{
user.MustChangePassword = false;
await this.unitOfWork.UserManager.UpdateAsync(user).ConfigureAwait(false);
model.IsSuccess = true;
this.logger.Info($"[{this.User.Identity.Name}] password changed");
return(this.View(model));
}
foreach (string error in result.Errors)
{
this.ModelState.AddModelError("", error);
}
}
else
{
this.ModelState.AddModelError("", "Incorrect current password provided");
}
}
}
return(this.View(model));
}
public static async Task <Mock <HttpRequestContext> > SetupUserIntoRequestContext(TelimenaPortalContext context, string devName, string devEmail, [CallerMemberName] string caller = "")
{
TelimenaUser teliUsr = context.Users.FirstOrDefault(x => x.Email == devEmail);
if (teliUsr == null)
{
teliUsr = await CreateTelimenaUser(context, devEmail, devName, caller).ConfigureAwait(false);
}
GenericIdentity identity = new GenericIdentity(teliUsr.UserName);
GenericPrincipal principal = new GenericPrincipal(identity, new[] { TelimenaRoles.Developer });
ClaimsPrincipal usr = new ClaimsPrincipal(principal);
Mock <HttpRequestContext> requestContext = new Mock <HttpRequestContext>();
requestContext.Setup(x => x.Principal).Returns(usr);
return(requestContext);
}
public void TestAddSecondUserToDeveloperTwice()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
GetTwoUsers(unit);
TelimenaUser jim = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
TelimenaUser jack = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
DeveloperTeam jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jack.Id);
jackDev.AssociateUser(jim);
unit.Complete();
jackDev.AssociateUser(jim);
unit.Complete();
Assert.AreEqual(2, jackDev.AssociatedUsers.Count);
}
public void TestRemoveDeveloper()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
GetTwoUsers(unit);
TelimenaUser jack = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
TelimenaUser jim = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
DeveloperTeam jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jack.Id);
jackDev.AssociateUser(jim);
unit.DeveloperRepository.Remove(jackDev);
unit.Complete();
Assert.IsNotNull(this.Context.Users.Single(x => x.Id == jack.Id));
Assert.IsNotNull(this.Context.Users.Single(x => x.Id == jim.Id));
Assert.IsNull(unit.DeveloperRepository.SingleOrDefault(x => x.Id == jackDev.Id));
}
public async Task <ActionResult> Index()
{
TelimenaUser telimenaUser = this.unitOfWork.Users.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
DeveloperTeam team = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.MainUser.Id == telimenaUser.Id).ConfigureAwait(false);
var model = new TeamViewModel()
{
Name = team.Name
};
foreach (TelimenaUser user in team.AssociatedUsers)
{
model.TeamMembers.Add(new SelectListItem()
{
Value = user.Email, Text = user.DisplayName
});
}
return(this.View("Index", model));
}
public static async Task <TelimenaUser> CreateTelimenaUser(TelimenaPortalContext context, string email, string displayName = null, [CallerMemberName] string caller = "")
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, context);
TelimenaUser user = new TelimenaUser(caller + "" + email, caller + "" + (displayName ?? email.ToUpper()));
var result = await unit.RegisterUserAsync(user, "P@ssword", TelimenaRoles.Developer).ConfigureAwait(false);
if (!result.Item1.Succeeded)
{
var msg = result.Item1.Errors?.FirstOrDefault();
if (msg != null && !msg.Contains("is already taken."))
{
Assert.Fail($"Failed to register user {user.UserName}. Error: {result.Item1.Errors?.FirstOrDefault()}");
}
}
unit.Complete();
return(user);
}
public void TestRemoveUser()
{
TelimenaUserManager manager = new TelimenaUserManager(new UserStore <TelimenaUser>(this.Context));
AccountUnitOfWork unit = new AccountUnitOfWork(null, manager, this.Context);
GetTwoUsers(unit);
TelimenaUser jack = unit.UserManager.FindByNameAsync(Helpers.GetName("*****@*****.**")).GetAwaiter().GetResult();
DeveloperTeam jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.MainUser.Id == jack.Id);
var jackDevId = jackDev.Id;
Assert.AreEqual(jackDevId, jack.AssociatedDeveloperAccounts.Single().Id);
unit.UserManager.DeleteAsync(jack).GetAwaiter().GetResult();
unit.Complete();
Assert.IsNull(unit.UserManager.FindByNameAsync(jack.UserName).GetAwaiter().GetResult());
jackDev = unit.DeveloperRepository.FirstOrDefault(x => x.Id == jackDevId);
Assert.IsNull(jackDev.MainUser);
Assert.AreEqual(Helpers.GetName("*****@*****.**"), jackDev.MainEmail);
}
