private async Task RegisterProgramInternal(DeveloperTeam developerTeam, Program program, ProgramAssembly primaryAss)
{
using (var dbContextTransaction = this.portalContext.Database.BeginTransaction())
{
try
{
developerTeam.AddProgram(program);
program.PrimaryAssembly = primaryAss;
this.portalContext.Programs.Add(program);
await this.portalContext.SaveChangesAsync().ConfigureAwait(false);
var savedPrg = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.PublicId == program.PublicId).ConfigureAwait(false);
var teleRoot = new TelemetryRootObject()
{
ProgramId = savedPrg.Id,
TelemetryKey = savedPrg.TelemetryKey
};
this.telemetryContext.TelemetryRootObjects.Add(teleRoot);
await this.telemetryContext.SaveChangesAsync().ConfigureAwait(false);
dbContextTransaction.Commit();
}
catch (Exception)
{
dbContextTransaction.Rollback();
throw;
}
}
}
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));
}
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());
}
private async Task <IdentityResult> HandleRoleRegistrationAsync(string[] roles, TelimenaUser user)
{
IdentityResult roleresult = IdentityResult.Success;
if (roles.Contains(TelimenaRoles.Viewer))
{
roleresult = await this.UserManager.AddToRoleAsync(user.Id, TelimenaRoles.Viewer).ConfigureAwait(false);
if (!roleresult.Succeeded)
{
return(roleresult);
}
}
if (roles.Contains(TelimenaRoles.Developer))
{
roleresult = await this.UserManager.AddToRoleAsync(user.Id, TelimenaRoles.Developer).ConfigureAwait(false);
if (roleresult.Succeeded)
{
DeveloperTeam developer = new DeveloperTeam(user);
this.DeveloperRepository.Add(developer);
this._context.Users.Attach(user);
}
}
return(roleresult);
}
public async Task <ActionResult> RenameTeam(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}"));
}
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}]"));
}
private async Task RegisterProgramInternalFallback(DeveloperTeam developerTeam, Program program, ProgramAssembly primaryAss)
{
using (DbContextTransaction dbContextTransaction = this.portalContext.Database.BeginTransaction())
{
List <DbEntityEntry> changedEntities = this.portalContext.ChangeTracker.Entries().ToList();
changedEntities.AddRange(this.telemetryContext.ChangeTracker.Entries().ToList());
foreach (DbEntityEntry dbEntityEntry in changedEntities)
{
if (dbEntityEntry.State == EntityState.Added)
{
dbEntityEntry.State = EntityState.Detached;
}
else
{
await dbEntityEntry.ReloadAsync().ConfigureAwait(false);
}
}
int topPrgId = this.telemetryContext.TelemetryRootObjects.OrderByDescending(x => x.ProgramId)
.FirstOrDefault()?.ProgramId ?? 0;
topPrgId++;
program.Id = topPrgId;
try
{
developerTeam.AddProgram(program);
string tblName = nameof(Program) + "s";
program.PrimaryAssembly = primaryAss;
this.portalContext.Database.ExecuteSqlCommand($"DBCC CHECKIDENT('[dbo].[{tblName}]', RESEED, {topPrgId})");
this.portalContext.Programs.Add(program);
await this.portalContext.SaveChangesAsync().ConfigureAwait(false);
Program savedPrg = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.PublicId == program.PublicId).ConfigureAwait(false);
TelemetryRootObject teleRoot = new TelemetryRootObject()
{
ProgramId = savedPrg.Id,
TelemetryKey = savedPrg.TelemetryKey
};
this.telemetryContext.TelemetryRootObjects.Add(teleRoot);
await this.telemetryContext.SaveChangesAsync().ConfigureAwait(false);
dbContextTransaction.Commit();
}
catch (Exception)
{
dbContextTransaction.Rollback();
throw;
}
}
}
private void DisplayTeams(DeveloperTeam teams)
{
DeveloperTeam team = new DeveloperTeam();
Console.WriteLine($"Team Name:{team.TeamName} \n" +
$"Team Id: {team.TeamId} \n" +
$"Team Members: {team.TeamMembers}");
}
private void SeedDeveloperTeamLIst()
{
DeveloperTeam automobileTeam = new DeveloperTeam("Automobile Team");
DeveloperTeam homeownersTeam = new DeveloperTeam("Homeowners Team");
_teamContentRepo.AddTeamContentToList(automobileTeam);
_teamContentRepo.AddTeamContentToList(homeownersTeam);
}
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);
}
/// <summary>
/// Handles adding program to both databases and commits transaction
/// </summary>
/// <param name="developerTeam">The developer team.</param>
/// <param name="program">The program.</param>
/// <param name="primaryAss">The primary ass.</param>
/// <returns>Task.</returns>
public async Task RegisterProgram(DeveloperTeam developerTeam, Program program, ProgramAssembly primaryAss)
{
try
{
await this.RegisterProgramInternal(developerTeam, program, primaryAss).ConfigureAwait(false);
}
catch (Exception)
{
await this.RegisterProgramInternalFallback(developerTeam, program, primaryAss)
.ConfigureAwait(false);
}
}
public void Post(int id, DeveloperTeam value)
{
if (value != null)
{
if (value.ID == id)
{
DeveloperTeam updatedItem = service.FindById(id);
updatedItem.Name = value.Name;
updatedItem.PeopleQuantity = value.PeopleQuantity;
service.Update(id, updatedItem);
}
}
}
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));
}
}
private void GetTeamsByID()
{
Console.WriteLine("Enter the id of the team whose information you seek.");
int id = int.Parse(Console.ReadLine());
DeveloperTeam teamId = _teamRepository.GetByTeamID(id);
if (teamId != null)
{
DisplayTeams(teamId);
}
else
{
Console.WriteLine("The ID you are searching for does not correspond with any team in our database.");
}
}
//private void CreateNewTeams()
//{
// Console.Clear(); // Creates a blank console
// DeveloperTeam newTeam = new DeveloperTeam();
// Console.WriteLine("Enter the name of the team you are creating");
// newTeam.TeamName = Console.ReadLine();
// Console.WriteLine("Enter the number ID given to the team");
// newTeam.TeamId = int.Parse(Console.ReadLine());
// Console.WriteLine("Who are the Team members");
// Developer newDeveloper = new Developer();
// newDeveloper.LastName = Console.ReadLine();
// newTeam.TeamMembers = newTeam.TeamMembers.Add(newDeveloper);
//}
private void GetTeamsByTeamName()
{
Console.WriteLine("Enter the name of the team whose information you desire.");
string teamName = Console.ReadLine();
DeveloperTeam teamFound = _teamRepository.GetTeamByName(teamName);
if (teamFound != null)
{
DisplayTeams(teamFound);
}
else
{
Console.WriteLine("The team you area looking for cannot be found.");
}
}
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}]"));
}
private async Task <GetTeamResult> GetTeamManagedByUser(int teamId, string userId)
{
DeveloperTeam team = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.Id == teamId).ConfigureAwait(false);
var result = new GetTeamResult();
if (team == null)
{
result.ErrorResult = this.HttpNotFound();
}
if (team.MainUserId != userId)
{
result.ErrorResult = this.RedirectToAction("AccessDenied", "Error");
}
result.Team = team;
return(result);
}
private async Task <GetTeamResult> GetTeam(int teamId, string userId)
{
DeveloperTeam team = await this.unitOfWork.Developers.FirstOrDefaultAsync(x => x.Id == teamId).ConfigureAwait(false);
var result = new GetTeamResult();
if (team == null)
{
result.ErrorResult = this.HttpNotFound();
}
if (team.AssociatedUsers.All(x => x.Id != userId))
{
result.ErrorResult = this.RedirectToAction("AccessDenied", "Error", new { roles = "Member of the team" });
}
result.Team = team;
return(result);
}
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 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);
}
//protected override void Seed(TelimenaPortalContext portalContext)
//{
// TelimenaPortalDbInitializer.SeedUsers(portalContext);
// TelimenaPortalDbInitializer.SeedToolkit(portalContext);
// portalContext.SaveChanges();
//}
private static void CreateAdmin(TelimenaPortalContext portalContext)
{
if (!portalContext.Users.Any(u => u.UserName == "superuser"))
{
UserStore <TelimenaUser> userStore = new UserStore <TelimenaUser>(portalContext);
UserManager <TelimenaUser> userManager = new UserManager <TelimenaUser>(userStore);
TelimenaUser user = new TelimenaUser("superuser", "Super User")
{
IsActivated = true,
#if DEBUG
MustChangePassword = false
#else
MustChangePassword = true
#endif
};
userManager.Create(user, "123456");
userManager.AddToRole(user.Id, TelimenaRoles.Admin);
var developer = new DeveloperTeam(user);
developer.Name = DefaultToolkitNames.TelimenaSystemDevTeam;
portalContext.Developers.AddOrUpdate(developer);
}
}
public void SetSuccessor(DeveloperTeam successor)
{
this.Successor = successor;
}
public void Put(DeveloperTeam value)
{
service.Create(value);
}
