public ActionResult Edit(int? id)
{
UsersService usersService = new UsersService();
UsersEditVM model = new UsersEditVM();
User user;
if (!id.HasValue)
{
user = new User();
}
else
{
user = usersService.GetByID(id.Value);
if (user == null)
{
return RedirectToAction("List");
}
}
model.ID = user.ID;
model.Username = user.Username;
model.FirstName = user.FirstName;
model.LastName = user.LastName;
model.Email = user.Email;
model.UserRole = user.UserRole;
model.CityID = user.CityID;
//model.Countries = new CountriesRepository().GetAll(); 1
//model.Countries = new SelectList(new CountriesRepository().GetAll(), "ID", "Name"); //2
model.Cities = usersService.GetSelectedCities(); // 3
model.Teams = usersService.GetSelectedTeams(user.Teams);
return View(model);
}
public void GetUserByName_returnUser()
{
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
var ret = service.GetUserByName("GoodUser", "appTest");
mockUsersRepository.Verify(x => x.GetUserByName("GoodUser", It.IsAny<string>()), Times.Once());
Assert.IsNotNull(ret);
}
public User login(String user, String password)
{
User userFebos = new User();
UsersService userService = new UsersService();
try
{
loginResponseResponse response = new loginResponseResponse();
response = userService.login(user, password);
List<loginResponseResponseVariable> data = response.data.ToList();
foreach (var d in data)
{
if (d.name == "token") { userFebos.token = d.value; }
if (d.name == "uid") { userFebos.uid = d.value; }
}
return userFebos;
}
catch (Exception err)
{
Console.WriteLine(err);
return userFebos;
}
}
public void GetUserByProviderUserKeyReturnUser()
{
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
var result = service.GetUserByProviderUserKey(goodId, "appTest");
Assert.IsNotNull(result);
Assert.AreEqual(goodId, result.Id);
}
public void SendCongratulationsEmail_ShouldSendEmail()
{
var user = FakeUser();
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
emailService.Setup(x => x.Send(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>())).Returns(true);
var ret = service.SendRegisterCongratulationsToEmail(user);
emailService.Verify(x => x.Send("*****@*****.**", It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Once());
Assert.IsTrue(ret);
}
/// <summary>
/// Initializes a new instance of the MainPage class
/// </summary>
/// <param name="userId">the user to look up</param>
/// <param name="apiKey">the API key to use</param>
public MainPage(int userId, string apiKey)
{
InitializeComponent();
IUsersService users = new UsersService(new EtsyContext(apiKey));
users.GetUserDetailsCompleted += this.GetUserDetailsCompleted;
users.GetUserDetails(userId, DetailLevel.Low);
}
public ActionResult Delete(int? id)
{
UnitOfWork unitOfWork = new UnitOfWork();
UsersService usersService = new UsersService(unitOfWork);
if (!id.HasValue)
{
return RedirectToAction("List");
}
usersService.Delete(id.Value);
return RedirectToAction("List");
}
public ResponseResult<User> Put([FromBody] User value)
{
using (var usersService = new UsersService())
{
usersService.Update(value);
}
return new ResponseResult<User>
{
Messages = new List<string>() { "OK" },
Result = value,
Succeed = true
};
}
public ResponseResult<User> Get(string id)
{
User user=null;
using (var usersService = new UsersService())
{
user = usersService.GetById(id);
}
return new ResponseResult<User>
{
Messages = new List<string>() { "OK" },
Result = user,
Succeed = true
};
}
public HttpResponseMessage Register([FromBody]Users user)
{
if (user != null && ModelState.IsValid)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, user);
user.DateCreated = DateTime.Now;
userService = new UsersService(user);
userService.AddUser();
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = user.userName }));
return response;
}
else
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
public void UsersServiceCanRetrieveFollowersByUserId()
{
//Setup
const string userId = "1"; //NOTE: This is @dalton's userId so it will take FOREVER to return, but it will return.
var restSharpApiCaller = new RestSharpApiCaller(ACCESS_TOKEN);
var usersService = new UsersService(restSharpApiCaller);
//Execute
var followers = usersService.GetFollowers(userId);
//Verify
followers.Data.ShouldNotBeNull();
followers.Data.Count().ShouldBeGreaterThan(0);
//Teardown
}
public void UsersServiceCanRetrieveFollowersOnMe()
{
//Setup
const string userId = "me";
var restSharpApiCaller = new RestSharpApiCaller(ACCESS_TOKEN);
var usersService = new UsersService(restSharpApiCaller);
//Execute
var myFollowers = usersService.GetFollowers(userId);
//Verify
myFollowers.Data.ShouldNotBeNull();
myFollowers.Data.Count().ShouldBeGreaterThan(0);
//Teardown
}
public void UsersServiceCanListUsersWhoHaveStarredAPost()
{
//Setup
const string postId = "1";
var restSharpApiCaller = new RestSharpApiCaller(ACCESS_TOKEN);
var usersService = new UsersService(restSharpApiCaller);
//Execute
var starringUsers = usersService.ListUsersWhoHaveStarredPost(postId);
//Verify
starringUsers.Data.ShouldNotBeNull();
starringUsers.Data.Count.ShouldBeGreaterThan(0);
//Teardown
}
public ActionResult Edit()
{
UnitOfWork unitOfWork = new UnitOfWork();
UsersService usersService = new UsersService(unitOfWork);
UsersEditVM model = new UsersEditVM();
TryUpdateModel(model);
User user;
if (model.ID == 0)
{
user = new User();
}
else
{
user = usersService.GetByID(model.ID);
if (user == null)
{
return RedirectToAction("List");
}
}
if (!ModelState.IsValid)
{
model.Cities = usersService.GetSelectedCities();
model.Teams = usersService.GetSelectedTeams(user.Teams, model.SelectedTeams);
return View(model);
}
user.ID = model.ID;
user.Username = model.Username;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
user.UserRole = model.UserRole;
user.CityID = model.CityID;
usersService.UpdateUserTeams(user, model.SelectedTeams);
usersService.Save(user);
return RedirectToAction("List");
}
public async Task DeleteUser_IdExiciting_ReturnTrue()
{
//Arrange
int id = 2;
this.mockUsersRepository
.Setup(p => p.FindByIdAsync(id))
.ReturnsAsync(new User()
{
UserId = 2,
FirstName = "Bohdan"
});
this.mockUsersRepository
.Setup(s => s.SaveChangesAsync())
.Verifiable();
var services = new UsersService(this.mockUsersRepository.Object, mapper);
//Act
var result = await services.DeleteUserAsync(id);
//Assert
Assert.True(result);
}
public async Task Given_ListOfUsersWithOneUserAccountLock_When_CheckingWhoIsLockedAsync_Then_CorrectLockedUserIsReturned()
{
// Arrange
IList <User> users = GenerateNotLockedUsers();
var lockedUser = Fixture.Build <User>().With(u => u.AccountLocked, true).Create();
users.Add(lockedUser);
var userContextMock = new Mock <UsersContext>();
userContextMock.Setup(x => x.Users).ReturnsDbSet(users);
var usersService = new UsersService(userContextMock.Object);
// Act
var lockedUsers = await usersService.GetLockedUsersAsync();
// Assert
Assert.Equal(new List <User> {
lockedUser
}, lockedUsers);
}
private static void InsertIntoLog(int LessonId, int Type, Context context, string Details, StudentLessons sl = null)
{
var Lesson = context.Lessons.Where(x => x.Id == LessonId).FirstOrDefault();
LogsLessons lg = new LogsLessons();
lg.Type = Type;
lg.TimeStamp = DateTime.Now;
lg.LessonDate = Lesson.Start;
lg.LessonId = LessonId;
lg.Instructor_Id = Lesson.Instructor_Id;
lg.Details = Details;
if (sl != null)
{
lg.StudentId = sl.User_Id;
lg.Status = sl.Status;
}
lg.UserId = UsersService.GetCurrentUser().Id;
context.LogsLessons.Add(lg);
}
public async Task Ensure_Unique_Username()
{
var options = DbContextHelper.GetTestInMemoryDatabase(nameof(Ensure_Unique_Username));
using (var context = new NoteTakerContext(options, httpContextAccessor.Object))
{
var user = new User
{
Id = Guid.NewGuid(),
Username = "******",
FirstName = "John",
LastName = "Smith",
InternalId = 1,
Created = DateTime.Now,
Modified = DateTime.Now,
PasswordHash = Guid.NewGuid().ToString()
};
context.Users.Add(user);
context.SaveChanges();
}
using (var context = new NoteTakerContext(options, httpContextAccessor.Object))
{
var createUser = new CreateUser()
{
Username = "******",
FirstName = "John",
LastName = "Smith",
Password = "******"
};
var usersService = new UsersService(context, logger, passwordHashingService.Object, tokenService.Object);
var createdUser = await usersService.CreateUserAsync(createUser);
createdUser.Should().BeNull();
}
}
public void CreateOrderShouldCreateOrder()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: $"CreateOrderShouldCreateOrder_Orders_Database")
.Options;
var dbContext = new ApplicationDbContext(options);
var mapper = this.SetUpAutoMapper();
var brandService = new BrandsService(dbContext, mapper);
var categoriesService = new CategoriesService(dbContext, mapper);
var usersService = new UsersService(dbContext, mapper);
var productsService = new ProductsService(dbContext, mapper);
var shoppingCartsService = new ShoppingCartsService(dbContext, productsService, usersService, mapper);
var ordersService = new OrdersService(dbContext, shoppingCartsService, mapper);
var favouritesService = new FavouritesService(dbContext, productsService, usersService, mapper);
this.SeeDbdWithBrands(dbContext);
this.SeedDbWithCategories(dbContext);
var brands = brandService.FindAllBrands();
var categories = categoriesService.FindAllCategories();
var image = new Mock <IFormFile>();
this.SeedDbWithCountries(dbContext);
this.SeedDbWithUserAndProduct(dbContext, productsService, mapper.Map <Category>(categories[0]), mapper.Map <Brand>(brands[0]), image.Object);
var user = dbContext.Users.FirstOrDefault(x => x.UserName == "1");
var products = productsService.FindAllProducts();
var cart = this.SeedDbShoppingCartWithProducts(dbContext, user.UserName, products[0].Id);
var model = this.CreateOrderCreateBindingModel();
var orderId = ordersService.CreateOrder(model, mapper.Map <ApplicationUserDTO>(user));
Assert.True(dbContext.Orders.Count() == 1);
}
public ActionResult Confirm()
{
UsersService usersService = new UsersService();
AccountConfirmVM model = new AccountConfirmVM();
TryUpdateModel(model);
User user;
user = usersService.GetByID(model.UserID);
if (user == null)
{
ModelState.AddModelError(String.Empty, "User not exist.");
}
else
{
if (user.Password == model.Key)
{
user.Password = model.Password;
usersService.Save(user);
return(this.RedirectToAction(c => c.Login()));
}
Guid validKey;
if (user.Password != model.Key && !Guid.TryParse(model.Key, out validKey))
{
return(this.RedirectToAction(c => c.Confirm(user.ID, user.Password)));
}
}
if (!ModelState.IsValid)
{
return(View(model));
}
return(View("InactiveConfirmationLink"));
}
public async Task <IActionResult> OnPostSubmit()
{
if (!ModelState.IsValid)
{
LoadRoles(RoleName);
return(Page());
}
if (Input.Roles.Contains(Enumerations.RolesEnum.Admins.ToString()) && !User.IsInRole(Enumerations.RolesEnum.Admins.ToString()))
{
ModelState.AddModelError("", UsersResources.msg_YouMustBeAdminToCreateAdmins);
return(Page());
}
var result = await UsersService.Add(new ReturnResult <UserViewModel>() { Value = Input });
ModelState.Merge(result);
if (!ModelState.IsValid)
{
LoadRoles(RoleName);
return(Page());
}
if (string.IsNullOrEmpty(ReturnUrl))
{
ShowMessage(CoreEnumerations.MessageTypes.info, UsersResources.UserCreatedSuccessfully);
return(RedirectToPage("/Users/Index", new { area = "UserManagementAdmin" }));
}
else
{
ShowMessage(CoreEnumerations.MessageTypes.info, UsersResources.UserCreatedSuccessfullyStepOne);
return(Redirect($"{ReturnUrl}/{result.Value.Id}"));
}
}
public async Task AddToWishListShouldThrowIfUserDoesNotExist()
{
var userRepo = new Mock <IRepository <User> >();
userRepo.Setup(r => r.All()).Returns(new List <User>
{
new User
{
Id = "1",
UserName = "******",
PurchaseOrders = new List <Order>(),
Reports = new List <Report>(),
MyProducts = new List <Product>()
},
new User
{
Id = "2",
UserName = "******",
PurchaseOrders = new List <Order>(),
Reports = new List <Report>(),
MyProducts = new List <Product>()
},
new User
{
Id = "3",
UserName = "******",
PurchaseOrders = new List <Order>(),
Reports = new List <Report>(),
MyProducts = new List <Product>()
}
}.AsQueryable());
var service = new UsersService(userRepo.Object, null, null);
await Assert.ThrowsAsync <NullReferenceException>(async() => await service.AddProductToWhishlist("1", "nqkuv"));
userRepo.Verify(r => r.SaveChangesAsync(), Times.Never);
}
public void DeleteUserShould_ReturnTrue_whenDeletedUser()
{
//Arrange
var options = InMemory.GetOptions("DeleteUserShould_ReturnTrue_whenDeletedUser");
using (var context = new BOContext(options))
{
var cut = new User()
{
Id = 1,
Name = "SuperMan",
Password = "******",
};
var user = new User()
{
Id = 2,
Name = "Batman",
Password = "******",
};
context.Users.Add(cut);
context.Users.Add(user);
context.SaveChanges();
}
using (var context = new BOContext(options))
{
//Act
var sut = new UsersService(context);
var result = sut.DeleteUser(1).Result;
//Assert
var deletedUsers = context.Users.Where(u => u.IsDeleted == true).Count();
var activeUsers = context.Users.Where(u => u.IsDeleted == false).Count();
Assert.IsTrue(result);
Assert.AreEqual(1, deletedUsers);
Assert.AreEqual(1, activeUsers);
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
if (model.Password != model.ConfirmPassword)
{
ModelState.AddModelError("", "Confirm the password");
return(View(model));
}
if (UsersService.GetUser(model.Email) == null)
{
UsersService.AddUser(model.FirstName, model.LastName, model.Email,
model.Password, model.Zipcode);
}
else
{
ModelState.AddModelError("", "Email is already registered");
}
return(RedirectToAction("Login", "Account"));
//var result = await UserManager.CreateAsync(user, model.Password);
//if (result.Succeeded)
//{
// await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// // Send an email with this link
// // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
// return RedirectToAction("Index", "Home");
//}
//AddErrors(result);
}
return(View(model));
}
public void AddUserToRoleShouldAddUserToRoleAndReturnTrue()
{
var options = new DbContextOptionsBuilder <XeonDbContext>()
.UseInMemoryDatabase(databaseName: "AddUserToRole_Users_Database")
.Options;
var dbContext = new XeonDbContext(options);
var username = "******";
var users = new List <XeonUser>
{
new XeonUser {
UserName = "******",
},
new XeonUser {
UserName = "******",
},
new XeonUser {
UserName = username,
}
};
dbContext.Users.AddRange(users);
dbContext.SaveChanges();
var store = new Mock <IUserStore <XeonUser> >();
var userManager = new Mock <UserManager <XeonUser> >(store.Object, null, null, null, null, null, null, null, null);
userManager.Setup(m => m.FindByNameAsync(username))
.Returns(Task.FromResult <XeonUser>(users.FirstOrDefault(x => x.UserName == username)));
var usersService = new UsersService(dbContext, userManager.Object);
var role = "Admin";
var isUserAddInRole = usersService.AddUserToRole(username, role);
Assert.True(isUserAddInRole);
}
/// <summary>
/// recover list of books by last update datetime
/// </summary>
/// <param name="vUserKey"></param>
/// <param name="vLastUpdate"></param>
/// <returns></returns>
public async Task <List <Book> > GetBooksByLastUpdate(User user)
{
try
{
int forContinue = 0;
while (forContinue < 2)
{
httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", user.Token);
httpClient.DefaultRequestHeaders.Add("lastUpdate", user.LastUpdate.ToString("yyyy-MM-ddThh:mm:ss"));
HttpResponseMessage response = await httpClient.GetAsync(AcessFirebase.ApiUri + "/GetBooksByLastUpdate");
if (response.IsSuccessStatusCode)
{
string result = response.Content.ReadAsStringAsync().Result;
return(JsonConvert.DeserializeObject <List <Book> >(result));
}
else
{
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
UsersService usersService = new UsersService();
user = await usersService.RefreshUserToken(user);
//retry get
forContinue++;
}
else
{
return(null);
}
}
}
return(null);
}
catch (Exception ex) { throw ex; }
}
public async Task <IActionResult> Index(LoginViewModel viewModel, string returnUrl = "")
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
UsersService usersService = new UsersService();
var user = usersService.Login(viewModel.UserName, viewModel.Pwd);
if (user != null)
{
var claimsIdentity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
claimsIdentity.AddClaims(new List <Claim>()
{
new Claim(ClaimTypes.Sid, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.Name),
new Claim(ClaimTypes.Role, "admin"),
});
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), new AuthenticationProperties()
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(60),
AllowRefresh = true
});
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
return(Redirect("/Home/Index"));
}
else
{
ModelState.AddModelError("Pwd", "请检查用户或者密码是否正确");
return(View(viewModel));
}
}
public IActionResult LoginAsCommonUser([FromBody] UserDTO user)
{
try
{
UsersService UsersService = new UsersService();
//Busca usuario por email e senha
var usu = UsersService.GetUserbyEmail(user.Email);
object use = null;
//Caso achar retorna 200 e o usuario
if (usu != null)
{
IdDTO usuId = new IdDTO(usu.Id);
use = UsersService.Login(user.Email, user.Password);
if (use != null)
{
return(Ok(usuId));
}
else
{
return(StatusCode(412));
}
}
else
{
return(StatusCode(422));
//caso contrario retorna 412
}
}
catch (Exception e)
{
throw e;
}
}
public void ValidUpsertShouldModifyFieldsValues()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsertShouldModifyFieldsValues))
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var crValidator = new CreateValidator();
var usersService = new UsersService(context, validator, crValidator, null, config);
var added = new Lab6.Viewmodels.UserPostModel
{
FirstName = "Nume",
LastName = "Prenume",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Create(added);
var updated = new Lab6.Models.User
{
FirstName = "Alin",
LastName = "Popescu",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var userUpdated = usersService.Upsert(1, updated);
Assert.NotNull(userUpdated);
Assert.AreEqual("Alin", userUpdated.FirstName);
Assert.AreEqual("Popescu", userUpdated.LastName);
}
}
public void AddUserToRoleShouldAddTheUserToTheRole()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options));
var username = "******";
var users = new List <ApplicationUser>
{
new ApplicationUser {
UserName = "******",
},
new ApplicationUser {
UserName = "******",
},
new ApplicationUser {
UserName = username,
},
};
userRepository.AddRangeAsync(users);
userRepository.SaveChangesAsync();
var store = new Mock <IUserStore <ApplicationUser> >();
var userManager = new Mock <UserManager <ApplicationUser> >(store.Object, null, null, null, null, null, null, null, null);
userManager.Setup(m => m.FindByNameAsync(username))
.Returns(Task.FromResult <ApplicationUser>(users.FirstOrDefault(x => x.UserName == username)));
var usersService = new UsersService(userRepository, userManager.Object);
var role = "Admin";
var isUserAddInRole = usersService.AddUserToRole(username, role);
Assert.True(isUserAddInRole);
}
public void UpdateUserShouldUpdateUserDetails()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpdateUserShouldUpdateUserDetails))
.Options;
using (var context = new UsersDbContext(options))
{
var UsersService = new UsersService(context, registerValidator, config);
UsersService.Register(user);
var addedUser = context.Users.Last();
int id = addedUser.Id;
//int id = (from user in context.Users orderby user.Id descending select user.Id).First();
//string username = (from user in context.Users orderby user.Id descending select user.Username).First();
Assert.AreEqual(addedUser.Username, user.Username);
User newUserDetails = new User
{
FirstName = "newnew",
LastName = "newnew",
Username = "******",
Password = "******"
};
context.Entry(addedUser).State = EntityState.Detached;
UsersService.UpdateUserNoRoleChange(id, newUserDetails);
string newUsername = (from user in context.Users orderby user.Id descending select user.Username).First();
Assert.AreEqual(newUsername, newUserDetails.Username);
}
}
public void UpsertShouldModifyFildsValues()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyFildsValues))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added22 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "Nume",
LastName = "Prenume",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Create(added22);
//context.Entry(added22).State = EntityState.Detached;
var updated = new Lab3.ViewModels.UserPostModel
{
FirstName = "Alin",
LastName = "Popescu",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var userUpdated = usersService.Upsert(1, updated);
Assert.NotNull(userUpdated);
Assert.AreEqual("Alin", userUpdated.FirstName);
Assert.AreEqual("Popescu", userUpdated.LastName);
}
}
public void Get_users_by_prefix_returns_matching_users()
{
// Arrange
using (UserDbContext context = InMemoryDatabase.Get())
{
context.Users.Add(new User()
{
Id = "1", Username = "******"
});
context.Users.Add(new User()
{
Id = "2", Username = "******"
});
context.Users.Add(new User()
{
Id = "3", Username = "******"
});
context.Users.Add(new User()
{
Id = "4", Username = "******"
});
context.SaveChanges();
}
using (UserDbContext context = InMemoryDatabase.Get())
{
var service = new UsersService(context);
// Act
List <UserDto> users = service.GetUsersByNamePrefix("user").Result.OrderBy(u => u.Id).ToList();
// Assert
Assert.AreEqual(3, users.Count);
Assert.AreEqual("user1", users[0].Username);
Assert.AreEqual("User2", users[1].Username);
Assert.AreEqual("user", users[2].Username);
}
}
public async Task DoesUserIdExistShouldReturnFalseIfDeleted()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Users.AddAsync(
new ApplicationUser
{
Id = "userId1",
UserName = "******",
IsDeleted = true,
});
await db.SaveChangesAsync();
var usersSevice = new UsersService(db);
var result = await usersSevice.DoesUserIdExistAsync("userId1");
Assert.False(result);
}
public async Task GetUserShouldReturnCorrectResult()
{
var options = new DbContextOptionsBuilder <AlexandriaDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var db = new AlexandriaDbContext(options);
await db.Users.AddAsync(
new ApplicationUser
{
Id = "userId1",
UserName = "******",
});
await db.SaveChangesAsync();
var usersSevice = new UsersService(db);
var result = await usersSevice.GetUserByIdAsync <UserTestModel>("userId1");
Assert.Equal("userId1", result.Id);
Assert.Equal("user1", result.Username);
}
public static User ToUpdateUser(User existingUser, RegisterPostModel registerPostModel, User connectedUser)
{
UserRole userRole = new UserRole();
userRole = Models.UserRole.Regular;
existingUser.FirstName = registerPostModel.FirstName;
existingUser.LastName = registerPostModel.LastName;
existingUser.Email = registerPostModel.Email;
existingUser.Username = registerPostModel.Username;
existingUser.Password = UsersService.ComputeSha256Hash(registerPostModel.Password);
if (connectedUser.UserRole == Models.UserRole.Admin)
{
existingUser.UserRole = userRole;
}
if (connectedUser.UserRole == Models.UserRole.UserManager && ((DateTime.Now - connectedUser.DateRegistered).Days > 180))
{
existingUser.UserRole = userRole;
}
return(existingUser);
}
public void EditUser_AllProperties_Test()
{
var init = new InitializeMockContext();
var mock = init.mock;
var controller = new UsersService(mock.Object, new PostService(mock.Object, mapper, cloudinaryService), new FollowersService(mock.Object, mapper), new SignInService(mock.Object));
var expectedAvatarImgLink = "Testowy Komentarz";
var expectedAbout = "abouut";
var expectedBackgroundImgLink = "bacckgf";
var expectedName = "namee";
var expectedLink = "linkdd";
var editedUser = controller.EditUser(new EditUserCommand {
Id = 1, AvatarImgLink = expectedAvatarImgLink,
About = expectedAbout, BackgroundImgLink = expectedBackgroundImgLink, Name = expectedName, Link = expectedLink
});
mock.Verify(m => m.SaveChanges(), Times.Once());
Assert.AreEqual(expectedAvatarImgLink, editedUser.AvatarImgLink);
Assert.AreEqual(expectedAbout, editedUser.About);
Assert.AreEqual(expectedBackgroundImgLink, editedUser.BackgroundImgLink);
Assert.AreEqual(expectedName, editedUser.Name);
Assert.AreEqual(expectedLink, editedUser.Link);
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new Labo2.ViewModels.RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public async Task GetUserCountWorkCorrectly()
{
var users = new List <ApplicationUser>();
for (int i = 0; i < 5; i++)
{
var user = new ApplicationUser()
{
Email = "test@test" + i.ToString(),
UserName = "******" + i.ToString(),
};
users.Add(user);
}
await this.dbContext.Users.AddRangeAsync(users);
await this.dbContext.SaveChangesAsync();
var service = new UsersService(this.userRepository);
var userCount = service.GetUserCount();
Assert.Equal(5, userCount);
}
public void ShouldChangeUserBalance()
{
var userTableRepository = Substitute.For <IUserTableRepository>();
UserEntity args = new UserEntity
{
Name = "Vasya",
SurName = "Pypckin",
Balance = 50000,
Phone = "88005553535"
};
userTableRepository.GetUserById(Arg.Is(1)).Returns(args);
UsersService usersService = new UsersService(userTableRepository);
usersService.ChangeUserBalance(1, -2000);
userTableRepository.Contains(Arg.Is <UserEntity>(
u => u.Name == args.Name &&
u.SurName == args.SurName &&
u.Balance == args.Balance - 2000 &&
u.Phone == args.Phone)).Returns(true);
userTableRepository.Received(1).SaveChanges();
}
private async void connectBtn_Click(object sender, EventArgs e)
{
if (!string.IsNullOrWhiteSpace(this.usernameTextBox.Text))
{
this.Hide();
var usersSrv = new UsersService(null);
var user = await usersSrv.Get(usernameTextBox.Text);
if (user == null)
{
MessageBox.Show(@"Invalid credentials", @"Log on failed", MessageBoxButtons.OK);
return;
}
var newForm = new ClientForm(user);
newForm.Closed += (s, args) => this.Close();
newForm.Show();
}
else
{
MessageBox.Show(@"Invalid credentials", @"Log on failed", MessageBoxButtons.OK);
}
}
public ActionResult Edit(int id, UserViewModel model)
{
if (this.ModelState.IsValid)
{
UsersService users = ServiceFactory.GetUsersService();
User user = new User
{
Username = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
Phone = model.Phone,
Role = model.Role
};
users.AddUser(user);
this.TempData["State"] = "User is updated!";
return(RedirectToAction("List", "Users"));
}
else
{
return(View("~/Views/Users/Add.cshtml", model));
}
}
public void ValidRegisterShouldCreateANewUser() //daca dau date vreau sa creeze un nou user
{
var options = new DbContextOptionsBuilder <TasksDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new TasksDbContext(options)) //creaza un DbContext dar InMemory
{
var usersService = new UsersService(context, config);
var added = new TaskAgendaProj.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******"
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public void IsValidUser_ShouldReturnFalse_WhenCompanyAndBulstatNotUnique()
{
var user = new User()
{
Bulstat = "test", IsCompany = true
};
var users = new List <User>
{
user
}.AsQueryable();
var repositoryMock = new Mock <IInternalDbRepository <User> >();
repositoryMock.Setup(x => x.All()).Returns(users);
var service = new UsersService(repositoryMock.Object);
var response = service.IsCompanyAndBulstatCompatibiltyValid(user);
Assert.IsFalse(response);
repositoryMock.VerifyAll();
}
/// <summary>
/// Represents a service (scoped) for getting the client's preferred theme.
/// </summary>
/// <param name="options">The options to configure the <see cref="ClientThemeService"/>.</param>
public ClientThemeService(IOptions <ClientThemeOptions> options, IHttpContextAccessor httpContextAccessor, JewellisDbContext dbContext, UserIdentityService userIdentity, UsersService users)
{
if (string.IsNullOrEmpty(options.Value.DefaultTheme))
{
throw new ArgumentNullException("{options.DefaultTheme} cannot be null or empty.");
}
if (options.Value.SupportedThemes == null)
{
throw new ArgumentNullException("{options.SupportedThemes} cannot be null.");
}
if (options.Value.SupportedThemes.Length < 1)
{
throw new ArgumentException("{options.SupportedThemes} must have at least 1 supported theme.");
}
this.Options = options.Value;
_httpContextAccessor = httpContextAccessor;
_dbContext = dbContext;
_userIdentity = userIdentity;
_users = users;
this.InitializeClientTheme();
}
public CommentLikeController(UsersService users, CommentsLikesService likes)
: base(users)
{
this.likes = likes;
}
public ActionResult List()
{
UsersService usersService = new UsersService();
UsersListVM model = new UsersListVM();
TryUpdateModel(model);
model.Users = usersService.GetAll();
if (!String.IsNullOrEmpty(model.Search))
{
model.Users = model.Users.Where(u => u.FirstName.ToLower().Contains(model.Search.ToLower()) ||
u.LastName.ToLower().Contains(model.Search.ToLower())).ToList();
}
switch (model.SortOrder)
{
case "city_asc":
model.Users = model.Users.OrderBy(u => u.City.Name).ToList();
break;
case "city_desc":
model.Users = model.Users.OrderByDescending(u => u.City.Name).ToList();
break;
case "username_asc":
model.Users = model.Users.OrderBy(u => u.Username).ToList();
break;
case "username_desc":
model.Users = model.Users.OrderByDescending(u => u.Username).ToList();
break;
case "lname_asc":
model.Users = model.Users.OrderBy(u => u.LastName).ToList();
break;
case "lname_desc":
model.Users = model.Users.OrderByDescending(u => u.LastName).ToList();
break;
case "fname_desc":
model.Users = model.Users.OrderByDescending(u => u.FirstName).ToList();
break;
case "fname_asc":
default:
model.Users = model.Users.OrderBy(u => u.FirstName).ToList();
break;
}
int pageSize = 2;
int pageNumber = model.Page ?? 1;
model.PagedUsers = model.Users.ToPagedList(pageNumber, pageSize);
return View(model);
}
public void SendResetPasswordEmail_ShouldReturnFalse_IfAProblem()
{
var user = FakeUser();
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
emailService.Setup(x => x.Send(user.Email, It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>())).Returns(false);
var ret = service.SendResetPasswordToEmail(user.Email, "12345678");
emailService.Verify(x => x.Send("*****@*****.**", It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Once());
Assert.IsFalse(ret);
}
public IHttpActionResult Get(string id)
{
using (var reportsService = new ReportsService())
{
var report = reportsService.GetById(id);
if (report == null) throw new Exception("Report does not exist");
//Verifica que el usuario exista. De ahí toma el userName para armar en el objeto
var user = new UsersService().GetById(report._userId);
if (user == null) throw new Exception("User report does not exist");
report.userName = user.uname;
return Ok(report);
}
}
public AccountController()
{
service = new UsersService();
}
public void GetUserByIdReturnNullIfWrong()
{
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
var result = service.GetUserByProviderUserKey(null, "appTest");
Assert.IsNull(result);
}
public void SendResetPasswordEmail_ShouldReturnFalse_IfNewPasswordNull()
{
var user = FakeUser();
var service = new UsersService(emailService.Object, mockUsersRepository.Object);
emailService.Setup(x => x.Send(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>())).Returns(true);
var ret = service.SendResetPasswordToEmail("*****@*****.**", null);
emailService.Verify(x => x.Send(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never());
Assert.IsFalse(ret);
}
public UsersController()
{
service = new UsersService();
}
