public void TestThatSystemDoesNotCreateDuplicateTeamMemberships()
{
_mockContainer.Teams.Add(new Data.Team()
{
Name = "Test Team",
Id = 100
});
var teams = new List <Continuum.Core.Models.Team>();
teams.Add(new Core.Models.Team()
{
Id = 100
});
teams.Add(new Core.Models.Team()
{
Id = 100
});
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
_controller.Put(user);
var team = _mockContainer.Teams.Where(i => i.Id == 100).First();
Assert.IsNotNull(team, "Could not retrieve team.");
Assert.IsTrue(team.TeamMembers.Count(i => i.UserId == _currentUser.Identity.Name) == 1, "Duplicate team entries created.");
}
public async Task <IActionResult> Find([FromQuery] string searchText)
{
var user = new Core.Models.User();
if (!String.IsNullOrWhiteSpace(searchText))
{
user = await _authService.GetUserByEmail(searchText);
if (user == null)
{
user = await _authService.GetUserByUsername(searchText);
}
if (user == null)
{
var tempGuid = new Guid();
if (Guid.TryParse(searchText.ToCharArray(), out tempGuid))
{
user = await _authService.GetUserById(searchText);
}
}
}
if (user == null)
{
ModelState.AddModelError("NotFound", "User not found");
return(BadRequest(ModelState));
}
return(Ok(user));
}
public async Task <ActionResult <List <Product> > > Get([FromQuery] int userId)
{
var ldUser = LaunchDarkly.Client.User.WithKey("1");
bool killSwitchEnabled = _ldClient.BoolVariation("killswitch.getproducts", ldUser, false);
if (killSwitchEnabled)
{
// application code to show the feature
return(Ok(new List <Product>()));
}
List <Product> products;
if (userId > 0)
{
Core.Models.User user = await _usersProvider.FindUserById(userId);
products = await _productsProvider.GetFoodProductsByCarbsForUser(user);
}
else
{
products = await _productsProvider.GetFoodProductsByCarbs();
}
products = products ?? new List <Product>();
return(Ok(products.ToList()));
}
public void TestThatNewTeamsForUserAreAdded()
{
_mockContainer.Teams.Add(new Data.Team()
{
Name = "Test Team",
Id = 100
});
var teams = new List <Continuum.Core.Models.Team>();
teams.Add(new Core.Models.Team()
{
Id = 100
});
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
_controller.Put(user);
var team = _mockContainer.Teams.Where(i => i.Id == 100).First();
Assert.IsNotNull(team, "Could not retrieve team.");
Assert.IsTrue(team.TeamMembers.Any(i => i.UserId == _currentUser.Identity.Name), "User was not added to the team.");
}
public async Task <IActionResult> SignIn(string EmailSign, string PasswordSign)
{
if (ModelState.IsValid)
{
if (EmailSign == null || EmailSign == "" || PasswordSign == null || PasswordSign == "")
{
ViewData["Error"] = "Field missing";
return(RedirectToAction("Index"));
}
Core.Models.User user = new Core.Models.User
{
Email = EmailSign,
Password = Users.HashPassword(PasswordSign)
};
var currentUser = await DataAccess.User.SignInUser(user);
if (currentUser == null || currentUser.Id == 0)
{
return(RedirectToLocal("/"));
}
Helper.AppHttpContext.HttpContext.Session.SetObject <long>("currentUserId", currentUser.Id);
return(Redirect(_configuration.GetValue <string>("RedirectFront")));
}
else
{
return(BadRequest());
}
}
public JsonResult <dynamic> Install(Core.Models.User adminUser, Core.Models.Portal portal, List <string> packages)
{
return(API.Execute <dynamic>(r =>
{
if (Portal.CurrentPortal == null)
{
portal.Name = "Default";
portal.Default = true;
var packagesToInstall = Videre.Core.Services.Update.GetPackages().Where(p => packages.Contains(p.Name));
//need to install account providers before we start creating accounts!
foreach (var package in packagesToInstall.Where(p => p.Type == "Account Provider"))
{
Update.InstallPackage(package.Name, null);
}
var portalId = Core.Services.Update.InstallPortal(adminUser, portal);
foreach (var package in packagesToInstall.Where(p => p.Type != "Account Provider"))
{
Update.InstallPackage(package.Name, portalId);
}
}
else
{
r.AddError("Portal already exists."); //todo: localize
}
}));
}
public async Task <bool> Delete(Core.Models.User user)
{
var dbUser = _mapper.Map <User>(user);
var result = await _userManager.DeleteAsync(dbUser);
return(result.Succeeded);
}
private static async Task AddAdminUserAsync(IServiceProvider serviceProvider)
{
var userManagement = serviceProvider.GetRequiredService <UserManager <Core.Models.User> >();
if (userManagement.Users.Count(p => p.Id == 1) > 0)
{
Console.WriteLine("The user has been already created");
return;
}
const string email = "*****@*****.**";
var user = new Core.Models.User
{
Email = email,
EmailConfirmed = true,
Name = "Galaxy Admin",
UserName = Guid.NewGuid().ToString(),
Id = 1,
NormalizedEmail = email.ToUpper()
};
var createUserResult = await userManagement.CreateAsync(user, "someRandomSecurePassword123!");
if (!createUserResult.Succeeded)
{
Console.WriteLine("Could not create user. " +
$"Reason is: {string.Join(" ", createUserResult.Errors.Select(x => x.Description))} ");
throw new ArgumentException("Could not create User");
}
}
public async void CreateAsync_WhenUserDoesNotExistsInDbAndDoesExistInAdAndIsActive_SaveUserToDatabseAndReturnSuccessful()
{
// arrange
var user = new Core.Models.User {
FirstName = "test", LastName = "last", EmailAddress = "*****@*****.**", IsActive = true
};
var adUser = new UserPrincipalFake
{
EmailAddress = user.EmailAddress,
Enabled = true
};
_userRepository
.Setup(i => i.GetUserByEmailAddressAsync(user.EmailAddress))
.ReturnsAsync((Data.Models.User)null);
_adRepository
.Setup(i => i.GetUserByEmailAddress(user.EmailAddress))
.Returns(adUser);
// act
var result = await _userCreationDiService.CreateAsync(user);
//assert
_userRepository.Verify(i => i.AddAsync(It.IsAny <Data.Models.User>()), "_userRepository.AddAsync");
_userRepository.Verify(i => i.SaveAsync(), "_userRepository.SaveAsync");
Assert.True(result.IsSuccessful, "result.IsSuccessful");
Assert.True(result.ErrorMessage == "", "result.ErrorMessage");
}
/// <summary>
/// Adds a new User to the DB.
/// </summary>
/// <param name="user"></param>
/// <returns>The user that was added</returns>
public async Task <Core.Models.User> PostUserAsync(Core.Models.User user)
{
if (!(await _dbContext.Users.FirstOrDefaultAsync(u => u.Email == user.Email) is null))
{
_logger.LogInformation($"User with email {user.Email} already exists.");
return(null);
}
User newUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Password = user.Password,
Address = user.Address,
City = user.City,
State = user.State,
Zip = user.Zip
};
_logger.LogInformation($"Added a User with email {user.Email} to DB.");
_dbContext.Users.Add(newUser);
await _dbContext.SaveChangesAsync();
var resultUser = await _dbContext.Users.FirstOrDefaultAsync(u => u.Email == user.Email);
return(Mapper.MapUser(resultUser));
}
public async Task <bool> Edit(Core.Models.User user)
{
var dbUser = await _userManager.FindByIdAsync(user.Id.ToString());
var result = await _userManager.UpdateAsync(_mapper.Map(user, dbUser));
return(result.Succeeded);
}
public async Task <bool> Create(Core.Models.User user)
{
user.Id = Guid.NewGuid();
var dbUser = _mapper.Map <User>(user);
var result = await _userManager.CreateAsync(dbUser);
return(result.Succeeded);
}
public User(Core.Models.User user)
{
Id = user.Id;
Username = user.Username;
FirstName = user.FirstName;
LastName = user.LastName;
Created = user.Created;
Modified = user.Modified;
}
public IActionResult Get(int id)
{
Core.Models.User user = _userService.Get(id);
if (user == null)
{
return(NotFound());
}
return(Ok(user.ToApiModel()));
}
public IActionResult Put(int id, [FromBody] UserModel updatedUser)
{
Core.Models.User user = _userService.Update(updatedUser.ToDomainModel());
if (user == null)
{
return(NotFound());
}
return(Ok(user.ToApiModel()));
}
protected override async Task OnInitializedAsync()
{
CurrentUser = await UserManager.GetUserAsync(HttpContextAccessor.HttpContext.User);
if (CurrentUser.Id != Item.UserId)
{
return;
}
}
public static User ToProto(this Core.Models.User user)
{
return(new User
{
Id = user.Id,
City = user.City,
FirstName = user.FirstName,
LastName = user.LastName
});
}
public async Task <ActionResult <User> > GetUser(int id)
{
Core.Models.User user = await _repository.GetUserAsync(id);
if (user == null)
{
return(NotFound());
}
return(Ok(Mapper.MapUser(user)));
}
public async Task <ActionResult <User> > PostUser(User user)
{
Core.Models.User addedUser = await _repository.PostUserAsync(Mapper.MapUser(user));
if (addedUser == null)
{
return(BadRequest($"Unable to add new user."));
}
return(CreatedAtAction("GetUser", new { id = user.Id }, user));
}
public User Map(Core.Models.User user)
{
return(new User
{
UserId = user.UserId,
Name = user.Name,
Surname = user.Surname,
CarnetId = user.CarnetId
});
}
public void TrialStatus_ShouldBe_MappedFromVpnPlan_AndExpirationTime(string vpnPlan, int expirationTime, PlanStatus expected)
{
// Arrange
var user = new Core.Models.User {
VpnPlan = vpnPlan, ExpirationTime = expirationTime
};
// Act
var result = user.TrialStatus();
// Assert
result.Should().Be(expected);
}
public void Paid_ShouldBe_MappedFromVpnPlan(string vpnPlan, bool expected)
{
// Arrange
var user = new Core.Models.User {
VpnPlan = vpnPlan
};
// Act
var result = user.Paid();
// Assert
result.Should().Be(expected);
}
public void Empty_ShouldBeTrue_WhenUsernameIsNullOrEmpty(string username, bool expected)
{
// Arrange
var user = new Core.Models.User {
Username = username
};
// Act
var result = user.Empty();
// Assert
result.Should().Be(expected);
}
public void GetAccountPlan_ShouldBe_MappedFormServices(int services, string expected)
{
// Arrange
var user = new Core.Models.User {
Services = services
};
// Act
var result = user.GetAccountPlan();
// Assert
result.Should().Be(expected);
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid && model != null)
{
if (model.Email == null || model.Email == "" || model.Firstname == null ||
model.Firstname == "" || model.Lastname == null || model.Lastname == "" || model.Password == null || model.Password == "")
{
ViewData["Error"] = "Field missing";
return(RedirectToAction("Index"));
}
try
{
Core.Models.User user = new Core.Models.User
{
Email = model.Email,
Password = Users.HashPassword(model.Password),
Firstname = model.Firstname,
Lastname = model.Lastname,
Nickname = $"{model.Firstname.ToLower()}.{model.Lastname.ToLower()}",
Description = "",
Gender = "",
Phone = "",
Picture = "",
AccessToken = "",
Private = false
};
var userInDb = DataAccess.User.Add(user);
if (userInDb == null)
{
ViewData["Error"] = "Impossible to save the current user";
return(RedirectToAction("Index"));
}
userInDb.objectID = user.Id.ToString();
AlgoliaClient client = new AlgoliaClient(_configuration.GetValue <string>("Algolia:AppId"),
_configuration.GetValue <string>("Algolia:AppSecret"));
Index usersIndex = client.InitIndex(_configuration.GetValue <string>("Algolia:IndexUser"));
usersIndex.AddObject(userInDb);
DataAccess.User.Update(userInDb);
Helper.AppHttpContext.HttpContext.Session.SetObject <long>("currentUserId", userInDb.Id);
return(Redirect(_configuration.GetValue <string>("RedirectFront")));
}
catch (Exception e)
{
ViewData["Error"] = "Impossible to save the current user\n" + e.Message;
return(RedirectToAction("Index"));
}
}
else
{
return(BadRequest());
}
}
public async Task <ActionResult> Consume([FromBody] ConsumeProductCommand command)
{
if (command.UserId > 0)
{
Core.Models.User user = await _usersProvider.FindUserById(command.UserId);
user.RecordConsumption(command.CarbAmount);
return(NotModified());
}
return(NotFound());
}
public void MapCommonConditionSuccessTest()
{
var user = new User(1, "John", "*****@*****.**", "url");
var userMapper = new UserMapper();
Core.Models.User result = userMapper.Map(user);
Assert.AreEqual(1, result.UserId);
Assert.AreEqual("John", result.Name);
Assert.AreEqual("*****@*****.**", result.Email);
Assert.AreEqual("url", result.ImageUrl);
}
public async Task Handle(Message message)
{
//if (message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Private)
//{
// await userInteractionService.SendMessage(message.Chat.Id, "You should add bot to a group");
// return;
//}
var user = new Core.Models.User(userInteractionService);
user.Id = message.From.Id;
user.Name = message.From.Username ?? message.From.FirstName ?? "Unknown";
await gamesManager.Join(message.Chat.Id, user);
}
public async Task <IActionResult> PutUser(int id, User user)
{
if (id != user.Id)
{
return(BadRequest());
}
Core.Models.User updatedUser = await _repository.PutUserAsync(id, Mapper.MapUser(user));
if (updatedUser == null)
{
return(BadRequest($"User with ID {id} was not found."));
}
return(Ok($"User with ID {id} was successfully updated."));
}
/// <summary>
/// Update a user
/// </summary>
/// <param name="id"></param>
/// <param name="users"></param>
/// <returns>Returns the user after updated</returns>
public async Task <Core.Models.User> PutUserAsync(int id, Core.Models.User user)
{
var userExists = await _dbContext.Users.FindAsync(id);
if (userExists == null)
{
_logger.LogInformation($"Unable to update user with id {id} because it was not found.");
return(null);
}
_logger.LogInformation($"Updating user with id {id}.");
_dbContext.Entry(userExists).CurrentValues.SetValues(user);
await _dbContext.SaveChangesAsync();
return(user);
}
public void TestThatEmptyTeamCollectionThrowsException()
{
var teams = new List<Continuum.Core.Models.Team>();
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
try
{
_controller.Put(user);
}
catch (HttpResponseException ex)
{
Assert.IsTrue(ex.Response.StatusCode == System.Net.HttpStatusCode.InternalServerError);
}
}
public void TestThatInvalidTeamIdThrowsException()
{
_mockContainer.Teams.Add(new Data.Team()
{
Name = "Test Team",
Id = 100
});
var teams = new List<Continuum.Core.Models.Team>();
teams.Add(new Core.Models.Team() { Id = 999 });
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
_controller.Put(user);
Assert.Fail();
}
public void TestThatSystemDoesNotCreateDuplicateTeamMemberships()
{
_mockContainer.Teams.Add(new Data.Team()
{
Name = "Test Team",
Id = 100
});
var teams = new List<Continuum.Core.Models.Team>();
teams.Add(new Core.Models.Team() { Id = 100 });
teams.Add(new Core.Models.Team() { Id = 100 });
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
_controller.Put(user);
var team = _mockContainer.Teams.Where(i => i.Id == 100).First();
Assert.IsNotNull(team, "Could not retrieve team.");
Assert.IsTrue(team.TeamMembers.Count(i => i.UserId == _currentUser.Identity.Name) == 1 , "Duplicate team entries created.");
}
public void TestThatNewTeamsForUserAreAdded()
{
_mockContainer.Teams.Add(new Data.Team()
{
Name = "Test Team",
Id = 100
});
var teams = new List<Continuum.Core.Models.Team>();
teams.Add(new Core.Models.Team() { Id = 100 });
Continuum.Core.Models.User user = new Core.Models.User()
{
UserId = _currentUser.Identity.Name,
Teams = teams
};
_controller.Put(user);
var team = _mockContainer.Teams.Where(i => i.Id == 100).First();
Assert.IsNotNull(team, "Could not retrieve team.");
Assert.IsTrue(team.TeamMembers.Any(i => i.UserId == _currentUser.Identity.Name), "User was not added to the team.");
}
public void TestThatUserCannotUpdateAnotherUserDetails()
{
Continuum.Core.Models.User user = new Core.Models.User() { UserId = "*****@*****.**" };
try
{
_controller.Put(user);
Assert.Fail("Cannot update another user's details.");
}
catch(HttpResponseException ex)
{
Assert.IsTrue(ex.Response.StatusCode == System.Net.HttpStatusCode.Forbidden);
}
}
