public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new MyIdentityUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new MyIdentityUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Register(Register model)
{
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
user.UserName = model.Email;
user.Email = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.MobileNumber = model.MobileNumber;
user.CreatedBy = User.Identity.GetUserId();
IdentityResult result = userManager.Create(user, model.Password);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, "Administrator");
return(RedirectToAction("Login", "Account"));
}
else
{
ModelState.AddModelError("UserName", "Error while creating the user!");
}
}
return(View(model));
}
public IActionResult Register([FromBody] RegisterViewModel registerObj)
{
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
user.UserName = registerObj.UserName;
user.Email = registerObj.Email;
user.FullName = registerObj.FullName;
user.BirthDate = registerObj.BirthDate;
IdentityResult result = _userManager.CreateAsync(user, registerObj.Password).Result;
_logger.LogError(result.ToString());
}
else
{
foreach (var modelStateValue in ModelState.Values)
{
foreach (var modelError in modelStateValue.Errors)
{
_logger.LogError(modelError.Exception, modelError.ErrorMessage);
}
}
}
return(Json(true));
}
public AuthenticateResponse(MyIdentityUser user, string token)
{
Id = user.Id;
FullName = user.FullName;
Phone = user.PhoneNumber;
Token = token;
}
public async Task <ActionResult> Register(RegisterUser registerUser)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new MyIdentityUser
{
UserName = registerUser.Email,
Email = registerUser.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
return(CustomResponse(GetUserResponse(user.Email)));
}
foreach (var error in result.Errors)
{
AddError(error.Description);
}
return(CustomResponse());
}
private async Task <string> GenerateJWT(MyIdentityUser user)
{
try
{
IList <string> iListRoleUser = await this._UserManager.GetRolesAsync(user);
List <Claim> listClaimUser = new List <Claim>
{
new Claim("MaNguoiDung", user.Id.ToString()),
new Claim("TenDangNhap", user.UserName),
new Claim("HoTen", user.FullName),
new Claim("SoDienThoai", user.PhoneNumber),
new Claim("NgaySinh", user.DateOfBirth?.ToString() ?? "Trống"),
new Claim("Email", user.Email),
new Claim("DiaChi", user.Address ?? "Trống"),
};
string roleUser = iListRoleUser.First();
listClaimUser.Add(new Claim(ClaimTypes.Role, roleUser));
listClaimUser.Add(new Claim("ChucVu", roleUser));
string key = _IConfiguration["JWT:Key"];
string issuer = _IConfiguration["JWT:Issuer"];
SymmetricSecurityKey symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));
SigningCredentials signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256);
JwtSecurityToken jwtSecurityToken = new JwtSecurityToken(issuer, issuer, listClaimUser, expires: DateTime.Now.AddHours(1), signingCredentials: signingCredentials);
string jwt = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
return(await Task.FromResult <string>(jwt));
}
catch (Exception)
{
throw;
}
}
public ActionResult Register(Register model)
{
if (ModelState.IsValid)
{
var user = new MyIdentityUser();
user.UserName = model.UserName;
user.Email = model.Email;
user.FullName = model.FullName;
user.BirthDate = model.BirthDate;
user.Bio = model.Bio;
IdentityResult result = userManager.Create(user, model.Password);
//redirection to login page
if (result.Succeeded)
{
//Pour l'exemple on donne les droits admin au nouvel utilisateur
userManager.AddToRole(user.Id, "Administrator");
return(RedirectToAction("Login", "Account"));
}
else
{
ModelState.AddModelError("UserName", "Error while creating the user!");
}
}
return(View(model));
}
public async Task <MyServiceResult> ResetPassword(string userId, string newPassword)
{
try
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new MyServiceResult
{
Successed = false,
Content = "Người dùng không tồn tại"
});
}
MyIdentityUser objMyIdentityUser = await this._UserManager.FindByIdAsync(userId);
if (objMyIdentityUser is null)
{
return(new MyServiceResult
{
Successed = false,
Content = "Người dùng không tồn tại"
});
}
IdentityResult objIdentityResultRemove = await this._UserManager.RemovePasswordAsync(objMyIdentityUser);
if (objIdentityResultRemove.Succeeded)
{
IdentityResult objIdentityResultAdd = await this._UserManager.AddPasswordAsync(objMyIdentityUser, newPassword);
if (objIdentityResultAdd.Succeeded)
{
return(new MyServiceResult
{
Successed = true,
Content = "Đặt lại mật khẩu thành công"
});
}
else
{
return(new MyServiceResult
{
Successed = false,
Content = "Đặt lại mật khẩu thất bại"
});
}
}
else
{
return(new MyServiceResult
{
Successed = false,
Content = "Đặt lại mật khẩu thất bại"
});
}
}
catch (Exception)
{
throw;
}
}
public async Task <MyServiceObjectResult <MyUserInfoModel> > GetInformation(string userId)
{
try
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new MyServiceObjectResult <MyUserInfoModel>
{
Successed = false,
Content = "Người dùng không tồn tại"
});
}
MyIdentityUser objMyIdentityUser = await this._UserManager.FindByIdAsync(userId);
if (objMyIdentityUser is null)
{
return(new MyServiceObjectResult <MyUserInfoModel>
{
Successed = false,
Content = "Người dùng không tồn tại"
});
}
MyUserInfoModel CUserModel = this._IMapper.Map <MyUserInfoModel>(objMyIdentityUser);
return(new MyServiceObjectResult <MyUserInfoModel>
{
Successed = true,
Content = "Lấy thông tin thành công",
Object = CUserModel
});
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult> Register(CustomRegisterUser registerUser)
{
var user = new MyIdentityUser
{
UserName = registerUser.Name,
Email = registerUser.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, Roles.BASIC);
await _userManager.AddClaimAsync(user, new Claim(Claims.Sample, ClaimsValues.READ));
await _userManager.AddClaimAsync(user, new Claim(Claims.Sample, ClaimsValues.WRITE));
return(Ok(createToken(user.UserName)));
}
else
{
var error = new BadRequestError();
foreach (var item in result.Errors)
{
error.AddMessage(item.Description);
}
var json = ErrorFormat.SerializeError(ModelState, error);
return(BadRequest(json));
}
}
public ActionResult Create([Bind(Include = "Id,LastName,FirstName,Phone,Email,SellerAccount,Login,Password")] Seller seller)
{
if (ModelState.IsValid)
{
// Creation du vendeur dans le SecurityContext du projet ASP.NET
using (var secudb = new SecurityDbContext())
{
IdentityRole userRole = RoleUtils.CreateOrGetRole("User");
UserManager <MyIdentityUser> userManager = new MyIdentityUserManager(new UserStore <MyIdentityUser>(secudb));
MyIdentityUser sellerUser = new MyIdentityUser()
{
UserName = seller.Login, Email = seller.Email, Login = seller.Login
};;
var result = userManager.Create(sellerUser, seller.Password);
if (!result.Succeeded)
{
throw new System.Exception("database insert fail");
}
RoleUtils.AssignRoleToUser(userRole, sellerUser);
}
// Creation du vendeur dans le ProductContext du projet librairie
db.Sellers.Add(seller);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(seller));
}
public JsonResult SavePurchase(ProductReceive O)
{
bool status = false;
if (ModelState.IsValid)
{
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore <MyIdentityUser> userStore = new UserStore <MyIdentityUser>(db);
UserManager <MyIdentityUser> userManager = new UserManager <MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
O.DateReceived = DateTime.Now;
O.UserId = user.Id;
_productReceiveService.AddProductReceive(O);
//Order order = new Order { OrderNo = O.OrderNo, OrderDate = O.OrderDate, Description = O.Description };
//foreach (var i in O.OrderDetails)
//{
// //
// // i.TotalAmount =
// order.OrderDetails.Add(i);
//}
//dc.Orders.Add(order);
//dc.SaveChanges();
status = true;
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status }
});
}
public ActionResult Register(Register model)
{
ClientValidationEdit(model);
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
user.UserName = model.UserName;
user.Email = model.Email;
IdentityResult result = userManager.Create(user, model.Password);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, "AdminD");
return(RedirectToAction("Create", "Clients", new { model.Email }));
}
else
{
ModelState.AddModelError("UserName", "Ошибка при создании пользователя!");
}
}
return(View(model));
}
public ActionResult Login(Login model, string returnUrl)
{
if (ModelState.IsValid)
{
MyIdentityUser user = userManager.Find(model.UserName, model.Password);
if (user != null)
{
IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity identity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationProperties props = new AuthenticationProperties();
props.IsPersistent = model.RememberMe;
authenticationManager.SignIn(props, identity);
Session["USER_INFO"] = user;
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
return(View(model));
}
public ActionResult Register(Register model, string RoleList, int BranchList)
{
ViewBag.RoleList = new SelectList(roleManager.Roles, "Id", "Name", RoleList);
ViewBag.BranchList = new SelectList(_branchService.GetAllBranches(), "BranchId", "BranchName", BranchList);
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
user.UserName = model.UserName;
user.Email = model.Email;
user.FullName = model.FullName;
user.BirthDate = model.BirthDate;
user.Bio = model.Bio;
user.Role = roleManager.FindById(RoleList).Name;
user.BranchId = BranchList;
IdentityResult result = userManager.Create(user, model.Password);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, roleManager.FindById(RoleList).Name);
return(RedirectToAction("Users", "Account"));
}
else
{
ModelState.AddModelError("UserName", "Error while creating the user!");
}
}
return(View(model));
}
public ActionResult Create([Bind(Include = "CustomerId,SalesType,ReferenceNo")] SalesInvoiceViewModel salesInvoiceViewModel, int CustomerList,
int BranchList, int?SalesTypeList)
{
if (ModelState.IsValid)
{
var exists = _salesInvoiceService.Get(t => t.ReferenceNo == salesInvoiceViewModel.ReferenceNo).FirstOrDefault();
if (exists != null)
{
return(View(salesInvoiceViewModel));
}
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore <MyIdentityUser> userStore = new UserStore <MyIdentityUser>(db);
UserManager <MyIdentityUser> userManager = new UserManager <MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
var salesInvoice = new SalesInvoice()
{
BranchId = BranchList,
CustomerId = CustomerList,
ReferenceNo = salesInvoiceViewModel.ReferenceNo,
SalesType = SalesTypeList ?? 0,
UserId = user.Id,
DateSold = DateTime.Now,
Status = "Draft"
};
_salesInvoiceService.AddSalesInvoice(salesInvoice);
return(RedirectToAction("Create", "SalesInvoices", new { id = salesInvoice.SalesInvoiceId }));
}
return(View(salesInvoiceViewModel));
}
public JsonResult SaveTransfer(ProductTransfer O)
{
bool status = false;
if (ModelState.IsValid)
{
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore <MyIdentityUser> userStore = new UserStore <MyIdentityUser>(db);
UserManager <MyIdentityUser> userManager = new UserManager <MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
O.DateTransfered = DateTime.Now;
O.UserId = user.Id;
_productTransferService.AddProductTransfer(O);
status = true;
}
else
{
status = false;
}
return(new JsonResult {
Data = new { status = status }
});
}
public IActionResult Register(RegisterViewModel regiModel)
{
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
user.UserName = regiModel.UserName;
user.Email = regiModel.Email;
user.FullName = regiModel.FullName;
user.BirthDate = regiModel.BirthDate;
IdentityResult result = userManager.CreateAsync(user, regiModel.Password).Result;
if (result.Succeeded)
{
if (!roleManager.RoleExistsAsync("NormalUser").Result)
{
MyIdentityRole role = new MyIdentityRole();
role.Name = "NormalUser";
role.Description = "Perform normal operations.";
IdentityResult roleResult = roleManager.CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", "Error while creating role!");
return(View(regiModel));
}
}
userManager.AddToRoleAsync(user, "NormalUser").Wait();
return(RedirectToAction("Login", "Account"));
}
}
return(View(regiModel));
}
// Print Invoice
public ActionResult Invoice(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductReceive productReceive = _productReceiveService.FindById(id.Value);
if (productReceive == null)
{
return(HttpNotFound());
}
var productReceiveLineItemViewModels = new List <ProductReceiveLineItemViewModel>();
foreach (var productReceiveLineItem in productReceive.ProductReceiveLineItems)
{
var productReceiveLineItemviewModel = new ProductReceiveLineItemViewModel()
{
ProductReceiveLineItemId = productReceiveLineItem.ProductReceiveLineItemId,
ProductId = productReceiveLineItem.ProductId,
Productname = _productService.FindBy(s => s.ProductcId == productReceiveLineItem.ProductId).First().ProductName,
Quantity = productReceiveLineItem.Quantity,
UnitCost = productReceiveLineItem.UnitCost,
UnitPrice = _productService.FindBy(s => s.ProductcId == productReceiveLineItem.ProductId).First().UnitPrice
};
productReceiveLineItemViewModels.Add(productReceiveLineItemviewModel);
}
ViewBag.LineItems = productReceiveLineItemViewModels;
MyIdentityUser user = userManager.FindById(productReceive.UserId);
ViewBag.UserName = user.FullName;
return(View(productReceive));
}
public ActionResult Create([Bind(Include = "DateTransfered,FromBranchId,ToBranchId,UserId")] ProductTransferViewModel productTransferViewModel)
{
if (ModelState.IsValid)
{
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore <MyIdentityUser> userStore = new UserStore <MyIdentityUser>(db);
UserManager <MyIdentityUser> userManager = new UserManager <MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
var productTransfer = new ProductTransfer()
{
//FromBranchId =1, //productTransferViewModel.FromBranchId,
//ToBranchId= 2, //productTransferViewModel.ToBranchId,
FromBranchId = productTransferViewModel.FromBranchId,
ToBranchId = productTransferViewModel.ToBranchId,
UserId = user.Id,
DateTransfered = DateTime.Now
};
_productTransferService.AddProductTransfer(productTransfer);
return(RedirectToAction("Create", "ProductTransfers", new { id = productTransfer.ProductTransferId }));
}
return(View(productTransferViewModel));
}
public ActionResult Index()
{
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore <MyIdentityUser> userStore = new UserStore <MyIdentityUser>(db);
UserManager <MyIdentityUser> userManager = new UserManager <MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
DbDataEntities dbTest = new DbDataEntities();
List <Customer> model = null;
if (userManager.IsInRole(user.Id, "Administrator"))
{
model = dbTest.Customers.ToList();
}
if (userManager.IsInRole(user.Id, "Operator"))
{
model = dbTest.Customers.Where(c => c.Country == "USA").ToList();
}
ViewBag.FullName = user.FullName;
return(View(model));
}
public IActionResult Index()
{
MyIdentityUser user = userManager.GetUserAsync
(HttpContext.User).Result;
return(View());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new MyIdentityUser {
UserName = model.UserName, Login = model.Login
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
IdentityRole defaultRole = RoleUtils.CreateOrGetRole(model.RoleId);
RoleUtils.AssignRoleToUser(defaultRole, user);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// Pour plus d'informations sur l'activation de la confirmation de compte et de la réinitialisation de mot de passe, visitez https://go.microsoft.com/fwlink/?LinkID=320771
// Envoyer un message électronique avec ce lien
// 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return(View(model));
}
public async Task Initialize()
{
if (_context.Database.EnsureCreated())
{
var adminRole = await _roleManager.CreateAsync(
new IdentityRole(Roles.ADMIN));
await _roleManager.CreateAsync(
new IdentityRole(Roles.BASIC));
var basicRole = await _roleManager.FindByNameAsync(Roles.BASIC);
await _roleManager.AddClaimAsync(basicRole, new Claim(Claims.Sample, ClaimsValues.READ));
var user = new MyIdentityUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
};
await _userManager.CreateAsync(user, "pedro123PEDRO@");
await _userManager.AddToRoleAsync(user, Roles.BASIC);
await _userManager.AddClaimAsync(user, new Claim(Claims.Sample, ClaimsValues.READ));
}
}
public ActionResult Login(Login model, string returnUrl)
{
if (ModelState.IsValid)
{
MyIdentityUser user = new MyIdentityUser();
try
{
CustomResponse res = APICalls.Get("AuthenticationAPI/Get?username="******"&password="******"&type=1");
if (res.Status == CustomResponseStatus.Successful && res.Response != null)
{
JavaScriptSerializer serializer1 = new JavaScriptSerializer();
serializer1.MaxJsonLength = 1000000000;
var uinfo = res.Response.ToString();
user = serializer1.Deserialize <MyIdentityUser>(uinfo);
}
}
catch (System.FormatException ex)
{
return(View());
}
if (user.Email != null)
{
IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity identity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationProperties props = new AuthenticationProperties();
props.IsPersistent = model.RememberMe;
authenticationManager.SignIn(props, identity);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
List <string> roless = userManager.GetRoles(user.Id).ToList();
if (roless[0] == "Administrator")
{
return(RedirectToRoute("DashboardRoute"));
}
else if (roless[0] == "Client")
{
return(RedirectToRoute("ClientDashboardRoute"));
}
else
{
return(RedirectToRoute("UserDashboardRoute"));
}
}
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
return(View());
}
}
return(View(model));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new MyIdentityUser();
if (_dbContext.Users.Any())
{
user = new MyIdentityUser {
UserName = Input.Username, Email = Input.Email, Role = Panda.Models.Enums.Role.User
};
}
else
{
user = new MyIdentityUser {
UserName = Input.Username, Email = Input.Email, Role = Panda.Models.Enums.Role.Admin
};
}
var isRoleExists = await _roleManager.RoleExistsAsync(user.Role.ToString());
if (!isRoleExists)
{
await _roleManager.CreateAsync(new IdentityRole(user.Role.ToString()));
}
var result = await _userManager.CreateAsync(user, Input.Password);
await _userManager.AddToRoleAsync(user, user.Role.ToString());
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);
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 <IActionResult> OnPostConfirmationAsync(IFormFile file, string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
// 画像登録
string imageName = "empty.js";
if (file != null)
{
file.OpenReadStream();
imageName = Path.GetFileName(file.FileName);
var filePath = Path.Combine(_hostingEnvironment.WebRootPath, "userImages", imageName);
// 画像ファイル名が重複していた場合、リネーム
if (System.IO.File.Exists(filePath))
{
// 修正
imageName.Insert(0, "_");
filePath.Insert(0, "_");
}
file.CopyTo(new FileStream(filePath, FileMode.Create));
}
var user = new MyIdentityUser {
UserName = Input.UserName, Email = Input.Email, ProfileImageUrl = "/userImages/" + imageName
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public static void AssignRoleToUser(IdentityRole role, MyIdentityUser user)
{
using (var ctx = new SecurityDbContext())
{
var userManager = new UserManager <MyIdentityUser>(new UserStore <MyIdentityUser>(ctx));
userManager.AddToRole(user.Id, role.Name);
}
}
private async Task SignIn(MyIdentityUser myIdentityUser)
{
var identity = await userManager.CreateIdentityAsync(myIdentityUser, DefaultAuthenticationTypes.ApplicationCookie);
var owinContext = Request.GetOwinContext();
var authManager = owinContext.Authentication;
authManager.SignIn(identity);
}