public virtual ActionResult Edit(string uuid)
        {
            var membershipConnect = new MembershipConnect()
            {
                Membership = Membership, UUID = uuid
            }.AsActual();

            return(View(membershipConnect));
        }
        public string GetUserName(AuthResult authResult, MembershipConnect membershipConnect)
        {
            string userName = authResult.UserName;

            if (!IsEmail(userName) && !string.IsNullOrEmpty(membershipConnect.UsernameFormat))
            {
                userName = string.Format(membershipConnect.UsernameFormat, userName);
            }
            return(userName);
        }
        public virtual ActionResult IsNameAvailable(string name)
        {
            var membershipConnect = new MembershipConnect()
            {
                Membership = Membership, Name = name
            }.AsActual();

            if (membershipConnect != null)
            {
                return(Json("The name is duplicate.".Localize(), JsonRequestBehavior.AllowGet));
            }
            return(Json(true, JsonRequestBehavior.AllowGet));
        }
        public virtual ActionResult Edit(MembershipConnect model, string @return)
        {
            JsonResultData data = new JsonResultData(ModelState);

            if (ModelState.IsValid)
            {
                data.RunWithTry((resultData) =>
                {
                    model.Membership = Membership;
                    _manager.Update(model, model);
                    resultData.RedirectUrl = @return;
                });
            }
            return(Json(data));
        }
        private static IAuthClient GetAuthClient(Kooboo.CMS.Membership.Models.Membership membership, string connectName)
        {
            var membershipConnect = new MembershipConnect()
            {
                Membership = membership, Name = connectName
            }.AsActual();

            if (membershipConnect == null)
            {
                throw new ArgumentException("Invalid membership connect.");
            }

            var authClient = Kooboo.CMS.Common.Runtime.EngineContext.Current.Resolve <IAuthClient>(membershipConnect.Name.ToLower());

            authClient.MembershipConnect = membershipConnect;

            return(authClient);
        }
        public string GetEmail(AuthResult authResult, MembershipConnect membershipConnect)
        {
            string email = "";

            if (IsEmail(authResult.UserName))
            {
                email = authResult.UserName;
            }
            else
            {
                email = "";
                if (authResult.ExtraData != null)
                {
                    var extraData = new Dictionary <string, string>(authResult.ExtraData, StringComparer.OrdinalIgnoreCase);
                    if (extraData.ContainsKey("email"))
                    {
                        email = extraData["email"];
                    }
                }
            }
            return(email);
        }
        public ActionResult ExternalLoginCallback(string returnUrl)
        {
            var membership  = GetMembership();
            var callbackUrl = GetCallbackUrl(returnUrl);
            var result      = OAuthWebSecurity.VerifyAuthentication(membership, this.HttpContext, callbackUrl);

            if (!result.IsSuccessful)
            {
                var reason = "";
                if (result.Error != null)
                {
                    reason = result.Error.Message;
                    Kooboo.HealthMonitoring.Log.LogException(result.Error);
                }
                return(RedirectToAction("ExternalLoginFailure", new { returnUrl = returnUrl, reason = reason }));
            }
            else
            {
                var membershipConnect = new MembershipConnect()
                {
                    Membership = membership, Name = result.Provider
                }.AsActual();
                if (membershipConnect != null)
                {
                    var membershipUser = _membershipUserManager.CreateOrUpdateOAuthMember(membership, membershipConnect, result, null);

                    if (membershipUser.IsApproved && !membershipUser.IsLockedOut)
                    {
                        HttpContext.Membership().SetAuthCookie(membershipUser.UserName, false);
                    }
                    else
                    {
                        return(RedirectToAction("ExternalLoginFailure", new { returnUrl = returnUrl, reason = "The member was locked out." }));
                    }
                }
            }
            return(RedirectToLocal(returnUrl));
        }
        public virtual MembershipUser CreateOrUpdateOAuthMember(Kooboo.CMS.Membership.Models.Membership membership, MembershipConnect membershipConnect, AuthResult authResult, Dictionary <string, string> profiles)
        {
            membership        = membership.AsActual();
            membershipConnect = membershipConnect.AsActual();

            var            userName       = _oauthMembershipProvider.GetUserName(authResult, membershipConnect);
            var            email          = _oauthMembershipProvider.GetEmail(authResult, membershipConnect);
            MembershipUser membershipUser = new MembershipUser()
            {
                Membership = membership, UserName = userName
            }.AsActual();
            Dictionary <string, string> extraData = null;

            if (authResult.ExtraData != null)
            {
                extraData = new Dictionary <string, string>(authResult.ExtraData);
            }
            if (membershipUser != null)
            {
                if (membershipUser.ProviderUserId == authResult.ProviderUserId)
                {
                    membershipUser.UtcLastLoginDate  = DateTime.UtcNow;
                    membershipUser.ProviderExtraData = extraData;
                    membershipUser.Profiles          = profiles;
                    membershipUser.MembershipGroups  = membershipConnect.MembershipGroups;
                    _provider.Update(membershipUser, membershipUser);
                }
            }
            else
            {
                membershipUser = new MembershipUser()
                {
                    Membership = membership, UserName = userName
                };
                membershipUser.Email             = email;
                membershipUser.IsApproved        = true;
                membershipUser.UtcCreationDate   = DateTime.UtcNow;
                membershipUser.UtcLastLoginDate  = DateTime.UtcNow;
                membershipUser.Profiles          = profiles;
                membershipUser.MembershipGroups  = membershipConnect.MembershipGroups;
                membershipUser.ProviderType      = authResult.Provider;
                membershipUser.ProviderUserId    = authResult.ProviderUserId;
                membershipUser.ProviderExtraData = extraData;
                _provider.Add(membershipUser);
            }

            return(_provider.Get(membershipUser));
        }