csharp-sdk-upm/Storage/Source/Public/AVUser.cs

using LeanCloud.Storage.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace LeanCloud {
    /// <summary>
    /// Represents a user for a LeanCloud application.
    /// </summary>
    [AVClassName("_User")]
    public class AVUser : AVObject {
        private static readonly IDictionary<string, IAVAuthenticationProvider> authProviders =
            new Dictionary<string, IAVAuthenticationProvider>();

        private static readonly HashSet<string> readOnlyKeys = new HashSet<string> {
            "sessionToken", "isNew"
        };

        internal static IAVUserController UserController {
            get {
                return AVPlugins.Instance.UserController;
            }
        }

        internal static IAVCurrentUserController CurrentUserController {
            get {
                return AVPlugins.Instance.CurrentUserController;
            }
        }

        /// <summary>
        /// Whether the AVUser has been authenticated on this device. Only an authenticated
        /// AVUser can be saved and deleted.
        /// </summary>
        [Obsolete("This property is deprecated, please use IsAuthenticatedAsync instead.")]
        public bool IsAuthenticated {
            get {
                lock (mutex) {
                    return SessionToken != null &&
                      CurrentUser != null &&
                      CurrentUser.ObjectId == ObjectId;
                }
            }
        }

        /// <summary>
        /// Whether the AVUser has been authenticated on this device, and the AVUser's session token is expired.
        /// Only an authenticated AVUser can be saved and deleted.
        /// </summary>
        public Task<bool> IsAuthenticatedAsync() {
            lock (mutex) {
                if (SessionToken == null || CurrentUser == null || CurrentUser.ObjectId != ObjectId) {
                    return Task.FromResult(false);
                }
            }
            var command = new AVCommand(String.Format("users/me?session_token={0}", CurrentSessionToken),
                method: "GET",
                data: null);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// Refresh this user's session token, and current session token will be invalid.
        /// </summary>
        public Task RefreshSessionTokenAsync(CancellationToken cancellationToken) {
            return UserController.RefreshSessionTokenAsync(ObjectId, SessionToken, cancellationToken).OnSuccess(t => {
                var serverState = t.Result;
                HandleSave(serverState);
            });
        }

        /// <summary>
        /// Removes a key from the object's data if it exists.
        /// </summary>
        /// <param name="key">The key to remove.</param>
        /// <exception cref="System.ArgumentException">Cannot remove the username key.</exception>
        public override void Remove(string key) {
            if (key == "username") {
                throw new ArgumentException("Cannot remove the username key.");
            }
            base.Remove(key);
        }

        protected override bool IsKeyMutable(string key) {
            return !readOnlyKeys.Contains(key);
        }

        internal override void HandleSave(IObjectState serverState) {
            base.HandleSave(serverState);

            SynchronizeAllAuthData();
            CleanupAuthData();

            MutateState(mutableClone => {
                mutableClone.ServerData.Remove("password");
            });
        }

        /// <summary>
        /// authenticated token.
        /// </summary>
        public string SessionToken {
            get {
                if (State.ContainsKey("sessionToken")) {
                    return State["sessionToken"] as string;
                }
                return null;
            }
        }

        internal static string CurrentSessionToken {
            get {
                Task<string> sessionTokenTask = GetCurrentSessionTokenAsync();
                sessionTokenTask.Wait();
                return sessionTokenTask.Result;
            }
        }

        internal static Task<string> GetCurrentSessionTokenAsync(CancellationToken cancellationToken = default) {
            return CurrentUserController.GetCurrentSessionTokenAsync(cancellationToken);
        }

        internal Task SetSessionTokenAsync(string newSessionToken) {
            return SetSessionTokenAsync(newSessionToken, CancellationToken.None);
        }

        internal Task SetSessionTokenAsync(string newSessionToken, CancellationToken cancellationToken) {
            MutateState(mutableClone => {
                mutableClone.ServerData["sessionToken"] = newSessionToken;
            });

            return SaveCurrentUserAsync(this);
        }

        /// <summary>
        /// Gets or sets the username.
        /// </summary>
        [AVFieldName("username")]
        public string Username {
            get { return GetProperty<string>(null, "Username"); }
            set { SetProperty(value, "Username"); }
        }

        /// <summary>
        /// Sets the password.
        /// </summary>
        [AVFieldName("password")]
        public string Password {
            private get { return GetProperty<string>(null, "Password"); }
            set { SetProperty(value, "Password"); }
        }

        /// <summary>
        /// Sets the email address.
        /// </summary>
        [AVFieldName("email")]
        public string Email {
            get { return GetProperty<string>(null, "Email"); }
            set { SetProperty(value, "Email"); }
        }

        /// <summary>
        /// 用户手机号。
        /// </summary>
        [AVFieldName("mobilePhoneNumber")]
        public string MobilePhoneNumber {
            get {
                return GetProperty<string>(null, "MobilePhoneNumber");
            }
            set {
                SetProperty<string>(value, "MobilePhoneNumber");
            }
        }

        /// <summary>
        /// 用户手机号是否已经验证
        /// </summary>
        /// <value><c>true</c> if mobile phone verified; otherwise, <c>false</c>.</value>
        [AVFieldName("mobilePhoneVerified")]
        public bool MobilePhoneVerified {
            get {
                return GetProperty<bool>(false, "MobilePhoneVerified");
            }
            set {
                SetProperty<bool>(value, "MobilePhoneVerified");
            }
        }

        /// <summary>
        /// 判断用户是否为匿名用户
        /// </summary>
        public bool IsAnonymous {
            get {
                bool rtn = false;
                if (this.AuthData != null) {
                    rtn = this.AuthData.Keys.Contains("anonymous");
                }
                return rtn;
            }
        }

        internal Task SignUpAsync(Task toAwait, CancellationToken cancellationToken) {
            return this.Create(toAwait, cancellationToken).OnSuccess(_ => SaveCurrentUserAsync(this)).Unwrap();
        }

        /// <summary>
        /// Signs up a new user. This will create a new AVUser on the server and will also persist the
        /// session on disk so that you can access the user using <see cref="CurrentUser"/>. A username and
        /// password must be set before calling SignUpAsync.
        /// </summary>
        public Task SignUpAsync() {
            return SignUpAsync(CancellationToken.None);
        }

        /// <summary>
        /// Signs up a new user. This will create a new AVUser on the server and will also persist the
        /// session on disk so that you can access the user using <see cref="CurrentUser"/>. A username and
        /// password must be set before calling SignUpAsync.
        /// </summary>
        /// <param name="cancellationToken">The cancellation token.</param>
        public Task SignUpAsync(CancellationToken cancellationToken) {
            return taskQueue.Enqueue(toAwait => SignUpAsync(toAwait, cancellationToken),
                cancellationToken);
        }

        #region 事件流系统相关 API

        /// <summary>
        /// 关注某个用户
        /// </summary>
        /// <param name="userObjectId">被关注的用户</param>
        /// <returns></returns>
        public Task<bool> FollowAsync(string userObjectId) {
            return this.FollowAsync(userObjectId, null);
        }

        /// <summary>
        /// 关注某个用户
        /// </summary>
        /// <param name="userObjectId">被关注的用户Id</param>
        /// <param name="data">关注的时候附加属性</param>
        /// <returns></returns>
        public Task<bool> FollowAsync(string userObjectId, IDictionary<string, object> data) {
            if (data != null) {
                data = this.EncodeForSaving(data);
            }
            var command = new AVCommand(string.Format("users/{0}/friendship/{1}", this.ObjectId, userObjectId),
              method: "POST",
              sessionToken: CurrentSessionToken,
              data: data);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 取关某一个用户
        /// </summary>
        /// <param name="userObjectId"></param>
        /// <returns></returns>
        public Task<bool> UnfollowAsync(string userObjectId) {
            var command = new AVCommand(string.Format("users/{0}/friendship/{1}", this.ObjectId, userObjectId),
             method: "DELETE",
             sessionToken: CurrentSessionToken,
             data: null);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 获取当前用户的关注者的查询
        /// </summary>
        /// <returns></returns>
        public AVQuery<AVUser> GetFollowerQuery() {
            AVQuery<AVUser> query = new AVQuery<AVUser>();
            query.RelativeUri = string.Format("users/{0}/followers", this.ObjectId);
            return query;
        }

        /// <summary>
        /// 获取当前用户所关注的用户的查询
        /// </summary>
        /// <returns></returns>
        public AVQuery<AVUser> GetFolloweeQuery() {
            AVQuery<AVUser> query = new AVQuery<AVUser>();
            query.RelativeUri = string.Format("users/{0}/followees", this.ObjectId);
            return query;
        }

        /// <summary>
        /// 同时查询关注了当前用户的关注者和当前用户所关注的用户
        /// </summary>
        /// <returns></returns>
        public AVQuery<AVUser> GetFollowersAndFolloweesQuery() {
            AVQuery<AVUser> query = new AVQuery<AVUser>();
            query.RelativeUri = string.Format("users/{0}/followersAndFollowees", this.ObjectId);
            return query;
        }

        /// <summary>
        /// 获取当前用户的关注者
        /// </summary>
        /// <returns></returns>
        public Task<IEnumerable<AVUser>> GetFollowersAsync() {
            return this.GetFollowerQuery().FindAsync();
        }

        /// <summary>
        /// 获取当前用户所关注的用户
        /// </summary>
        /// <returns></returns>
        public Task<IEnumerable<AVUser>> GetFolloweesAsync() {
            return this.GetFolloweeQuery().FindAsync();
        }


        //public Task<AVStatus> SendStatusAsync()
        //{

        //}

        #endregion

        /// <summary>
        /// Logs in a user with a username and password. On success, this saves the session to disk so you
        /// can retrieve the currently logged in user using <see cref="CurrentUser"/>.
        /// </summary>
        /// <param name="username">The username to log in with.</param>
        /// <param name="password">The password to log in with.</param>
        /// <returns>The newly logged-in user.</returns>
        public static Task<AVUser> LogInAsync(string username, string password) {
            return LogInAsync(username, password, CancellationToken.None);
        }

        /// <summary>
        /// Logs in a user with a username and password. On success, this saves the session to disk so you
        /// can retrieve the currently logged in user using <see cref="CurrentUser"/>.
        /// </summary>
        /// <param name="username">The username to log in with.</param>
        /// <param name="password">The password to log in with.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The newly logged-in user.</returns>
        public static Task<AVUser> LogInAsync(string username,
            string password,
            CancellationToken cancellationToken) {
            return UserController.LogInAsync(username, null, password, cancellationToken).OnSuccess(t => {
                AVUser user = AVObject.FromState<AVUser>(t.Result, "_User");
                return SaveCurrentUserAsync(user).OnSuccess(_ => user);
            }).Unwrap();
        }

        /// <summary>
        /// Logs in a user with a username and password. On success, this saves the session to disk so you
        /// can retrieve the currently logged in user using <see cref="CurrentUser"/>.
        /// </summary>
        /// <param name="sessionToken">The session token to authorize with</param>
        /// <returns>The user if authorization was successful</returns>
        public static Task<AVUser> BecomeAsync(string sessionToken) {
            return BecomeAsync(sessionToken, CancellationToken.None);
        }

        /// <summary>
        /// Logs in a user with a username and password. On success, this saves the session to disk so you
        /// can retrieve the currently logged in user using <see cref="CurrentUser"/>.
        /// </summary>
        /// <param name="sessionToken">The session token to authorize with</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The user if authorization was successful</returns>
        public static Task<AVUser> BecomeAsync(string sessionToken, CancellationToken cancellationToken) {
            return UserController.GetUserAsync(sessionToken, cancellationToken).OnSuccess(t => {
                AVUser user = AVObject.FromState<AVUser>(t.Result, "_User");
                return SaveCurrentUserAsync(user).OnSuccess(_ => user);
            }).Unwrap();
        }

        protected override Task SaveAsync(Task toAwait, CancellationToken cancellationToken) {
            lock (mutex) {
                if (ObjectId == null) {
                    throw new InvalidOperationException("You must call SignUpAsync before calling SaveAsync.");
                }
                return base.SaveAsync(toAwait, cancellationToken).OnSuccess(_ => {
                    if (!CurrentUserController.IsCurrent(this)) {
                        return Task.FromResult(0);
                    }
                    return SaveCurrentUserAsync(this);
                }).Unwrap();
            }
        }

        internal override Task<AVObject> FetchAsyncInternal(Task toAwait, IDictionary<string, object> queryString, CancellationToken cancellationToken) {
            return base.FetchAsyncInternal(toAwait, queryString, cancellationToken).OnSuccess(t => {
                if (!CurrentUserController.IsCurrent(this)) {
                    return Task<AVObject>.FromResult(t.Result);
                }
                // If this is already the current user, refresh its state on disk.
                return SaveCurrentUserAsync(this).OnSuccess(_ => t.Result);
            }).Unwrap();
        }

        /// <summary>
        /// Logs out the currently logged in user session. This will remove the session from disk, log out of
        /// linked services, and future calls to <see cref="CurrentUser"/> will return <c>null</c>.
        /// </summary>
        /// <remarks>
        /// Typically, you should use <see cref="LogOutAsync()"/>, unless you are managing your own threading.
        /// </remarks>
        public static void LogOut() {
            // TODO (hallucinogen): this will without a doubt fail in Unity. But what else can we do?
            LogOutAsync().Wait();
        }

        /// <summary>
        /// Logs out the currently logged in user session. This will remove the session from disk, log out of
        /// linked services, and future calls to <see cref="CurrentUser"/> will return <c>null</c>.
        /// </summary>
        /// <remarks>
        /// This is preferable to using <see cref="LogOut()"/>, unless your code is already running from a
        /// background thread.
        /// </remarks>
        public static Task LogOutAsync() {
            return LogOutAsync(CancellationToken.None);
        }

        /// <summary>
        /// Logs out the currently logged in user session. This will remove the session from disk, log out of
        /// linked services, and future calls to <see cref="CurrentUser"/> will return <c>null</c>.
        ///
        /// This is preferable to using <see cref="LogOut()"/>, unless your code is already running from a
        /// background thread.
        /// </summary>
        public static Task LogOutAsync(CancellationToken cancellationToken) {
            return GetCurrentUserAsync().OnSuccess(t => {
                LogOutWithProviders();

                AVUser user = t.Result;
                if (user == null) {
                    return Task.FromResult(0);
                }

                return user.taskQueue.Enqueue(toAwait => user.LogOutAsync(toAwait, cancellationToken), cancellationToken);
            }).Unwrap();
        }

        internal Task LogOutAsync(Task toAwait, CancellationToken cancellationToken) {
            string oldSessionToken = SessionToken;
            if (oldSessionToken == null) {
                return Task.FromResult(0);
            }

            // Cleanup in-memory session.
            MutateState(mutableClone => {
                mutableClone.ServerData.Remove("sessionToken");
            });
            var revokeSessionTask = AVSession.RevokeAsync(oldSessionToken, cancellationToken);
            return Task.WhenAll(revokeSessionTask, CurrentUserController.LogOutAsync(cancellationToken));
        }

        private static void LogOutWithProviders() {
            foreach (var provider in authProviders.Values) {
                provider.Deauthenticate();
            }
        }

        /// <summary>
        /// Gets the currently logged in AVUser with a valid session, either from memory or disk
        /// if necessary.
        /// </summary>
        public static AVUser CurrentUser {
            get {
                var userTask = GetCurrentUserAsync();
                // TODO (hallucinogen): this will without a doubt fail in Unity. How should we fix it?
                userTask.Wait();
                return userTask.Result;
            }
        }

        public static Task<AVUser> GetCurrentAsync() {
            var userTask = GetCurrentUserAsync();
            return userTask;
        }

        /// <summary>
        /// Gets the currently logged in AVUser with a valid session, either from memory or disk
        /// if necessary, asynchronously.
        /// </summary>
        public static Task<AVUser> GetCurrentUserAsync() {
            return GetCurrentUserAsync(CancellationToken.None);
        }

        /// <summary>
        /// Gets the currently logged in AVUser with a valid session, either from memory or disk
        /// if necessary, asynchronously.
        /// </summary>
        internal static Task<AVUser> GetCurrentUserAsync(CancellationToken cancellationToken) {
            return CurrentUserController.GetAsync(cancellationToken);
        }

        private static Task SaveCurrentUserAsync(AVUser user) {
            return SaveCurrentUserAsync(user, CancellationToken.None);
        }

        private static Task SaveCurrentUserAsync(AVUser user, CancellationToken cancellationToken) {
            return CurrentUserController.SetAsync(user, cancellationToken);
        }

        internal static void ClearInMemoryUser() {
            CurrentUserController.ClearFromMemory();
        }

        /// <summary>
        /// Constructs a <see cref="AVQuery{AVUser}"/> for AVUsers.
        /// </summary>
        public static AVQuery<AVUser> Query {
            get {
                return new AVQuery<AVUser>();
            }
        }

        #region Legacy / Revocable Session Tokens

        private static readonly object isRevocableSessionEnabledMutex = new object();
        private static bool isRevocableSessionEnabled;

        /// <summary>
        /// Tells server to use revocable session on LogIn and SignUp, even when App's Settings
        /// has "Require Revocable Session" turned off. Issues network request in background to
        /// migrate the sessionToken on disk to revocable session.
        /// </summary>
        /// <returns>The Task that upgrades the session.</returns>
        public static Task EnableRevocableSessionAsync() {
            return EnableRevocableSessionAsync(CancellationToken.None);
        }

        /// <summary>
        /// Tells server to use revocable session on LogIn and SignUp, even when App's Settings
        /// has "Require Revocable Session" turned off. Issues network request in background to
        /// migrate the sessionToken on disk to revocable session.
        /// </summary>
        /// <returns>The Task that upgrades the session.</returns>
        public static Task EnableRevocableSessionAsync(CancellationToken cancellationToken) {
            lock (isRevocableSessionEnabledMutex) {
                isRevocableSessionEnabled = true;
            }

            return GetCurrentUserAsync(cancellationToken).OnSuccess(t => {
                var user = t.Result;
                return user.UpgradeToRevocableSessionAsync(cancellationToken);
            });
        }

        internal static void DisableRevocableSession() {
            lock (isRevocableSessionEnabledMutex) {
                isRevocableSessionEnabled = false;
            }
        }

        internal static bool IsRevocableSessionEnabled {
            get {
                lock (isRevocableSessionEnabledMutex) {
                    return isRevocableSessionEnabled;
                }
            }
        }

        internal Task UpgradeToRevocableSessionAsync() {
            return UpgradeToRevocableSessionAsync(CancellationToken.None);
        }

        public Task UpgradeToRevocableSessionAsync(CancellationToken cancellationToken) {
            return taskQueue.Enqueue(toAwait => UpgradeToRevocableSessionAsync(toAwait, cancellationToken),
                cancellationToken);
        }

        internal Task UpgradeToRevocableSessionAsync(Task toAwait, CancellationToken cancellationToken) {
            string sessionToken = SessionToken;

            return toAwait.OnSuccess(_ => {
                return AVSession.UpgradeToRevocableSessionAsync(sessionToken, cancellationToken);
            }).Unwrap().OnSuccess(t => {
                return SetSessionTokenAsync(t.Result);
            }).Unwrap();
        }

        #endregion

        /// <summary>
        /// Requests a password reset email to be sent to the specified email address associated with the
        /// user account. This email allows the user to securely reset their password on the LeanCloud site.
        /// </summary>
        /// <param name="email">The email address associated with the user that forgot their password.</param>
        public static Task RequestPasswordResetAsync(string email) {
            return RequestPasswordResetAsync(email, CancellationToken.None);
        }

        /// <summary>
        /// Requests a password reset email to be sent to the specified email address associated with the
        /// user account. This email allows the user to securely reset their password on the LeanCloud site.
        /// </summary>
        /// <param name="email">The email address associated with the user that forgot their password.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        public static Task RequestPasswordResetAsync(string email,
            CancellationToken cancellationToken) {
            return UserController.RequestPasswordResetAsync(email, cancellationToken);
        }

        /// <summary>
        /// Updates current user's password. Need the user's old password,
        /// </summary>
        /// <returns>The password.</returns>
        /// <param name="oldPassword">Old password.</param>
        /// <param name="newPassword">New password.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        public Task UpdatePassword(string oldPassword, string newPassword, CancellationToken cancellationToken) {
            return UserController.UpdatePasswordAsync(ObjectId, SessionToken, oldPassword, newPassword, cancellationToken);
        }

        /// <summary>
        /// Gets the authData for this user.
        /// </summary>
        internal IDictionary<string, IDictionary<string, object>> AuthData {
            get {
                IDictionary<string, IDictionary<string, object>> authData;
                if (this.TryGetValue<IDictionary<string, IDictionary<string, object>>>(
                    "authData", out authData)) {
                    return authData;
                }
                return null;
            }
            private set {
                this["authData"] = value;
            }
        }

        private static IAVAuthenticationProvider GetProvider(string providerName) {
            IAVAuthenticationProvider provider;
            if (authProviders.TryGetValue(providerName, out provider)) {
                return provider;
            }
            return null;
        }

        /// <summary>
        /// Removes null values from authData (which exist temporarily for unlinking)
        /// </summary>
        private void CleanupAuthData() {
            lock (mutex) {
                if (!CurrentUserController.IsCurrent(this)) {
                    return;
                }
                var authData = AuthData;

                if (authData == null) {
                    return;
                }

                foreach (var pair in new Dictionary<string, IDictionary<string, object>>(authData)) {
                    if (pair.Value == null) {
                        authData.Remove(pair.Key);
                    }
                }
            }
        }

        /// <summary>
        /// Synchronizes authData for all providers.
        /// </summary>
        private void SynchronizeAllAuthData() {
            lock (mutex) {
                var authData = AuthData;

                if (authData == null) {
                    return;
                }

                foreach (var pair in authData) {
                    SynchronizeAuthData(GetProvider(pair.Key));
                }
            }
        }

        private void SynchronizeAuthData(IAVAuthenticationProvider provider) {
            bool restorationSuccess = false;
            lock (mutex) {
                var authData = AuthData;
                if (authData == null || provider == null) {
                    return;
                }
                IDictionary<string, object> data;
                if (authData.TryGetValue(provider.AuthType, out data)) {
                    restorationSuccess = provider.RestoreAuthentication(data);
                }
            }

            if (!restorationSuccess) {
                this.UnlinkFromAsync(provider.AuthType, CancellationToken.None);
            }
        }

        public Task LinkWithAsync(string authType, IDictionary<string, object> data, CancellationToken cancellationToken) {
            return taskQueue.Enqueue(toAwait => {
                AuthData = new Dictionary<string, IDictionary<string, object>>();
                AuthData[authType] = data;
                return SaveAsync(cancellationToken);
            }, cancellationToken);
        }

        public Task LinkWithAsync(string authType, CancellationToken cancellationToken) {
            var provider = GetProvider(authType);
            return provider.AuthenticateAsync(cancellationToken)
              .OnSuccess(t => LinkWithAsync(authType, t.Result, cancellationToken))
              .Unwrap();
        }

        /// <summary>
        /// Unlinks a user from a service.
        /// </summary>
        public Task UnlinkFromAsync(string authType, CancellationToken cancellationToken) {
            return LinkWithAsync(authType, null, cancellationToken);
        }

        /// <summary>
        /// Checks whether a user is linked to a service.
        /// </summary>
        internal bool IsLinked(string authType) {
            lock (mutex) {
                return AuthData != null && AuthData.ContainsKey(authType) && AuthData[authType] != null;
            }
        }

        internal static Task<AVUser> LogInWithAsync(string authType,
            IDictionary<string, object> data,
            bool failOnNotExist,
            CancellationToken cancellationToken) {
            AVUser user = null;

            return UserController.LogInAsync(authType, data, failOnNotExist, cancellationToken).OnSuccess(t => {
                user = AVObject.FromState<AVUser>(t.Result, "_User");

                lock (user.mutex) {
                    if (user.AuthData == null) {
                        user.AuthData = new Dictionary<string, IDictionary<string, object>>();
                    }
                    user.AuthData[authType] = data;
                    user.SynchronizeAllAuthData();
                }

                return SaveCurrentUserAsync(user);
            }).Unwrap().OnSuccess(t => user);
        }

        internal static Task<AVUser> LogInWithAsync(string authType,
            CancellationToken cancellationToken) {
            var provider = GetProvider(authType);
            return provider.AuthenticateAsync(cancellationToken)
              .OnSuccess(authData => LogInWithAsync(authType, authData.Result, false, cancellationToken))
              .Unwrap();
        }

        internal static void RegisterProvider(IAVAuthenticationProvider provider) {
            authProviders[provider.AuthType] = provider;
            if (CurrentUser != null) {
                CurrentUser.SynchronizeAuthData(provider);
            }
        }

        #region 手机号登录

        internal static Task<AVUser> LogInWithParametersAsync(Dictionary<string, object> strs, CancellationToken cancellationToken) {
            AVUser avUser = CreateWithoutData<AVUser>(null);

            return UserController.LogInWithParametersAsync("login", strs, cancellationToken).OnSuccess(t => {
                var user = CreateWithoutData<AVUser>(null);
                user.HandleFetchResult(t.Result);
                return SaveCurrentUserAsync(user).OnSuccess(_ => user);
            }).Unwrap();
        }

        /// <summary>
        /// 以手机号和密码实现登陆。
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="password">密码</param>
        /// <returns></returns>
        public static Task<AVUser> LogInByMobilePhoneNumberAsync(string mobilePhoneNumber, string password) {
            return LogInByMobilePhoneNumberAsync(mobilePhoneNumber, password, CancellationToken.None);
        }

        /// <summary>
        /// 用邮箱作和密码匹配登录
        /// </summary>
        /// <param name="email">邮箱</param>
        /// <param name="password">密码</param>
        /// <returns></returns>
        public static Task<AVUser> LogInByEmailAsync(string email, string password, CancellationToken cancellationToken = default) {
            return UserController.LogInAsync(null, email, password, cancellationToken).OnSuccess(t => {
                AVUser user = FromState<AVUser>(t.Result, "_User");
                return SaveCurrentUserAsync(user).OnSuccess(_ => user);
            }).Unwrap();
        }


        /// <summary>
        /// 以手机号和密码匹配登陆
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="password">密码</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public static Task<AVUser> LogInByMobilePhoneNumberAsync(string mobilePhoneNumber, string password, CancellationToken cancellationToken) {
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "mobilePhoneNumber", mobilePhoneNumber },
                { "password", password }
            };
            return LogInWithParametersAsync(strs, cancellationToken);
        }

        /// <summary>
        /// 以手机号和验证码登陆
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="smsCode">短信验证码</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public static Task<AVUser> LogInBySmsCodeAsync(string mobilePhoneNumber, string smsCode, CancellationToken cancellationToken = default) {
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "mobilePhoneNumber", mobilePhoneNumber },
                { "smsCode", smsCode }
            };
            return LogInWithParametersAsync(strs, cancellationToken);
        }

        /// <summary>
        /// Requests the login SMS code asynchronous.
        /// </summary>
        /// <param name="mobilePhoneNumber">The mobile phone number.</param>
        /// <returns></returns>
        public static Task<bool> RequestLogInSmsCodeAsync(string mobilePhoneNumber) {
            return RequestLogInSmsCodeAsync(mobilePhoneNumber, CancellationToken.None);
        }

        /// <summary>
        /// Requests the login SMS code asynchronous.
        /// </summary>
        /// <param name="mobilePhoneNumber">The mobile phone number.</param>
        /// <param name="validateToken">Validate token.</param>
        /// <returns></returns>
        public static Task<bool> RequestLogInSmsCodeAsync(string mobilePhoneNumber, string validateToken) {
            return RequestLogInSmsCodeAsync(mobilePhoneNumber, null, CancellationToken.None);
        }

        /// <summary>
        /// Requests the login SMS code asynchronous.
        /// </summary>
        /// <param name="mobilePhoneNumber">The mobile phone number.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns></returns>
        public static Task<bool> RequestLogInSmsCodeAsync(string mobilePhoneNumber, CancellationToken cancellationToken) {
            return RequestLogInSmsCodeAsync(mobilePhoneNumber, null, cancellationToken);
        }

        /// <summary>
        /// Requests the login SMS code asynchronous.
        /// </summary>
        /// <param name="mobilePhoneNumber">The mobile phone number.</param>
        /// <param name="validateToken">Validate token.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns></returns>
        public static Task<bool> RequestLogInSmsCodeAsync(string mobilePhoneNumber, string validateToken, CancellationToken cancellationToken) {
            Dictionary<string, object> strs = new Dictionary<string, object> {
                { "mobilePhoneNumber", mobilePhoneNumber },
            };
            if (string.IsNullOrEmpty(validateToken)) {
                strs.Add("validate_token", validateToken);
            }
            var command = new AVCommand("requestLoginSmsCode", "POST", CurrentSessionToken, data: strs);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 手机号一键登录
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="smsCode">短信验证码</param>
        /// <returns></returns>
        public static Task<AVUser> SignUpOrLogInByMobilePhoneAsync(string mobilePhoneNumber, string smsCode, CancellationToken cancellationToken) {
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "mobilePhoneNumber", mobilePhoneNumber },
                { "smsCode", smsCode }
            };
            return UserController.LogInWithParametersAsync("usersByMobilePhone", strs, cancellationToken).OnSuccess(t => {
                var user = CreateWithoutData<AVUser>(null);
                user.HandleFetchResult(t.Result);
                return SaveCurrentUserAsync(user).OnSuccess(_ => user);
            }).Unwrap();
        }

        /// <summary>
        /// 手机号一键登录
        /// </summary>
        /// <returns>signup or login by mobile phone async.</returns>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="smsCode">短信验证码</param>
        public static Task<AVUser> SignUpOrLogInByMobilePhoneAsync(string mobilePhoneNumber, string smsCode) {
            return SignUpOrLogInByMobilePhoneAsync(mobilePhoneNumber, smsCode, CancellationToken.None);
        }

        #region mobile sms shortcode sign up & log in.
        /// <summary>
        /// Send sign up sms code async.
        /// </summary>
        /// <returns>The sign up sms code async.</returns>
        /// <param name="mobilePhoneNumber">Mobile phone number.</param>
        public static Task SendSignUpSmsCodeAsync(string mobilePhoneNumber) {
            return AVCloud.RequestSMSCodeAsync(mobilePhoneNumber);
        }

        /// <summary>
        /// Sign up by mobile phone async.
        /// </summary>
        /// <returns>The up by mobile phone async.</returns>
        /// <param name="mobilePhoneNumber">Mobile phone number.</param>
        /// <param name="smsCode">Sms code.</param>
        public static Task<AVUser> SignUpByMobilePhoneAsync(string mobilePhoneNumber, string smsCode) {
            return SignUpOrLogInByMobilePhoneAsync(mobilePhoneNumber, smsCode);
        }

        /// <summary>
        /// Send log in sms code async.
        /// </summary>
        /// <returns>The log in sms code async.</returns>
        /// <param name="mobilePhoneNumber">Mobile phone number.</param>
        public static Task SendLogInSmsCodeAsync(string mobilePhoneNumber) {
            return RequestLogInSmsCodeAsync(mobilePhoneNumber);
        }

        /// <summary>
        /// Log in by mobile phone async.
        /// </summary>
        /// <returns>The in by mobile phone async.</returns>
        /// <param name="mobilePhoneNumber">Mobile phone number.</param>
        /// <param name="smsCode">Sms code.</param>
        public static Task<AVUser> LogInByMobilePhoneAsync(string mobilePhoneNumber, string smsCode) {
            return LogInBySmsCodeAsync(mobilePhoneNumber, smsCode);
        }
        #endregion
        #endregion

        #region 重置密码
        /// <summary>
        ///  请求重置密码，需要传入注册时使用的手机号。
        /// </summary>
        /// <param name="mobilePhoneNumber">注册时使用的手机号</param>
        /// <returns></returns>
        public static Task RequestPasswordResetBySmsCode(string mobilePhoneNumber) {
            return RequestPasswordResetBySmsCode(mobilePhoneNumber, null, CancellationToken.None);
        }

        /// <summary>
        ///  请求重置密码，需要传入注册时使用的手机号。
        /// </summary>
        /// <param name="mobilePhoneNumber">注册时使用的手机号</param>
        /// <param name="cancellationToken">cancellationToken</param>
        /// <returns></returns>
        public static Task RequestPasswordResetBySmsCode(string mobilePhoneNumber, CancellationToken cancellationToken) {
            return RequestPasswordResetBySmsCode(mobilePhoneNumber, null, cancellationToken);
        }

        /// <summary>
        ///  请求重置密码，需要传入注册时使用的手机号。
        /// </summary>
        /// <param name="mobilePhoneNumber">注册时使用的手机号</param>
        /// <param name="validateToken">Validate token.</param>
        /// <returns></returns>
        public static Task RequestPasswordResetBySmsCode(string mobilePhoneNumber, string validateToken) {
            return RequestPasswordResetBySmsCode(mobilePhoneNumber, validateToken, CancellationToken.None);
        }

        /// <summary>
        ///  请求重置密码，需要传入注册时使用的手机号。
        /// </summary>
        /// <param name="mobilePhoneNumber">注册时使用的手机号</param>
        /// <param name="validateToken">Validate token.</param>
        /// <param name="cancellationToken">cancellationToken</param>
        /// <returns></returns>
        public static Task RequestPasswordResetBySmsCode(string mobilePhoneNumber, string validateToken, CancellationToken cancellationToken) {
            string currentSessionToken = AVUser.CurrentSessionToken;
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "mobilePhoneNumber", mobilePhoneNumber },
            };
            if (string.IsNullOrEmpty(validateToken)) {
                strs.Add("validate_token", validateToken);
            }
            var command = new AVCommand("requestPasswordResetBySmsCode", "POST", currentSessionToken, data: strs);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 通过验证码重置密码。
        /// </summary>
        /// <param name="newPassword">新密码</param>
        /// <param name="smsCode">6位数验证码</param>
        /// <returns></returns>
        public static Task<bool> ResetPasswordBySmsCodeAsync(string newPassword, string smsCode) {
            return AVUser.ResetPasswordBySmsCodeAsync(newPassword, smsCode, CancellationToken.None);
        }

        /// <summary>
        /// 通过验证码重置密码。
        /// </summary>
        /// <param name="newPassword">新密码</param>
        /// <param name="smsCode">6位数验证码</param>
        /// <param name="cancellationToken">cancellationToken</param>
        /// <returns></returns>
        public static Task<bool> ResetPasswordBySmsCodeAsync(string newPassword, string smsCode, CancellationToken cancellationToken) {
            string currentSessionToken = AVUser.CurrentSessionToken;
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "password", newPassword }
            };
            var command = new AVCommand("resetPasswordBySmsCode/" + smsCode, "PUT", currentSessionToken, data: strs);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 发送认证码到需要认证的手机上
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <returns></returns>
        public static Task<bool> RequestMobilePhoneVerifyAsync(string mobilePhoneNumber) {
            return RequestMobilePhoneVerifyAsync(mobilePhoneNumber, null, CancellationToken.None);
        }

        /// <summary>
        /// 发送认证码到需要认证的手机上
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="validateToken">Validate token.</param>
        /// <returns></returns>
        public static Task<bool> RequestMobilePhoneVerifyAsync(string mobilePhoneNumber, string validateToken) {
            return RequestMobilePhoneVerifyAsync(mobilePhoneNumber, validateToken, CancellationToken.None);
        }

        /// <summary>
        /// 发送认证码到需要认证的手机上
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="cancellationToken">CancellationToken</param>
        /// <returns></returns>
        public static Task<bool> RequestMobilePhoneVerifyAsync(string mobilePhoneNumber, CancellationToken cancellationToken) {
            return RequestMobilePhoneVerifyAsync(mobilePhoneNumber, null, cancellationToken);
        }

        /// <summary>
        /// 发送认证码到需要认证的手机上
        /// </summary>
        /// <param name="mobilePhoneNumber">手机号</param>
        /// <param name="validateToken">Validate token.</param>
        /// <param name="cancellationToken">CancellationToken</param>
        /// <returns></returns>
        public static Task<bool> RequestMobilePhoneVerifyAsync(string mobilePhoneNumber, string validateToken, CancellationToken cancellationToken) {
            string currentSessionToken = CurrentSessionToken;
            Dictionary<string, object> strs = new Dictionary<string, object>()
            {
                { "mobilePhoneNumber", mobilePhoneNumber }
            };
            if (string.IsNullOrEmpty(validateToken)) {
                strs.Add("validate_token", validateToken);
            }
            var command = new AVCommand("requestMobilePhoneVerify", "POST", currentSessionToken, data: strs);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 验证手机验证码是否为有效值
        /// </summary>
        /// <param name="code">手机收到的验证码</param>
        /// <param name="mobilePhoneNumber">手机号，可选</param>
        /// <returns></returns>
        public static Task<bool> VerifyMobilePhoneAsync(string code, string mobilePhoneNumber) {
            var command = new AVCommand("verifyMobilePhone/" + code.Trim() + "?mobilePhoneNumber=" + mobilePhoneNumber.Trim(),
                "POST",
                null,
                data: null);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        /// 验证手机验证码是否为有效值
        /// </summary>
        /// <param name="code">手机收到的验证码</param>
        /// <returns></returns>
        public static Task<bool> VerifyMobilePhoneAsync(string code) {
            var command = new AVCommand("verifyMobilePhone/" + code.Trim(),
                "POST",
                null,
                data: null);

            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }

        /// <summary>
        ///  验证手机验证码是否为有效值
        /// </summary>
        /// <param name="code">手机收到的验证码</param>
        /// <param name="cancellationToken">cancellationToken</param>
        /// <returns></returns>
        public static Task<bool> VerifyMobilePhoneAsync(string code, CancellationToken cancellationToken) {
            return VerifyMobilePhoneAsync(code, CancellationToken.None);
        }

        #endregion

        #region 邮箱验证
        /// <summary>
        /// 申请发送验证邮箱的邮件，一周之内有效
        /// 如果该邮箱已经验证通过，会直接返回 True，并不会真正发送邮件
        /// 注意，不能频繁的调用此接口，一天之内只允许向同一个邮箱发送验证邮件 3 次，超过调用次数，会直接返回错误
        /// </summary>
        /// <param name="email">邮箱地址</param>
        /// <returns></returns>
        public static Task<bool> RequestEmailVerifyAsync(string email) {
            Dictionary<string, object> strs = new Dictionary<string, object> {
                { "email", email }
            };
            var command = new AVCommand("requestEmailVerify",
                "POST",
                null,
                data: strs);
            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).ContinueWith(t => {
                return AVClient.IsSuccessStatusCode(t.Result.Item1);
            });
        }
        #endregion

        #region in no-local-storage enviroment

        internal Task Create() {
            return Create(CancellationToken.None);
        }

        internal Task Create(CancellationToken cancellationToken) {
            return taskQueue.Enqueue(toAwait => Create(toAwait, cancellationToken),
               cancellationToken);
        }

        internal Task Create(Task toAwait, CancellationToken cancellationToken) {
            if (AuthData == null) {
                // TODO (hallucinogen): make an Extension of Task to create Task with exception/canceled.
                if (string.IsNullOrEmpty(Username)) {
                    TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
                    tcs.TrySetException(new InvalidOperationException("Cannot sign up user with an empty name."));
                    return tcs.Task;
                }
                if (string.IsNullOrEmpty(Password)) {
                    TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
                    tcs.TrySetException(new InvalidOperationException("Cannot sign up user with an empty password."));
                    return tcs.Task;
                }
            }
            if (!string.IsNullOrEmpty(ObjectId)) {
                TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
                tcs.TrySetException(new InvalidOperationException("Cannot sign up a user that already exists."));
                return tcs.Task;
            }

            IDictionary<string, IAVFieldOperation> currentOperations = StartSave();

            return toAwait.OnSuccess(_ => {
                return UserController.SignUpAsync(State, currentOperations, cancellationToken);
            }).Unwrap().ContinueWith(t => {
                if (t.IsFaulted || t.IsCanceled) {
                    HandleFailedSave(currentOperations);
                } else {
                    var serverState = t.Result;
                    HandleSave(serverState);
                }
                return t;
            }).Unwrap();
        }
        #endregion


        #region task session token for http request
        internal static Task<string> TakeSessionToken(string sesstionToken = null) {
            var sessionTokenTask = Task.FromResult(sesstionToken);
            if (sesstionToken == null)
                sessionTokenTask = AVUser.GetCurrentAsync().OnSuccess(u => {
                    if (u.Result != null)
                        return u.Result.SessionToken;
                    return null;
                });
            return sessionTokenTask;
        }
        #endregion


        #region AVUser Extension
        public IDictionary<string, IDictionary<string, object>> GetAuthData() {
            return AuthData;
        }

        /// <summary>
        /// use 3rd auth data to sign up or log in.if user with the same auth data exits,it will transfer as log in.
        /// </summary>
        /// <param name="data">OAuth data, like {"accessToken":"xxxxxx"}</param>
        /// <param name="platform">auth platform,maybe "facebook"/"twiiter"/"weibo"/"weixin" .etc</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public static Task<AVUser> LogInWithAuthDataAsync(IDictionary<string, object> data,
            string platform,
            AVUserAuthDataLogInOption options = null,
            CancellationToken cancellationToken = default) {
            if (options == null) {
                options = new AVUserAuthDataLogInOption();
            }
            return LogInWithAsync(platform, data, options.FailOnNotExist, cancellationToken);
        }

        public static Task<AVUser> LogInWithAuthDataAndUnionIdAsync(
            IDictionary<string, object> authData,
            string platform,
            string unionId,
            AVUserAuthDataLogInOption options = null,
            CancellationToken cancellationToken = default) {
            if (options == null) {
                options = new AVUserAuthDataLogInOption();
            }
            MergeAuthData(authData, unionId, options);
            return LogInWithAsync(platform, authData, options.FailOnNotExist, cancellationToken);
        }

        public static Task<AVUser> LogInAnonymouslyAsync(CancellationToken cancellationToken = default) {
            var data = new Dictionary<string, object> {
                { "id", Guid.NewGuid().ToString() }
            };
            var options = new AVUserAuthDataLogInOption();
            return LogInWithAuthDataAsync(data, "anonymous", options, cancellationToken);
        }

        [Obsolete("please use LogInWithAuthDataAsync instead.")]
        public static Task<AVUser> LogInWithAsync(string authType, IDictionary<string, object> data, CancellationToken cancellationToken) {
            return LogInWithAsync(authType, data, false, cancellationToken);
        }

        /// <summary>
        /// link a 3rd auth account to the user.
        /// </summary>
        /// <param name="data">OAuth data, like {"accessToken":"xxxxxx"}</param>
        /// <param name="platform">auth platform,maybe "facebook"/"twiiter"/"weibo"/"weixin" .etc</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public Task AssociateAuthDataAsync(IDictionary<string, object> data, string platform, CancellationToken cancellationToken = default) {
            return LinkWithAsync(platform, data, cancellationToken);
        }

        public Task AssociateAuthDataAndUnionIdAsync(
            IDictionary<string, object> authData,
            string platform,
            string unionId,
            AVUserAuthDataLogInOption options = null,
            CancellationToken cancellationToken = default) {
            if (options == null) {
                options = new AVUserAuthDataLogInOption();
            }
            MergeAuthData(authData, unionId, options);
            return LinkWithAsync(platform, authData, cancellationToken);
        }

        /// <summary>
        /// unlink a 3rd auth account from the user.
        /// </summary>
        /// <param name="platform">auth platform,maybe "facebook"/"twiiter"/"weibo"/"weixin" .etc</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public Task DisassociateWithAuthDataAsync(string platform, CancellationToken cancellationToken = default) {
            return UnlinkFromAsync(platform, cancellationToken);
        }

        /// 合并为支持 AuthData 的格式
        static void MergeAuthData(IDictionary<string, object> authData, string unionId, AVUserAuthDataLogInOption options) {
            authData["platform"] = options.UnionIdPlatform;
            authData["main_account"] = options.AsMainAccount;
            authData["unionid"] = unionId;
        }
        #endregion
    }
}