namespace Users.Models
{
    //IdentityUser：ASP.NET Identity已经内建了表示用户的基类
    //自定义的用户类应从IdentityUser派生，以便得到IdentityUser的一些默认的属性
    public class AppUser : IdentityUser
    {
    }
}

namespace Users.Models
{
    public class UserView
    {
        public string Id { get; set; }
        [Required]
        public string Name { get; set; }
        [Required]
        public string Email { get; set; }
        [Required]
        [MaxLength(,ErrorMessage ="字符太长")]
        public string Password { get; set; }
    }
}

namespace Users.Infrastructure
{
    //EF数据库上下文
    public class AppIdentityDbContext : IdentityDbContext<AppUser>
    {
        //基类构造函数接收一个数据库名称以便创建出EF数据库上下文对象
        public AppIdentityDbContext( ) : base( "IdentityDb" ) { }

//利用静态构造函数，在代码块里使用System.Data.Entity.DataBase类初始化数据库，通过DbInit指定数据库的创建模式
        static AppIdentityDbContext( )
        {
            Database.SetInitializer<AppIdentityDbContext>( new DbInit( ) );
        }

//获取一个EF数据库上下文对象
        public static AppIdentityDbContext Create( )
        {
            return new AppIdentityDbContext( );
        }
    }

//为了能在创建数据库的同时能插入一个超级管理员以便于超级管理员可以访问本站的任何资源（比如可以为用户分配角色）
    //为此，创建了一个DbInit从DropCreateDatabaseIfModelChanges的派生
    public class DbInit : DropCreateDatabaseIfModelChanges<AppIdentityDbContext>
    {
        private void InsertData( AppIdentityDbContext context )
        {
            //创建一个用户存储器和角色管理器，这两个对象需要存储器，而存储器需要ASP.NET Identity基于EF的数据库上下文作为参数
            //我们会频繁使用用户管理器和角色管理器，增删改查到数据库就靠这两个类型
            AppUserManager userManager = new AppUserManager( new UserStore<AppUser>( context ) );
            AppRoleManager roleManager = new AppRoleManager( new RoleStore<AppRole>( context ) );
            string roleName = "超级无敌管理员";
            string userName = "hanshi";
            string email = "admin@example.com";
            string password = "111111";

IdentityResult roleResult= roleManager.Create( new AppRole( roleName ) ); //向数据库插入一个角色
            IdentityResult userResult = userManager.Create( new AppUser { UserName = userName,Email=email }, password );//向数据库插入一个用户
            if (roleResult.Succeeded && userResult.Succeeded) //如果数据库操作是成功的
            {
                AppUser user = userManager.FindByName( userName ); //获得刚才插入数据库的用户以便得到其ID
                userManager.AddToRole( user.Id, roleName ); //为该用户分配一个角色
            }
        }
        //向数据库插入数据
        protected override void Seed( AppIdentityDbContext context )
        {
            InsertData( context );
            base.Seed( context );
        }
    }
}

namespace Users.Infrastructure
{
    //UserManager<T>：ASP.NET Identity已经内建了表示管理用户的基类
    //自定义的用户管理类应从UserManager<T>派生，以便得到UserManager<T>提供的方法
    public class AppUserManager : UserManager<AppUser>
    {
        //用户管理器基类需要一个用户存储器以便提供管理用户的API方法，要实例化自定义的用户管理器则必须向户管理器基类传递一个用户存储器
        public AppUserManager(IUserStore<AppUser> store) : base(store) { }

//获取一个用户管理器
        public static AppUserManager Create(IdentityFactoryOptions<AppUserManager> options, IOwinContext context)
        {
            AppIdentityDbContext db = context.Get<AppIdentityDbContext>();//获取已经注册在owin环境下的ASP.NET Identity基于EF的数据库操作上下文对象
            AppUserManager manager = new AppUserManager(new UserStore<AppUser>(db));//创建用户管理类的实例
            return manager;
        }
    }
}

[assembly: OwinStartup(typeof(Users.StartUp))]
namespace Users
{
    //启动类
    public class StartUp
    {
        public void Configuration(IAppBuilder appBuilder)
        {
            appBuilder.CreatePerOwinContext< AppIdentityDbContext>(AppIdentityDbContext.Create);
            appBuilder.CreatePerOwinContext<AppUserManager>(AppUserManager.Create);
            //指示ASP.NET Identity如何用Cookie去标识已认证的用户
            appBuilder.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                //未认证用户发起请求时应重定向的地址
                LoginPath = new PathString("/Account/Login"),
            });
        }
    }
}

using Users.Models;
using Microsoft.Owin;
using Users.Infrastructure;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.Owin;
using Microsoft.AspNet.Identity.EntityFramework;

namespace Users.Controllers
{
    public class AdminController : Controller
    {
        //获取一个用户管理器的实例
        private AppUserManager UserManager
        {
            get
            {
                //HttpContext是System.Web.Mvc提供的表示Http请求的上下文对象
                //而Microsoft.Owin.Host.SystemWeb程序集中的Microsoft.AspNet.Identity.Owin命名空间下的HttpContextBaseExtensions为HttpContext扩展了一个叫做GetOwinContext的方法
                //GetOwinContext方法作用是：当Http请求到达后，获取Http请求的owin执行环境的上下文对象，
                //我们会经常用到IOwinContext，因为它直接替代了HttpContext的工作
                IOwinContext owinContext = HttpContext.GetOwinContext();
                //利用owin执行环境的上下文对象的GetUserManager方法（在Microsoft.AspNet.Identity.Owin命名空间下的扩展方法）可以通过指定泛型参数获取自定义的用户管理器或角色管理器
                AppUserManager userManager = owinContext.GetUserManager<AppUserManager>();
                return userManager;
            }
        }

//显示用户列表
        public ActionResult Index()
        {
            List<UserView> users = new List<UserView>();
            foreach (AppUser user in UserManager.Users)
            {
                users.Add(new UserView { Id = user.Id, Name = user.UserName, Email = user.Email, Password = user.PasswordHash });
            }
            return View(users);
        }

//添加新用户
        public ActionResult Create()
        {
            return View();
        }

[HttpPost]
        public async Task<ActionResult> Create(UserView user)
        {
            if (!ModelState.IsValid) return View(user);
            AppUser appUser = new AppUser
            {
                UserName = user.Name,
                Email = user.Email
            };
            IdentityResult result = await UserManager.CreateAsync(appUser, user.Password);
            if (!result.Succeeded)
            {

AddErrorsIntoModelState(result);
                return View(user);
            }
            return RedirectToAction("index");
        }

//删除用户
        public async Task<ActionResult> Delete(string id)
        {
            if (id != null)
            {
                AppUser user = await UserManager.FindByIdAsync(id);
                if (user != null)
                {
                    IdentityResult result = await UserManager.DeleteAsync(user);
                    if (!result.Succeeded)
                    {
                        AddErrorsIntoModelState(result);
                    }
                }
            }
            return RedirectToAction("index");
        }

//编辑用户
        public async Task<ActionResult> Edit(string id)
        {
            if (id != null)
            {
                AppUser user = await UserManager.FindByIdAsync(id);
                if (user == null) return RedirectToAction("index");
                UserView userView = new UserView
                {
                    Name = user.UserName,
                    Email = user.Email,
                    Password = user.PasswordHash
                };
                return View(userView);
            }
            return RedirectToAction("index");
        }

[HttpPost]
        public async Task<ActionResult> Edit(UserView userView)
        {
            if (!ModelState.IsValid) return View();
            AppUser user = await UserManager.FindByNameAsync(userView.Name);
            if (user == null)
            {
                ModelState.AddModelError("", "无此用户，无法修改");
            }
            else
            {
                user.Email = userView.Email;
                user.PasswordHash = UserManager.PasswordHasher.HashPassword(userView.Password);//转换密码为哈希码
                IdentityResult result = await UserManager.UpdateAsync(user);
                if (!result.Succeeded) AddErrorsIntoModelState(result);
            }
            return RedirectToAction("index");
        }

//执行增删改查任务出现错误后，调用此方法将错误信息写入ModelSate
        private void AddErrorsIntoModelState(IdentityResult result)
        {
            foreach (string error in result.Errors)
            {
                ModelState.AddModelError("", error);
            }
        }
    }
}

namespace Users.Controllers
{
    public class AccountController : Controller
    {
        //获取用户管理器
        private AppUserManager userManager
        {
            get { return HttpContext.GetOwinContext().GetUserManager<AppUserManager>(); }
        }

//获取身份认证管理器
        private IAuthenticationManager AuthorManager
        {
            get { return HttpContext.GetOwinContext( ).Authentication; }
        }

//用户请求的Url被OWIN模块的中间件ASP.NET Identity拦截后被重定向到此Action，同时用户请求的Url会作为查询字符串自动附加
        public ActionResult Login(string returnUrl)
        {
            //如果当前用户是已经登录认证过的用户
            //但他试图去访问一个Authorize指定为特定角色才能访问的Controller或Action方法，
            //但因为它是非特定角色的用户，所以他会被Authorize导向到Login方法里面来
            //此时应检测他是否是登录用户，如果是则导向error页
            if (HttpContext.User.Identity.IsAuthenticated) return RedirectToAction( "Error", "Message" );
            ViewBag.ReturnUrl = returnUrl;
            return View();
        }

[HttpPost]       
        public async Task<ActionResult> Login(LoginView loginView,string returnUrl)
        {
            //如果当前用户还未登录则测试其输入的数据能否模型绑定，如果能则执行以下逻辑
            if (ModelState.IsValid)
            {
                AppUser xUser = await userManager.FindAsync(loginView.name, loginView.Password);
                
                if (xUser == null)
                {
                    ModelState.AddModelError("name", "无此用户");
                }
                else
                {
                    //ClaimsIdentity：类似于HttpContext.User.Identity，是一个存储发起请求的用户的信息的标识，
                    ClaimsIdentity identity = await userManager.CreateIdentityAsync(xUser, DefaultAuthenticationTypes.ApplicationCookie);
                    //不管是否具备本站的身份认证cookie，目前先将其签出（移除），使其无效
                    AuthorManager.SignOut();
                    //将用户的认证cookie签入，使其生效
                    AuthorManager.SignIn(new AuthenticationProperties
                    {
                        //使当前用户的认证cookie持久化，也即当前用户发起的任何请求都不再需要认证，这个读取cookie的操作由Identity自动完成，无需你手动编写逻辑
                        IsPersistent = true
                    }, identity);
                    return Redirect(string.IsNullOrEmpty( returnUrl )==true?"/Home/index": returnUrl );
                }
            }
            ViewBag.ReturnUrl = returnUrl;
            return View("Login");
        }

//注销        
        public ActionResult Logout()
        {
            AuthorManager.SignOut( );
            return RedirectToAction( "login" );
        }
    }
}

namespace Users.Models
{
    //自定义一个角色类，使其从IdentityRole派生
    public class AppRole:IdentityRole
    {
        public AppRole() : base() { }
        public AppRole(string roleName) : base(roleName) { }
    }
}

namespace Users.Infrastructure
{
    public class AppRoleManager:RoleManager<AppRole>
    {
        public AppRoleManager(RoleStore<AppRole> store) : base(store) { }

//获取一个角色管理器
        public static AppRoleManager Create(IdentityFactoryOptions<AppRoleManager> options, IOwinContext context)
        {
            //获取已经注册在owin环境下的ASP.NET Identity基于EF的数据库操作上下文对象
            AppIdentityDbContext db =context.Get<AppIdentityDbContext>();
            return new AppRoleManager(new RoleStore<AppRole>(db));//创建角色管理类的实例
        }
    }
}

Boolean

//http://www.w3.org/2001/XMLSchema#boolean

Integer32 

//http://www.w3.org/2001/XMLSchema#integer32

String

//http://www.w3.org/2001/XMLSchema#string

Time 

//http://www.w3.org/2001/XMLSchema#time