internal void AddUserAndRole()
{
// access the application context and create result variables.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// create roleStore object that can only contain IdentityRole objects by using the ApplicationDbContext object.
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// create admin role if it doesn't already exist
if (!roleMgr.RoleExists("admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "admin" });
}
// create a UserManager object based on the UserStore object and the ApplicationDbContext object.
// defines admin email account
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Pa$$word1");
// If the new admin user was successfully created, add the new user to the "admin" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "admin");
}
}
internal void AddUserAndRole()
{
// Access the application context and create result variable.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole Objects.
var roleStore = new RoleStore<IdentityRole>(context);
// Create a RoleManager object that is only allowed to contain IdentityRole objects.
// When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object.
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// Then, you create the "canEdit" role if it doesn't already exist.
if (!roleMgr.RoleExists("canEdit"))
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "canEdit" });
// Create a UserManager object based on the UserStore objcet and the ApplicationDbContext objcet.
// Note that you can create new objects and use them as parameters in a single line of code, rather than using multiple lines of code, as you did for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Pa$$word1");
// If the new "canEdit" user was successfully created, add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit"))
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
/// <summary>
/// Checks for the three roles - Admin, Employee and Complainant and
/// creates them if not present
/// </summary>
public static void InitializeRoles()
{ // Access the application context and create result variables.
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole objects.
var roleStore = new RoleStore<IdentityRole>(context);
RoleManager roleMgr = new RoleManager();
if (!roleMgr.RoleExists("Administrator"))
{
roleMgr.Create(new ApplicationRole { Name = "Administrator" });
}
if (!roleMgr.RoleExists("Employee"))
{
roleMgr.Create(new ApplicationRole { Name = "Employee" });
}
if (!roleMgr.RoleExists("Complainant"))
{
roleMgr.Create(new ApplicationRole { Name = "Complainant" });
}
if (!roleMgr.RoleExists("Auditor"))
{
roleMgr.Create(new ApplicationRole { Name = "Auditor" });
}
// Create a UserManager object based on the UserStore object and the ApplicationDbContext
// object. Note that you can create new objects and use them as parameters in
// a single line of code, rather than using multiple lines of code, as you did
// for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Admin123");
// If the new "canEdit" user was successfully created,
// add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Administrator"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "Administrator");
}
appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Auditor123");
// If the new "canEdit" user was successfully created,
// add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Auditor"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "Auditor");
}
}
internal void AddUserAndRole()
{
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
RoleStore<IdentityRole> roleStore = new RoleStore<IdentityRole>(context);
RoleManager<IdentityRole> roleMgr = new RoleManager<IdentityRole>(roleStore);
//create admin role
if(!roleMgr.RoleExists("admin")) {
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "admin" });
}
//create master user
UserManager<ApplicationUser> userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
ApplicationUser appUser = new ApplicationUser {
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Baseball1!");
//add to admin role
if(!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "admin")) {
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "admin");
}
}
internal void AddUserAndRole()
{
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("Admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "Admin" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "adminA123...");
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
}
internal void AddUserAndRole()
{
Models.ApplicationDbContext db = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(db);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("canEdit"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "canEdit" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "NhatSinh123*");
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
}
internal void AddToNormalUserRole(ApplicationUser user)
{
Models.ApplicationDbContext context = new ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (!userMgr.IsInRole(userMgr.FindByEmail(user.Email).Id, "Normal"))
{
userMgr.AddToRole(userMgr.FindByEmail(user.Email).Id, "Normal");
}
}
/*This should be removed after the first admin gets made */
// GET: MakeMeAdmin/Create
public ActionResult Create(string email)
{
using (var context = new ApplicationDbContext())
{
var fadmin = context.KeyValueSettings.FirstOrDefault(s => s.Key == "FirstAdminSet");
if (fadmin == null || fadmin.Value == "false")
{
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
roleManager.Create(new IdentityRole("Admin"));
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var user = userManager.FindByEmail(email);
userManager.AddToRole(user.Id, "Admin");
if (fadmin == null)
{
context.KeyValueSettings.Add(new KeyValueSettings() { Key = "FirstAdminSet", Value = "true" });
}
else
{
fadmin.Value = "true";
}
context.SaveChanges();
return Json(true, JsonRequestBehavior.AllowGet);
}
}
return Json(false, JsonRequestBehavior.AllowGet);
}
public string getUserId(string user_name)
{
Models.ApplicationDbContext context = new ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var Id = userMgr.FindByEmail(user_name).Id;
return Id;
}
protected override void Seed(Context context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data. E.g.
//
// context.People.AddOrUpdate(
// p => p.FullName,
// new Person { FullName = "Andrew Peters" },
// new Person { FullName = "Brice Lambson" },
// new Person { FullName = "Rowan Miller" }
// );
//
var userStore = new UserStore<ApplicationUser>(context);
var mngr = new UserManager<ApplicationUser>(userStore);
context.Roles.AddOrUpdate(r => r.Name, new IdentityRole { Name = "Administrators" });
ApplicationUser adm = new ApplicationUser();
adm.Email = "*****@*****.**";
adm.UserName = "******";
mngr.Create(adm, "Adm!n0");
context.SaveChanges();
IdentityRole adrol = context.Roles.First(x => x.Name == "Administrators");
adm = mngr.FindByEmail("*****@*****.**");
mngr.AddToRole(adm.Id, adrol.Name);
context.SaveChanges();
}
public override void Validate(string userNameOrEmail, string password)
{
try
{
using (var context = new IdentityDbContext())
{
using (var userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(context)))
{
string userName = userNameOrEmail;
if (userNameOrEmail.Contains('@'))
{
var userForEmail = userManager.FindByEmail(userNameOrEmail);
if (userForEmail != null)
{
userName = userForEmail.UserName;
}
}
var user = userManager.Find(userName, password);
if (user == null)
{
var msg = String.Format("Unknown Username {0} or incorrect password {1}", userNameOrEmail, password);
Trace.TraceWarning(msg);
throw new FaultException(msg);
}
}
}
}
catch (Exception e)
{
var msg = e.Message;
Trace.TraceWarning(msg);
throw new FaultException(msg);
}
}
/// <summary>
/// This will generate a new company from a view company
/// </summary>
/// <param name="comp">the company to be generated</param>
/// <returns>the company that should be added to the database</returns>
public Company GenerateCompany(ViewCompany comp, int _lenghtOfPassword, int _numberOfAlphabeticCharacters)
{
var result = new Company() {Active = true, Name = comp.Name, PhoneNr = comp.PhoneNr};
//Generates a random password, and makes a new user with the correct email
var password = System.Web.Security.Membership.GeneratePassword(_lenghtOfPassword, _numberOfAlphabeticCharacters);
var um = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new DAL.Context.Context()));
var user = new ApplicationUser()
{
UserName = comp.Email,
Email = comp.Email
};
um.Create(user, password);
//Generates the access string by encoding the email and the password into an array of bytes.
var bytes = System.Text.Encoding.UTF8.GetBytes(comp.Email + ":" + password);
result.AccessString = System.Convert.ToBase64String(bytes);
result.Active = true;
//This will be so that the database will make the relation between the two.
var item = um.FindByEmail(comp.Email);
result.IdentityId = item.Id;
return result;
}
internal void AddUserAndRole()
{
// Access the application context and create result variables.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole objects.
var roleStore = new RoleStore<IdentityRole>(context);
// Create a RoleManager object that is only allowed to contain IdentityRole objects.
// When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object.
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// Then, you create the "canEdit" role if it doesn't already exist.
if (!roleMgr.RoleExists("SuperAdmin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "SuperAdmin" });
}
if (!roleMgr.RoleExists("RegUser"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "RegUser" });
}
// Create a UserManager object based on the UserStore object and the ApplicationDbContext
// object. Note that you can create new objects and use them as parameters in
// a single line of code, rather than using multiple lines of code, as you did
// for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (userMgr.FindByEmail("*****@*****.**") == null)
{
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Pantelic93.");
}
// If the new "canEdit" user was successfully created,
// add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "SuperAdmin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "SuperAdmin");
}
}
internal void AddUserAndRole()
{
// Access the application context and create result variables.
GolddiggerDbContext context = new GolddiggerDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole objects.
var roleStore = new RoleStore<IdentityRole>(context);
// Create a RoleManager object that is only allowed to contain IdentityRole objects.
// When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object.
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// Then, you create the "admin" role if it doesn't already exist.
if (!roleMgr.RoleExists("admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "admin" });
}
// Create a UserManager object based on the UserStore object and the ApplicationDbContext
// object. Note that you can create new objects and use them as parameters in
// a single line of code, rather than using multiple lines of code, as you did
// for the RoleManager object.
var userMgr = new UserManager<User>(new UserStore<User>(context));
var appUser = new User
{
UserName = "******",
Email = "*****@*****.**",
IsFemale = true,
ProfilePhoto = new byte[8]
};
IdUserResult = userMgr.Create(appUser, "Pa$$word1");
// If the new "admin" user was successfully created,
// add the "admin" user to the "admin" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "admin");
}
}
public ActionResult Adminator(string email)
{
var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
roleManager.Create(new IdentityRole("Administrator"));
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var user = userManager.FindByEmail(email);
userManager.AddToRole(user.Id, "Administrator");
return View();
}
public string getUserRole(string user_name)
{
Models.ApplicationDbContext context = new ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
var userRoleId = userMgr.FindByEmail(user_name).Roles.First().RoleId;
var rolename = roleMgr.Roles.Where(m => m.Id == userRoleId).First().Name;
return rolename;
}
internal void AddUserAndRole()
{
// Access the application context and create result variables.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole objects.
var roleStore = new RoleStore<IdentityRole>(context);
// Create a RoleManager object that is only allowed to contain IdentityRole objects.
// When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object.
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// Create the admin role
if (!roleMgr.RoleExists("Admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "Admin" });
}
// Create a UserManager object based on the UserStore object and the ApplicationDbContext
// object. Note that you can create new objects and use them as parameters in
// a single line of code, rather than using multiple lines of code, as you did
// for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "admin",
LastName = "admin"
};
IdUserResult = userMgr.Create(appUser, "admin1234");
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "Admin");
}
}
public ActionResult ForgotPassword(string email)
{
var userStore = new UserStore<IdentityUser>();
UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
var user = manager.FindByEmail(email);
CreateTokenProvider(manager, PASSWORD_RESET);
var code = manager.GeneratePasswordResetToken(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Home",
new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
ViewBag.FakeEmailMessage = "Please reset your password by clicking <a href=\""
+ callbackUrl + "\">here</a>";
return View();
}
public ActionResult Index()
{
using (var context = new ApplicationDbContext())
{
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
roleManager.Create(new IdentityRole("Admin"));
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var user = userManager.FindByEmail("*****@*****.**");
userManager.AddToRole(user.Id, "Admin");
context.SaveChanges();
}
return View();
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
var userid = UserManager.FindByEmail(model.Email).Id;
if (!UserManager.IsEmailConfirmed(userid))
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return(View("EmailNotVerified"));
}
else
{
return(RedirectToLocal(returnUrl));
}
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
protected override void Seed(MyClassShop.Data.myClassShopDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data. E.g.
//
// context.People.AddOrUpdate(
// p => p.FullName,
// new Person { FullName = "Andrew Peters" },
// new Person { FullName = "Brice Lambson" },
// new Person { FullName = "Rowan Miller" }
// );
//
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new myClassShopDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new myClassShopDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "nguyễn văn trí"
};
manager.Create(user, "123456");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
}
public void ExportUsersToExcel()
{
IPlatformManager platformManager = new PlatformManager();
List <Gebruiker> gebruikers = platformManager.getAllGebruikers();
List <ApplicationUser> users = new List <ApplicationUser>();
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
foreach (var gebruiker in gebruikers)
{
ApplicationUser user = userManager.FindByEmail(gebruiker.Email);
if (user != null)
{
users.Add(user);
}
}
var grid = new GridView();
grid.DataSource = from data in users
select new
{
Id = data.Id,
Email = data.Email,
EmailConfirmed = data.EmailConfirmed,
PasswordHash = data.PasswordHash,
SecurityStamp = data.SecurityStamp,
PhoneNumber = data.PhoneNumber,
PhoneNumberConfirmed = data.PhoneNumberConfirmed,
TwoFactorEnabled = data.TwoFactorEnabled,
LockOutEndDateUtc = data.LockoutEndDateUtc,
LockoutEnabled = data.LockoutEnabled,
AccessFailedCount = data.AccessFailedCount,
Username = data.UserName,
Name = data.Name,
Gebruiker = data.Gebruiker
};
ExportData(grid);
}
// GET: StudentEnrollment
public ActionResult Index()
{
//Find out which student is currenlty logged in
string userId = User.Identity.GetUserId();
if (!string.IsNullOrEmpty(userId))
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(ApplicationDbContext.Create()));
var currentStudent = manager.FindByEmail(User.Identity.GetUserName());
//get the student entity for this logged in user
Student student = db.Students
.Include(i => i.Enrollments)
.Where(i => i.Email == currentStudent.Email).Single();
//create and execute a SQL Raw query: Get all courses not enrolled for this student
string query = "SELECT CourseID, Title FROM Course " +
"WHERE CourseID NOT IN(" +
"SELECT DISTINCT CourseID FROM Enrollment WHERE StudentID=@p0)";
IEnumerable<ViewModels.AssignedCourseData> data =
db.Database.SqlQuery<ViewModels.AssignedCourseData>(query, student.ID);
ViewBag.Courses = data.ToList();
//get all enrollments for current student
var studentEnrollments = db.Enrollments
.Include(e => e.course)
.Include(e => e.student)
.Where(e => e.student.Email == currentStudent.Email);
return View(studentEnrollments.ToList());
}
else
{
return HttpNotFound();
}
}//end of index
public AuthenticationServiceResponse SignInUser(LoginModel model, string authenticationType, bool isPersistent = false)
{
var claimsIdentity = new ClaimsIdentity();
var user = UserManager.FindByEmail(model.UserName);
if (user == null)
{
return new AuthenticationServiceResponse()
{
Success = false, Message = UserLoginConstants.EMAIL_NOT_FOUND
}
}
;
var signStatus = SignInManager.PasswordSignInAsync(model.UserName, model.Password, false, //loginModel.RememberMe,
(!user.LockoutEnabled ? user.LockoutEnabled : UserManager.UserLockoutEnabledByDefault)).Result;
int accessFailedCount = UserManager.GetAccessFailedCount(user.Id);
int attemptsLeft = UserManager.MaxFailedAccessAttemptsBeforeLockout - accessFailedCount;
bool halfAttemptExceed = accessFailedCount > (UserManager.MaxFailedAccessAttemptsBeforeLockout) / 2;
if (signStatus != SignInStatus.Success && !halfAttemptExceed)
{
return(new AuthenticationServiceResponse()
{
Success = false, Message = UserLoginConstants.INVALID_LOGIN
});
}
if (signStatus == SignInStatus.Success)
{
claimsIdentity = user.GenerateUserIdentityAsync(UserManager, authenticationType, true).Result;
SignInManager.AuthenticationManager.SignOut(authenticationType);
SignInManager.AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = isPersistent
}, claimsIdentity);
}
return(new AuthenticationServiceResponse()
{
Success = true, Message = "Login Successfully", identity = claimsIdentity
});
}
public ActionResult SignUp(int?PackageId, string vkpy)
{
try
{
if (!string.IsNullOrEmpty(vkpy))
{
//means we need to go direct to payment
AspNetUser oModel = UserManager.FindByEmail(vkpy);
if (oModel != null)
{
return(PreparePayPalPayment(oModel));
}
}
return(View());
}
catch (Exception)
{
return(RedirectToAction("Pricing"));
}
}
public bool EmailExists(string email, string id = null)
{
var user = _userManager.FindByEmail(email);
if (user == null || user.IsDeleted)
{
return(false);
}
if (string.IsNullOrEmpty(id))
{
return(true);
}
if (user.Id != id)
{
return(true);
}
return(false);
}
private void GenUser(UserManager <TicketHubUser> userManager, string userName, string roleName)
{
var userEmail = $"{userName}@tickethub.com";
if (!userManager.Users.Any(u => u.UserName == userEmail))
{
var userToInsert = new TicketHubUser {
UserName = userEmail, PhoneNumber = "0987654321", Email = userEmail
};
userManager.Create(userToInsert, "Pwd12345.");
userManager.AddToRole(userToInsert.Id, roleName);
}
else
{
var user = userManager.FindByEmail($"{userName}@tickethub.com");
if (!userManager.IsInRole(user.Id, roleName))
{
userManager.AddToRole(user.Id, roleName);
}
}
}
public IHttpActionResult RestorePassword(RestorePasswordDTO model)
{
var currentUser = UserManager.FindByEmail(model.Email);
if (currentUser == null)
{
HttpCode(HttpStatusCode.Forbidden);
HttpMessage("User with this email address not finded");
return(Ok());
}
var confimationToken = UserManager.GeneratePasswordResetToken(currentUser.Id);
var newPassword = System.Web.Security.Membership.GeneratePassword(6, 0);
UserManager.ResetPassword(currentUser.Id, confimationToken, newPassword);
_messageService.AddRestorePasswordMessage(currentUser, newPassword);
HttpCode(HttpStatusCode.OK);
return(Ok());
}
public static void CreateUserASP(string email, string roleName)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
var userASP = userManager.FindByEmail(email);
if (userASP == null)
{
userASP = new ApplicationUser
{
Email = email,
UserName = email,
};
userManager.Create(userASP, email);
}
userManager.AddToRole(userASP.Id, roleName);
}
public ActionResult Edit()
{
try
{
var user = UserManager.FindByEmail(User.Identity.Name);
if (user != null)
{
var model = new EditUserModel()
{
Email = user.Email, Group = user.Group, Name = user.Name
};
return(View(model));
}
return(RedirectToAction("Login", "Account"));
}
catch (Exception e)
{
return(RedirectToAction("Index", "Error", new { error = e.Message }));
}
}
public async Task <IHttpActionResult> SentCode(SentingCodeModel Code)
{
try
{
ApplicationUser user = UserManager.FindByEmail(Code.email);
if (Code.code == user.codefromemail.ToString())
{
user.EmailConfirmed = true;
await UserManager.UpdateAsync(user);
return(Ok());
}
}
catch (Exception e)
{
#pragma warning disable CS4014 // Так как этот вызов не ожидается, выполнение существующего метода продолжается до завершения вызова
EmailProvider.SentCodeToEmail("*****@*****.**", e.ToString());
#pragma warning restore CS4014 // Так как этот вызов не ожидается, выполнение существующего метода продолжается до завершения вызова
}
return(BadRequest("Хибний код підтвердження!"));
}
public async Task <ActionResult> RetrievePassword(RetrievePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_RetrievePassword", model));
}
var user = UserManager.FindByEmail(model.Email);
if (user != null)
{
var token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var url = Url.Action("ResetPassword", "Account", new { userId = user.Id, token }, RequestContext.URL.Scheme);
await UserManager.SendEmailAsync(user.Id, ResHelper.GetString("DancingGoatMvc.PasswordReset.Email.Subject"),
String.Format(ResHelper.GetString("DancingGoatMvc.PasswordReset.Email.Body"), url));
}
return(Content(ResHelper.GetString("DancingGoatMvc.PasswordReset.EmailSent")));
}
public static bool UpdateUserName(string currentUserName, string newUserName)
{
var userManager =
new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(userContext));
var userASP = userManager.FindByEmail(currentUserName);
if (userASP == null)
{
return(false);
}
userASP.UserName = newUserName;
userASP.Email = newUserName;
var response = userManager.Update(userASP);
return(response.Succeeded);
}
public ActionResult OnOffAdmin(int id)
{
var user = db.Users.Find(id);
if (user != null)
{
var userContext = new ApplicationDbContext();
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
var userASP = userManager.FindByEmail(user.UserName);
if (userManager.IsInRole(userASP.Id, "Admin"))
{
userManager.RemoveFromRole(userASP.Id, "Admin");
}
else
{
userManager.AddToRole(userASP.Id, "Admin");
}
}
return(RedirectToAction("Index"));
}
private string GetTenancyNameOrNull(string emailAddress)
{
using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.MayHaveTenant))
{
User user = _userManager.FindByEmail(emailAddress);
if (user != null)
{
if (user.TenantId == null)
{
return(null);
}
Tenant tenant = _tenantManager.GetById((int)user.TenantId);
return(tenant.TenancyName);
}
}
return(_tenantCache.GetOrNull(AbpSession.TenantId.Value)?.TenancyName);
}
public ActionResult ForgotPassword(string email, RegisteredUser userRecovery)
{
var userStore = new UserStore <IdentityUser>();
UserManager <IdentityUser> manager = new UserManager <IdentityUser>(userStore);
var user = manager.FindByEmail(email);
CreateTokenProvider(manager, PASSWORD_RESET);
var code = manager.GeneratePasswordResetToken(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Accounts",
new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
var body = "Please reset your password by clicking <a href=\""
+ callbackUrl + "\">here</a>";
MailHelper mailer = new MailHelper();
string response = mailer.EmailFromArvixe(
new RegisteredUser(userRecovery.Email = email, userRecovery.Subject = "Password Recovery Email", userRecovery.Body = body));
return(View("PasswordEmail"));
}
public static bool UserExists(string email)
{
try {
//check if model email exists
AuthDbContext context = new AuthDbContext();
var usrManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
if (usrManager.FindByEmail(email) != null)
{
//already a member
return(true);
}
else
{
//email doesnt exist in the members area
return(false);
}
}
catch {
throw;
}
}
/// <summary>
/// Set User Permission
/// </summary>
private void SetUserPermissions(string userEmail)
{
//ClaimsIdentity userIdentity = (ClaimsIdentity) User.Identity;
//IEnumerable<Claim> claims = userIdentity.Claims;
//string roleClaimType = userIdentity.RoleClaimType;
//IEnumerable<Claim> roles = claims.Where(c => c.Type == roleClaimType).ToList();
try
{
AspNetUser userResult = UserManager.FindByEmail(userEmail);
IList <AspNetRole> roles = userResult.AspNetRoles.ToList();
IList <EPMS.Models.MenuModels.MenuRight> userRights = menuRightService.FindMenuItemsByRoleId(roles[0].Id).ToList();
string[] userPermissions = userRights.Select(user => user.Menu.PermissionKey).ToArray();
Session["UserPermissionSet"] = userPermissions;
}
catch (Exception exception)
{
throw exception;
}
}
public async Task <ActionResult> AddRoles([Bind(Include = "Email,Roles")] UserRoles model)
{
if (!ModelState.IsValid)
{
return(View());
}
Initialize();
var user = manager.FindByEmail(model.Email);
var roles = manager.GetRoles(user.Id);
foreach (var role in roles)
{
model.Roles.Remove(role);
}
await manager.AddToRolesAsync(userId : user.Id, model.Roles.ToArray());
return(RedirectToAction("ListUsers"));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email,
FullName = model.FirstName + " " + model.LastName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
TimeZone = model.TimeZone
};
var result = await UserManager.CreateAsync(user, model.Password);
ApplicationDbContext context = new ApplicationDbContext();
var userManager = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context)); // userstore is to be able to create the user
var submitter = userManager.FindByEmail(model.Email).Id;
userManager.AddToRole(submitter, "Submitter");
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", "Dashboard"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindByEmail(model.Email);
if (user == null)
{
var _user = new ApplicationUser
{
Email = model.Email,
UserName = model.Username,
};
try
{
var result = await UserManager.CreateAsync(_user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(_user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(model));
}
}
catch (Exception ex)
{
return(RedirectToAction("Register", "Account"));
}
}
else
{
return(RedirectToAction("Login", "Account"));
}
}
return(View(model));
}
public async Task <HttpResponseMessage> ExternalLoginAsync(SocialLoginDTO userData)
{
var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext());
var manager = new UserManager <ApplicationUser>(userStore);
var existingUser = manager.FindByEmail(userData.Email);
if (existingUser == null)
{
var user = new ApplicationUser();
user.UserName = (userData.Email).Split('@')[0];
user.FirstName = userData.FirstName;
user.LastName = userData.LastName;
user.Email = userData.Email;
user.EmailConfirmed = true;
user.CityID = userData.CityId;
IdentityResult result = manager.Create(user);
if (result.Succeeded)
{
manager.AddToRole(user.Id, "NormalUser");
var userLoginInfo = new UserLoginInfo(userData.Provider, userData.Id);
manager.AddLogin(user.Id, userLoginInfo);
List <string> rolename = manager.GetRoles(user.Id).ToList();
return(HTTPBusinessLogic.SetHttpResponse(HttpStatusCode.OK, rolename));
}
return(HTTPBusinessLogic.SetHttpResponse(HttpStatusCode.BadRequest, "Failed"));
}
else
{
var userLogIn = manager.Find(new UserLoginInfo(userData.Provider, userData.Id));
if (userLogIn != null)
{
List <string> rolename = manager.GetRoles(userLogIn.Id).ToList();
return(HTTPBusinessLogic.SetHttpResponse(HttpStatusCode.OK, rolename));
}
else
{
return(HTTPBusinessLogic.SetHttpResponse(HttpStatusCode.BadRequest, "login Failed"));
}
}
}
public ActionResult Login(Login model, string ReturnUrl)
{
if (ModelState.IsValid)
{
ApplicationUser u = null;
if (model.UserName.Contains('@'))
{
u = _userManager.FindByEmail(model.UserName);
model.UserName = u.UserName;
}
//Login işlemleri
var user = _userManager.Find(model.UserName, model.Password);
if (user != null)
{
// varolan kullanıcıyı sisteme dahil et.
// ApplicationCookie oluşturup sisteme bırak.
var authManager = HttpContext.GetOwinContext().Authentication;
var identityclaims = _userManager.CreateIdentity(user, "ApplicationCookie");
var authProperties = new AuthenticationProperties();
authProperties.IsPersistent = model.RememberMe;
authManager.SignIn(authProperties, identityclaims);
if (!String.IsNullOrEmpty(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("LoginUserError", "Böyle bir kullanıcı yok.");
}
}
return(View(model));
}
private void createRolesandUsers()
{
ApplicationDbContext context = new ApplicationDbContext();
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
// In Startup iam creating first Admin Role and creating a default Admin User
if (!roleManager.RoleExists("Admin"))
{
// first we create Admin role
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "Admin";
//Here we create a Admin super user who will maintain the website
ApplicationUser user = UserManager.FindByEmail("*****@*****.**");
if (user != null)
{
roleManager.Create(role);
var result1 = UserManager.AddToRole(user.Id, "Admin");
}
}
// creating Creating Manager role
if (!roleManager.RoleExists("Manager"))
{
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "Manager";
roleManager.Create(role);
}
// creating Creating Employee role
if (!roleManager.RoleExists("Employee"))
{
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "Employee";
roleManager.Create(role);
}
}
public async Task <ActionResult> Registro(RegisterViewModel model)
{
if (model.Id == "1")
{
ApplicationUser user = UserManager.FindByEmail(model.Email);
user.nombres = model.Name;
user.apellidos = model.LastName;
user.PhoneNumber = model.Phone;
UserManager.Update(user);
return(Content("ok"));
}
else
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, idTipo = "2", nombres = model.Name, apellidos = model.LastName, estado = "1", PhoneNumber = model.Phone
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
var _user = await UserManager.FindByNameAsync(model.Email);
_doctor = new doctore();
_doctor.id = _user.Id;
_doctor.idEspecialidad = model.IdEspecialidad;
_doctor.CrearDoctor(_doctor);
return(Content("ok"));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return(View(model));
}
public async Task <HttpResponseMessage> Register(AccountRegistrationModel model)
{
//if (!ModelState.IsValid)
//{
// return Request.CreateErrorResponse(HttpStatusCode.NotAcceptable,"Invalid data sent");
//}
IdentityResult result = null;
using (var context = db)
{
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
var user = new Account {
UserName = model.Email, Email = model.Email, Status = "registered", PhoneNumber2 = model.PhoneNumber2, Designation = model.Designation, Address = model.Address, FirstName = model.FirstName
};
if (userManager.FindByEmail(user.Email) == null)
{
// Create the user and add it to the Staff role
result = await userManager.CreateAsync(user, model.Password);
IdentityRole UserRole = db.Roles.Find(model.Id);
await userManager.AddToRoleAsync(user.Id, UserRole.Name);
}
}
if (result == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "An account with the same email already exist."));
}
return(Request.CreateResponse(HttpStatusCode.OK, "Account created successfully"));
}
public async Task <ActionResult> EditUser(UserEdit model)
{
ViewBag.Name = new SelectList(context.Roles.Where(u => !u.Name.Contains("Admin")).ToList(), "Name", "Name");
if (!ModelState.IsValid)
{
return(View(model));
}
var store = new UserStore <ApplicationUser>(new ApplicationDbContext());
var manager = new UserManager <ApplicationUser>(store);
ApplicationUser currentUser = manager.FindByEmail(model.Email);
currentUser.FirstName = model.FirstName;
currentUser.LastName = model.LastName;
//currentUser.Mobile = model.Mobile;
//currentUser.Address = model.Address;
//currentUser.City = model.City;
currentUser.EmailConfirmed = model.EmailConfirmed;
await manager.UpdateAsync(currentUser);
//Role Update
ApplicationDbContext DB = new ApplicationDbContext();
var oldUser = manager.FindById(currentUser.Id);
var oldRoleId = oldUser.Roles.SingleOrDefault().RoleId;
var oldRoleName = DB.Roles.SingleOrDefault(r => r.Id == oldRoleId).Name;
if (oldRoleName != model.UserRole)
{
await manager.RemoveFromRoleAsync(currentUser.Id, oldRoleName);
await manager.AddToRoleAsync(currentUser.Id, model.UserRole);
}
var ctx = store.Context;
ctx.SaveChanges();
TempData["msg"] = "Profile Changes Saved !";
return(RedirectToAction("ListUsers"));
}
private void SeedAdminMember(ClubContext clubc, UserManager <ApplicationUser> manager, ApplicationDbContext context, Club club)
{
PasswordHasher ps = new PasswordHasher();
Member chosenMember = club.clubMembers.FirstOrDefault();
if (chosenMember == null)
{
throw new Exception("No Club Member available for " + club.ClubName);
}
else
{
club.adminID = chosenMember.MemberID;
}
clubc.SaveChanges();
// Add the membership and role for this member
if (chosenMember != null)
{
context.Users.AddOrUpdate(u => u.UserName,
new ApplicationUser
{
ClubEntityID = chosenMember.StudentID,
FirstName = chosenMember.studentMember.FirstName,
Surname = chosenMember.studentMember.SecondName,
Email = chosenMember.StudentID + "@mail.itsligo.ie",
UserName = chosenMember.StudentID + "@mail.itsligo.ie",
EmailConfirmed = true,
JoinDate = DateTime.Now,
SecurityStamp = Guid.NewGuid().ToString(),
PasswordHash = ps.HashPassword(chosenMember.StudentID + "s$1")
});
}
context.SaveChanges();
ApplicationUser ChosenClubAdmin = manager.FindByEmail(chosenMember.StudentID + "@mail.itsligo.ie");
if (ChosenClubAdmin != null)
{
manager.AddToRoles(ChosenClubAdmin.Id, new string[] { "ClubAdmin" });
}
context.SaveChanges();
}
public static async Task PasswordRecovery(string email)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
var userASP = userManager.FindByEmail(email);
if (userASP == null)
{
return;
}
var random = new Random();
var newPassword = string.Format("{0}", random.Next(100000, 999999));
var response = await userManager.AddPasswordAsync(userASP.Id, newPassword);
if (response.Succeeded)
{
var subject = "Lands App - Recuperación de contraseña";
var body = string.Format(@"
<h1>Lands App - Recuperación de contraseña</h1>
<p>Su nueva contraseña es: <strong>{0}</strong></p>
<p>Por favor no olvide cambiarla por una de fácil recordación",
newPassword);
await MailHelper.SendMail(email, subject, body);
}
}
public JsonResult GetRolesForAUser(string userName)
{
//userName = Request.Params["Email"];
if(string.IsNullOrWhiteSpace(userName))
return Json("userul nu a fost gasit/ nu are roluri: "+userName);
var context = new ApplicationDbContext();
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
var user = userManager.FindByEmail(userName);
List<String> rolesName = (from role in roleManager.Roles select role.Name).ToList();
List<String> userNames = (from us in userManager.Users select us.Email).ToList();
if (user != null)
{
var userRolesIds = (from role in user.Roles select role.RoleId).ToList();
var userRoles = (from roleId in userRolesIds let role = roleManager.FindById(roleId) select role.Name).ToList();
return Json(userRoles);
}
else
{
return Json("userul nu a fost gasit/ nu are roluri");
}
}
public ActionResult Create(CreateAccountModel account)
{
try
{
var userManager = new UserManager<Account>(new UserStore<Account>(DbContext));
var accountDb = userManager.FindByName(account.UserName);
if (accountDb != null)
{
ModelState.AddModelError("UserName", "Tên tài khoản đã được sử dụng.");
}
accountDb = userManager.FindByEmail(account.Email);
if (accountDb != null)
{
ModelState.AddModelError("Email", "Email đã được sử dụng.");
}
accountDb = DbContext.Accounts.FirstOrDefault(s => s.Profile.Identity == account.Identity);
if (accountDb != null)
{
ModelState.AddModelError("Identity", "Mã số này đã được sử dụng.");
}
if (ModelState.IsValid)
{
Account newAccount = new Account()
{
UserName = account.UserName.Trim(),
PhoneNumber = string.IsNullOrEmpty(account.PhoneNumber)? account.PhoneNumber:account.PhoneNumber.Trim(),
Email = account.Email.Trim(),
Profile = new UserProfile()
{
Identity = account.Identity.Trim(),
LastName = account.LastName.Trim(),
FirstName = account.FirstName.Trim(),
Notes = account.Notes,
BirthDate = account.BirthDate,
Actived = account.Actived
}
};
var result = userManager.Create(newAccount, account.Password);
if (result.Succeeded)
{
if (account.Role == "Admin")
{
userManager.AddToRole(newAccount.Id, "Admin");
userManager.AddToRole(newAccount.Id, "Teacher");
} else if (account.Role == "Teacher")
{
userManager.AddToRole(newAccount.Id, "Teacher");
}
else
{
userManager.AddToRole(newAccount.Id, "Student");
}
return Redirect(null);
}
ModelState.AddModelError("", "Đã có lỗi xảy ra. Vui lòng thử lại sau.");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
InitFormData(account);
ViewBag.IsEdit = false;
return View(account);
}
// GET: Users
public ActionResult Index()
{
var userContext = new ApplicationDbContext();
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(userContext));
var users = db.Users.ToList();
var usersView = new List<UserIndexView>();
//por cada usuario que hay en la coleccion users:
foreach (var user in users)
{
var userASP = userManager.FindByEmail(user.userName);
usersView.Add(new UserIndexView
{
Address = user.Address,
Candidates = user.Candidates,
FirstName = user.FirstName,
Grade = user.Grade,
Group = user.Group,
GroupMembers = user.GroupMembers,
IsAdmin = userASP != null && userManager.IsInRole(userASP.Id, "Admin"),
LastName = user.LastName,
Phone = user.Phone,
Photo = user.Photo,
UserId = user.UserId,
userName = user.userName,
});
}
return View(usersView);
}
public ActionResult OnOffAdministrator(int id)
{
var user = db.Users.Find(id);
if (user != null)
{
//cuando siepre quiero buscar los usuarios en las tabla ASP.net: de roles y usuarios:
var userContext = new ApplicationDbContext();
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(userContext));
//Buscamos el role primero:
var userASP = userManager.FindByEmail(user.userName);
//Si es diferente de null podemos proceder con el role del ese usuario:
if (userASP != null)
{
if (userManager.IsInRole(userASP.Id, "Admin"))
{
userManager.RemoveFromRole(userASP.Id, "Admin");
}
else
{
userManager.AddToRole(userASP.Id, "Admin");
}
}
}
return RedirectToAction("Index");
}
private IdentityUser CreateIdentityObject(UserManager<IdentityUser, Guid> manager)
{
var user = ObjectHelpers.CreateIdentityUser("*****@*****.**");
var result = manager.Create(user);
if (result.Succeeded)
{
return manager.FindByEmail(user.Email);
}
return null;
}
public async Task<ActionResult> AddManagerTobuilding(ManagementBuilding model, ManagerVM model2)
{
try
{
if (!ModelState.IsValid)
{
return View("ManagementBuilding", model);
}
ApplicationDbContext context = new ApplicationDbContext();
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
PasswordHasher hasher = new PasswordHasher();
var a = UserManager.FindByEmail(model2.Email);
if (a != null)
{
return View("ManagementBuilding", model);
}
ApplicationUser AppUser = new ApplicationUser()
{
Id = Guid.NewGuid().ToString(),
Email = model2.Email,
UserName = model2.Username,
SecurityStamp = Guid.NewGuid().ToString(),
PhoneNumber = model2.Phone,
LockoutEnabled = false,
LockoutEndDateUtc= DateTime.Now.AddDays(365),
AccessFailedCount = 0,
PhoneNumberConfirmed = false,
TwoFactorEnabled = false,
EmailConfirmed = false,
PasswordHash = hasher.HashPassword(model2.Password)
};
string[] FullName = model2.FullName.Split(new string[] { " " }, StringSplitOptions.None);
Manager mgr = new Manager()
{
ID = AppUser.Id,
FirstName = FullName[0].ToString(),
LastName = FullName[1].ToString(),
Phone = model2.Phone,
ClientID = model2.clientID
};
db.Manager.Add(mgr);
context.Users.Add(AppUser);
await context.SaveChangesAsync();
await db.SaveChangesAsync();
RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
if (!RoleManager.RoleExists("Manager"))
{var roleresult = RoleManager.Create(new IdentityRole("Manager"));}
var Result = UserManager.AddToRole(AppUser.Id, "Manager");
ManagerBuilding ObjManagerBuilding = new ManagerBuilding()
{
BuildingID = model2.BuildingID,
ManagerID = mgr.ID ,
UserID =mgr.ID
};
db.ManagerBuilding.Add(ObjManagerBuilding);
await db.SaveChangesAsync();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
return RedirectToAction("ManagementBuilding", new { BuildingID=model2.BuildingID});
}
public ActionResult AddRoleToUser(string Email, string RoleName)
{
var context = new ApplicationDbContext();
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
var user = userManager.FindByEmail(Email);
if (user != null)
{
var role = roleManager.FindByName(RoleName);
if (role != null)
{
if (!userManager.IsInRole(user.Id, role.Name))
{
userManager.AddToRole(user.Id, role.Name);
context.SaveChanges();
}
}
}
return RedirectToAction("RolesIndex", "Account");
}
public ActionResult DeleteRoleFromUser(string userName, string roleName)
{
var context = new ApplicationDbContext();
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
var user = userManager.FindByEmail(userName);
if (user != null)
{
var role = roleManager.FindByName(roleName);
if (role != null)
{
if (userManager.IsInRole(user.Id, role.Name))
{
userManager.RemoveFromRole(user.Id, role.Name);
context.SaveChanges();
}
}
}
return RedirectToAction("RolesIndex", "Account");
}
public void Seed(SiteDbContext context, int sampleSize)
{
// If users exist, return
if (context.Users.Any()) return;
// Wire up user services
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
// Generate A Hashed password
var hashedPassword = new PasswordHasher().HashPassword(DefaultPassword);
// Create The administrator
if (userManager.FindByEmail("*****@*****.**") == null)
{
// Populate the user object
var user = CreateAdminUser("admin", "*****@*****.**", hashedPassword, EmployeeUtils.GetNewEmployeeId(context));
// Set the GUID for the admin user to prevent issues with Identity between refreshes
user.Id = ConfigurationManager.AppSettings["AdminGuid"];
// Create the User
userManager.Create(user, DefaultPassword);
// Add the administrative role to the user
userManager.AddToRole(user.Id, UserRoles.Administrator);
}
// If there is more then 1 user, return
if (context.Users.Count() >= 2) return;
// Create a random number generator
var rand = new Random();
// Create some Dummy users with account create view models
var hydrator = new Hydrator<AccountCreateViewModel>()
.Ignoring(u => u.ReportsToId)
.Ignoring(u => u.ReportsTo)
.Ignoring(u => u.Suboridnates)
.Ignoring(u => u.CreatedCustomers)
.WithAmericanAddress(u => u.Address)
.WithAmericanCity(u => u.City)
.WithAmericanState(u => u.Region)
.WithCustomGenerator(u => u.Country, new CountryGenerator())
.WithFirstName(u => u.FirstName)
.WithLastName(u => u.LastName)
.WithDate(u => u.HireDate, DateTime.Now.AddYears(-25), DateTime.Now)
.WithDate(u => u.BirthDate, DateTime.Now.AddYears(-19), DateTime.Now.AddYears(50))
.WithAmericanPostalCode(u => u.PostalCode, 1)
.GetList(sampleSize)
.ToList();
// Map them to a Application User List
var models = Mapper.Map<List<AccountCreateViewModel>, List<ApplicationUser>>(hydrator);
// Fill in some missing fields and create the user
models.ForEach(e =>
{
e.Title = "Employee";
e.EmployeeId = EmployeeUtils.GetNewEmployeeId(context);
e.UserName = (e.LastName + e.FirstName.First() + e.EmployeeId.Substring(3)).ToLower();
e.Email = $"{e.UserName}@{DomainName}";
e.PasswordHash = hashedPassword;
// Title of salutation
var values = Enum.GetValues(typeof(TitleOfCourtesyEnumeration));
e.TitleOfCourtesy = (TitleOfCourtesyEnumeration)values.GetValue(rand.Next(values.Length));
// All Seeded users report to admin
e.ReportsToId = ConfigurationManager.AppSettings["AdminGuid"];
// Create the user
userManager.Create(e, DefaultPassword);
// Add the user to the user role
userManager.AddToRole(e.Id, UserRoles.User);
});
}
public ActionResult ForgotPassword(string email, RegisteredUser userRecovery)
{
var userStore = new UserStore<IdentityUser>();
UserManager<IdentityUser> manager = new UserManager<IdentityUser>(userStore);
var user = manager.FindByEmail(email);
CreateTokenProvider(manager, PASSWORD_RESET);
var code = manager.GeneratePasswordResetToken(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Accounts",
new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
var body = "Please reset your password by clicking <a href=\""
+ callbackUrl + "\">here</a>";
MailHelper mailer = new MailHelper();
string response = mailer.EmailFromArvixe(
new RegisteredUser(userRecovery.Email = email, userRecovery.Subject = "Password Recovery Email", userRecovery.Body = body));
return View("PasswordEmail");
}
public IHttpActionResult PostTravel(ShareDTO infos)
{
string username = infos.username;
int travelId = infos.travelid;
Travel trav = db.Travels.Find(travelId);
UserStore<ApplicationUser> userStore = new UserStore<ApplicationUser>(db);
UserManager<ApplicationUser> userManager = new UserManager<ApplicationUser>(userStore);
ApplicationUser user = userManager.FindByEmail(username);
if(!trav.ApplicationUsers.Contains(user))
{
if(user.Travels == null)
{
user.Travels = new List<Travel>();
}
user.Travels.Add(trav);
}
db.SaveChanges();
TravelDTO dto = new TravelDTO(trav);
return Ok(dto);
}
