コード例 #1
0
        public ExternalLoginData Parse(ClaimsIdentity identity)
        {
            if (identity == null)
            {
                return null;
            }

            var nameClaim = identity.FindFirst(ClaimTypes.NameIdentifier);
            if (nameClaim == null || String.IsNullOrEmpty(nameClaim.Issuer) || String.IsNullOrEmpty(nameClaim.Value))
            {
                throw new ApplicationException("Cannot find a claim of ClaimTypes.NameIdentifier");
            }

            if (nameClaim.Issuer == ClaimsIdentity.DefaultIssuer)
            {
                return null;
            }

            var loginData = new ExternalLoginData
                {
                    ProviderName = nameClaim.Issuer,
                    ProviderKey = nameClaim.Value,
                    Name = identity.GetFirstOrDefault(ClaimTypes.Name),
                    Email = identity.GetFirstOrDefault(ClaimTypes.Email),
                };

            ParseDetailLoginData(identity, ref loginData);

            return loginData;
        }
コード例 #2
0
        public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            string redirectUri = "";

            if (error != null)
            {
                return(BadRequest(Uri.EscapeDataString(error)));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }

            var redirectUriValidationResult = ValidateClientAndRedirectUri(this.Request, ref redirectUri);

            if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
            {
                return(BadRequest(redirectUriValidationResult));
            }

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            if (externalLogin.LoginProvider != provider)
            {
                Request.GetOwinContext().Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return(new ChallengeResult(provider, null));
            }

            IdentityUser user = await IsUserRegistered(externalLogin);

            bool hasRegistered          = (user != null);
            bool isRegisteredAsExternal = IsRegisteredAsExternal(user);

            var email = HttpUtility.UrlEncode(externalLogin.Email);

            redirectUri = string.Format("{0}#external_access_token={1}&provider={2}&haslocalaccount={3}&external_email={4}&isregisteredasexternal={5}",
                                        redirectUri,
                                        externalLogin.ExternalAccessToken,
                                        externalLogin.LoginProvider,
                                        hasRegistered.ToString(),
                                        email,
                                        isRegisteredAsExternal);

            return(Redirect(redirectUri));
        }
コード例 #3
0
        public async Task<IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            if (error != null)
            {
                return Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return new ChallengeResult(provider, this);
            }

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return InternalServerError();
            }

            if (externalLogin.LoginProvider != provider)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return new ChallengeResult(provider, this);
            }

            ApplicationUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider,
                externalLogin.ProviderKey));

            bool hasRegistered = user != null;

            if (hasRegistered)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                
                 ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(UserManager,
                    OAuthDefaults.AuthenticationType);
                ClaimsIdentity cookieIdentity = await user.GenerateUserIdentityAsync(UserManager,
                    CookieAuthenticationDefaults.AuthenticationType);

                AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(user.UserName);
                Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
            }
            else
            {
                IEnumerable<Claim> claims = externalLogin.GetClaims();
                ClaimsIdentity identity = new ClaimsIdentity(claims, OAuthDefaults.AuthenticationType);
                Authentication.SignIn(identity);
            }

            return Ok();
        }
コード例 #4
0
        public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            string redirectUri = "http://localhost:54046/";

            if (error != null)
            {
                return(BadRequest(Uri.EscapeDataString(error)));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }

            //Fix this.

            //var redirectUriValidationResult = ValidateClientAndRedirectUri(this.Request, ref redirectUri);

            //if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
            //{
            //    return BadRequest(redirectUriValidationResult);
            //}

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            if (externalLogin.LoginProvider != provider)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return(new ChallengeResult(provider, this));
            }


            IdentityUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));

            bool hasRegistered = user != null;

            redirectUri = string.Format("{0}#external_access_token={1}&provider={2}&haslocalaccount={3}&external_user_name={4}",
                                        redirectUri,
                                        externalLogin.ExternalAccessToken,
                                        externalLogin.LoginProvider,
                                        hasRegistered.ToString(),
                                        externalLogin.UserName);

            return(Redirect(redirectUri));
        }
コード例 #5
0
        public async Task <UserInfoViewModel> GetUserInfo()
        {
            var externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            var user          = await UserManager.FindByEmailAsync(User.Identity.GetUserName());

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                FirstName = user.FirstName,
                LastName = user.LastName,
                Phone = user.PhoneNumber
            });
        }
コード例 #6
0
        private async Task <IdentityUser> IsUserRegistered(ExternalLoginData externalLogin)
        {
            // check user existence by provider id
            IdentityUser user = await _processor.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));

            if (user != null)
            {
                return(user);
            }

            // if user is not registered via facebook, maybe the e-mail address is still used for manual registration.
            return(await _processor.FindByEmailAsync(externalLogin.Email));

            //return (user != null);
        }
コード例 #7
0
        public UserModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            var rols = ((ClaimsIdentity)User.Identity).Claims
                       .Where(c => c.Type == ClaimTypes.Role)
                       .Select(c => c.Value);


            return(new UserModel
            {
                Id = User.Identity.GetUserId(),
                Username = User.Identity.GetUserName(),
                Roles = rols,
            });
        }
コード例 #8
0
        public UserInfoViewModel GetUserInfo()
        {
            // HttpContext.Current.User.Identity.Name
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            //获取用户相关信息

            var GOwinContex  = HttpContext.Current.GetOwinContext();//.OwinContext.GetUserManager<ApplicationUserManager>();
            var _userManager = GOwinContex.GetUserManager <ApplicationUserManager>();

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName()
            });
        }
コード例 #9
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            Guid userId = Guid.Parse(User.Identity.GetUserId());
            var  user   = Context.Users.First(item => item.AspUserId.Equals(userId));

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                UserBirthDate = user.UserBirthDate,
                UserFirstName = user.UserFirstName,
                UserLastName = user.UserLastName,
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            });
        }
コード例 #10
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (!User.Equals(null))
            {
                return new UserInfoViewModel
                {
                    Email = User.Identity.GetUserName(),
                    HasRegistered = externalLogin == null,
                    LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
                };
            }

            return null;
        }
コード例 #11
0
        public async Task <IHttpActionResult> Login(ExternalLoginProviderName provider, string error = null)
        {
            string redirectUri = string.Empty;

            if (error != null)
            {
                return(BadRequest(Uri.EscapeDataString(error)));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }

            var redirectUriValidationResult = ValidateClientAndRedirectUri(this.Request, ref redirectUri);

            if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
            {
                return(BadRequest(redirectUriValidationResult));
            }

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            if (externalLogin.LoginProvider != provider)
            {
                this.OwinAuthentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return(new ChallengeResult(provider, this));
            }

            IdentityUser <Guid, CustomUserLogin, CustomUserRole, CustomUserClaim> user = await _authRepository.FindAsync(new UserLoginInfo(externalLogin.LoginProvider.ToString(), externalLogin.ProviderKey));

            bool hasRegistered = user != null;

            redirectUri = string.Format("{0}#external_access_token={1}&provider={2}&haslocalaccount={3}&external_user_name={4}",
                                        redirectUri,
                                        externalLogin.ExternalAccessToken,
                                        externalLogin.LoginProvider,
                                        hasRegistered.ToString(),
                                        externalLogin.UserName);

            return(Redirect(redirectUri));
        }
コード例 #12
0
        public async Task <UserInfoViewModel> GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            ApplicationUser   user          = await UserManager.FindByIdAsync(User.Identity.GetUserId());

            IList <string> rolesForUser = await UserManager.GetRolesAsync(User.Identity.GetUserId());

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                FirstName = user.FirstName,
                LastName = user.LastName,
                Roles = rolesForUser.ToArray(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            });
        }
コード例 #13
0
        public async Task <UserInfoViewModel> GetUserInfoAsync()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            var             uId  = User.Identity.GetUserId();
            ApplicationUser user = await UserManager.FindByIdAsync(uId);

            return(new UserInfoViewModel
            {
                Id = uId,
                Name = user.FullName(),
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin?.LoginProvider,
                Roles = UserManager.GetRoles(uId)
            });
        }
コード例 #14
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            var userId  = User.Identity.GetUserId();
            var context = new EscortServiceHouseEntities();
            var user    = context.Users.Find(userId);

            return(new UserInfoViewModel
            {
                UserId = User.Identity.GetUserId(),
                Username = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                Roles = user.Roles.Select(r => context.Roles.Find(r.RoleId).Name).ToList()
            });
        }
コード例 #15
0
        public UserInfoViewModel GetCurrentUser()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            Model.User user = userBusiness.GetUserByExternalId(User.Identity.GetUserId()).Data;

            UserInfoViewModel retVal = !User.Identity.IsAuthenticated  ? null :
                                       new UserInfoViewModel
            {
                UserName      = User.Identity.GetUserName(),
                HasRegistered = user != null,
                IsAdmin       = UserManager.IsInRole(User.Identity.GetUserId(), Constants.RoleNames.Admin),
                HasPassword   = UserManager.HasPassword(User.Identity.GetUserId()),
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            };

            return(retVal);
        }
コード例 #16
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            var userdetail = _userRepository.FindByName(User.Identity.GetUserName());

            return(new UserInfoViewModel
            {
                UserName = User.Identity.GetUserName(),
                Role = CurrentUser.Role,
                FirstName = userdetail.FirstName,
                LastName = userdetail.LastName,
                EmployeeCode = userdetail.EmployeeCode,
                Email = userdetail.Email,
                PhoneNumber = userdetail.PhoneNumber,
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            });
        }
コード例 #17
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            var userId  = User.Identity.GetUserId();
            var account = db.Accounts.Find(userId);
            var roles   = ((ClaimsIdentity)User.Identity).Claims.Where(x => x.Type == ClaimTypes.Role).ToList();


            return(new UserInfoViewModel
            {
                Id = User.Identity.GetUserId(),
                Username = User.Identity.GetUserName(),
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                Roles = roles.Select(x => x.Value).ToArray(),
                Account = account
            });
        }
コード例 #18
0
        public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            string redirectUri = string.Empty;

            if (error != null)
            {
                return(BadRequest(Uri.EscapeDataString(error)));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }


            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            if (externalLogin.LoginProvider != provider)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return(new ChallengeResult(provider, this));
            }

            IdentityUser user = await _repo.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));

            bool hasRegistered = user != null;

            redirectUri = string.Format("{0}#external_access_token={1}&provider={2}&haslocalaccount={3}&external_user_name={4}",
                                        redirectUri,
                                        externalLogin.ExternalAccessToken,
                                        externalLogin.LoginProvider,
                                        hasRegistered.ToString(),
                                        externalLogin.UserName);

            return(Redirect(redirectUri));
        }
コード例 #19
0
        public virtual async Task <IActionResult> SignInExternalAsync([FromBody][Required] LoginExternal loginExternal, CancellationToken cancellationToken = default)
        {
            var accessToken = await this.IdentityManager
                              .SignInExternalAsync(loginExternal, cancellationToken);

            ExternalLoginData externalLoginData = null;

            if (accessToken == null)
            {
                externalLoginData = await this.IdentityManager
                                    .GetExternalProviderInfoAsync(loginExternal, cancellationToken);
            }

            var response = new ExternalLoginResponse
            {
                Data        = externalLoginData,
                AccessToken = accessToken
            };

            return(this.Ok(response));
        }
コード例 #20
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);


            ApplicationUser user = UserManager.FindById(User.Identity.GetUserId());

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                Age = user.Age,
                Weight = user.Weight,
                Height = user.Height,
                MaleOrFemale = user.MaleOrFemale,
                CarbGoal = user.CarbGoal,
                ProteinGoal = user.ProteinGoal,
                FatGoal = user.FatGoal,
                CalorieGoal = user.DailyCalorieGoalToLoseWeight
            });
        }
コード例 #21
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            var    nm        = User.Identity.GetUserName();
            string userEmail = string.Empty;
            string fname     = string.Empty;
            string lname     = string.Empty;

            if (nm.Contains("@"))
            {
                userEmail = nm;
                if (externalLogin == null)
                {
                    // Retrieve user name from the
                    SkillsmartUser user = UserManager.FindByName(userEmail);
                    fname = user.Claims.First(c => c.ClaimType == SkillsmartUser.FirstName).ClaimValue;
                    lname = user.Claims.First(c => c.ClaimType == SkillsmartUser.LastName).ClaimValue;
                }
            }

            else if (nm.Contains(" "))
            {
                string[] tokens = nm.Split(' ');
                fname = tokens[0];
                if (tokens.Length > 1)
                {
                    lname = tokens[1];
                }
            }
            return(new UserInfoViewModel
            {
                email = userEmail,
                firstName = fname,
                lastName = lname,
                hasRegistered = externalLogin == null,
                loginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            });
        }
コード例 #22
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            string            role          = "";

            if (User.IsInRole("Admin"))
            {
                role = "Admin";
            }
            if (User.IsInRole("SuperAdmin"))
            {
                role = "SuperAdmin";
            }
            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                Role = role,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                UserId = Guid.Parse(User.Identity.GetUserId())
            });
        }
コード例 #23
0
        public async Task <IHttpActionResult> AddExternalLogin(AddExternalLoginBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            AuthManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);

            AuthenticationTicket ticket = AccessTokenFormat.Unprotect(model.ExternalAccessToken);

            if (ticket == null || ticket.Identity == null || (ticket.Properties != null &&
                                                              ticket.Properties.ExpiresUtc.HasValue &&
                                                              ticket.Properties.ExpiresUtc.Value < DateTimeOffset.UtcNow))
            {
                return(BadRequest("External login failure."));
            }

            ExternalLoginData externalData = ExternalLoginData.FromIdentity(ticket.Identity);

            if (externalData == null)
            {
                return(BadRequest("The external login is already associated with an account."));
            }

            //IdentityResult result = await UserManager.AddLoginAsync(User.Identity.GetUserId(),
            //    new UserLoginInfo(externalData.LoginProvider, externalData.ProviderKey));

            IdentityResult result = await UserManager.AddLoginAsync(User.Identity.GetGuidUserId(),
                                                                    new UserLoginInfo(externalData.LoginProvider, externalData.ProviderKey));

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }

            return(Ok());
        }
コード例 #24
0
        public async Task <UserInfoViewModel> GetUserInfoAsync()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
            string            City          = "";
            string            UserId        = "";

#pragma warning disable CS0219 // The variable 'CityId' is assigned but its value is never used
            string CityId = "";
#pragma warning restore CS0219 // The variable 'CityId' is assigned but its value is never used
            string Name        = "";
            string PhoneNumber = "";
            var    Email       = User.Identity.GetUserName();
            var    UserRole    = await UserManager.GetRolesAsync(User.Identity.GetUserId());

            using (SSCEntities db = new SSCEntities())
            {
                var User = db.AspNetUsers.Where(a => a.UserName == Email)?.FirstOrDefault();
                if (User != null)
                {
                    City        = User.City;
                    UserId      = User.Id;
                    PhoneNumber = User.PhoneNumber;
                    Name        = User.Name;
                }
            }

            return(new UserInfoViewModel
            {
                Email = User.Identity.GetUserName(),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null,
                City = City,
                UserId = UserId,
                PhoneNumber = PhoneNumber,
                Name = Name,
                UserRole = UserRole.FirstOrDefault()
            });
        }
コード例 #25
0
        public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            MundialitoUser user = new MundialitoUser
            {
                UserName  = model.UserName,
                Email     = model.Email,
                FirstName = model.FirstName,
                LastName  = model.LastName
            };

            user.Logins.Add(new IdentityUserLogin
            {
                LoginProvider = externalLogin.LoginProvider,
                ProviderKey   = externalLogin.ProviderKey
            });
            IdentityResult result = await UserManager.CreateAsync(user);

            IHttpActionResult errorResult = GetErrorResult(result);

            if (errorResult != null)
            {
                return(errorResult);
            }

            return(Ok());
        }
コード例 #26
0
        public UserInfoViewModel GetUserInfo()
        {
            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            MundialitoUser user = UserManager.FindById(User.Identity.GetUserId());


            if (user == null)
            {
                throw new Exception("Session expired. Please login again");
            }

            return(new UserInfoViewModel
            {
                UserName = user.UserName,
                FirstName = user.FirstName,
                LastName = user.LastName,
                Email = user.Email,
                Roles = string.Join(",", user.Roles.Select(role => role.Role.Name)),
                HasRegistered = externalLogin == null,
                LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
            });
        }
コード例 #27
0
        public async Task <IHttpActionResult> AddExternalLogin(AddExternalLoginBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);

            AuthenticationTicket ticket = AccessTokenFormat.Unprotect(model.ExternalAccessToken);

            if (ticket == null || ticket.Identity == null || (ticket.Properties != null &&
                                                              ticket.Properties.ExpiresUtc.HasValue &&
                                                              ticket.Properties.ExpiresUtc.Value < DateTimeOffset.UtcNow))
            {
                return(BadRequest("Сбой внешнего входа."));
            }

            ExternalLoginData externalData = ExternalLoginData.FromIdentity(ticket.Identity);

            if (externalData == null)
            {
                return(BadRequest("Внешнее имя входа уже связано с учетной записью."));
            }

            IdentityResult result = await UserManager.AddLoginAsync(User.Identity.GetUserId(),
                                                                    new UserLoginInfo(externalData.LoginProvider, externalData.ProviderKey));

            IHttpActionResult errorResult = GetErrorResult(result);

            if (errorResult != null)
            {
                return(errorResult);
            }

            return(Ok());
        }
コード例 #28
0
        public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            if (error != null)
            {
                return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null || externalLogin.LoginProvider != provider)
            {
                Authentication.SignOut(CookieAuthenticationDefaults.AuthenticationType);
                return(Redirect(Url.Content("~/")));
            }

            IdentityAccount account = await _userManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));

            if (account == null)
            {
                IdentityResult result = null;

                account = await _userManager.FindByNameAsync(externalLogin.UserName);

                if (account == null)
                {
                    account = new IdentityAccount {
                        UserName = externalLogin.UserName
                    };
                    result = await _userManager.CreateAsync(account);

                    if (!result.Succeeded)
                    {
                        return(InternalServerError());
                    }
                }

                UserLoginInfo login = new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey);
                result = await _userManager.AddLoginAsync(account.Id, login);

                if (!result.Succeeded)
                {
                    return(InternalServerError());
                }
            }

            Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
            ClaimsIdentity oAuthIdentity = await _userManager.CreateIdentityAsync(account,
                                                                                  OAuthDefaults.AuthenticationType);

            ClaimsIdentity cookieIdentity = await _userManager.CreateIdentityAsync(account,
                                                                                   CookieAuthenticationDefaults.AuthenticationType);

            AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(account.UserName);

            Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);

            return(Ok());
        }
コード例 #29
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     loginData.Profile = "https://www.facebook.com/" + loginData.ProviderKey;
 }
コード例 #30
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     loginData.Profile = string.Format("https://twitter.com/{0}", loginData.UserName);
 }
コード例 #31
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
 }
コード例 #32
0
        /// <summary>
        /// Register User Internal
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal async Task <RegisterUserResult> RegisterInternal(RegisterGeneralModel model)
        {
            var userResult = new RegisterUserResult();

            using (IUnitOfWork unitOfWork = UnitOfWork.Create())
            {
                var checkUserEmail = unitOfWork.UserRepository.GetAll().FirstOrDefault(a => a.Email == model.Email || a.UserName == model.Email);

                if (checkUserEmail != null)
                {
                    userResult.AddError(HttpStatusCode.BadRequest, 10, "This email is already taken ***");
                    return(userResult);
                }

                unitOfWork.BeginTransaction();

                //Create user record
                var user = new ApplicationUser
                {
                    Id        = Guid.NewGuid().ToString(),
                    FirstName = model.FirstName ?? string.Empty,
                    LastName  = model.LastName ?? string.Empty,
                    UserName  = model.Email,
                    Email     = model.Email,
                    //AvatarFileId = model.AvatarFileId,
                    HasTempPassword = true,
                    CreatedById     = DbConstants.AdminUserId,
                    CreatedDate     = DateTime.Now
                };

                if (!string.IsNullOrEmpty(model.UserName))
                {
                    var names = model.UserName.Split(' ');

                    user.FirstName = names[0];
                    user.LastName  = names.Length > 1 ? names[1] : "";
                }

                if (!string.IsNullOrEmpty(model.Password))
                {
                    user.PasswordHash = new PasswordHasher().HashPassword(model.Password);
                }

                user.AutopilotTrack = true;
                user.SecurityStamp  = Guid.NewGuid().ToString();


                #region Need To redo
                {
                    ISchedulerFactory factory   = new StdSchedulerFactory();
                    IScheduler        scheduler = factory.GetScheduler();
                    JobDataMap        dataMap   = new JobDataMap();

                    dataMap["registermodel"] = model;
                    dataMap["userId"]        = user.Id;
                    dataMap["OperationType"] = "Registration";

                    var job = JobBuilder.Create <UpdateContactJob>()
                              .WithIdentity("UpdateContactJob").UsingJobData(dataMap)
                              .Build();

                    var jobKey = new JobKey("UpdateContactJob");

                    ITrigger trigger = TriggerBuilder.Create()
                                       .WithIdentity("trigger1")
                                       .StartAt(DateTime.Now)
                                       .ForJob(jobKey)
                                       .Build();

                    if (!scheduler.CheckExists(jobKey))
                    {
                        scheduler.ScheduleJob(job, trigger);
                    }

                    scheduler.Start();
                }
                #endregion


                unitOfWork.UserRepository.Insert(user);
                await unitOfWork.SaveAsync();

                ApplicationUserRole userRole = new ApplicationUserRole();
                userRole.RoleId = DataLayer.DbConstants.CustomerUserRole;
                userRole.UserId = user.Id;
                unitOfWork.UserRoleRepository.Insert(userRole);

                await unitOfWork.SaveAsync();

                Address address = new Address();
                address.CreatedById = user.Id;
                address.CreatedDate = DateTime.Now;

                unitOfWork.AddressRepository.Insert(address);
                await unitOfWork.SaveAsync();

                CustomerDetails customer = new CustomerDetails();
                customer.Id           = Guid.NewGuid();
                customer.CreatedById  = user.Id;
                customer.CreatedDate  = DateTime.Now;
                customer.UserId       = user.Id;
                customer.ContactPhone = model.ContactPhone;
                customer.AddressId    = address.Id;

                customer.ModifiedReason = "created";
                unitOfWork.CustomerDetailsRepository.Insert(customer);

                await unitOfWork.SaveAsync();

                if (!string.IsNullOrEmpty(model.Provider) && !string.IsNullOrEmpty(model.ExternalAccessToken))
                {
                    var loginInfo = await this.SignInManager.AuthenticationManager.GetExternalLoginInfoAsync();

                    ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(loginInfo.ExternalIdentity as ClaimsIdentity);

                    ApplicationUserLogin userLogin = new ApplicationUserLogin();
                    userLogin.UserId        = user.Id;
                    userLogin.ProviderKey   = loginInfo.Login.ProviderKey;
                    userLogin.LoginProvider = loginInfo.Login.LoginProvider;

                    unitOfWork.UserLoginRepository.Insert(userLogin);

                    await unitOfWork.SaveAsync();
                }

                unitOfWork.CommitTransaction();

                if (model.Provider == null)
                {
                    //Senf verification Email
                    {
                        string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);

                        var callbackUrl = string.Format("{0}/#/confirm-email?userId={1}&code={2}", Url.Link("Default", new { controller = "account" }), user.Id, Uri.EscapeDataString(code));
                        await EmailNitificationHelper.Create().SendConfirmationEmail(user, UserManager, callbackUrl);
                    }
                }

                userResult.UserId = user.Id;

                return(userResult);
            }
        }
コード例 #33
0
        public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
        {
            string redirectUri = string.Empty;

            if (error != null)
            {
                return(BadRequest(Uri.EscapeDataString(error)));//Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error));
            }

            if (!User.Identity.IsAuthenticated)
            {
                return(new ChallengeResult(provider, this));
            }

            //var redirectUriValidationResult = ValidateClientAndRedirectUri(this.Request, ref redirectUri);

            //if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
            //{
            //    return BadRequest(redirectUriValidationResult);
            //}

            ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);

            if (externalLogin == null)
            {
                return(InternalServerError());
            }

            if (externalLogin.LoginProvider != provider)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                return(new ChallengeResult(provider, this));
            }

            ApplicationUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider,
                                                                                 externalLogin.ProviderKey));

            bool hasRegistered = user != null;

            if (hasRegistered)
            {
                Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);

                ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(UserManager,
                                                                                    OAuthDefaults.AuthenticationType);

                ClaimsIdentity cookieIdentity = await user.GenerateUserIdentityAsync(UserManager,
                                                                                     CookieAuthenticationDefaults.AuthenticationType);

                AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(user);
                Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
            }
            else
            {
                IEnumerable <Claim> claims   = externalLogin.GetClaims();
                ClaimsIdentity      identity = new ClaimsIdentity(claims, OAuthDefaults.AuthenticationType);
                Authentication.SignIn(identity);
            }

            return(Ok());
        }
コード例 #34
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     loginData.Profile = identity.GetFirstOrDefault("urn:github:url");
     loginData.UserName = identity.GetFirstOrDefault(ClaimTypes.Name);
     loginData.Name = identity.GetFirstOrDefault("urn:github:name");
 }
コード例 #35
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     loginData.Profile = identity.GetFirstOrDefault("urn:linkedin:url");
     loginData.Name = identity.GetFirstOrDefault("urn:linkedin:name");
 }
コード例 #36
0
 public void Parse(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     loginData.Profile = identity.GetFirstOrDefault("urn:google:profile");
 }
コード例 #37
0
        public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
        {
            try
            {
                ExternalLoginData externalLogin = await ExternalLoginData.FromToken(model.Provider, model.Token);

                if (externalLogin == null)
                {
                    throw new Exception("externalLogin can not be found, externalLogin is null");
                }

                if (externalLogin.LoginProvider != model.Provider)
                {
                    Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
                    throw new Exception("Provider Conflicts, the Provider which send by user is not the same of the externalLogin's provider");
                }

                User user = await UserService.Obj.FindByEmailAsync(model.Email);

                bool registered = user != null;
                if (!registered)
                {
                    user = new User(model.Name, model.Email);
                    user.UpdateRoles(RoleService.Obj.GetByNames(RoleNames.UserRole));
                    user.PerformConfirmEmail();

                    user = await UserService.Obj.CreateExternalUserAsync(user, new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));
                }

                // Authenticate
                ClaimsIdentity identity = await UserService.Obj.CreateIdentityAsync(user, OAuthDefaults.AuthenticationType);

                IEnumerable <Claim> claims = externalLogin.GetClaims();
                identity.AddClaims(claims);
                Authentication.SignIn(identity);

                ClaimsIdentity oAuthIdentity = new ClaimsIdentity(Startup.OAuthOptions.AuthenticationType);

                oAuthIdentity.AddClaim(new Claim(ClaimTypes.Name, user.UserName));
                oAuthIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()));

                oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, RoleNames.UserRole));

                AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, new AuthenticationProperties());

                DateTime currentUtc = DateTime.UtcNow;
                ticket.Properties.IssuedUtc  = currentUtc;
                ticket.Properties.ExpiresUtc = currentUtc.Add(Startup.OAuthOptions.AccessTokenExpireTimeSpan);

                string accessToken  = Startup.OAuthOptions.AccessTokenFormat.Protect(ticket);
                string refreshToken = Startup.OAuthOptions.RefreshTokenFormat.Protect(ticket);
                Request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);

                var token = new
                {
                    userName      = user.UserName,
                    userId        = user.Id,
                    access_token  = accessToken,
                    refresh_token = refreshToken,
                    token_type    = "bearer",
                    expires_in    = Startup.OAuthOptions.AccessTokenExpireTimeSpan.TotalSeconds.ToString(),
                    issued        = currentUtc.ToString("ddd, dd MMM yyyy HH':'mm':'ss 'GMT'"),
                    expires       = currentUtc.Add(Startup.OAuthOptions.AccessTokenExpireTimeSpan).ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'")
                };

                return(Ok(token));
            }
            catch (Exception ex)
            {
                TracingSystem.TraceException(ex);
                return(InternalServerError());
            }
        }
コード例 #38
0
 private void ParseDetailLoginData(ClaimsIdentity identity, ref ExternalLoginData loginData)
 {
     var detailParser = new ExternalLoginDataParserFactory().Create(loginData.ProviderName);
     detailParser.Parse(identity, ref loginData);
 }
コード例 #39
0
        public async Task<IHttpActionResult> RegisterExternal(ExternalLoginData externalLoginData)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            var info = await Authentication.GetExternalLoginInfoAsync();
            if (info == null)
                return InternalServerError();

            var user = new ApplicationUser() { UserName = externalLoginData.UserName, Email = externalLoginData.Email };
            IdentityResult result = await UserManager.CreateAsync(user);

            if (!result.Succeeded)
                return GetErrorResult(result);

            result = await UserManager.AddLoginAsync(user.Id, info.Login);
            if (!result.Succeeded)
                return GetErrorResult(result);

            return Ok();
        }