YandexMusic/YandexMusic.API/API/YUserAPIAsync.cs

using System.Security.Authentication;
using System.Text.RegularExpressions;

using YandexMusic.API.Common;
using YandexMusic.API.Models.Account;
using YandexMusic.API.Models.Common;
using YandexMusic.API.Requests.Account;

namespace YandexMusic.API
{
    /// <summary>
    /// API для пользователя
    /// </summary>
    public partial class YUserAPI : YCommonAPI
    {
        #region Вспомогательные функции

        private async Task<bool> GetCsrfTokenAsync(AuthStorage storage)
        {
            using HttpResponseMessage authMethodsResponse = await new YGetAuthMethodsBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            if (!authMethodsResponse.IsSuccessStatusCode)
                throw new HttpRequestException("Невозможно получить CFRF-токен.");

            string responseString = await authMethodsResponse.Content
                .ReadAsStringAsync();
            Match match = Regex.Match(responseString, "\"csrf_token\" value=\"([^\"]+)\"");

            if (!match.Success || match.Groups.Count < 2)
                return false;

            storage.AuthToken = new YAuthToken
            {
                CsfrToken = match.Groups[1].Value
            };

            return true;
        }

        private async Task<bool> LoginByCookiesAsync(AuthStorage storage)
        {
            if (storage.AuthToken == null)
                throw new AuthenticationException("Невозможно инициализировать сессию входа.");

            YAccessToken accessToken = await new YGetAuthCookiesBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            storage.IsAuthorized = !string.IsNullOrEmpty(accessToken.AccessToken);

            storage.AccessToken = accessToken;
            storage.Token = accessToken.AccessToken;

            YShortAccountInfo validateTokenResponse = await new YGetShortAccountInifoBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            if (validateTokenResponse.Status != YAuthStatus.Ok)
                throw new Exception("Вход в аккаунт не выполнен.");

            storage.IsAuthorized = !string.IsNullOrWhiteSpace(validateTokenResponse.Uid);

            return storage.IsAuthorized;
        }

        #endregion Вспомогательные функции



        public YUserAPI(YandexMusicApi yandex) : base(yandex)
        {
        }

        /// <summary>
        /// Авторизация
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <param name="token">Токен авторизации</param>
        /// <returns></returns>
        public async Task AuthorizeAsync(AuthStorage storage, string token)
        {
            if (string.IsNullOrEmpty(token))
                throw new Exception("Задан пустой токен авторизации.");

            storage.Token = token;

            // Пытаемся получить информацию о пользователе
            YResponse<YAccountResult> authInfo = await GetUserAuthAsync(storage);

            // Если не авторизован, то авторизуем
            if (string.IsNullOrEmpty(authInfo.Result.Account.Uid))
                throw new Exception("Пользователь незалогинен.");

            // Флаг авторизации
            storage.IsAuthorized = true;
            storage.User = authInfo.Result.Account;
        }

        /// <summary>
        /// Получение информации об авторизации
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public Task<YResponse<YAccountResult>> GetUserAuthAsync(AuthStorage storage)
        {
            return new YGetAuthInfoBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();
        }

        /// <summary>
        /// Создание сеанса и получение доступных методов авторизации
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <param name="userName">Имя пользователя</param>
        /// <returns></returns>
        public async Task<YAuthTypes> CreateAuthSessionAsync(AuthStorage storage, string userName)
        {
            if (!await GetCsrfTokenAsync(storage))
                throw new Exception("Невозможно инициализировать сессию входа.");

            YAuthTypes types = await new YGetAuthLoginUserBuilder(api, storage)
                .Build((storage.AuthToken.CsfrToken, userName))
                .GetResponseAsync();

            storage.AuthToken.TrackId = types.TrackId;

            return types;
        }

        /// <summary>
        /// Получение ссылки на QR-код
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public async Task<string> GetAuthQRLinkAsync(AuthStorage storage)
        {
            if (!await GetCsrfTokenAsync(storage))
                throw new Exception("Невозможно инициализировать сессию входа.");

            YAuthQR result = await new YGetAuthQRBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            if (result.Status != YAuthStatus.Ok)
                return string.Empty;

            storage.AuthToken = new YAuthToken
            {
                TrackId = result.TrackId,
                CsfrToken = result.CsrfToken
            };

            return $"https://passport.yandex.ru/auth/magic/code/?track_id={result.TrackId}";
        }

        /// <summary>
        /// Авторизация по QR-коду
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public async Task<YAuthQRStatus> AuthorizeByQRAsync(AuthStorage storage)
        {
            if (storage.AuthToken == null)
                throw new Exception("Не выполнен запрос на авторизацию по QR.");

            try
            {
                YAuthQRStatus qrStatus = await new YGetAuthLoginQRBuilder(api, storage)
                    .Build(null)
                    .GetResponseAsync();
                if (qrStatus.Status != YAuthStatus.Ok)
                    return qrStatus;

                bool ok = await LoginByCookiesAsync(storage);
                if (!ok)
                    throw new AuthenticationException("Ошибка авторизации по QR.");

                return qrStatus;
            }
            catch (Exception ex)
            {
                throw new AuthenticationException("Ошибка авторизации по QR.", ex);
            }
        }

        /// <summary>
        /// Получение <see cref="YAuthCaptcha"/>
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public Task<YAuthCaptcha> GetCaptchaAsync(AuthStorage storage)
        {
            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");

            return new YGetAuthCaptchaBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();
        }

        /// <summary>
        /// Авторизация по captcha
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <param name="captchaValue">Значение captcha</param>
        /// <returns></returns>
        public Task<YAuthBase> AuthorizeByCaptchaAsync(AuthStorage storage, string captchaValue)
        {
            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");

            return new YGetAuthLoginCaptchaBuilder(api, storage)
                .Build(captchaValue)
                .GetResponseAsync();
        }

        /// <summary>
        /// Получение письма авторизации на почту пользователя
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public Task<YAuthLetter> GetAuthLetterAsync(AuthStorage storage)
        {
            return new YGetAuthLetterBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();
        }

        /// <summary>
        /// Авторизация после подтверждения входа через письмо
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <returns></returns>
        public async Task<bool> AuthorizeByLetterAsync(AuthStorage storage)
        {
            YAuthLetterStatus status = await new YGetAuthLoginLetterBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            if (status.Status == YAuthStatus.Ok && !status.MagicLinkConfirmed)
                throw new Exception("Не подтвержден вход посредством e-mail.");

            return await LoginByCookiesAsync(storage);
        }

        /// <summary>
        /// Авторизация с помощью пароля из приложения Яндекс
        /// </summary>
        /// <param name="storage">Хранилище</param>
        /// <param name="password">Пароль</param>
        /// <returns></returns>
        public async Task<YAuthBase> AuthorizeByAppPasswordAsync(AuthStorage storage, string password)
        {
            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");

            YAuthBase response = await new YGetAuthAppPasswordBuilder(api, storage)
                .Build(password)
                .GetResponseAsync();

            if (response.Status == YAuthStatus.Ok)
            {
                bool ok = await LoginByCookiesAsync(storage);
                if (!ok)
                    throw new AuthenticationException("Ошибка авторизации.");
            }

            return response;
        }

        /// <summary>
        /// Получение <see cref="YAccessToken"/> после авторизации с помощью QR, e-mail, пароля из приложения
        /// </summary>
        public async Task<YAccessToken> GetAccessTokenAsync(AuthStorage storage)
        {
            if (storage.AuthToken == null)
                throw new Exception("Не найдена сессия входа.");

            YAccessToken accessToken = await new YGetMusicTokenBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();

            storage.Token = accessToken.AccessToken;

            return accessToken;
        }

        /// <summary>
        /// Получение информации о пользователе через логин Яндекса
        /// </summary>
        public Task<YLoginInfo> GetLoginInfoAsync(AuthStorage storage)
        {
            return new YGetLoginInfoBuilder(api, storage)
                .Build(null)
                .GetResponseAsync();
        }


    }
}