public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//TODO: Add fields to user here so they will be saved to the database
//Create a new user with all the properties you need for the class
var user = new AppUser {
UserName = model.Email, Email = model.Email, FName = model.FirstName, LName = model.LastName, MidInitial = model.MidInitial, PhoneNumber = model.PhoneNumber, Address = model.Address, City = model.City, State = model.State, ZipCode = model.ZipCode, CreditCardOne = model.CreditCardOne, CreditCardTypeOne = model.CreditCardTypeOne
};
//Add the new user to the database
var result = await UserManager.CreateAsync(user, model.Password);
if (User.IsInRole("Manager"))
{
var result1 = await UserManager.CreateAsync(user, "password");
if (result1.Succeeded) //user was created successfully
{
await UserManager.AddToRoleAsync(user.Id, "Employee");
//sign the user in
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
//send them to the home page
return(RedirectToAction("Index", "Home"));
}
}
if (result.Succeeded) //user was created successfully
{
await UserManager.AddToRoleAsync(user.Id, "Customer");
//sign the user in
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
EmailMessaging.SendEmail(user.Email, "Welcome to LHM!", "Thank You for Joining Longhorn Music, " + user.FName + "!");
//send them to the home page
return(RedirectToAction("Index", "Home"));
}
//if there was a problem, add the error messages to what we will display
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private void CreateIdentity(string sessionJson)
{
var session = _apiProvider.DeserializeJson <Session>(sessionJson);
var appUser = new AppUser(session.UserId.ToString(), "User");
var task = _appUserManager.CreateIdentityAsync(appUser, DefaultAuthenticationTypes.ApplicationCookie);
task.Wait();
var claim = task.Result;
var authMgr = HttpContext.GetOwinContext().Authentication;
var authProperties = new AuthenticationProperties()
{
IsPersistent = false
};
authProperties.Dictionary["Session"] = sessionJson;
foreach (var role in session.Roles)
{
var appRole = _appRoleManager.FindById(role.RoleID.ToString());
if (appRole != null)
{
_appUserManager.AddToRoleAsync(appUser.Id.ToString(), appRole.Name);
}
}
authMgr.SignIn(authProperties, claim);
}
public async Task <ActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
result = await UserManager.AddToRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("_Error", result.Errors));
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
result = await UserManager.RemoveFromRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("_Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
return(View("_Error", new string[] { "Role Not Found" }));
}
public async Task <ActionResult> Register(RegisterViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var RoleToJoin = new AppRole("user");
var user = new AppUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, RoleToJoin.Name);
await SignInManager.SignInAsync(user, false, false);
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("List", "Product"));
}
return(Redirect(returnUrl));
}
AddErrors(result);
}
return(View(model));
}
public async Task <IHttpActionResult> Create(UserAddRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = request.Username, Email = request.Email, JoinDate = DateTime.Now.Date
};
IdentityResult createUserResult = await AppUserManager.CreateAsync(user, request.Password);
if (!createUserResult.Succeeded)
{
return(GetErrorResult(createUserResult));
}
IdentityResult addUserToRoleResult = await AppUserManager.AddToRoleAsync(user.Id, "user");
if (!addUserToRoleResult.Succeeded)
{
return(GetErrorResult(addUserToRoleResult));
}
string code = await this.AppUserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code }));
await this.AppUserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(Created(new Uri(Url.Link("GetUserById", new { id = user.Id })), TheModelFactory.Create(user)));
}
public static void EnsureSeedData(this AppIdentityDbContext context)
{
AppUserManager userMgr = new AppUserManager(new UserStore <AppUser, AppRole, AppIdentityDbContext, string>(context), null, new PasswordHasher <AppUser>(), null, null, null, null, null, null);
AppRoleManager roleMgr = new AppRoleManager(new RoleStore <AppRole, AppIdentityDbContext, string>(context), null, null, null, null, null);
string roleName = "Administrators";
string userName = "******";
string password = "******";
string email = "*****@*****.**";
if (!roleMgr.RoleExistsAsync(roleName).Result)
{
roleMgr.CreateAsync(new AppRole(roleName)).Wait();
}
AppUser user = userMgr.FindByNameAsync(userName).Result;
if (user == null)
{
user = new AppUser {
UserName = userName, Email = email
};
userMgr.CreateAsync(user, password).Wait();
user = userMgr.FindByNameAsync(userName).Result;
}
if (!userMgr.IsInRoleAsync(user, roleName).Result)
{
userMgr.AddToRoleAsync(user, roleName).Wait();
}
context.SaveChanges();
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//Create a new user with all the properties you need for the class
var user = new AppUser {
UserName = model.Email, Email = model.Email, FName = model.FName, LName = model.LName, PhoneNumber = model.PhoneNumber, Address = model.Address, City = model.City, State = model.State, Zip = model.Zip
};
//Add the new user to the database
var result = await UserManager.CreateAsync(user, model.Password);
// Once you get roles working, you may want to add users to roles upon creation
await UserManager.AddToRoleAsync(user.Id, "Customer"); //adds user to role called "User"
if (result.Succeeded) //user was created successfully
{
//sign the user in
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
//send them to the home page
return(RedirectToAction("Index", "Home"));
}
//if there was a problem, add the error messages to what we will display
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//Add fields to user here so they will be saved to do the database
var user = new AppUser {
UserName = model.Email, Email = model.Email, FName = model.FName, MInitial = model.MInitial, LName = model.LName, StreetAddress = model.StreetAddress, City = model.City, State = model.State, Zip = model.Zip, Phone = model.Phone, Birthday = model.Birthday
};
var result = await UserManager.CreateAsync(user, model.Password);
db.SaveChanges();
//Once you get roles working, you may want to add users to roles upon creation
await UserManager.AddToRoleAsync(user.Id, "User");
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Edit(RoleModificationModel model)
{
IdentityResult result;
if (!ModelState.IsValid)
{
return(View("Error", new[] { "Role Not Found" }));
}
foreach (var userId in model.IdsToAdd ?? Enumerable.Empty <string>())
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
foreach (var userId in model.IdsToDelete ?? Enumerable.Empty <string>())
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
private async Task SeedAsync(AppContext context)
{
var user = new ShopUser()
{
UserName = AdminUser.UserName,
Email = AdminUser.Email,
FirstName = AdminUser.FirstName,
LastName = AdminUser.LastName,
};
var role = new AppRole(RoleNames.Admin);
///
UserStore <ShopUser> uStore = new UserStore <ShopUser>(context);
var userManager = new AppUserManager(uStore);
RoleStore <AppRole> rStore = new RoleStore <AppRole>(context);
var roleManager = new AppRoleManager(rStore);
var adminRole = await roleManager.FindByNameAsync(RoleNames.Admin);
if (adminRole == null)
{
adminRole = new AppRole(RoleNames.Admin);
await roleManager.CreateAsync(adminRole);
}
// await roleManager.CreateAsync(new AppRole(RoleNames.Admin));
var result = await userManager.CreateAsync(user, AdminUser.Password);
user = await userManager.FindByNameAsync(AdminUser.UserName);
await userManager.AddToRoleAsync(user.Id, RoleNames.Admin);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//TODO: Add fields to user here so they will be saved to the database
//Create a new user with all the properties you need for the class
var user = new AppUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber, OKToText = model.OKToText, McCombsMajors = model.McCombsMajors
};
//Add the new user to the database
var result = await UserManager.CreateAsync(user, model.Password);
//TODO: Once you get roles working, you may want to add users to roles upon creation
await UserManager.AddToRoleAsync(user.Id, "Member"); //adds user to role called "Member"
// --OR--
//await UserManager.AddToRoleAsync(user.Id, "Employee"); //adds user to role called "Employee"
if (result.Succeeded) //user was created successfully
{
//sign the user in
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
//send them to the home page
return(RedirectToAction("Index", "Home"));
}
//if there was a problem, add the error messages to what we will display
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//TODO: Add in other fields
var user = new AppUser {
UserName = model.Email, Email = model.Email, FName = model.FName
};
var result = await UserManager.CreateAsync(user, model.Password);
await UserManager.AddToRoleAsync(user.Id, "User");
// --OR--
// await UserManager.AddToRoleAsync(user.Id, "Employee");
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <UserModel> CreateUserAsync(NewUserModel model)
{
var user = new AppUser()
{
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
MiddleName = model.MiddleName,
Description = model.Description,
Email = model.Email,
EmailConfirmed = true,
PhoneNumber = model.PhoneNumber,
PhoneNumberConfirmed = true,
Enabled = true,
ProjectId = model.ProjectId,
RouteIds = model.RouteIds
};
var role = await _roleRepository.GetByIdAsync(model.RoleId);
CheckRoleData(user, role);
var userResult = await _userManager.CreateAsync(user, model.Password);
if (userResult.Succeeded)
{
var roleResult = await _userManager.AddToRoleAsync(user, role.NormalizedName);
if (!roleResult.Succeeded)
{
ThrowIdentityError(roleResult.Errors);
}
await _emailService.SendEmailAsync(
user.Email,
"Регистрация в системе ЦОДД",
GetNewUserEmail(user, model.Password));
}
else
{
ThrowIdentityError(userResult.Errors);
}
var result = await GetByIdFullAsync(user.Id);
return(result);
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await AppRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return(BadRequest(ModelState));
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
if (!AppUserManager.IsInRole(user, role.Name))
{
IdentityResult result = await AppUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be added to role", user));
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
IdentityResult result = await AppUserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be removed from role", user));
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <ActionResult> CreateEmployee(CreateEmployeeViewModel model)
{
if (ModelState.IsValid)
{
var user = new AppUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, MI = model.MI, Address = model.Address, City = model.City, State = model.State, ZipCode = model.ZipCode, PhoneNumber = model.PhoneNumber, DOB = DateTime.Now, IsTerminated = false, IsActive = true, HasAccount = false
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, "Employee");
return(RedirectToAction("EmployeePortal", "Manage"));
}
AddErrors(result);
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//TODO: Add fields to user here so they will be saved to do the database
var user = new AppUser {
UserName = model.EmailAddress, Email = model.EmailAddress, FName = model.FName, LName = model.LName, DOB = model.DOB, StreetAddress = model.Address, City = model.City, ZIP = model.ZIP, PhoneNumber = model.PhoneNumber, PasswordHash = model.Password, State = model.State
};
var result = await UserManager.CreateAsync(user, model.Password);
string user1 = User.Identity.GetUserId();
AppUser u = db.Users.Find(user1);
if (User.IsInRole("Manager"))
{
await UserManager.AddToRoleAsync(user.Id, "Employee");
Success(string.Format("New Employee created!"), true);
return(RedirectToAction("ManagerHome", "Account"));
}
else
{
await UserManager.AddToRoleAsync(user.Id, "Customer");
}
// --OR--
// await UserManager.AddToRoleAsync(user.Id, "Employee");
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href="" + callbackUrl + "">here</a>");
return(RedirectToAction("Index", "Apply"));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = model.Email,
Email = model.Email,
FName = model.FName,
LName = model.LName,
PhoneNumber = model.phoneNumber,
OkToText = model.OkToText,
Major = model.Major
};
// Populate the data to Member as well and linked with UserID
var member = new Member
{
UserId = user.Id,
Email = model.Email,
FirstName = model.FName,
LastName = model.LName,
phoneNumber = model.phoneNumber,
OkToText = model.OkToText,
Major = model.Major
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// Add to Role
await UserManager.AddToRoleAsync(user.Id, "Member");
// Add the record to Members
var db = new AppDbContext();
db.Members.Add(member);
db.SaveChanges();
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <HttpResponseMessage> KorisnikUpdate(HttpRequestMessage request, [FromBody] KorisnikModel model)
{
HttpResponseMessage response = null;
try
{
var user = await AppUserManager.FindByIdAsync(model.Id);
user.Id = model.Id;
user.Email = model.Email;
user.GradId = model.GradId;
user.Ime = model.Ime;
user.Prezime = model.Prezime;
user.Ulica = model.Ulica;
user.Broj = model.Broj;
user.Telefon = model.Telefon;
user.PostanskiBroj = model.PostanskiBroj;
user.IsDeleted = model.IsOnemogucen;
var result = await AppUserManager.UpdateAsync(user);
if (result.Succeeded)
{
var prethodneUloge = await AppUserManager.GetRolesAsync(user.Id);
foreach (var uloga in prethodneUloge)
{
await AppUserManager.RemoveFromRoleAsync(user.Id, uloga);
}
if ((model.Uloge.Contains("Admin") || model.Uloge.Contains("Uposlenik")) && model.Uloge.Contains("Klijent"))
{
model.Uloge = model.Uloge.Where(val => val != "Klijent").ToArray();
}
foreach (var uloga in model.Uloge)
{
await AppUserManager.AddToRoleAsync(user.Id, uloga);
}
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, result.Errors);
}
}
catch (Exception ex)
{
response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
}
return(response);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//TODO: Add fields to user here so they will be saved to the database
//Create a new user with all the properties you need for the class
var user = new AppUser {
UserName = model.Email, Email = model.Email, FName = model.FName, MName = model.MName, LName = model.LName, StreetAddress = model.StreetAddress, City = model.City, State = model.State, ZipCode = model.ZipCode, PhoneNumber = model.PhoneNumber, IsAccountEnabled = model.IsAccountEnabled
};
db.SaveChanges();
//Add the new user to the database
var result = await UserManager.CreateAsync(user, model.Password);
//TODO: Once you get roles working, you may want to add users to roles upon creation
//await UserManager.AddToRoleAsync(user.Id, "User"); //adds user to role called "User"
// --OR--
if (result.Succeeded) //user was created successfully
{
//sign the user in
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
await UserManager.AddToRoleAsync(user.Id, "Customer"); //adds user to role called "Customer"
//Send confirmation email
EmailController.AccountCreation(user);
//send them to the page to add their credit cards
return(RedirectToAction("CustomerDashboard", "Account"));
}
//if there was a problem, add the error messages to what we will display
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email
};
var role = Input.Role;
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
await _userManager.AddToRoleAsync(user, role);
//Add area
Area organization = new Area();
organization.Name = Input.Area;
_context.Add(organization);
if (await _context.SaveChangesAsync() != 0)
{
user.AreaId = organization.AreaId;
await _userManager.UpdateAsync(user);
}
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_repo.Exists(createUserModel.PhoneNumber))
{
return(BadRequest("Phone number is already taken"));
}
var user = new ApplicationUser()
{
UserName = createUserModel.UserName,
Email = createUserModel.Email,
CustomerInfoId = createUserModel.CustomerInfoId,
JoinDate = DateTime.Now.Date,
PhoneNumber = createUserModel.PhoneNumber,
EmailConfirmed = true
};
IdentityResult addUserResult = await AppUserManager.CreateAsync(user, createUserModel.Password);
if (addUserResult.Succeeded)
{
IdentityResult addRoleResult = await AppUserManager.AddToRoleAsync(user.Id, "Customer");
if (!addRoleResult.Succeeded)
{
return(GetErrorResult(addRoleResult));
}
}
else
{
return(GetErrorResult(addUserResult));
}
string code = await this.AppUserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code = code }));
//TODO: Uncomment to send email confirmations
//await this.AppUserManager.SendEmailAsync(user.Id, "Confirm your account"
//, "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
return(Created(locationHeader, TheModelFactory.Create(user)));
}
protected override async Task <CreateUserResult> RunAsync(YbpContext <UserRegistrationProcess> context, CreateUserInfo prm)
{
var user = new AppUser
{
Email = prm.Email,
UserName = $"{prm.FirstName}_{prm.LastName}".Trim(),
PhoneNumber = prm.PhoneNumber
};
var result = new CreateUserResult {
Errors = new List <string>()
};
foreach (var v in _userManager.UserValidators)
{
var ir = await v.ValidateAsync(_userManager, user);
if (ir.Succeeded)
{
continue;
}
result.Errors.AddRange(ir.Errors.Select(x => x.Description));
}
if (result.Errors.Any())
{
return(result);
}
var u = await _userManager
.CreateAsync(user);
if (!u.Succeeded)
{
return(result);
}
result.UserId = user.Id;
result.Success = true;
context.Id = $"{user.Id}";
await _userManager.AddToRoleAsync(user, prm.Role);
if (prm.Role == SystemRole.RegularUser)
{
context.Flags[UserRegistrationProcess.Flags.NeedSendInvitation] = true;
}
return(result);
}
public async void Register([FromForm] UserRegistrationModel userRegistration)
{
AppUser user = await AppUserManager.FindByNameAsync(userRegistration.UserName);
if (user == null)
{
user = new AppUser();
user.PasswordHash = AppUserManager.PasswordHasher.HashPassword(user, userRegistration.Password);
user.UserName = userRegistration.UserName;
await AppUserManager.CreateAsync(user);
await AppUserManager.AddToRoleAsync(user, "Admin");
}
}
public async Task <IHttpActionResult> RegisterExternal(ExternalUserAddRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var externalAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
if (externalAccessToken == null)
{
return(BadRequest("Invalid Provider or External Access Token"));
}
AppUser appUser = await AppUserManager.FindAsync(new UserLoginInfo(model.Provider, externalAccessToken.user_id));
if (appUser != null)
{
return(BadRequest("External user is already registered"));
}
appUser = new AppUser {
UserName = model.Username, Email = model.Email, EmailConfirmed = true, JoinDate = DateTime.Now
};
IdentityResult result = await AppUserManager.CreateAsync(appUser, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
IdentityResult addUserToRoleResult = await AppUserManager.AddToRoleAsync(appUser.Id, "user");
if (!addUserToRoleResult.Succeeded)
{
return(GetErrorResult(addUserToRoleResult));
}
var info = new ExternalLoginInfo
{
DefaultUserName = model.Username,
Login = new UserLoginInfo(model.Provider, externalAccessToken.user_id)
};
result = await AppUserManager.AddLoginAsync(appUser.Id, info.Login);
return(result.Succeeded ? Ok(GenerateLocalAccessTokenResponse(model.Username)) : GetErrorResult(result));
}
public async Task <HttpResponseMessage> KorisnikKreiraj(HttpRequestMessage request, [FromBody] KorisnikModel model)
{
HttpResponseMessage response = null;
try
{
var user = new Korisnik
{
UserName = model.Email,
Email = model.Email,
GradId = model.GradId,
Ime = model.Ime,
Prezime = model.Prezime,
Ulica = model.Ulica,
Broj = model.Broj,
Telefon = model.Telefon,
PostanskiBroj = model.PostanskiBroj,
IsDeleted = model.IsOnemogucen
};
var result = await AppUserManager.CreateAsync(user, model.Lozinka);
if (result.Succeeded)
{
if ((model.Uloge.Contains("Admin") || model.Uloge.Contains("Uposlenik")) && model.Uloge.Contains("Klijent"))
{
model.Uloge = model.Uloge.Where(val => val != "Klijent").ToArray();
}
foreach (var uloga in model.Uloge)
{
await AppUserManager.AddToRoleAsync(user.Id, uloga);
}
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, result.Errors);
}
}
catch (Exception ex)
{
response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
}
return(response);
}
public async Task <IHttpActionResult> CreateUser(AccountCreateBindingModels accountCreateBindingModels)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userInfo = new UserInfo()
{
FirstName = accountCreateBindingModels.FirstName,
LastName = accountCreateBindingModels.LastName,
JobTitle = accountCreateBindingModels.JobTitle,
Address = accountCreateBindingModels.Address,
Sex = accountCreateBindingModels.Sex,
IsEmployeeProfile = accountCreateBindingModels.IsEmployeeProfile,
IsActiveEmployee = accountCreateBindingModels.IsActiveEmployee
};
var user = new ApplicationUser()
{
UserName = accountCreateBindingModels.UserName,
Email = accountCreateBindingModels.Email,
UserInfo = userInfo
};
IdentityResult addUserResult = await this.AppUserManager.CreateAsync(user, accountCreateBindingModels.Password).ConfigureAwait(true);
if (!addUserResult.Succeeded)
{
return(GetErrorResult(addUserResult));
}
// assigning default user role to user
var addedUser = this.AppUserManager.FindByName(user.UserName);
IdentityResult assignRolesResult = await AppUserManager.AddToRoleAsync(addedUser.Id, "User").ConfigureAwait(true);
if (!assignRolesResult.Succeeded)
{
return(GetErrorResult(assignRolesResult));
}
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
return(Created(locationHeader, TheModelFactory.Create(user)));
}
public async Task <IActionResult> Register(RegisterModel model)
{
try
{
//Checks if model is valid
if (!ModelState.IsValid)
{
return(View(model));
}
//Converts RegisterModel to AppUser type
AppUser newUser = model.ToAppUserEntity();
//Sets default properties for new user
newUser.SetDefaultPhotoPathAndUserName();
//Creates new user
var result = await _appUserManager.CreateAsync(newUser, newUser.PasswordHash);
//Checks if user is created and returns model with errors if it isn't
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View("Index", model));
}
//Adds new user to role
await _appUserManager.AddToRoleAsync(newUser, "normaluser");
//Signs in new user
await _signInManager.SignInAsync(newUser, false);
//Gets id of new user to redirect him to his profile
int currentUserId = await _appUserManager.GetCurrentUserIdAsync(newUser.Email);
return(RedirectToAction("Profile", "User", new { id = currentUserId }));
}
catch
{
return(View(model));
}
}
public async Task <IHttpActionResult> AddUserToRole([FromBody] RoleBindingModel userData)
{
var role = await AppRoleManager.FindByIdAsync(userData.RoleId);
if (role != null)
{
IdentityResult result = await AppUserManager.AddToRoleAsync(userData.UserId, role.Name);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
return(NotFound());
}
public async Task <ActionResult> AuditClubAY(int?id, string AuditDesc = "")
{
if (id == null)
{
Session["Error"] = "错误操作！审批过程未发现任务编号";
return(RedirectToAction("Error404", "Home"));
}
ClubNumber club = db.ClubNumbers.Where(c => c.AuditID == id).FirstOrDefault();
if (club == null)
{
Session["Error"] = "未发现社团";
return(RedirectToAction("Error404", "Home"));
}
int res = AuditFun(id ?? 0, EnumAuditState.通过, AuditDesc);
if (res == 1)
{
return(RedirectToAction("AuditClub", new { Msg = "社团申请任务[" + id + "]审批成功" }));
}
else if (res == 2)
{
club.State = (int)EnumState.正常;
club.CreateDate2 = DateTime.Now;
db.Entry(club).State = System.Data.Entity.EntityState.Modified;
if (club.User != null)
{
AppUser uid = db.Users.Where(u => u.UserName == club.User.UserId).FirstOrDefault();
AppUserManager userManager = HttpContext.GetOwinContext().GetUserManager <AppUserManager>();
bool c = userManager.IsInRoleAsync(uid.Id, "CAdmin").Result;
if (!c)
{
await userManager.AddToRoleAsync(uid.Id, "CAdmin");
}
}
db.SaveChanges();
return(RedirectToAction("AuditClub", new { Msg = "社团申请任务[" + id + "]审批成功" }));
}
else
{
return(RedirectToAction("AuditClub", new { Msg = "失败！社团申请任务[" + id + "]审批失败" }));
}
}
public async Task <ActionResult> ManageRole(UserInRoleViewModel userList)
{
AppRole appRole = await RoleManager.FindByIdAsync(userList.RoleID);
if (appRole == null)
{
ViewBag.Error = $"Error occurred while looking for role with ID = {userList.RoleID ?? "NULL ID"}";
return(View("Error"));
}
for (int i = 0; i < userList.IsInRole.Count; i++)
{
AppUser user = await UserManager.FindByNameAsync(userList.Users[i]);
IdentityResult result;
if (userList.IsInRole[i] && !(await UserManager.IsInRoleAsync(user.Id, userList.RoleName)))
{
result = await UserManager.AddToRoleAsync(user.Id, userList.RoleName);
}
else if (!userList.IsInRole[i] && await UserManager.IsInRoleAsync(user.Id, userList.RoleName))
{
result = await UserManager.RemoveFromRoleAsync(user.Id, userList.RoleName);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < userList.IsInRole.Count)
{
continue;
}
else
{
return(RedirectToAction("EditRole", new { id = userList.RoleID }));
}
}
}
return(RedirectToAction("EditRole", new { id = userList.RoleID }));
}
