protected async void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
// ユーザーとロールの初期化
// ロールの作成
var roleManager = new ApplicationRoleManager(new UserStore());
await roleManager.CreateAsync(new ApplicationRole { Name = "admin" });
await roleManager.CreateAsync(new ApplicationRole { Name = "users" });
var userManager = new ApplicationUserManager(new UserStore());
// 一般ユーザーの作成
await userManager.CreateAsync(new ApplicationUser { UserName = "******" }, "p@ssw0rd");
await userManager.AddToRoleAsync(
(await userManager.FindByNameAsync("tanaka")).Id,
"users");
// 管理者の作成
await userManager.CreateAsync(new ApplicationUser { UserName = "******" }, "p@ssw0rd");
await userManager.AddToRoleAsync(
(await userManager.FindByNameAsync("super_tanaka")).Id,
"users");
await userManager.AddToRoleAsync(
(await userManager.FindByNameAsync("super_tanaka")).Id,
"admin");
Debug.WriteLine("-----------");
}
public async Task <IdentityResult> SetUserRole(PanelUser user, IdentityRole role)
{
if (_roleManager.FindByName(role.Name) == null)
{
var roleResult = await _roleManager.CreateAsync(role);
if (!roleResult.Succeeded)
{
return(roleResult);
}
}
if (!_userManager.IsInRole(user.Id, role.Name))
{
var refreshTokens = _context.RefreshTokens.Where(item => item.Subject == user.UserName);
foreach (var refreshToken in refreshTokens)
{
_context.RefreshTokens.Remove(refreshToken);
}
_context.SaveChanges();
return(_userManager.AddToRole(user.Id, role.Name));
}
return(null);
}
public async Task <IHttpActionResult> CreateAsync(CreateRoleBindingDto model)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var role = new IdentityRole {
Name = model.Name
};
var result = await ApplicationRoleManager.CreateAsync(role);
return(result.Succeeded ? Created(new Uri(Url.Link("GetRoleById", new { role.Id })), role) : GetErrorResult(result));
}
public async Task <Tuple <bool, string[]> > CreateRoleAsync(RoleDTO role, IEnumerable <int> claims)
{
ObjectMapper mapper = new ObjectMapper();
ApplicationRole appRole = mapper.ConvertRoleToIdentityRole(role);
using (var dbContextTransaction = _context.Database.BeginTransaction())
{
try
{
var result = await _appRoleManager.CreateAsync(appRole);
if (!result.Succeeded)
{
return(Tuple.Create(false, result.Errors.ToArray()));
}
appRole = await _appRoleManager.FindByNameAsync(appRole.Name);
if (claims != null)
{
List <RolePermissionMap> rolePermissionList = new List <RolePermissionMap>();
foreach (int claim in claims)
{
RolePermissionMap tmpDTO = new RolePermissionMap();
tmpDTO.PermissionId = claim;
tmpDTO.RoleId = appRole.Id;
rolePermissionList.Add(tmpDTO);
}
_context.RolePermissionMaps.AddRange(rolePermissionList);
await _context.SaveChangesAsync();
dbContextTransaction.Commit();
}
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw ex;
}
}
return(Tuple.Create(true, new string[] { appRole.Id }));
}
public async Task <ActionResult> Create(RoleViewModel roleViewModel)
{
if (ModelState.IsValid)
{
var role = new IdentityRole(roleViewModel.Name);
var roleresult = await _roleManager.CreateAsync(role);
if (!roleresult.Succeeded)
{
ModelState.AddModelError("", roleresult.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <RoleModel> AddRoleAsync(ApplicationRoleManager roleManager, RoleModel role)
{
ApplicationRole newRole = new ApplicationRole()
{
Description = role.Description,
Level = role.Level,
Name = role.Name
};
await roleManager.CreateAsync(newRole);
newRole = await roleManager.FindByNameAsync(role.Name);
role.Id = newRole.Id;
return(role);
}
private static void EnsureRoleCreated(string roleName, ApplicationDbContext _context, ApplicationRoleManager _roleManager)
{
try
{
if (_context.Roles.FirstOrDefault(x => x.Name == roleName) == null)
{
var myAppRole = new ApplicationRole();
myAppRole.Name = roleName;
_roleManager.CreateAsync(myAppRole).Wait();
}
}
catch (Exception ex)
{
throw;
}
}
public ActionResult Index()
{
const string userName = "******";
const string password = "******";
const string roleName = "Admin";
const string phoneNumber = "0546889421";
var appUserStore = new UserStore <ApplicationUser>(db);
var appUserManager = new UserManager <ApplicationUser>(appUserStore);
var appRoleManager = new ApplicationRoleManager(new RoleStore <IdentityRole>(db));
try
{
var user = db.Users.SingleOrDefault(u => u.UserName == userName);
var role = db.Roles.SingleOrDefault(r => r.Name == roleName);
if (role == null)
{
appRoleManager.CreateAsync(new IdentityRole(roleName)).Wait();
role = db.Roles.SingleOrDefault(r => r.Name == roleName);
}
if (user == null)
{
appUserManager.CreateAsync(new ApplicationUser {
UserName = userName, PhoneNumber = phoneNumber
}, password).Wait();
user = db.Users.SingleOrDefault(u => u.UserName == userName);
}
var userRole = user.Roles.SingleOrDefault(r => r.RoleId == role.Id);
if (userRole == null)
{
appUserManager.AddToRoleAsync(user.Id, roleName).Wait();
}
}
catch (Exception ex)
{
// Error catched!
}
ViewBag.TopArtists = db.Artists.OrderByDescending(item => item.numOfViews).Take(10);
ViewBag.TopAlbums = db.Albums.OrderByDescending(item => item.numOfViews).Take(10);
ViewBag.TopSongs = db.Songs.OrderByDescending(item => item.numOfViews).Take(10);
return(View());
}
public async Task CreateRoleAsync(RoleDTO role)
{
var existingRole = await _roleManager.FindByNameAsync(role.Name);
if (existingRole == null)
{
IdentityRole roleToCreate = new IdentityRole {
Name = role.Name
};
await _roleManager.CreateAsync(roleToCreate);
}
else
{
throw new RoleException($"The role with name: {existingRole.Name} already exists!");
}
}
/// <summary>
/// انتساب نقش به کاربر
/// </summary>
/// <param name="user"></param>
/// <param name="role"></param>
/// <returns></returns>
public async Task <IdentityResult> SetUserRole(ApplicationUser user, IdentityRole role)
{
if (_roleManager.FindByName(role.Name) == null)
{
var roleResult = await _roleManager.CreateAsync(role);
if (!roleResult.Succeeded)
{
return(roleResult);
}
}
if (!_userManager.IsInRole(user.Id, role.Name))
{
return(_userManager.AddToRole(user.Id, role.Name));
}
return(null);
}
public async Task SetInitialDataAsync(User adminDto, List <string> roles)
{
foreach (var roleName in roles)
{
var role = await _roleManager.FindByNameAsync(roleName);
if (role == null)
{
role = new ApplicationRole {
Name = roleName
};
await _roleManager.CreateAsync(role);
}
}
await CreateAsync(adminDto);
}
private async Task SeedMembershipAsync(ApplicationDbContext context)
{
// create user
var userManager = new ApplicationUserManager(new NetUserStore(context));
if (!context.Users.Any(u => u.UserName == "*****@*****.**"))
{
await userManager.CreateAsync(new ApplicationUser
{
UserName = "******",
FirstName = "Zulkifli",
LastName = "Fauzi",
Email = "*****@*****.**",
EmailConfirmed = true,
PhoneNumber = "081339621240"
},
"Password*1"
);
}
// create roles
string[] rolesToCreate = new string[] { "Anggota", "Bendahara", "Administrator" };
var roleManager = new ApplicationRoleManager(new NetRoleStore(context));
foreach (var role in rolesToCreate)
{
if (!context.Roles.Any(r => r.Name.Equals(role, StringComparison.InvariantCultureIgnoreCase)))
{
await roleManager.CreateAsync(new NetRole
{
Name = role
}
);
}
}
// add user to role
var adminUser = await userManager.FindByNameAsync("*****@*****.**");
bool isAppAdmin = await userManager.IsInRoleAsync(adminUser.Id, "Administrator");
if (!isAppAdmin)
{
await userManager.AddToRoleAsync(adminUser.Id, "Administrator");
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// 如需如何啟用帳戶確認和密碼重設的詳細資訊，請造訪 http://go.microsoft.com/fwlink/?LinkID=320771
// 傳送包含此連結的電子郵件
// 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, "確認您的帳戶", "請按一下此連結確認您的帳戶 <a href=\"" + callbackUrl + "\">這裏</a>");
//[說明] 預計的角色及使用者
//Role: admin
//* [email protected] / aA123456!
//Role: test
//* [email protected] / aA123456!
//預設的角色名稱
var roleName = "test";
//判斷角色是否存在
if (RoleManager.RoleExists(roleName) == false)
{
//角色不存在,建立角色
var role = new IdentityRole(roleName);
await RoleManager.CreateAsync(role);
}
//將使用者加入該角色
await UserManager.AddToRoleAsync(user.Id, roleName);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// 如果執行到這裡，發生某項失敗，則重新顯示表單
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
if (!await RoleManager.RoleExistsAsync("Users"))
{
var roleResult = await RoleManager.CreateAsync(new Microsoft.AspNet.Identity.EntityFramework.IdentityRole("Users"));
if (!roleResult.Succeeded)
{
AddErrors(roleResult);
return(View(model));
}
}
var role = await RoleManager.FindByNameAsync("Users");
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = await UserManager.AddToRoleAsync(user.Id, "Users");
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 <RoleModel> CreateRoleAsync(RoleModel model)
{
// Create the role
var role = new ApplicationRole {
Name = model.Name, Description = model.Description ?? string.Empty
};
IdentityResult result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
throw new BadRequestException();
}
// Get the role to return as part of the response
var roleModel = await GetRoleByNameAsync(role.Name);
return(roleModel);
}
public async Task <ActionResult> Create(RoleViewModel roleViewModel)
{
if (ModelState.IsValid)
{
var role = new ApplicationRole(roleViewModel.Name);
var roleresult = await _roleManager.CreateAsync(role);
if (roleresult.Succeeded)
{
return(RedirectToAction("Index"));
}
AddErrors(roleresult);
return(View());
}
return(View());
}
public async Task AddAdminAndRoles(ApplicationContext context, List <string> roles)
{
ApplicationRoleManager roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(context));
foreach (string roleName in roles)
{
var role = await roleManager.FindByNameAsync(roleName);
if (role == null)
{
role = new ApplicationRole {
Name = roleName
};
await roleManager.CreateAsync(role);
}
}
await CreateAdmin(context);
}
public async Task <ActionResult> Create(CreateRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await _roleManager.CreateAsync(new ApplicationDbMovies.Models.ApplicationRole
{
Name = model.Name,
Description = model.Description
});
if (!result.Succeeded)
{
ModelState.AddModelError("", "Something went wrong");
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> CreateRoleCollection([FromBody] IEnumerable <RoleForCreationDto> roleCollection)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var roleEntities = _mapper.MapTo <IEnumerable <Role> >(roleCollection);
foreach (var roleEntity in roleEntities)
{
await _roleManager.CreateAsync(roleEntity);
}
var roleCollectionToReturn = _mapper.MapTo <IEnumerable <RoleDto> >(roleEntities);
var idsAsString = string.Join(",", roleCollectionToReturn.Select(x => x.Id));
return(AcceptedAtRoute("GetRoleCollection", new { ids = idsAsString }, roleCollectionToReturn));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser()
{
UserName = model.Email,
Email = model.Email,
NickName = model.NickName
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInAsync(user, isPersistent : false);
#region Add role to group
//角色名稱
var roleName = "Visitor";
//判斷角色是否存在
if (RoleManager.RoleExists(roleName) == false)
{
//角色不存在,建立角色
var role = new IdentityRole(roleName);
await RoleManager.CreateAsync(role);
}
//將使用者加入該角色
await UserManager.AddToRoleAsync(user.Id, roleName);
#endregion
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
// 如果執行到這裡，發生某項失敗，則重新顯示表單
return(View(model));
}
public async Task <IActionResult> PostRole([FromBody] RoleRequest roleRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationRole role = new ApplicationRole {
Name = roleRequest.Name
};
IdentityResult result = await rolemanager.CreateAsync(role);
if (result.Succeeded)
{
return(Ok(role)); // Todo: 201 Created
}
return(BadRequest(result.Errors));
}
public async Task <ActionResult> CreateRole([FromBody] RoleForCreationDto role)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var roleEntity = _mapper.MapTo <Role>(role);
var result = await _roleManager.CreateAsync(roleEntity);
if (!result.Succeeded)
{
throw new Exception("Creating a role failed on save.");
}
var roleToReturn = _mapper.MapTo <RoleDto>(roleEntity);
return(CreatedAtRoute("GetRole", new { id = roleToReturn.Id }, roleToReturn));
}
public async Task<string> Get(string roleName, string action)
{
var context = ApplicationDbContext.Create();
var roleManager = new ApplicationRoleManager(new RoleStore<ApplicationRole>(context));
switch (action)
{
case createAction:
if (roleManager.RoleExists(roleName)) return "新增角色失败，该角色名称已存在";
await roleManager.CreateAsync(new ApplicationRole(roleName));
return "新增角色成功";
case deleteAction:
if (!roleManager.RoleExists(roleName)) return "删除角色失败，该角色名称不存在";
var role = roleManager.FindByName(roleName);
await roleManager.DeleteAsync(role);
return "删除角色成功";
default:
return "无效的操作指令";
}
}
public async Task <IHttpActionResult> Create(CreateRoleRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CustomRole role = new CustomRole {
Id = GuidUtility.GetNewSequentialGuid(), Name = model.Name
};
var result = await _applicationRoleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(CreatedAtRoute(UriName.Identity.Roles.GET_ROLE, new { id = role.Id }, _identityRoleResponseFactory.Create(role)));
}
public async Task <IHttpActionResult> Create(CreateRoleModel createRoleModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityRole identityRole = new IdentityRole {
Name = createRoleModel.Name
};
IdentityResult identityResult = await ApplicationRoleManager.CreateAsync(identityRole);
if (!identityResult.Succeeded)
{
return(GetErrorResult(identityResult));
}
Uri locationHeader = new Uri(Url.Link("GetRoleById", new { id = identityRole.Id }));
return(Created(locationHeader, ModelFactory.Create(identityRole)));
}
public async Task <ActionResult> Create([Bind(Include = "Name")] ApplicationRoleViewModel applicationRoleViewModel)
{
if (ModelState.IsValid)
{
ApplicationRole applicationRole = new ApplicationRole {
Name = applicationRoleViewModel.Name
};
var roleResult = await RoleManager.CreateAsync(applicationRole);
if (!roleResult.Succeeded)
{
ModelState.AddModelError("", roleResult.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <bool> CreateRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
{
data.CreatedBy = ExtBusinessLogic.UserValue(claim);
data.ModifiedBy = ExtBusinessLogic.UserValue(claim);
ApplicationRole roleData = _mapper.Map <ApplicationRole>(data);
bool roleExist = await _roleManager.RoleExistsAsync(roleData.Name);
if (roleExist)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.RoleAlreadyExist);
}
roleData.GenerateNewId();
var result = await _roleManager.CreateAsync(roleData);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
}
return(true);
}
public async Task <IHttpActionResult> Create(CreateRoleBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = new IdentityRole {
Name = model.Name
};
var result = await roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(NotFound());
}
Uri locationHeader = new Uri(Url.Link("api/role/{id}", new { id = role.Id }));
return(Created(locationHeader, result));
}
public async Task <ActionResult> CreateRole_POST(CreateRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (await RoleManager.RoleExistsAsync(model.Role))
{
ModelState.AddModelError("Role",
$"The role '{model.Role}' is already registered!");
}
else
{
await RoleManager.CreateAsync(new ApplicationRole(model.Role));
TempData["Message"] = $"Role '{model.Role}' created successfully!";
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> Roles()
{
var failures = new List <string>();
TimeZoneInfo pst = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
DateTime longAgo = new DateTime(1800, 1, 1);
var legacyRoles = await legacyDb.Roles.ToArrayAsync();
foreach (var role in legacyRoles)
{
await roleManager.CreateAsync(new ApplicationRole { Id = role.Id, Name = role.Name, Description = role.Description });
}
var roleRoles = legacyDb.RoleRoles.OrderBy(f => f.RoleRow_Id).ToArray();
ApplicationRole child = new ApplicationRole();
foreach (var row in roleRoles)
{
if (child == null || row.RoleRow_Id != child.Id)
{
if (child != null)
{
await roleManager.UpdateAsync(child);
}
child = await roleManager.FindByIdAsync(row.RoleRow_Id);
}
child.Ancestors.Add(new RoleRoleMembership
{
ParentId = row.RoleRow_Id1,
Child = child,
IsDirect = true
});
}
// await roleManager.RebuildInheritance();
return(Content("Done\n\n" + string.Join("\n", failures)));
}
public async Task <IdentityResult> CreateOrUpdateAsync(RoleViewModel model)
{
if (model.Id == 0)
{
var applicationRole = Mapper.Map <ApplicationRole>(model);
applicationRole.Id = 1;
var result = await _applicationRoleManager.CreateAsync(applicationRole);
model.Id = applicationRole.Id;
return(result);
}
var role = _applicationRoleManager.FindByIdAsync(model.Id).Result;
if (role == null)
{
return(IdentityResult.Failed());
}
MapApplicationRole(role, model);
var updateResult = await _applicationRoleManager.UpdateAsync(role);
return(updateResult);
}
public async Task <ActionResult> AddRole(RoleViewModel roleViewModel)
{
try
{
if (ModelState.IsValid)
{
if (!RoleManager.RoleExists(roleViewModel.Name))
{
var role = new IdentityRole(roleViewModel.Name);
var roleresult = await RoleManager.CreateAsync(role);
if (roleresult.Succeeded)
{
TempData["Msg"] = _hlp.getMsg(AlertType.success.ToString(), "Added successfully!");
return(RedirectToAction("Roles"));
}
else
{
return(Json(new { IsAuthenticated = true, IsSuccessful = false, Error = roleresult.Errors.First() }));
}
}
else
{
return(Json(new { IsAuthenticated = true, IsSuccessful = false, Error = "The role already exist!" }));
}
}
else
{
return(Json(new { IsAuthenticated = true, IsSuccessful = false, Error = "Please enter a valid role name!" }));
}
}
catch (Exception ex)
{
return(Json(new { IsAuthenticated = true, IsSuccessful = false, Error = ex.Message }));
}
}
public async Task<IdentityResult> SaveChanges(JObject newRole)
{
string roleName = ((dynamic)newRole).Name.Value;
string roleId = ((dynamic)newRole).Id.Value;
//dynamic oldRole = ((dynamic)newRole).oldRole.Value;
IdentityResult result = null;
var roleStore = new RoleStore<IdentityRole>(_contextProvider.Context);
var roleManager = new ApplicationRoleManager(roleStore);
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
result = await roleManager.CreateAsync(new IdentityRole(roleName));
}
return result;
}
public async System.Threading.Tasks.Task<ActionResult> TutorCreate(CreateTutorViewModel model)
{
if (ModelState.IsValid)
{
if (Request.Files.Count != 1)//如果文件列表为空则返回
{
ViewBag.Alert = "请检查上传文件！";
return View();
}
var file = Request.Files[0];//只上传第一个文件
var user = Models.User.Create(model.Email, model.DisplayName);
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//为账户添加角色
var roleName = "Tutor";
ApplicationRoleManager roleManager = new ApplicationRoleManager(new RoleStore<IdentityRole>(db));
//判断角色是否存在
if (!roleManager.RoleExists(roleName))
{
//角色不存在则建立角色
await roleManager.CreateAsync(new IdentityRole(roleName));
}
//将用户加入角色
await UserManager.AddToRoleAsync(user.Id, roleName);
// 有关如何启用帐户确认和密码重置的详细信息，请访问 http://go.microsoft.com/fwlink/?LinkID=320771
// 发送包含此链接的电子邮件
// 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, "确认你的帐户", "请通过单击 <a href=\"" + callbackUrl + "\">這裏</a>来确认你的帐户");
var avatar = Material.Create(user.DisplayName, MaterialType.Avatar, file, db);
if (avatar == null)
{
TempData["ALert"] = "请检查上传文件！";
return View(model);
}
var tutor = new TutorInformation { Id = Guid.NewGuid(), Tutor = db.Users.Find(user.Id), Avatar = avatar, Position = model.Position, Introduction = model.Introduction };
db.TutorInformations.Add(tutor);
db.SaveChanges();
ViewBag.Alert = "操作成功！";
return View();
}
}
ViewBag.Alert = "操作失败！";
return View();
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User { UserName = model.Email, Email = model.Email, DisplayName = model.DisplayName, Time = DateTime.Now, IsDisabled = false, Profile = new Profile { Email = model.Email, Phone = "", Searchable = true, InformationPrivacy = false, Other = "" } };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
//为账户添加角色
var roleName = "student";
ApplicationRoleManager roleManager = new ApplicationRoleManager(new RoleStore<IdentityRole>(new BaseDbContext()));
//判断角色是否存在
if (!roleManager.RoleExists(roleName))
{
//角色不存在则建立角色
await roleManager.CreateAsync(new IdentityRole(roleName));
}
//将用户加入角色
await UserManager.AddToRoleAsync(user.Id, roleName);
// 有关如何启用帐户确认和密码重置的详细信息，请访问 http://go.microsoft.com/fwlink/?LinkID=320771
// 发送包含此链接的电子邮件
// 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, "确认你的帐户", "请通过单击 <a href=\"" + callbackUrl + "\">這裏</a>来确认你的帐户");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
return View(model);
}
