// GET: Home
public async Task<ActionResult> Index()
{
var context = new ApplicationDbContext(); // DefaultConnection
var store = new UserStore<CustomUser>(context);
var manager = new UserManager<CustomUser>(store);
var email = "*****@*****.**";
var password = "******";
var user = await manager.FindByEmailAsync(email);
if (user == null)
{
user = new CustomUser
{
UserName = email,
Email = email,
FirstName = "Super",
LastName = "Admin"
};
await manager.CreateAsync(user, password);
}
else
{
user.FirstName = "Super";
user.LastName = "Admin";
await manager.UpdateAsync(user);
}
return Content("Hello, Index");
}
// GET: Home
public async Task<ActionResult> Index()
{
var context = new ApplicationDbContext(); // DefaultConnection
var store = new UserStore<CustomUser>(context);
var manager = new UserManager<CustomUser>(store);
var signInManager = new SignInManager<CustomUser, string>(manager,
HttpContext.GetOwinContext().Authentication);
var email = "*****@*****.**";
var password = "******";
var user = await manager.FindByEmailAsync(email);
if (user == null)
{
user = new CustomUser
{
UserName = email,
Email = email,
FirstName = "Super",
LastName = "Admin"
};
await manager.CreateAsync(user, password);
}
else
{
var result = await signInManager.PasswordSignInAsync(user.UserName, password, true, false);
if (result == SignInStatus.Success)
{
return Content("Hello, " + user.FirstName + " " + user.LastName);
}
//user.FirstName = "Super";
//user.LastName = "Admin";
//await manager.UpdateAsync(user);
}
return Content("Hello, Index");
}
public override Task AuthenticateExternalAsync(ExternalAuthenticationContext context)
{
// look for the user in our local identity system from the external identifiers
var user = Users.SingleOrDefault(x => x.Provider == context.ExternalIdentity.Provider && x.ProviderID == context.ExternalIdentity.ProviderId);
string name = "Unknown";
if (user == null)
{
// new user, so add them here
var nameClaim = context.ExternalIdentity.Claims.First(x => x.Type == Constants.ClaimTypes.Name);
if (nameClaim != null) name = nameClaim.Value;
user = new CustomUser
{
Subject = Guid.NewGuid().ToString(),
Provider = context.ExternalIdentity.Provider,
ProviderID = context.ExternalIdentity.ProviderId,
Claims = new List<Claim> { new Claim(Constants.ClaimTypes.Name, name) }
};
Users.Add(user);
}
name = user.Claims.First(x => x.Type == Constants.ClaimTypes.Name).Value;
context.AuthenticateResult = new AuthenticateResult(user.Subject, name, identityProvider: user.Provider);
return Task.FromResult(0);
}
public async Task<IActionResult> Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
model.Errors.AddModelStateErrors(ModelState);
return View(model);
}
var user = new CustomUser(model.Email);
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var signInResult = await signInManager.PasswordSignInAsync(user.UserName, model.Password, false, false);
if (signInResult.Succeeded)
{
return RedirectToAction("Index", "Home");
}
model.Errors.Add("Registration was successful however sign-in failed. Please try to sign in again");
}
else
{
foreach (var error in result.Errors)
{
model.Errors.Add(error.Description);
}
}
return View(model);
}
public Task<Thinktecture.IdentityServer.Core.Authentication.ExternalAuthenticateResult> AuthenticateExternalAsync(string subject, Thinktecture.IdentityServer.Core.Models.ExternalIdentity externalUser)
{
// look for the user in our local identity system from the external identifiers
var user = Users.SingleOrDefault(x => x.Provider == externalUser.Provider.Name && x.ProviderID == externalUser.ProviderId);
string name = "Unknown";
if (user == null)
{
// new user, so add them here
var nameClaim = externalUser.Claims.First(x => x.Type == Constants.ClaimTypes.Name);
if (nameClaim != null) name = nameClaim.Value;
user = new CustomUser {
Subject = Guid.NewGuid().ToString(),
Provider = externalUser.Provider.Name,
ProviderID = externalUser.ProviderId,
Claims = new List<Claim> { new Claim(Constants.ClaimTypes.Name, name) }
};
Users.Add(user);
}
name = user.Claims.First(x => x.Type == Constants.ClaimTypes.Name).Value;
if (user.IsRegistered)
{
// user not registered so we will issue a partial login and redirect them to our registration page
return Task.FromResult<ExternalAuthenticateResult>(new ExternalAuthenticateResult(user.Provider, user.Subject, name));
}
else
{
// user is registered so continue
return Task.FromResult<ExternalAuthenticateResult>(new ExternalAuthenticateResult("/core/externalregistration", user.Provider, user.Subject, name));
}
}
// GET: Home
public async Task<ActionResult> Index()
{
var email = "*****@*****.**";
var password = "******";
var user = await UserManager.FindByEmailAsync(email);
if (user == null)
{
user = new CustomUser
{
UserName = email,
Email = email,
FirstName = "Super",
LastName = "Admin"
};
await UserManager.CreateAsync(user, password);
}
else
{
var result = await SignInManager.PasswordSignInAsync(user.UserName, password, true, false);
if (result == SignInStatus.Success)
{
return Content("Hello, " + user.FirstName + " " + user.LastName);
}
//user.FirstName = "Super";
//user.LastName = "Admin";
//await manager.UpdateAsync(user);
}
return Content("Hello, Index");
}
public static void InternalSeed(CustomDbContext db)
{
var userManager = HttpContext.Current.GetOwinContext().GetUserManager<CustomUserManager>();
var roleManager = HttpContext.Current.GetOwinContext().Get<CustomRoleManager>();
const string name = "*****@*****.**";
const string password = "******";
const string roleName = "Admin";
//Create Role Admin if it does not exist
var role = roleManager.FindByName(roleName);
if (role == null)
{
role = new CustomRole(roleName);
var roleresult = roleManager.Create(role);
}
var user = userManager.FindByName(name);
if (user == null)
{
user = new CustomUser { UserName = name, Email = name };
var result = userManager.Create(user, password);
result = userManager.SetLockoutEnabled(user.Id, false);
}
// Add user admin to Role Admin if not already added
var rolesForUser = userManager.GetRoles(user.Id);
if (!rolesForUser.Contains(role.Name))
{
var result = userManager.AddToRole(user.Id, role.Name);
}
}
public async Task<ActionResult> Create(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var succeded = true;
var user = new CustomUser { UserName = model.Email, Email = model.Email };
var adminresult = await UserManager.CreateAsync(user, model.Password);
if (!adminresult.Succeeded)
{
ModelState.AddModelError("", adminresult.Errors.First());
}
else
{
user = await UserManager.FindByEmailAsync(model.Email);
var result = await UserManager.AddToCategoryAsync(user.Id, model.Category);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
}
else
{
return RedirectToAction("Index");
}
}
}
model.CategoriesList = new SelectList(await CategoryManager.Categories.ToListAsync(), "Name", "Name");
return View(model);
}
public static void AddNewUser(CustomUser NewCustomUser)
{
lock (GatesToUsers)
{
CurrentCollectionOfUsers.Add(NewCustomUser);
string UsersDataJson = JsonConvert.SerializeObject(CurrentCollectionOfUsers);
AccessorToWebConfig CurrentAccessorToWebConfig = new AccessorToWebConfig();
string FullPathToJsonDirectory = HttpContext.Current.Server.MapPath("/" + CurrentAccessorToWebConfig.NameOfDirectoryForJsonData);
string FullPathToFile = FullPathToJsonDirectory + "/" + CurrentAccessorToWebConfig.NameOfFileForJsonData;
File.WriteAllText(FullPathToFile, UsersDataJson, Encoding.UTF8);
}
}
public void AddUser(CustomUser customUser)
{
if (customUser == null)
{
throw new ArgumentNullException();
}
if (GetUserById(customUser.Id) != null)
{
throw new InvalidOperationException("Cannot add a user with the same Id: " + customUser.Id);
}
var user = xmlUserMap.Map(customUser);
GetUsersParentNode().Add(user);
CheckSync(true);
}
// GET: Home
public async Task<ActionResult> Index()
{
var email = "*****@*****.**";
var password = "******";
var user = await UserManager.FindByEmailAsync(email);
var roles = ApplicationRoleManager.Create(HttpContext.GetOwinContext());
if (!await roles.RoleExistsAsync(SecurityRoles.Admin))
{
await roles.CreateAsync(new IdentityRole {Name = SecurityRoles.Admin});
}
if (!await roles.RoleExistsAsync(SecurityRoles.IT))
{
await roles.CreateAsync(new IdentityRole { Name = SecurityRoles.IT });
}
if (!await roles.RoleExistsAsync(SecurityRoles.Accounting))
{
await roles.CreateAsync(new IdentityRole { Name = SecurityRoles.Accounting });
}
if (user == null)
{
user = new CustomUser
{
UserName = email,
Email = email,
FirstName = "Super",
LastName = "Admin"
};
await UserManager.CreateAsync(user, password);
}
else
{
//await UserManager.AddToRoleAsync(user.Id, SecurityRoles.Admin);
}
return Content("Hello, Index");
}
//
// GET: /Manage/Index
public virtual async Task <ActionResult> Index(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
: message == ManageMessageId.Error ? "An error has occurred."
: message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
: message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
: "";
var userId = User.Identity.GetUserId();
var model = new IndexViewModel
{
HasPassword = HasPassword(),
PhoneNumber = await CustomUser.GetPhoneNumberAsync(userId),
TwoFactor = await CustomUser.GetTwoFactorEnabledAsync(userId),
Logins = await CustomUser.GetLoginsAsync(userId),
BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(userId)
};
return(View(model));
}
public async Task <IActionResult> ManageRole(List <string> userId, string role)
{
if (!(await _customRoleService.IsUserInRoleAsync(await _userManager.GetUserAsync(User), Roles.DemoUser.ToString())))
{
foreach (var id in userId)
{
CustomUser user = await _dbContext.Users.FindAsync(id);
if (!await _customRoleService.IsUserInRoleAsync(user, role))
{
var userRole = await _customRoleService.ListUserRoleAsync(user);
foreach (var roles in userRole)
{
await _customRoleService.RemoveUserFromRoleAsync(user, roles);
}
await _customRoleService.AddUserToRoleAsync(user, role);
}
}
return(View());
}
return(RedirectToAction("DemoUser", "Projects"));
}
//
// GET: /Manage/ManageLogins
public virtual async Task <ActionResult> ManageLogins(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
var user = await CustomUser.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(View("Error"));
}
var userLogins = await CustomUser.GetLoginsAsync(User.Identity.GetUserId());
var otherLogins = AuthenticationManager.GetExternalAuthenticationTypes().Where(auth => userLogins.All(ul => auth.AuthenticationType != ul.LoginProvider)).ToList();
ViewBag.ShowRemoveButton = user.Password != null || userLogins.Count > 1;
return(View(new ManageLoginsViewModel
{
CurrentLogins = userLogins,
OtherLogins = otherLogins
}));
}
public ActionResult <CustomUser> Login(CustomUser user)
{
var isValid = _context.UserItems.Any(u => u.Email.Equals(user.Email) &&
u.Password.Equals(user.Password));
var User = _context.UserItems.Where(u => u.Email == user.Email).FirstOrDefault();
//var projectName = _context.Project.Where(p => p.ProjectId == User.ProjectId).FirstOrDefault().ProjectName;
if (isValid)
{
CustomUser customUser = new CustomUser
{
UserId = User.UserId,
UserName = User.UserName,
Email = user.Email,
//ProjectName = projectName,
ProjectId = User.ProjectId,
};
return(customUser);
}
return(null);
}
public async Task <IActionResult> ChangePassword(ChangePasswordVM changePasswordVM)
{
if (!ModelState.IsValid)
{
return(View(changePasswordVM));
}
string activeUserName = User.Identity.Name;
CustomUser customUserFromDb = await _userManager.FindByNameAsync(activeUserName);
IdentityResult result = await _userManager.ChangePasswordAsync(customUserFromDb, changePasswordVM.CurrentPassword, changePasswordVM.NewPassword);
await _userManager.UpdateAsync(customUserFromDb);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Hazırki şifrə yanlışdır və ya yeni şifrə tələblərə uyğun deyil.");
return(View(changePasswordVM));
}
TempData["PasswordChanged"] = true;
return(RedirectToAction("List", "Employee"));
}
public ActionResult <CustomUser> Register([FromBody] UserCredentials credentials)
{
var userExists = _users
.OfType <CustomUser>()
.FindSync(user => user.Email == credentials.Email)
.Any();
if (userExists)
{
return(BadRequest("User is already registered!"));
}
var customUser = new CustomUser
{
Id = Guid.NewGuid().ToString(),
Email = credentials.Email,
PasswordHash = HashPassword(credentials.Password)
};
_users.InsertOne(customUser);
return(customUser);
}
public async Task <IActionResult> Register([FromBody] UserViewModel user)
{
if (user == null || !ModelState.IsValid)
{
return(BadRequest());
}
CustomUser customUser = new CustomUser {
UserName = user.UserName, Email = user.Email
};
IdentityResult result = await _userManager.CreateAsync(customUser, user.Password);
if (result.Succeeded)
{
IdentityResult claimIdentityResult = await _userManager.AddClaimAsync(customUser, new Claim(ClaimTypes.Role, user.Role));
if (claimIdentityResult.Succeeded)
{
return(Created(string.Empty, null));
}
}
return(StatusCode(500, result.Errors));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
CustomUser user = new CustomUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User Created a new account with password");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User Created a new account with password");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
return(View(model));
}
public List <OrderInvoiceViewModel> CreateOrderInvoiceList(CustomUser user)
{
List <OrderInvoiceViewModel> oivmList = new List <OrderInvoiceViewModel>();
List <OrderInventory> oList = new List <OrderInventory>();
foreach (OrderInventory o in _repo.orderInventories)
{
foreach (Order order in _repo.orders)
{
if (order.Id == user.Id && o.OrderId == order.OrderId)
{
oList.Add(o);
}
}
}
foreach (OrderInventory o in _repo.orderInventories)
{
Product p = _repo.products.FirstOrDefault(x => x.ProductId == o.ProductId);
oivmList.Add(_mapper.CreateOrderInvoiceViewModel(user, p, o));
}
return(oivmList);
}
private async Task CreateRoles(IServiceProvider serviceProvider)
{
var RoleManager = serviceProvider.GetRequiredService <RoleManager <CustomRole> >();
var UserManager = serviceProvider.GetRequiredService <UserManager <CustomUser> >();
string[] roleNames = { "Admin" };
IdentityResult roleResult;
foreach (var roleName in roleNames)
{
var roleExist = await RoleManager.RoleExistsAsync(roleName);
if (!roleExist)
{
roleResult = await RoleManager.CreateAsync(new CustomRole(roleName));
}
}
var _user = await UserManager.FindByEmailAsync("*****@*****.**");
if (_user == null)
{
var adminUser = new CustomUser
{
UserName = "******",
Email = "*****@*****.**",
};
string adminPassword = "******";
var createAdminUser = await UserManager.CreateAsync(adminUser, adminPassword);
if (createAdminUser.Succeeded)
{
await UserManager.AddToRoleAsync(adminUser, "Admin");
}
}
}
public async Task <IActionResult> Post([FromBody] RegisterModel model)
{
try
{
var newUser = new CustomUser {
FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(newUser, model.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(x => x.Description);
return(Ok(new RegisterResult {
Successful = false, Errors = errors
}));
}
// Add all new users to the User role
await _userManager.AddToRoleAsync(newUser, "User");
// Add new users whose email starts with 'admin' to the Admin role
if (newUser.Email.StartsWith("azur"))
{
await _userManager.AddToRoleAsync(newUser, "Admin");
}
return(Ok(new RegisterResult {
Successful = true
}));
}
catch
{
return(Ok(new RegisterResult {
Successful = false
}));
}
}
public void CallUnitOfWork_CommitOnce_WhenCalledWithIntId()
{
// Arrange
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Id = 1
};
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedStatisticRepository = new Mock <IEFRepository <Statistic> >();
var statistic = new Statistic()
{
CustomUserId = 1
};
var statistics = new List <Statistic>()
{
statistic
}.AsQueryable();
mockedStatisticRepository.Setup(x => x.All).Returns(statistics);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedStatisticFactory = new Mock <IStatisticFactory>();
var statisticService = new StatisticService(
mockedUserService.Object,
mockedStatisticRepository.Object,
mockedUnitOfWork.Object,
mockedStatisticFactory.Object);
int userId = 1;
// Act
statisticService.AddNotificationStatistic(userId);
// Assert
mockedUnitOfWork.Verify(x => x.Commit(), Times.Once);
}
public void IncreasedStatistic_NotificationCountWithOne_WhenCalledWithIntId()
{
// Arrange
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Id = 1
};
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedStatisticRepository = new Mock <IEFRepository <Statistic> >();
var statistic = new Statistic()
{
CustomUserId = 1
};
var statistics = new List <Statistic>()
{
statistic
}.AsQueryable();
mockedStatisticRepository.Setup(x => x.All).Returns(statistics);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedStatisticFactory = new Mock <IStatisticFactory>();
var statisticService = new StatisticService(
mockedUserService.Object,
mockedStatisticRepository.Object,
mockedUnitOfWork.Object,
mockedStatisticFactory.Object);
int userId = 1;
// Act
statisticService.AddNotificationStatistic(userId);
// Assert
Assert.AreEqual(statistic.NotificationsCount, 1);
}
public void CallUserService_GetByIndentityIdOnce()
{
// Arrange
var mockedPublicationRepository = new Mock <IEFRepository <Publication> >();
var mockedFriendsService = new Mock <IFriendService>();
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Publications = new List <Publication>()
};
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedPublicationFactory = new Mock <IPublicationFactory>();
var mockedDateTimeService = new Mock <IDateTimeService>();
var mockedPublicationImageFactory = new Mock <IPublicationImageFactory>();
var mockedCommentService = new Mock <ICommentService>();
var publicationService = new PublicationService(
mockedPublicationRepository.Object,
mockedFriendsService.Object,
mockedUserService.Object,
mockedUnitOfWork.Object,
mockedPublicationFactory.Object,
mockedDateTimeService.Object,
mockedPublicationImageFactory.Object,
mockedCommentService.Object);
string userId = "test-id";
int skip = 0;
int count = 2;
// Act
publicationService.UserPublications(userId, skip, count);
// Assert
mockedUserService.Verify(x => x.GetByIndentityId(It.Is <string>(i => i == userId)), Times.Once);
}
public void ReturnDefaultView()
{
// Arrange
var mockedAccountService = new Mock <IAccountService>();
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Id = 2
};
mockedUserService.Setup(x => x.GetById(It.IsAny <int>())).Returns(user);
var mockedFriendService = new Mock <IFriendService>();
var mockedViewModelService = new Mock <IViewModelService>();
var model = new ProfileViewModel()
{
Friends = new List <ProfileFriendViewModel>()
};
mockedViewModelService.Setup(x => x.GetMappedProfile(It.IsAny <CustomUser>())).Returns(model);
var profileController = new ProfileController(
mockedAccountService.Object,
mockedUserService.Object,
mockedFriendService.Object,
mockedViewModelService.Object);
int id = 4;
// Act & Assert
profileController
.WithCallTo(x => x.Index(id))
.ShouldRenderDefaultView()
.WithModel <ProfileViewModel>(x =>
{
Assert.AreEqual(model, x);
});
}
public void CallStatisticRepository_UpdateOnce()
{
// Arrange
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Id = 1
};
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedStatisticRepository = new Mock <IEFRepository <Statistic> >();
var statistic = new Statistic()
{
CustomUserId = 1
};
var statistics = new List <Statistic>()
{
statistic
}.AsQueryable();
mockedStatisticRepository.Setup(x => x.All).Returns(statistics);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedStatisticFactory = new Mock <IStatisticFactory>();
var statisticService = new StatisticService(
mockedUserService.Object,
mockedStatisticRepository.Object,
mockedUnitOfWork.Object,
mockedStatisticFactory.Object);
string userId = "some-id";
// Act
statisticService.AddMessageStatistic(userId);
// Assert
mockedStatisticRepository.Verify(x => x.Update(It.Is <Statistic>(s => s == statistic)), Times.Once);
}
public void CallDateTimeService_GetCurrentDateOnce()
{
// Arrange
var mockedPublicationRepository = new Mock <IEFRepository <Publication> >();
var publication = new Publication();
mockedPublicationRepository.Setup(x => x.GetById(It.IsAny <int>())).Returns(publication);
var mockedFriendsService = new Mock <IFriendService>();
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser();
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedPublicationFactory = new Mock <IPublicationFactory>();
var mockedDateTimeService = new Mock <IDateTimeService>();
var mockedPublicationImageFactory = new Mock <IPublicationImageFactory>();
var mockedCommentService = new Mock <ICommentService>();
var publicationService = new PublicationService(
mockedPublicationRepository.Object,
mockedFriendsService.Object,
mockedUserService.Object,
mockedUnitOfWork.Object,
mockedPublicationFactory.Object,
mockedDateTimeService.Object,
mockedPublicationImageFactory.Object,
mockedCommentService.Object);
int publicationId = 12;
string content = "some content";
string userId = "test-id";
// Act
publicationService.CreatePublicationComment(publicationId, content, userId);
// Assert
mockedDateTimeService.Verify(x => x.GetCurrentDate(), Times.Once);
}
public virtual async Task <ActionResult> VerifyCode(VerifyCodeViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// The following code protects for brute force attacks against the two factor codes.
// If a user enters incorrect codes for a specified amount of time then the user account
// will be locked out for a specified amount of time.
// You can configure the account lockout settings in IdentityConfig
var result = await CustomSignIn.TwoFactorSignInAsync(model.Provider, model.Code, isPersistent : model.RememberMe, rememberBrowser : model.RememberBrowser);
switch (result)
{
case SignInStatus.Success:
var userId = await CustomSignIn.GetVerifiedUserIdAsync().WithCurrentCulture();
var accountBL = ServiceLocator.Current.GetInstance <IAccountBL>();
await accountBL.ApproveVerification(Convert.ToInt32(userId));
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
var user = await CustomUser.FindByIdAsync(userId);
await CustomSignIn.SignInAsync(user, model.RememberMe, model.RememberBrowser);
return(RedirectToLocal(model.ReturnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid code.");
return(View(model));
}
}
public async Task <IActionResult> CreateUser(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CustomUser
{
UserName = model.Email,
Email = model.Email,
R = 1.5,
P = 1000,
C = 678,
A = 2000,
K0 = 0.65,
K1 = 1.25,
K2 = 1.85,
K3 = 2.45,
Func = "-2*x + 4*x^2/3 - 7"
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await _userManager.ConfirmEmailAsync(user, token);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> MyLists(string name)
{
if (name == null)
{
return(NotFound());
}
CustomUser customUserFromDb = await _userManager.FindByNameAsync(name);
if (customUserFromDb == null)
{
return(NotFound());
}
IEnumerable <Announcement> announcements = _context.Announcements.Where(announce => announce.CustomUserId == customUserFromDb.Id)
.Include(announce => announce.Automobile)
.ThenInclude(announce => announce.Model)
.ThenInclude(announce => announce.Brand)
.Include(announce => announce.Location)
.Include(announce => announce.Automobile)
.ThenInclude(announce => announce.Color)
.Include(announce => announce.Automobile)
.ThenInclude(announce => announce.Fuel);
return(View(announcements));
}
public void CallUserService_GetByIndentityIdOnce()
{
// Arrange
var mockedUserService = new Mock <IUserService>();
var user = new CustomUser()
{
Id = 1
};
mockedUserService.Setup(x => x.GetByIndentityId(It.IsAny <string>())).Returns(user);
var mockedStatisticRepository = new Mock <IEFRepository <Statistic> >();
var statistics = new List <Statistic>()
{
new Statistic()
{
CustomUserId = 1
}
}.AsQueryable();
mockedStatisticRepository.Setup(x => x.All).Returns(statistics);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedStatisticFactory = new Mock <IStatisticFactory>();
var statisticService = new StatisticService(
mockedUserService.Object,
mockedStatisticRepository.Object,
mockedUnitOfWork.Object,
mockedStatisticFactory.Object);
string userId = "some-id";
// Act
statisticService.RemoveNotificationStatistic(userId);
// Assert
mockedUserService.Verify(x => x.GetByIndentityId(It.Is <string>(i => i == userId)), Times.Once);
}
public async Task <IActionResult> ChangePassword(ChangePasswordVM changePasswordVM)
{
if (!ModelState.IsValid)
{
return(View(changePasswordVM));
}
currentUser = await MainUtility.FindAnActiveUser(_userManager, User.Identity.Name);
CustomUser customUserFromDb = await _userManager.FindByIdAsync(currentUser.Id);
IdentityResult result = await _userManager.ChangePasswordAsync(customUserFromDb, changePasswordVM.CurrentPassword, changePasswordVM.NewPassword);
await _userManager.UpdateAsync(customUserFromDb);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Hazırki şifrə yanlışdır və ya yeni şifrə tələblərə uyğun deyil.");
return(View(changePasswordVM));
}
TempData["PasswordChanged"] = true;
return(RedirectToAction("MyPosts", "Profile", new { userId = currentUser.Id }));
}
public Order PlaceOrder(CustomUser user)
{
List <InvoiceViewModel> ivmList = CreateInvoiceList(user);
Order order = new Order()
{
CartId = user.CartId,
Id = user.Id,
LocationId = ivmList.FirstOrDefault(x => x.Id == user.Id).LocationId,
OrderTime = DateTime.Now,
OrderTotal = ivmList.Sum(x => x.LineTotal)
};
_repo.orders.Add(order);
foreach (InvoiceViewModel ivm in ivmList)
{
_repo.orderInventories.Add(new OrderInventory()
{
OrderId = order.OrderId, ProductId = ivm.Product.ProductId, OrderQuantity = ivm.Quantity
});
}
EmptyCurrentCart(user);
_repo.CommitSave();
return(order);
}
private async Task <string> EnsureUser(IServiceProvider serviceProvider,
string testUserPw, string UserName)
{
var userManager = serviceProvider.GetService <ICustomUserManager>();
var user = await userManager.FindByNameAsync(UserName);
if (user == null)
{
user = new CustomUser
{
UserName = UserName,
EmailConfirmed = true
};
var result = await userManager.CreateAsync(user, testUserPw);
}
if (user == null)
{
throw new Exception("The password is probably not strong enough!");
}
return(user.Id);
}
private void CreateAndLoginUser()
{
if (!IsValid)
{
return;
}
var manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
var signInManager = Context.GetOwinContext().GetUserManager <ApplicationSignInManager>();
var user = new CustomUser {
UserName = email.Text, Email = email.Text
};
IdentityResult result = manager.Create(user);
if (result.Succeeded)
{
var loginInfo = Context.GetOwinContext().Authentication.GetExternalLoginInfo();
if (loginInfo == null)
{
RedirectOnFail();
return;
}
result = manager.AddLogin(user.Id, loginInfo.Login);
if (result.Succeeded)
{
signInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// var code = manager.GenerateEmailConfirmationToken(user.Id);
// Send this link via email: IdentityHelper.GetUserConfirmationRedirectUrl(code, user.Id)
IdentityHelper.RedirectToReturnUrl(Request.QueryString["ReturnUrl"], Response);
return;
}
}
AddErrors(result);
}
public async Task CreateTemporaryUserAsync()
{
string IpAdress = _userDetector.GetUserIpAdress();
string connectionId = _userDetector.GetUserConnectionId();
if (_context.Users.FirstOrDefault(u => u.IpAdress == IpAdress && u.ConnectionId == connectionId) == null)
{
var NumberOfUser = _context.Users.ToList().Count() + 1;
var tempEmail = "tempUser" + NumberOfUser.ToString() + "@lanonlinemarket.com";
var userName = tempEmail;
var user = new CustomUser
{
UserName = userName,
Email = tempEmail,
FirstName = "User",
LastName = $"#{NumberOfUser}",
IpAdress = IpAdress,
ConnectionId = connectionId,
ImageData = null,
ContentType = null,
Street = null,
State = null,
City = null,
Zipcode = null,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, "Abc123!");
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, "TemporaryUser");
}
}
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CustomUser { UserName = model.Email, Email = model.Email };
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 https://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);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public void CallUserRepository_GetByIdOnce()
{
// Arrange
var mockedAspIdentityUserFactory = new Mock <IAspIdentityUserFactory>();
var mockedUserFactory = new Mock <ICustomUserFactory>();
var mockedUserRepository = new Mock <IEFRepository <CustomUser> >();
var user = new CustomUser()
{
ProfileImage = new ProfileImage()
{
Content = new byte[] { 1, 2 }
}
};
mockedUserRepository.Setup(x => x.GetById(It.IsAny <int>())).Returns(user);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedImageService = new Mock <IImageService>();
var mockedProfileLogoFactory = new Mock <IProfileLogoFactory>();
var accountService = new AccountService(
mockedAspIdentityUserFactory.Object,
mockedUserFactory.Object,
mockedUserRepository.Object,
mockedUnitOfWork.Object,
mockedImageService.Object,
mockedProfileLogoFactory.Object);
var stream = new MemoryStream();
int id = 2;
// Act
accountService.ChangeProfileImage(stream, id);
// Assert
mockedUserRepository.Verify(x => x.GetById(It.Is <int>(i => i == id)), Times.Once);
}
public void Initialize()
{
int index = 0;
int max_index = 100;
db_user = DBCustomUser.GetInstance();
db_product = DB_Product.GetInstance();
db_userproduct = DB_UserProduct.GetInstance();
Product product;
user = new CustomUser
{
Username = "******",
Password = "******",
Email = "ClassLibriry1 - Test UserProduct Database - User",
Wallet = 5000.0,
IsActive = true,
LoggedIn = true
};
db_user.CreateUser(user);
while (index < max_index)
{
product = new Product
{
Name = "ClassLibriry1 - Test UserProduct Database - Product",
Price = 50.0 + (double)index
};
db_product.CreateProduct(product);
index++;
}
products = db_product.FindProductByPriceHigher(25.0);
}
/// <summary>
/// Пользователи, которые входят в группу
/// </summary>
/// <param name="groupName"></param>
/// <returns></returns>
public static CustomUserList GetGroupUsers(string groupName)
{
var result = new CustomUserList();
using (var ctx = new PrincipalContext(ContextType.Domain))
using (var groupPrincipal = GroupPrincipal.FindByIdentity(ctx, groupName))
{
if (groupPrincipal != null)
{
foreach (UserPrincipal user in groupPrincipal.GetMembers(true))
{
if (user.Enabled == true)
{
HasUserInfo ifUser = new PrUser(user);
var OutUser = new CustomUser(ifUser);
result.Add(OutUser);
}
}
}
}
return(result);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new CustomUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var 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 this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return View("DisplayEmail");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return RedirectToAction("Index", "Manage");
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return View("ExternalLoginFailure");
}
var user = new CustomUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
public void UpdateUser(CustomUser customUser)
{
if (customUser == null)
{
throw new ArgumentNullException();
}
if (GetUserById(customUser.Id) == null)
{
throw new InvalidOperationException("Cannot edit user with id: " + customUser.Id + ". User does not exist.");
}
if (GetUserElementsByEmail(customUser.EmailAddress).Count() > 1)
{
throw new InvalidOperationException("Cannot edit the email because another user with the same email already exists: " + customUser.EmailAddress);
}
var user = xmlUserMap.Map(customUser);
GetUserElementsById(customUser.Id).Remove();
GetUsersParentNode().Add(user);
CheckSync();
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
bool isValid = true;
MembershipUser newUser = null;
status = MembershipCreateStatus.Success;
DateTime currentDate = DateTime.Now;
if (username == null || username.Trim().Length == 0)
{
status = MembershipCreateStatus.InvalidUserName;
isValid = false;
}
if (isValid && (password == null || password.Trim().Length == 0))
{
status = MembershipCreateStatus.InvalidPassword;
isValid = false;
}
// only validate the e-mail format in case it is neither null nor empty
if (isValid && !String.IsNullOrWhiteSpace(email))
{
String strRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" +
@"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" +
@".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$";
Regex regex = new Regex(strRegex);
if (!regex.IsMatch(email))
{
status = MembershipCreateStatus.InvalidEmail;
isValid = false;
}
}
CustomUserDAO userDAO = new CustomUserDAO();
/*
* Validate e-mail for the case where it is required to be unique. Here the
* API states that if so, there MUST be an e-mail provided, as stated in:
* http://msdn.microsoft.com/en-us/library/d8t4h2es.aspx
*
* You can see that in the following part:
*
* "The SqlMembershipProvider provides an option to require a unique e-mail
* address for each user. If the RequiresUniqueEmail property is true, you
* will need to use one of the CreateUser overloads that allows you to specify
* an e-mail address for the user being created. Otherwise, a
* MembershipCreateUserException will be thrown."
*
*/
if (isValid && RequiresUniqueEmail)
{
// the e-mail cannot be null nor empty
if (String.IsNullOrWhiteSpace(email))
{
status = MembershipCreateStatus.InvalidEmail;
isValid = false;
}
// since the validation above passed, check whether the e-mail is unique
if (isValid)
{
CustomUser sameEmailUser = userDAO.FindByEmail(email, this.ApplicationName);
if (sameEmailUser != null)
{
status = MembershipCreateStatus.DuplicateEmail;
isValid = false;
}
}
}
// validates password
if (isValid)
{
ValidatePasswordEventArgs args = new ValidatePasswordEventArgs(username, password, true);
OnValidatingPassword(new ValidatePasswordEventArgs(username, password, true));
if (args.Cancel)
{
status = MembershipCreateStatus.InvalidPassword;
isValid = false;
}
}
if (providerUserKey == null)
{
providerUserKey = Guid.NewGuid();
}
else if (!(providerUserKey is Guid))
{
status = MembershipCreateStatus.InvalidProviderUserKey;
isValid = false;
}
if (isValid)
{
CustomUser sameNameUser = userDAO.FindByName(username, this.appName);
if (sameNameUser != null)
{
status = MembershipCreateStatus.DuplicateUserName;
isValid = false;
}
}
if (isValid)
{
CustomUser user = new CustomUser(this.membershipApplication,
(Guid) providerUserKey,
username,
MembershipEncryptionManager.Encrypt(password, PasswordFormat),
email,
passwordQuestion,
passwordAnswer,
isApproved,
false,
currentDate,
currentDate,
currentDate,
currentDate);
userDAO.SaveOrUpdate(user);
newUser = CreateMembershipUser(user);
status = MembershipCreateStatus.Success;
}
return newUser;
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
CustomUser NewUser = new CustomUser(username, password);
DataStorageForJson.AddNewUser(NewUser);
status = MembershipCreateStatus.Success;
return this.GetUser(username, true);
}
private MembershipUser CreateMembershipUser(CustomUser user)
{
DateTime theDateTime = new DateTime();
return new MembershipUser(providerName,
user.Name,
user.Id,
user.Email,
user.PasswordQuestion,
user.Comment,
user.IsApproved.HasValue ? user.IsApproved.Value : true,
user.IsLockedOut.HasValue ? user.IsLockedOut.Value : false,
user.CreationDate = user.CreationDate,
user.LastLoginDate.HasValue ? user.LastLoginDate.Value : theDateTime,
user.LastActivityDate.HasValue ? user.LastActivityDate.Value : theDateTime,
user.LastPasswordChangedDate.HasValue ? user.LastPasswordChangedDate.Value : theDateTime,
user.LastLockedOutDate.HasValue ? user.LastLockedOutDate.Value : theDateTime);
}
protected async Task SignInAsync(CustomUser user, bool isPersistent)
{
AuthenticationManager.SignOut(
DefaultAuthenticationTypes.ExternalCookie,
DefaultAuthenticationTypes.TwoFactorCookie
);
AuthenticationManager.SignIn(
new AuthenticationProperties { IsPersistent = isPersistent },
UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie).Result
);
}
