public AuthRepository(IContextFactory contextFactory)
 {
     _contextFactory = contextFactory;
     _authContext = new AuthContext();
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_authContext));
     _userManager.UserTokenProvider = new TotpSecurityStampBasedTokenProvider<IdentityUser, string>();
 }

 /*
 ** Pop an authorization context that was previously pushed
 ** by sqlite3AuthContextPush
 */
 void sqlite3AuthContextPop(AuthContext *pContext)
 {
     if( pContext->pParse ){
     pContext->pParse->zAuthContext = pContext->zAuthContext;
     pContext->pParse = 0;
     }
 }

        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {
           
            //context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
            AuthContext _auth = new AuthContext();
            UserManager<IdentityUser> _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_auth));
            RoleManager<IdentityRole> _roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(_auth));

            AuthRepository _repo = new AuthRepository();
            IdentityUser user = await _repo.FindUser(context.UserName, context.Password);
                
            if (user == null)
            {
                context.SetError("invalid_grant", "The user name or password is incorrect.");
                return;
            }


            var userIdentity = await _userManager.CreateIdentityAsync(user, context.Options.AuthenticationType);

            foreach (IdentityUserRole role in user.Roles)
            {
                var iRole = _roleManager.FindById(role.RoleId);
                userIdentity.AddClaim(new Claim(ClaimTypes.Role, iRole.Name));
            }
            
            userIdentity.AddClaim(new Claim("sub", context.UserName));
            userIdentity.AddClaim(new Claim("role", "user"));
            
            var ticket = new AuthenticationTicket(userIdentity, null);

            context.Validated(ticket);
        }

 public AuthRepository()
 {
     _db = new DataContext();
     _ctx = new AuthContext();
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
     _roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(_ctx));
 }

        public async Task<Confirmed> Get(string id)
        {
           string uid = Encoding.ASCII.GetString(HttpServerUtility.UrlTokenDecode(id));
            Confirmed c = new Confirmed();
            string fullstring = Util.Decrypt(uid, true);
            int index = fullstring.IndexOf("{GreenTime}");
           string  UserName = fullstring.Substring(0, index);
            string Password = fullstring.Substring(index + 11);

            AuthContext context = new AuthContext();
           IdentityUser user = null;
          
            People ps = context.Peoples.Where(p => p.email == UserName).SingleOrDefault();
            ps.emailConfirmed = true;

            using (AuthRepository _repo = new AuthRepository())
            {

                user = await _repo.FindUser(UserName, Password);


                if (user != null)
                {
                    context.updatePeople(ps);
                    c.isConfirmed = true;

                    return c;
                }
            }
        
            return c;
        }

 public LoginViewModel(DataRetrieval dataRetrieval, AuthContext authContext)
 {
     _dataRetrieval = dataRetrieval;
     _authContext = authContext;
     LoginCommand = new DelegateCommand(LoginExecuted, LoginCanExecute);
     UserName = "[email protected]";
     Password = "Testing123";
 }

 public AuthContext Get()
 {
     if (dataContext == null)
     {
         dataContext = new AuthContext();
     }
     return dataContext;
 }

 private void AuthContextPop(AuthContext ctx)
 {
     if (ctx.Parse != null)
     {
         ctx.Parse._authContext = ctx.Context;
         ctx.Parse = null;
     }
 }

 public ApplicationRepository()
 {
     _ctx = new AuthContext();
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
     RefreshTokens = new RefreshTokenRepository(_ctx);
     Audiences = new AudienceRepository(_ctx);
     Files = new FileRepository(_ctx);
 }

       public UserRepository()
       {
           _authContext = new AuthContext();
           _userManager = new UserManager<User>(new UserStore<User>(_authContext));



       }

 //private UserManager<MemberUser> _userInfo;
 public AuthRepository()
 {
     _ctx = new AuthContext();
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
     _roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(_ctx));
     //_userroleManager = new UserManager<IdentityUserRole>();
     //_userInfo = new UserManager<MemberUser>(new UserStore<MemberUser>(_ctx));
     
     
 }

    public AccountController()
    {
        _repo = new AuthRepository();
        _ctx = new AuthContext();

        UserStore<UserModel> userStore = new UserStore<UserModel>(_ctx);
        _userManager = new UserManager<UserModel>(userStore);

        _userBCA = new UserBusinessComponentAdapter();
    }

        /*
        ** Push an authorization context.  After this routine is called, the
        ** zArg3 argument to authorization callbacks will be zContext until
        ** popped.  Or if pParse==0, this routine is a no-op.
        */
        void sqlite3AuthContextPush(
Parse *pParse,
AuthContext *pContext,
string zContext
)
        {
            Debug.Assert( pParse );
            pContext->pParse = pParse;
            pContext->zAuthContext = pParse->zAuthContext;
            pParse->zAuthContext = zContext;
        }

 public async Task<IdentityResult> UpdateUser(IdentityUser user)
 {
     IdentityResult user1 = null;
     try
     {
         _ctx = new AuthContext();
         _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
         user1 = await _userManager.UpdateAsync(user);
     }
     catch (Exception ex) { }
     return user1;
 }

 public AuthRepository()
 {
     _ctx = new AuthContext();
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
     _userManager.PasswordValidator = new PasswordValidator() {
         RequiredLength = 3,
         RequireNonLetterOrDigit = false,
         RequireDigit = false,
         RequireLowercase = false,
         RequireUppercase = false
     };
 }

 public static void AddUserIfNotExists(string userName, string pwd)
 {
     using (var ctx = new AuthContext())
     {
         using (var userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(ctx)))
         {
             var userExists = userManager.Users.Any(u => u.UserName == userName);
             if (!userExists)
             {
                 userManager.Create(new IdentityUser(userName), pwd);
             }
         }
     } 
 }

        public AuthRepository()
        {
            try
            {
                _ctx = new AuthContext();
                _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.TraceError("AuthRepository Exception.",ex.Message);

                //throw;
            }
        }

        public IHttpActionResult Get()
        {

            AuthContext context = new AuthContext();

            //ClaimsPrincipal principal = Request.GetRequestContext().Principal as ClaimsPrincipal;

            //var Name = ClaimsPrincipal.Current.Identity.Name;
            //var Name1 = User.Identity.Name;

            //var userName = principal.Claims.Where(c => c.Type == "sub").Single().Value;

             return Ok(Helper.createUsers());
        }

 public AuthRepository()
 {
     var provider = new DpapiDataProtectionProvider("Microbrew.it");
     _ctx = new AuthContext();
     //_userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
     _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx))
     {
         EmailService = new EmailService()
     };
     _userManager.UserTokenProvider = new DataProtectorTokenProvider<IdentityUser>(provider.Create("ASP.NET Identity"))
     {
         //Sets the lifespan of the confirm email token and the reset password token.
         TokenLifespan = TimeSpan.FromMinutes(1),
     };
 }

        public void Execute()
        {

            var container = new WindsorContainer().Install(FromAssembly.This());

            GlobalConfiguration.Configuration.Services.Replace(
                typeof(IHttpControllerActivator),
                new WindsorControllerActivator(container.Kernel));

            var locator = new WindsorServiceLocator(container);
            ServiceLocator.SetLocatorProvider(() => locator);

            var securityContext = new AuthContext();
            securityContext.Database.Initialize(true);

            var context = new RMSContext();
            context.Database.Initialize(true);
        }