/// <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;
//var authUserDetails = await GetUserAuthDetailsAsync(storage);
//var authUser = authUserDetails.User;
storage.User = authInfo.Result.Account;
}
/// <summary>
/// Получение ссылки для загрузки
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="track">Трек</param>
/// <returns></returns>
public string GetFileLink(AuthStorage storage, YTrack track)
{
var mainDownloadResponse = GetMetadataForDownload(storage, track).Result.First(m => m.Codec == "mp3");
var storageDownloadResponse = GetDownloadFileInfo(storage, mainDownloadResponse);
return(BuildLinkForDownload(mainDownloadResponse, storageDownloadResponse));
}
private void HandleChangeCharacter(GameSession session)
{
session.FieldManager.RemovePlayer(session, session.FieldPlayer);
DatabaseManager.UpdateCharacter(session.Player);
AuthData authData = AuthStorage.GetData(session.Player.AccountId);
session.SendFinal(MigrationPacket.GameToLogin(LoginEndpoint, authData));
}
public YandexClient( )
{
Log.Information("Connecting to Yandex Music...");
yAuthStorage = new AuthStorage( );
yandexMusicClient = new YandexMusicApi( );
yandexMusicClient.User.Authorize(yAuthStorage, Config.YMLogin, Config.YMPassword);
Log.Information("Connection to Yandex Music successful");
}
/// <summary>
/// Добавление трека
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="tracks">Треки для добавления</param>
/// <returns></returns>
public async Task <YResponse <YPlaylist> > InsertTracksAsync(AuthStorage storage, YPlaylist playlist, params YTrack[] tracks)
{
return(await ChangePlaylist(storage, playlist, new List <YPlaylistChange> {
new YPlaylistChange {
Operation = YPlaylistChangeType.Insert,
At = 0,
Tracks = tracks.Select(t => t.GetKey()).ToList()
}
})
.ContinueWith(p => Get(storage, p.Result.Result)));
}
public YandexTestHarness()
{
AppSettings = GetAppSettings();
Storage = new AuthStorage(new DebugSettings("responses", "log.txt")
{
ClearDirectory = true
});
API = new YandexMusicApi();
}
public override void Handle(GameSession session, PacketReader packet)
{
byte function = packet.ReadByte();
if (function == 0)
{
session.FieldManager.RemovePlayer(session, session.FieldPlayer);
AuthData authData = AuthStorage.GetData(session.Player.AccountId);
session.SendFinal(MigrationPacket.GameToLogin(loginEndpoint, authData));
}
}
/// <summary>
/// Выгрузка в файл
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
/// <param name="filePath">Путь для файла</param>
public void ExtractToFile(AuthStorage storage, string trackKey, string filePath)
{
var fileLink = GetFileLink(storage, trackKey);
try {
using (var client = new WebClient()) {
client.DownloadFile(fileLink, filePath);
}
}
catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}
protected override T GetAccount <T>(string identifier)
{
try
{
var data = AuthStorage.GetSecured(identifier, ClientId, ClientSecret, SharedGroupAccess);
return(string.IsNullOrWhiteSpace(data) ? null : (T)(object)Deserialize <SoundCloudAccount>(data));
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
return(base.GetAccount <T>(identifier));
}
/// <summary>
/// Удаление
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="kinds">Тип</param>
/// <returns></returns>
public async Task <bool> DeleteAsync(AuthStorage storage, string kinds)
{
try {
await new YPlaylistRemoveRequest(api, storage)
.Create(kinds)
.GetResponseAsync();
return(true);
}
catch (Exception ex) {
Console.WriteLine(ex);
}
return(false);
}
/// <summary>
/// Получение двоичного массива данных
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
/// <returns></returns>
public byte[] ExtractData(AuthStorage storage, string trackKey)
{
var fileLink = GetFileLink(storage, trackKey);
var bytes = default(byte[]);
try {
using (var client = new WebClient()) {
bytes = client.DownloadData(fileLink);
}
}
catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
return(bytes);
}
/// <summary>
/// Получение персональных плейлистов
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="type">Тип</param>
/// <returns>Плейлист</returns>
private async Task <YResponse <YPlaylist> > GetPersonalPlaylist(AuthStorage storage, YGeneratedPlaylistType type)
{
return(await LandingAsync(storage)
.ContinueWith(list =>
{
YPlaylist playlist = list.GetAwaiter().GetResult().Result.Blocks
.FirstOrDefault(b => b.Type == "personal-playlists")
?.Entities
.FirstOrDefault(e => e.Data.Type == type)
?.Data
.Data;
return playlist == null
? null
: Get(storage, playlist);
}));
}
protected override void HandleCommon(Session session, PacketReader packet)
{
long accountId = packet.ReadLong();
int tokenA = packet.ReadInt();
int tokenB = packet.ReadInt();
Logger.Info($"LOGIN USER: {accountId}");
AuthData authData = AuthStorage.GetData(accountId);
if (authData == null)
{
throw new ArgumentException("Attempted connection to game with unauthorized account");
}
else if (tokenA != authData.TokenA || tokenB != authData.TokenB)
{
throw new ArgumentException("Attempted login with invalid tokens...");
}
session.Send((byte)SendOp.MOVE_RESULT, 0x00, 0x00);
}
/// <summary>
/// Удаление треков
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="tracks">Треки для удаления</param>
/// <returns></returns>
public async Task <YResponse <YPlaylist> > DeleteTracksAsync(AuthStorage storage, YPlaylist playlist, params YTrack[] tracks)
{
List <YPlaylistChange> changes = RemoveIdentical(tracks)
.Select(t => playlist.Tracks.Select(c => c.Track).ToList().IndexOf(t))
.Where(i => i != -1)
.Select(i => {
YTrackContainer t = playlist.Tracks[i];
return(new YPlaylistChange {
Operation = YPlaylistChangeType.Delete,
From = i,
To = i + 1,
Tracks = new List <YTrackAlbumPair> {
t.Track.GetKey()
}
});
})
.ToList();
return(await ChangePlaylist(storage, playlist, changes));
}
public void HandleSelect(LoginSession session, PacketReader packet)
{
long charId = packet.ReadLong();
packet.ReadShort(); // 01 00
logger.Info($"Logging in to game with charId:{charId}");
var endpoint = new IPEndPoint(IPAddress.Loopback, GameServer.PORT);
var authData = new AuthData
{
TokenA = session.GetToken(),
TokenB = session.GetToken(),
CharacterId = charId,
};
// Write AuthData to storage shared with GameServer
AuthStorage.SetData(session.AccountId, authData);
session.Send(MigrationPacket.LoginToGame(endpoint, authData));
//LoginPacket.LoginError("message?");
}
static Clients( )
{
Log.Information("Connecting to Spotify...");
SpotifyClientConfig spotify_config = SpotifyClientConfig.CreateDefault( )
.WithAuthenticator(
new ClientCredentialsAuthenticator(
Config.SotifyClientID,
Config.SotifyClientSecret));
_spotify_client = new SpotifyClient(spotify_config);
Log.Information("Connection to Spotify successful");
Log.Information("Connecting to Yandex Music...");
_yAusthStorage = new AuthStorage( );
_yandex_music_client = new YandexMusicApi( );
_yandex_music_client.User.Authorize(_yAusthStorage, Config.YMLogin, Config.YMPassword);
Log.Information("Connection to Yandex Music successful");
}
public async Task СreateOrUpdateAuthStorageAsync(string id, string acessToken, string refresh)
{
var authStorage = new AuthStorage()
{
UserId = id,
AcessToken = acessToken,
RefreshToken = refresh
};
var filter = new BsonDocument("_id", id);
var user = await AuthStorages.Find(filter)
.FirstOrDefaultAsync();
if (user != null)
{
await UpdateAuthStorageAsync(id, acessToken, refresh);
return;
}
await AuthStorages.InsertOneAsync(authStorage);
}
public void HandleSelect(LoginSession session, PacketReader packet)
{
long charId = packet.ReadLong();
packet.ReadShort(); // 01 00
Logger.Info("Logging in to game with char id: {charId}", charId);
string ipAddress = Environment.GetEnvironmentVariable("IP");
int port = int.Parse(Environment.GetEnvironmentVariable("GAME_PORT"));
IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
AuthData authData = new AuthData
{
TokenA = LoginSession.GetToken(),
TokenB = LoginSession.GetToken(),
CharacterId = charId,
};
// Write AuthData to storage shared with GameServer
AuthStorage.SetData(session.AccountId, authData);
session.SendFinal(MigrationPacket.LoginToGame(endpoint, authData));
// LoginPacket.LoginError("message?");
}
/// <summary>
/// Изменение плейлиста
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="changes">Список изменений</param>
/// <returns>Плейлист после изменений</returns>
private async Task <YResponse <YPlaylist> > ChangePlaylist(AuthStorage storage, YPlaylist playlist, List <YPlaylistChange> changes)
{
return(await new YPlaylistChangeRequest(api, storage)
.Create(playlist, changes)
.GetResponseAsync <YResponse <YPlaylist> >());
}
/// <summary>
/// Удаление треков
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="tracks">Треки для удаления</param>
/// <returns></returns>
public YResponse <YPlaylist> DeleteTracks(AuthStorage storage, YPlaylist playlist, params YTrack[] tracks)
{
return(DeleteTracksAsync(storage, playlist, tracks).GetAwaiter().GetResult());
}
/// <summary>
/// Получение персональных списков
/// </summary>
/// <param name="storage">Хранилище</param>
/// <returns></returns>
public async Task <YResponse <YLanding> > LandingAsync(AuthStorage storage)
{
return(await new YGetPlaylistMainPageRequest(api, storage)
.Create()
.GetResponseAsync <YResponse <YLanding> >());
}
/// <summary>
/// Удаление
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <returns></returns>
public Task <bool> DeleteAsync(AuthStorage storage, YPlaylist playlist)
{
return(DeleteAsync(storage, playlist.Kind));
}
/// <summary>
/// Удаление
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <returns></returns>
public bool Delete(AuthStorage storage, YPlaylist playlist)
{
return(DeleteAsync(storage, playlist.Kind).GetAwaiter().GetResult());
}
/// <summary>
/// Удаление
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="kinds">Тип</param>
/// <returns></returns>
public bool Delete(AuthStorage storage, string kinds)
{
return(DeleteAsync(storage, kinds).GetAwaiter().GetResult());
}
/// <summary>
/// Переименование
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="kinds">Идентификатор плейлиста</param>
/// <param name="name">Заголовок</param>
/// <returns></returns>
public async Task <YResponse <YPlaylist> > RenameAsync(AuthStorage storage, string kinds, string name)
{
return(await new YPlaylistRenameRequest(api, storage)
.Create(kinds, name)
.GetResponseAsync <YResponse <YPlaylist> >());
}
/// <summary>
/// Переименование
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="name">Заголовок</param>
/// <returns></returns>
public YResponse <YPlaylist> Rename(AuthStorage storage, YPlaylist playlist, string name)
{
return(RenameAsync(storage, playlist.Kind, name).GetAwaiter().GetResult());
}
/// <summary>
/// Переименование
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="playlist">Плейлист</param>
/// <param name="name">Заголовок</param>
/// <returns></returns>
public Task <YResponse <YPlaylist> > RenameAsync(AuthStorage storage, YPlaylist playlist, string name)
{
return(RenameAsync(storage, playlist.Kind, name));
}
/// <summary>
/// Переименование
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="kinds">Идентификатор плейлиста</param>
/// <param name="name">Заголовок</param>
/// <returns></returns>
public YResponse <YPlaylist> Rename(AuthStorage storage, string kinds, string name)
{
return(RenameAsync(storage, kinds, name).GetAwaiter().GetResult());
}
/// <summary>
/// Получение персональных списков
/// </summary>
/// <param name="storage">Хранилище</param>
/// <returns></returns>
public YResponse <YLanding> Landing(AuthStorage storage)
{
return(LandingAsync(storage).GetAwaiter().GetResult());
}
/// <summary>
/// Создание
/// </summary>
/// <param name="storage">Хранилище</param>
/// <param name="name">Заголовок</param>
/// <returns></returns>
public YResponse <YPlaylist> Create(AuthStorage storage, string name)
{
return(CreateAsync(storage, name).GetAwaiter().GetResult());
}