public StatisticsController()
 {
     db = new ApplicationDbContext();
     userStore = new UserStore<ApplicationUser>(db);
     userManager = new ApplicationUserManager(userStore);
     statisticsService = new StatisticsService(db);
 }

 public ManageUsersController(ApplicationDbContext context, ApplicationUserManager userManager, IEmailService emailService, ICurrentUser currentUser)
 {
     _context = context;
     _userManager = userManager;
     _emailService = emailService;
     _currentUser = currentUser;
 }

 public AccountController(
     ApplicationUserManager userManager,
     ApplicationSignInManager signInManager)
 {
     this.UserManager = userManager;
     this.SignInManager = signInManager;
 }

        public async static Task<IEnumerable<Claim>> GetClaims(ClaimsIdentity user)
        {
            List<Claim> claims = new List<Claim>();
            using (edisDbEntities db = new edisDbEntities())
            {
                if (user.HasClaim(c => c.Type == ClaimTypes.Role && c.Value == AuthorizationRoles.Role_Client))
                {

                    var userManager = new ApplicationUserManager(new UserStore<ApplicationUser>(new ApplicationDbContext()));
                    var userProfile = await userManager.FindByNameAsync(user.Name);

                    var client = db.Clients.FirstOrDefault(c => c.ClientUserID == userProfile.Id);
                    if (client != null)
                    {
                        var clientGroup = db.ClientGroups.FirstOrDefault(c => c.ClientGroupID == client.ClientGroupID);
                        if (clientGroup != null && clientGroup.MainClientID == client.ClientUserID)
                        {
                            claims.Add(CreateClaim(ClaimType_ClientGroupLeader, ClaimValue_ClientGroupLeader_Leader));
                        }
                        else
                        {
                            claims.Add(CreateClaim(ClaimType_ClientGroupLeader, ClaimValue_ClientGroupLeader_Member));
                        }
                    }
                }
            }
            return claims;
        }

 /// <summary>
 /// Regenerates the identity callback function for cookie configuration (above).
 /// </summary>
 /// <param name="applicationUserManager">The application user manager.</param>
 /// <param name="applicationUser">The application user.</param>
 private static async Task<ClaimsIdentity> RegenerateIdentityCallback(ApplicationUserManager applicationUserManager, ApplicationUser applicationUser)
 {
     // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
     var userIdentity = await applicationUserManager.CreateIdentityAsync(applicationUser, DefaultAuthenticationTypes.ApplicationCookie);
     // Add custom user claims here
     return userIdentity;
 }

 public bool AddUserToRole(string userId, string roleName)
 {
     var um = new ApplicationUserManager(
         new UserStore<ApplicationUser>(context));
     var idResult = um.AddToRole(userId, roleName);
     return idResult.Succeeded;
 }

        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 = "tanaka" }, "[email protected]");
            await userManager.AddToRoleAsync(
                (await userManager.FindByNameAsync("tanaka")).Id,
                "users");
            // 管理者の作成
            await userManager.CreateAsync(new ApplicationUser { UserName = "super_tanaka" }, "[email protected]");
            await userManager.AddToRoleAsync(
                (await userManager.FindByNameAsync("super_tanaka")).Id,
                "users");
            await userManager.AddToRoleAsync(
                (await userManager.FindByNameAsync("super_tanaka")).Id,
                "admin");

            Debug.WriteLine("-----------");
        }

 public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager )
 {
     sendMail = new SendMail();
     UserManager = userManager;
     SignInManager = signInManager;
     usService = new UserService();
 }

 public IdentityModelHelper(ApplicationUserManager userManager, ApplicationRoleManager roleManager)
 {
     Contract.Assert(null != userManager);
     Contract.Assert(null != roleManager);
     _userManager = userManager;
     _roleManager = roleManager;
 }

 public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager,
     ApplicationRoleManager roleManager)
 {
     UserManager = userManager;
     SignInManager = signInManager;
     RoleManager = roleManager;
 }

 public ManageController(ApplicationSignInManager signinManager, ApplicationUserManager appUserManager, IAuthenticationManager authenticationManager)
     : base(appUserManager)
 {
     AuthenticationManager = authenticationManager;
     UserManager = appUserManager;
     SignInManager = signinManager;
 }

        public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, LmsUserManager lmsUserManager)
        {
            UserManager = userManager;
            SignInManager = signInManager;
            _lmsUserManager = lmsUserManager;

        }

        public ActionResult CreateAccount(NewUserModel model)
        {
            if (ModelState.IsValid)
            {
                ApplicationUserManager um = new ApplicationUserManager(new ApplicationUserStore(new ApplicationDbContext()));
                var pass = StringHelper.RandomString(8, 10);
                var user = new ApplicationUser()
                {
                    Id = Guid.NewGuid().ToString(),
                    UserName = model.UserName,
                    Email = model.Email,
                    Created = DateTime.Now,
                    LastLogin = null
                };
                var result = um.Create(user, pass);
                if(result.Succeeded)
                {
                    MailHelper.WelcomeSendPassword(user.UserName, user.Email, pass);
                    return RedirectToAction("Index", "People");
                }
                else
                {
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("", error);
                    }
                }
            }

            return View(model);
        }

 public IdentityUnitOfWork(string connectionString)
 {
     db = new StoreContext(connectionString);
     UserManager = new ApplicationUserManager(new UserStore<ApplicationUser>(db));
     RoleManager = new ApplicationRoleManager(new RoleStore<ApplicationRole>(db));
     ClientManager = new ClientManager(db);
 }

 public TestWeekMenuController()
 {
     _unitOfWork = new UnitOfWork(new ApplicationDbContext());
     _db = _unitOfWork.GetContext();
     _weekMenuService = new MenuForWeekService(_unitOfWork.RepositoryAsync<MenuForWeek>());
     _userManager = new ApplicationUserManager(new UserStore<User>(_unitOfWork.GetContext()));
 }

 public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, ILogAppService logAppService, IPrestadorAppService prestadorAppService)
 {
     _userManager = userManager;
     _signInManager = signInManager;
     _logAppService = logAppService;
     _prestadorAppService = prestadorAppService;
 }

 public bool CreateUser(ApplicationUser user, string password)
 {
     var um = new ApplicationUserManager(
         new UserStore<ApplicationUser>(context));
     var idResult = um.Create(user, password);
     return idResult.Succeeded;
 }

 public ClaimsIdentity GenerateUserIdentity(ApplicationUserManager manager)
 {
     // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
     var userIdentity = manager.CreateIdentity(this, DefaultAuthenticationTypes.ApplicationCookie);
     // Add custom user claims here
     return userIdentity;
 }

        public void TestRegister()
        {
            //http://blogs.interknowlogy.com/2014/08/21/mvc-series-part-2-accountcontroller-testing/
            Mock<IEmailer> EmailerMock = new Mock<IEmailer>();
            Mock<IUserStore<ApplicationUser>> userStoreMock = new Mock<IUserStore<ApplicationUser>>();
            ApplicationUserManager userManager = new ApplicationUserManager(userStoreMock.Object);
            //IAuthenticationManager authManager = AuthenticationManager.
            Mock< IAuthenticationManager> authMock = new Mock<IAuthenticationManager>();
            ApplicationSignInManager manager = new ApplicationSignInManager(userManager, authMock.Object);

            AccountController Controller = new AccountController(userManager, manager, EmailerMock.Object);
            Mock<AccountController> ControllerMock = new Mock<AccountController>(EmailerMock.Object);

            Mock<ApplicationUserManager> UserManagerMock = new Mock<ApplicationUserManager>();
            Mock<ApplicationSignInManager> AppSignInManagerMock = new Mock<ApplicationSignInManager>();

            RegisterViewModel vm = new RegisterViewModel()
            {
                UserName    = "Test",
                Email = "[email protected]",

                UserRole = "Teacher"
            };

            var result = Controller.Register(vm).Result;

            EmailerMock.Verify(a => a.Send());
        }

        public void ConfigureOAuth(IAppBuilder app, HttpConfiguration config)
        {
            UserManagerFactory = () =>
            {
                try
                {
                    var userRepository = config.DependencyResolver.GetService(typeof(IUserRepository));
                    var userManager =
                        new ApplicationUserManager(userRepository as IUserRepository);
                    return userManager;
                }
                catch (Exception)
                {
                    return null;
                }
            };

            app.CreatePerOwinContext(UserManagerFactory);

            var oAuthServerOptions = new OAuthAuthorizationServerOptions()
            {
                AllowInsecureHttp = true,
                TokenEndpointPath = new PathString("/token"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
                Provider = new SimpleAuthorizationProvider()
            };

            app.UseOAuthAuthorizationServer(oAuthServerOptions);

            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
        }