public IActionResult RegisterCustomer(RegisterCustomerViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.Name,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Customer").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Customer"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Böyle bir rol ekleyemedik");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Customer").Wait();
return(RedirectToAction("LoginCustomer"));
}
}
return(View(registerViewModel));
}
public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login", "Account"));
}
}
return(View(registerViewModel));
}
public static async Task Initialize(RoleManager <CustomIdentityRole> roleManager)
{
if (!await roleManager.RoleExistsAsync("Admin"))
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
await roleManager.CreateAsync(role);
}
if (!await roleManager.RoleExistsAsync("mod"))
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "mod"
};
await roleManager.CreateAsync(role);
}
if (!await roleManager.RoleExistsAsync("User"))
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "User"
};
await roleManager.CreateAsync(role);
}
if (!await roleManager.RoleExistsAsync("Anonymous"))
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Anonymous"
};
await roleManager.CreateAsync(role);
}
}
public async Task <string> CreateRole(string roleStr)
{
if (!_roleManager.RoleExistsAsync("Back Office Order Management").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Back Office Order Management",
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return("we cannot add the role");
}
else if (roleResult.Succeeded)
{
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.edit"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.delete"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.list"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.invoice"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.documantcontrol"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.list"));
}
//return View();
}
if (!_roleManager.RoleExistsAsync("Salesman").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Salesman"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return("we cannot add the role");
}
else
{
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "owndeal.create"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "owndeal.update"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "owndeal.list"));
}
}
return("Role creation success");
}
public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager
.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("User").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "User"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!result.Succeeded)
{
ModelState.AddModelError("", "Role can't added!");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "User").Wait();
return(RedirectToAction("Login"));
}
TempData.Add("message", "The information you entered is registered or your password is not secure. Please check your information and try again!");
}
return(View(registerViewModel));
}
private static void InitRolesAndAdminProfile(PortalContext context)
{
var currentcontext = HttpContext.Current;
var userManager = HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>();
var roleManager = HttpContext.Current.GetOwinContext().Get <ApplicationRoleManager>();
const string name = "webadmin";
const string email = "*****@*****.**";
const string password = "******";
var rolenames = new[]
{
Roles.SuperAdministrator,
Roles.Administrator,
Roles.Moderator,
Roles.Judge,
Roles.Competitor,
Roles.Member
};
foreach (string rolename in rolenames)
{
CustomIdentityRole role = roleManager.FindByName(rolename);
if (role == null)
{
role = new CustomIdentityRole {
Name = rolename
};
IdentityResult roleresult = roleManager.Create(role);
}
}
var country = context.Countries.Single(x => x.CountryName == "Russia");
UserProfile user = userManager.FindByName(name);
if (user == null)
{
user = new UserProfile {
UserName = name, Email = email, NickName = name, IdCountry = country.CountryId
};
IdentityResult result = userManager.Create(user, password);
}
IList <string> rolesForUser = userManager.GetRoles(user.Id);
CustomIdentityRole adminrole = roleManager.FindByName(rolenames.First());
if (!rolesForUser.Contains(adminrole.Name))
{
IdentityResult result = userManager.AddToRole(user.Id, adminrole.Name);
}
}
//[HttpGet]
public async Task <string> CheckCreateRole(string roleStr)
{
var t = roleStr.Trim().ToUpper();
t = Regex.Replace(t, @"\s", "");
//t.Replace(" ", String.Empty);
//t.Replace("_", String.Empty);
//return t;
// Back Office Order Management
var roleQueryRes = _roleManager.Roles.Where(p => p.NormalizedName == t).FirstOrDefault();
if (roleQueryRes == null)
//if (!_roleManager.RoleExistsAsync(t).Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = roleStr,
NormalizedName = t
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return("we cannot add the role");
}
else if (roleResult.Succeeded)
{
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.edit"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.delete"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.list"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.invoice"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.documantcontrol"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "deal.list"));
}
//return View();
return("Role creation success");
}
else
{
return("Role already created");
}
}
//[ValidateAntiForgeryToken] //see surf ataklarını engellemeye çalışıyoruz
public IActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email,
PhoneNumber = registerViewModel.PhoneNumber
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", _localizer["Sorry! We can not add the role"]);
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login", "Account"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("Password", error.Description);
}
return(View(registerViewModel));
}
}
return(View(registerViewModel));
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = model.UserName,
Email = model.Email
};
IdentityResult result = _userManager.CreateAsync(user, model.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return(View(model));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login", "Account"));
}
else
{
string data = "";
foreach (var item in result.Errors)
{
data += " " + item.Description;
}
TempData.Add("message", data);
}
}
return(View(model));
}
public async Task <IActionResult> Role()
{
//CustomIdentityRole generalRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.General
//};
//await _roleManager.CreateAsync(generalRole);
//CustomIdentityRole privateRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.Private
//};
//await _roleManager.CreateAsync(privateRole);
//CustomIdentityRole helpRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.Help
//};
//await _roleManager.CreateAsync(helpRole);
//CustomIdentityRole educationRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.Education
//};
//await _roleManager.CreateAsync(educationRole);
//CustomIdentityRole createRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.Create
//};
//await _roleManager.CreateAsync(createRole);
//CustomIdentityRole deleteRole = new CustomIdentityRole
//{
// Name = AppConst.UserRole.Delete
//};
//await _roleManager.CreateAsync(deleteRole);
CustomIdentityRole readerRole = new CustomIdentityRole
{
Name = AppConst.UserRole.Reader
};
await _roleManager.CreateAsync(readerRole);
alertUi.AlertUiType = AlertUiType.success;
AlertUiMessage();
return(View());
}
public IActionResult RegisterUser(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
var userExists = _userManager.Users.FirstOrDefault(u => u.Email == registerViewModel.Email && u.UserName == registerViewModel.UserName);
if (userExists != null)
{
TempData.Add("message", "Bu bilgiler ile daha önce kayıt olunmuştur..");
return(View("RegisterUser"));
}
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email,
PhoneNumber = registerViewModel.Phone,
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("User").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "User"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Kullanıcı eklenemedi");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "User").Wait();
TempData.Add("message", "Başarılı bir şekilde kayıt oldunuz.");
return(View("RegisterUser"));
}
}
return(View());
}
public async Task <IActionResult> SignUp(RegisterViewModel registerViewModel)
{
if (!ModelState.IsValid)
{
return(View(registerViewModel));
}
var user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult identityResult = await _userManager.CreateAsync(user, registerViewModel.Password);
if (!identityResult.Succeeded)
{
ModelState.AddModelError(string.Empty, "Register is failed!");
return(View(registerViewModel));
}
//Sistemde admin adında bir role var mı?
if (!await _roleManager.RoleExistsAsync(Role.ADMIN))
{
var customIdentityRole = new CustomIdentityRole
{
Name = Role.ADMIN
};
var roleResult = await _roleManager.CreateAsync(customIdentityRole);
if (!roleResult.Succeeded)
{
ModelState.AddModelError(string.Empty, "We can't add the role!");
return(View(registerViewModel));
}
}
await _userManager.AddToRoleAsync(user, Role.ADMIN);
return(RedirectToAction(nameof(SignIn)));
}
public async Task <IActionResult> RegisterUser(RegisterWithRoleViewModel registerWithRoleViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerWithRoleViewModel.Email,
Email = registerWithRoleViewModel.Email,
};
IdentityResult result = _userManager.CreateAsync(user, registerWithRoleViewModel.Password).Result;
if (result.Succeeded)
{
// await roleManager.AddClaimAsync(adminRole, new Claim(CustomClaimTypes.Permission, "projects.view"));
//await _userManager.AddClaimAsync(user, new Claim("claimtip", user.Email));
CustomIdentityRole role = await _roleManager.FindByNameAsync(registerWithRoleViewModel.Role.Trim());
if (role == null)
{
await _userManager.DeleteAsync(user);
ModelState.AddModelError("Error", "role not verified");
}
else
{
_userManager.AddToRoleAsync(user, registerWithRoleViewModel.Role.Trim()).Wait();
}
// _userManager.AddToRoleAsync(user, "Manager").Wait();
//return RedirectToAction("Login", "Acc");
}
else
{
List <IdentityError> errors = result.Errors.ToList <IdentityError>();
foreach (var error in errors)
{
ModelState.AddModelError("Error", error.Description);
}
}
}
return(View(registerWithRoleViewModel));
}
public async Task <IActionResult> Edit(CustomIdentityRole role)
{
if (!ModelState.IsValid)
{
return(View(role));
}
var identityRole = await _roleManager.FindByIdAsync(role.Id);
identityRole.Name = role.Name;
var result = await _roleManager.UpdateAsync(identityRole);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Rol güncellenemedi");
return(View(role));
}
return(RedirectToAction("Index", "Role"));
}
public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid) //gelen kayıt formu eksiksiz ise
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
//atamaları yap.
IdentityResult result =
_userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded) //eğer sonuç doğru ise---------------->ROLE KISMI<------------------------------------
{
if (!_roleManager.RoleExistsAsync("Admin").Result) //admin adında bir role yoksa
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin" //admin adında bir role oluştur.
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)//eğer rol oluşmadıysa
{
ModelState.AddModelError("", "Role Eklenemiyor.");
return(View(registerViewModel));
}
}
_userManager.AddToRoleAsync(user, "Admin").Wait();
return(RedirectToAction("Login", "Account"));
}
}
return(View(registerViewModel));
}
public async Task <IActionResult> Create(RoleAddViewModel roleAddViewModel)
{
if (!ModelState.IsValid)
{
return(View(roleAddViewModel));
}
var role = new CustomIdentityRole
{
Name = roleAddViewModel.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Rol eklenemedi.");
return(View(roleAddViewModel));
}
return(RedirectToAction("Index", "Role"));
}
public ActionResult Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result =
_userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Admin").Result)
//sistemde admin diye bir role var mı kontrolü
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
//role yoksa burada yeni role oluşturuldu.
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We couldn't add the role!");
return(View(registerViewModel));
}
}
//role manager yoksa role manager oluşturulur:
_userManager.AddToRoleAsync(user, "Admin").Wait();
//kullanıcıya rol ekleme işlemini addtorole ile gerçekleştiriyoruz.
return(RedirectToAction("Login", "Account"));
}
}
return(View(registerViewModel));
}
public static void EnsureDataSeed(this PlaneBookingContext db, RoleManager <CustomIdentityRole> roleManager)
{
if (!roleManager.RoleExistsAsync("NormalUser").Result)
{
CustomIdentityRole role = new CustomIdentityRole();
role.Name = "NormalUser";
role.Description = "Perform normal operations.";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync("Administrator").Result)
{
CustomIdentityRole role = new CustomIdentityRole();
role.Name = "Administrator";
role.Description = "Perform all the operations.";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!db.Tutors.Any() || !db.TutorAvailabilities.Any())
{
var tutor = new List <Tutor>
{
new Tutor
{
Description = "Mike",
CreatedAt = DateTime.Now,
Availabilities = new List <TutorAvailability>
{
new TutorAvailability
{
TutorId = 1,
Description = "Free slot",
ScheduleDate = new DateTime(2020, 08, 15),
CreatedAt = DateTime.Now
},
new TutorAvailability
{
TutorId = 1,
Description = "Free slot 2",
ScheduleDate = new DateTime(2020, 08, 16),
CreatedAt = DateTime.Now
},
new TutorAvailability
{
TutorId = 1,
Description = "Free slot 3",
ScheduleDate = new DateTime(2020, 08, 17),
CreatedAt = DateTime.Now
}
}
},
new Tutor
{
Description = "George",
CreatedAt = DateTime.Now,
Availabilities = new List <TutorAvailability>
{
new TutorAvailability
{
TutorId = 2,
Description = "Free slot 1",
ScheduleDate = new DateTime(2020, 08, 15),
CreatedAt = DateTime.Now
},
new TutorAvailability
{
TutorId = 2,
Description = "Free slot 2",
ScheduleDate = new DateTime(2020, 08, 17),
CreatedAt = DateTime.Now
}
}
}
};
db.Tutors.AddRange(tutor);
var airport = new List <Airport>
{
new Airport
{
Description = "Panso",
CreatedAt = DateTime.Now,
Location = "Panama",
Planes = new List <Plane>
{
new Plane
{
Description = "MiG-21",
CreatedAt = DateTime.Now,
PlaneDepartures = new List <PlaneDeparture>
{
new PlaneDeparture
{
PlaneId = 1,
Description = "Free slot",
Departure = new DateTime(2020, 09, 15),
CreatedAt = DateTime.Now
},
new PlaneDeparture
{
PlaneId = 1,
Description = "Free slot",
Departure = new DateTime(2020, 09, 18),
CreatedAt = DateTime.Now
}
}
},
new Plane
{
Description = "Hawker",
CreatedAt = DateTime.Now,
PlaneDepartures = new List <PlaneDeparture>
{
new PlaneDeparture
{
PlaneId = 2,
Description = "Free slot",
Departure = new DateTime(2020, 08, 15),
CreatedAt = DateTime.Now
}
}
}
,
new Plane
{
Description = "B-52",
CreatedAt = DateTime.Now,
PlaneDepartures = new List <PlaneDeparture>
{
new PlaneDeparture
{
PlaneId = 3,
Description = "Free slot",
Departure = new DateTime(2020, 08, 10),
CreatedAt = DateTime.Now
}
}
}
}
}
};
db.Airports.AddRange(airport);
db.SaveChanges();
}
}
public async Task <IActionResult> Register(RegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.Email,
Email = registerViewModel.Email,
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("Manager").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Manager"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "projects.delete"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "projects.create"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "projects.update"));
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return(View(registerViewModel));
}
;
//return View(registerViewModel);
}
if (!_roleManager.RoleExistsAsync("Admin").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "Admin"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "allprojects.delete"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "allprojects.create"));
await _roleManager.AddClaimAsync(role, new Claim(ClaimsIdentity.DefaultRoleClaimType, "allprojects.update"));
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role");
return(View(registerViewModel));
}
;
//return View(registerViewModel);
}
// await roleManager.AddClaimAsync(adminRole, new Claim(CustomClaimTypes.Permission, "projects.view"));
await _userManager.AddClaimAsync(user, new Claim("claimtip", user.Email));
_userManager.AddToRoleAsync(user, "Admin").Wait();
_userManager.AddToRoleAsync(user, "Manager").Wait();
return(RedirectToAction("Login", "Acc"));
}
}
return(View(registerViewModel));
}
public async Task <IActionResult> Register(RegisterViewModel registerViewModel, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
CustomIdentityUser user = new CustomIdentityUser
{
UserName = registerViewModel.UserName,
Email = registerViewModel.Email
};
IdentityResult result = _userManager.CreateAsync(user, registerViewModel.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("User").Result)
{
CustomIdentityRole role = new CustomIdentityRole
{
Name = "User"
};
IdentityResult roleResult = _roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "We can't add the role!");
return(View(registerViewModel));
}
}
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
//await _emailSender.SendEmailConfirmationAsync(registerViewModel.Email, callbackUrl);
_userManager.AddToRoleAsync(user, "User").Wait();
// Email Confirmation
string confirmationToken = _userManager.GenerateEmailConfirmationTokenAsync(user).Result;
var confirmationLink = Url.Action("ConfirmEmail", "Account", new
{
userid = user.Id,
token = confirmationToken
},
protocol: HttpContext.Request.Scheme);
string confirmationEmailBody = string.Format("<a href='" + confirmationLink + "'>") + "</a>";// confirmation link
SmtpClient client = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
Credentials = new NetworkCredential("*****@*****.**", "np13novembre"),
DeliveryMethod = SmtpDeliveryMethod.Network,
EnableSsl = true
};
MailMessage mail = new MailMessage
{
//string link = String.Format("<a href=\"http://*****:*****@gmail.com", user.Email),
Body = "Dear " + user.Email + ",\nYour Mbs account has been created successfully." +
"Please confirm",
Subject = "your account is activated"
};
mail.To.Add(new MailAddress(user.Email));
client.Send(mail);
// End email confirmation
return(RedirectToAction("Login", "Account"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(" ", error.Description);
}
}
}
return(View(registerViewModel));
}
