public static SyncConfiguration GetConfig(string login = null, string password = null)
{
if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password))
{
login = Task.Run(() => SecureStorage.GetAsync(LOGIN)).Result;
password = Task.Run(() => SecureStorage.GetAsync(PASSWORD)).Result;
}
var app = Realms.Sync.App.Create(Constants.AppId);
var user = Task.Run(() => app.LogInAsync(Credentials.EmailPassword(login, password))).Result;
var userCustomData = user.GetCustomData <CustomUserData>();
return(new SyncConfiguration(userCustomData.DredgeId, user));
}
public async void GenerateAccount3_Clicked(System.Object sender, System.EventArgs e)
{
createaccounts(helper.StorageAccountName3);
GenerateAccount3.Text = helper.StorageAccountName3 + " created";
GenerateAccount3.IsEnabled = false;
GetAccount3Info.IsVisible = true;
GenerateAccount3p.Text = helper.StorageAccountName3 + " created";
GenerateAccount3p.IsEnabled = false;
GetAccount3Infop.IsVisible = true;
var network = await SecureStorage.GetAsync(helper.StorageNetwork);
// DisableNetworkToggles(network);
buttonstate();
}
protected override void OnStart()
{
SessionManager.Username = SecureStorage.GetAsync("usn").Result;
SessionManager.Password = SecureStorage.GetAsync("psw").Result;
if (string.IsNullOrEmpty(SessionManager.Username) || string.IsNullOrEmpty(SessionManager.Password))
{
IsLoginPage = true;
MainPage = new LoginView();
}
else
{
IsLoginPage = false;
MainPage = new NavigationPage(new MainView());
}
}
public async Task Saves_And_Loads(string key, string data)
{
#if __IOS__
// Try the new platform specific api
await SecureStorage.SetAsync(key, data, Security.SecAccessible.AfterFirstUnlock);
var b = await SecureStorage.GetAsync(key);
Assert.Equal(data, b);
#endif
await SecureStorage.SetAsync(key, data);
var c = await SecureStorage.GetAsync(key);
Assert.Equal(data, c);
}
public string GetData(SecureDataType dataType)
{
try
{
return(SecureStorage.GetAsync(dataType.ToString()).Result);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
return(null);
//var prefs = PreferenceManager.GetDefaultSharedPreferences(context);
//return prefs.GetString(dataType.ToString(), null);
}
//protected override async void OnAppearing()
//{
// base.OnAppearing();
// string password = null;
// string username = null;
// try
// {
// var oauthToken = await SecureStorage.GetAsync("oauth_token1");
// //password = oauthToken;
// //string hemuli = "3";
// if (oauthToken != null)
// {
// string[] nameParts = oauthToken.ToString().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
// username = nameParts[0].ToString();
// password = nameParts[1].ToString();
// //await DisplayAlert("", "Toimii", "Close");
// if (!string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(username))
// {
// HttpClient client = new HttpClient();
// var uri = new Uri(string.Format("https://joonanmobiili.azurewebsites.net/api/login?username="******"&password="******"application/json"));
// HttpResponseMessage response = await client.GetAsync(uri);
// if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
// {
// // var errorMessage1 = response.Content.ReadAsStringAsync().Result.Replace("\\", "").Trim(new char[1]
// // {
// //'"'
// // });
// // await DisplayAlert("", errorMessage1, "Close");
// // //Toast.MakeText(this, errorMessage1, ToastLength.Long).Show();
// await Navigation.PushAsync(new EmployeePage());
// }
// else
// {
// var errorMessage1 = response.Content.ReadAsStringAsync().Result.Replace("\\", "").Trim(new char[1]
// {
// '"'
// });
// await DisplayAlert("", errorMessage1, "Close");
// //Toast.MakeText(this, errorMessage1, ToastLength.Long).Show();
// }
// }
// }
// }
// catch
// {
// await DisplayAlert("AutoKirjautuminen", "oath token ei onnaa", "Close");
// }
// //await DisplayAlert("", "asdgasdg", "Close");
//}
protected async void AutoKirjautuminen()
{
string password = null;
string username = null;
try
{
var oauthToken = await SecureStorage.GetAsync("oauth_token1");
if (oauthToken != null)
{
string[] nameParts = oauthToken.ToString().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
username = nameParts[0].ToString();
password = nameParts[1].ToString();
if (!string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(username))
{
HttpClient client = new HttpClient();
var uri = new Uri(string.Format("https://joonanmobiili.azurewebsites.net/api/login?username="******"&password="******"application/json"));
HttpResponseMessage response = await client.GetAsync(uri);
if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
{
await Navigation.PushAsync(new EmployeePage());
await DisplayAlert("", "Tervetuloa takaisin " + username + "!", "Kiitos");
}
else
{
var errorMessage1 = response.Content.ReadAsStringAsync().Result.Replace("\\", "").Trim(new char[1]
{
'"'
});
await DisplayAlert("", errorMessage1, "Close");
}
}
}
else
{
ohitus = false;
}
}
catch
{
await DisplayAlert("AutoKirjautuminen", "oath token ei onnaa", "Close");
}
}
public GrupoDetailsViewModel(INavigationService navigationService, IGruposRegionRepository gruposRegionRepository,
IGrupoPokemonsRepository grupoPokemonsRepository)
: base(navigationService)
{
_navigationService = navigationService;
_gruposRegionRepository = gruposRegionRepository;
_grupoPokemonsRepository = grupoPokemonsRepository;
#region Commands Logic
DeleteGroup = new Command(async(obj) =>
{
var action = await App.Current.MainPage.DisplayAlert("Warning", "Do you want to delete this group?", "Yes", "No");
if (action)
{
UserDialogs.Instance.ShowLoading(null, MaskType.Clear);
//delete pokemons that belong to this group
await _grupoPokemonsRepository.DeteleDataByGrupoId(GroupId);
//then, delete group
await _gruposRegionRepository.DeleteData(GroupId, await SecureStorage.GetAsync("UserId"), string.Empty);
UserDialogs.Instance.HideLoading();
await App.Current.MainPage.DisplayAlert("Success",
"Your group was deleted successfully", "ok");
var navigationParams = new NavigationParameters();
navigationParams.Add("DeletedGrupoId", GroupId);
await _navigationService.GoBackAsync(navigationParams);
}
});
ModifyGroup = new Command(async(obj) =>
{
var navigationParams = new NavigationParameters();
navigationParams.Add("GruposRegion", GruposRegion);
navigationParams.Add("IsCreate", false);
navigationParams.Add("PokemonsAdded", PokemonsAdded);
await _navigationService.NavigateAsync("PokemonRegionView", navigationParams);
});
#endregion
}
protected override async void OnStart()
{
#pragma warning disable CS0612 // Type or member is obsolete
try
{
string username = await SecureStorage.GetAsync("username");
string password = await SecureStorage.GetAsync("password");
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
APIService.Username = username;
APIService.Password = password;
if (Connectivity.NetworkAccess >= NetworkAccess.Local)
{
try
{
APIService.CurrentUser = await _service.Get <Model.Users>(null, "MyProfile");
if ((await APIService.GetCurrentUser()).Role.Name == "User")
{
Current.MainPage = new MainPage();
return;
}
await Current.MainPage.DisplayAlert("Error", "Error logging in.", "OK");
}
catch (Exception)
{
await Current.MainPage.DisplayAlert("Error", "Session has expired. Please log in again.", "OK");
}
}
else
{
Current.MainPage = new MainPage();
return;
}
}
}
catch (Exception)
{
// Possible that device doesn't support secure storage on device.
}
Current.MainPage = new LoginPage();
}
public static async Task <WebServiceResault> inf_CallWebServiceAsync <WebServiceResault, post_data>(inf_method method, string url, post_data data = default(post_data))
{
var oauthToken = await SecureStorage.GetAsync("oauth_token");
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", oauthToken);
client.BaseAddress = new Uri(url);
try
{
HttpResponseMessage response;
switch (method)
{
case inf_method.Get:
response = await client.GetAsync(client.BaseAddress);
break;
case inf_method.Post:
string json = JsonConvert.SerializeObject(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");
response = await client.PostAsync(client.BaseAddress, content);
break;
default:
response = null;
break;
}
response.EnsureSuccessStatusCode();
var jsonResult = response.Content.ReadAsStringAsync().Result;
WebServiceResault result = JsonConvert.DeserializeObject <WebServiceResault>(jsonResult);
return(result);
}
catch (HttpRequestException e)
{
System.Diagnostics.Debug.WriteLine(e);
inf_mobile_exception_managerAsync(e.Message);
return(default(WebServiceResault));
}
}
private async Task SetMeetup(object obj)
{
if (IsBusy)
{
return;
}
IsBusy = true;
string id1 = await SecureStorage.GetAsync("ID");
var Uri1 = new Uri("https://server-cy3lzdr3na-uc.a.run.app/user/" + id1);
string Data1 = await RestService.Read(Uri1);
var users1 = JsonConvert.DeserializeObject <List <User> >(Data1);
var User1 = users1.Find(user => user.Id == id1);
User1.Busy = true;
await RestService.Update(User1, Uri1);
string id2 = obj as string;
var Uri2 = new Uri("https://server-cy3lzdr3na-uc.a.run.app/user/" + id2);
string Data2 = await RestService.Read(Uri2);
var users2 = JsonConvert.DeserializeObject <List <User> >(Data2);
var User2 = users2.Find(user => user.Id == id2);
User2.Busy = true;
await RestService.Update(User2, Uri2);
var Uri = new Uri("https://server-cy3lzdr3na-uc.a.run.app/meetup/");
var Meetup = new Meetup();
Meetup.Id = id1 + id2;
Meetup.User1 = id1;
Meetup.User2 = id2;
Meetup.Time = DateTime.Now;
Meetup.User1Name = User1.Name;
Meetup.User2Name = User2.Name;
await RestService.Create(Meetup, Uri);
IsBusy = false;
await GetAvailableUsers();
await GetMeetups();
}
private async void FetchAndSetView(object sender, EventArgs e)
{
if (mRecyclerView.GetAdapter() != null)
{
await Task.Delay(2000);
}
var TempAllNotes = await NotesDatabase.GetAllNotesList();
AllNotes = new List <NoteModel>();
if (TempAllNotes != null)
{
string password = await SecureStorage.GetAsync("AppPassword");
if (password == null)
{
return;
}
for (int i = 0; i < TempAllNotes.Count; i++)
{
try
{
var DecryptionResult = DecryptionService.DecryptText(TempAllNotes[i].NoteContent, password);
if (DecryptionResult.Result)
{
TempAllNotes[i].NoteContent = DecryptionResult.DecryptedString;
AllNotes.Add(TempAllNotes[i]);
}
}
catch (Exception)
{
}
}
}
AllNotes = AllNotes.OrderByDescending(i => i.NoteLastModifiedTime.Ticks).ToList();
notesAdapter = new NotesAdapter(AllNotes);
notesAdapter.ItemClick += NotesAdapter_ItemClick;
if (mRecyclerView.GetAdapter() == null)
{
mRecyclerView.SetAdapter(notesAdapter);
}
else
{
mRecyclerView.SwapAdapter(notesAdapter, false);
}
IsLoading = false;
swipeContainer.Refreshing = false;
}
public async Task <ulong?> GetAccountBalance(string accountname)
{
Account account = null;
string myaddress = "";
string network = await SecureStorage.GetAsync(StorageNetwork);
if (!(accountname == StorageMultisig))
{
string mnemonic = await SecureStorage.GetAsync(accountname);
if (mnemonic != null)
{
if (mnemonic != " ")
{
account = new Account(mnemonic);
myaddress = account.Address.ToString();
}
}
}
else
{
// multisig address
myaddress = await SecureStorage.GetAsync(accountname);
}
algodApiInstance = await CreateApiInstance();
if (algodApiInstance != null)
{
if (String.IsNullOrEmpty(myaddress) || myaddress == " ")
{
}
else
{
// var task = algodApiInstance.AccountInformationAsync(myaddress);
// task.Wait();
// var accountinfo = task.Result;
Algorand.V2.Model.Account accountinfo = await algodApiInstance.AccountInformationAsync(myaddress);
if (accountinfo != null)
{
return((ulong?)accountinfo.Amount);
}
}
}
return((ulong?)0);
}
/// <summary>
/// Получить пользователя текущего сеанса.
/// </summary>
/// <returns>Данные о текущем пользователе или null</returns>
public async Task <UserModel> GetUserAsync()
{
var content = string.Empty;
try
{
// Получаем сериализованные данные подключёного пользователя из безопасного хранилища
content = await SecureStorage.GetAsync("ConnectedUser");
}
catch (Exception exp)
{
}
// Если контент не пустой,
// то десериализуем данные из JSON в объект данных о пользователе
return(string.IsNullOrEmpty(content) ? null
: JsonConvert.DeserializeObject <UserModel>(content));
}
/// <summary>
/// Generate a subheader for JPEG files.
/// </summary>
/// <param name="fileName">The filename of the jpg file to be sent.</param>
/// <param name="dBId">The DBId the image is associated with.</param>
/// <returns></returns>
private async static Task <byte[]> GenerateImageHeader(string fileName, string dBId)
{
byte[] headerData = new byte[imageHeaderSize];
byte[] username = Encoding.Unicode.GetBytes(CredentialManager.Username);
Array.Copy(username, headerData, username.Length);
byte[] password = Encoding.Unicode.GetBytes(await SecureStorage.GetAsync("password"));
Array.Copy(password, 0, headerData, maxUsernameSize, password.Length);
byte[] fileNameBytes = Encoding.Unicode.GetBytes(fileName);
Array.Copy(fileNameBytes, 0, headerData, maxUsernameSize + maxPasswordSize, fileNameBytes.Length);
byte[] dBIdBytes = Encoding.Unicode.GetBytes(dBId);
Array.Copy(dBIdBytes, 0, headerData, maxUsernameSize + maxPasswordSize + maxImageNameSize, dBIdBytes.Length);
return(headerData);
}
public virtual byte[] GetData(string name, bool secure)
{
try
{
if (secure)
{
// get the data
var data = Task.Run(async() => await SecureStorage.GetAsync(name)).Result;
return((string.IsNullOrEmpty(data)) ? null : Encoding.ASCII.GetBytes(data));
}
else
{
// open the file
name = GetPath(name);
if (!File.Exists(name))
{
return(null);
}
using (Stream stream = File.Open(name, FileMode.Open, FileAccess.Read))
{
using (var ms = new MemoryStream())
{
while (true)
{
byte[] d = new byte[1024];
int result = stream.Read(d, 0, 1024);
ms.Write(d, 0, result);
if (result < 1024)
{
break;
}
}
// deserialize
ms.Seek(0, SeekOrigin.Begin);
return(ms.ToArray());
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** LocalStorageServiceBase.GetData - Exception: {0}", ex));
return(null);
}
}
public virtual TEntity Get <TEntity>(string name, bool secure)
{
try
{
if (secure)
{
// get the data
var data = Task.Run(async() => await SecureStorage.GetAsync(name)).Result;
return((string.IsNullOrEmpty(data)) ? default(TEntity) : Serializer.Deserialize <TEntity>(data));
}
else
{
// open the file
name = GetPath(name);
if (!File.Exists(name))
{
return(default(TEntity));
}
using (Stream stream = File.Open(name, FileMode.Open, FileAccess.Read))
{
using (var ms = new MemoryStream())
{
while (true)
{
byte[] d = new byte[1024];
int result = stream.Read(d, 0, 1024);
ms.Write(d, 0, result);
if (result < 1024)
{
break;
}
}
// deserialize
ms.Seek(0, SeekOrigin.Begin);
byte[] data = ms.ToArray();
return(Serializer.Deserialize <TEntity>(System.Text.Encoding.UTF8.GetString(data, 0, data.Length)));
}
}
}
}
catch (FileNotFoundException fex)
{
return(default(TEntity));
}
}
/// <summary>
/// Attempts fetching all tokens from the cache.
/// </summary>
/// <param name="key">
/// Identifies the tokens (typically a client/app id).
/// </param>
/// <returns>
/// An <see cref="AuthResult"/> item.
/// </returns>
public override async Task <BoolValue <AuthResult> > TryGetAsync(string key = null)
{
key ??= DefaultKey;
var cached = await base.TryGetAsync(key);
if (cached || !_isRefreshTokenPersisted)
{
return(cached);
}
// look for persisted refresh token ...
var refreshToken = await SecureStorage.GetAsync(key);
return(refreshToken is null
? cached
: BoolValue <AuthResult> .Success(new AuthResult(_authConfig, _log, new TokenInfo(refreshToken, TokenRole.RefreshToken))));
}
public async Task SendMessage(object sender, System.EventArgs e)
{
await Connect();
var model = new MessageViewModel
{
MessageContent = MessageEntry.Text,
Receiver = Title,
Sender = await SecureStorage.GetAsync("currentUser")
};
await hubConnection.InvokeAsync("SendMessage", model);
await UpdateCurrentConvo(await SecureStorage.GetAsync("currentUser"), Title);
await Disconnect();
}
public async Task <Tuple <string, string> > GetToken()
{
string accessToken;
try
{
accessToken = await SecureStorage.GetAsync(AccessTokenKey);
AccessToken = accessToken;
}
catch (Exception)
{
return(null); // No token was found. User has yet to be authenticated
}
return(new Tuple <string, string>("Bearer", accessToken));
}
private async void InitializeForm()
{
try {
var registrationNumberSecure = await SecureStorage.GetAsync(REGISTRATION_NUMBER);
registrationNumber.Text = registrationNumberSecure;
} catch (Exception ex) {
}
university.Text = Preferences.Get(UNIVERSITY, "Universitatea");
name.Text = Preferences.Get(NAME, " ");
preName.Text = Preferences.Get(PRENAME, " ");
faculty.Text = Preferences.Get(FACULTY, " ");
specialization.Text = Preferences.Get(SPECIALIZATION, " ");
releaseDate.Date = Preferences.Get(RELEASE_DATE, DateTime.Now);
imageProfile.Source = Preferences.Get(IMAGE_PROFILE, " ");
imageSignature.Source = Preferences.Get(IMAGE_SIGNATURE, " ");
}
public async Task Saves_And_Loads(string key, string data, bool emulatePreApi23)
{
#if __ANDROID__
SecureStorage.AlwaysUseAsymmetricKeyStorage = emulatePreApi23;
#elif __IOS__
if (Utils.IsiOSSimulator)
{
return;
}
#endif
await SecureStorage.SetAsync(key, data);
var c = await SecureStorage.GetAsync(key);
Assert.Equal(data, c);
}
public async Task <bool> SignInSilentAsync()
{
var refreshToken = await SecureStorage.GetAsync(Constants.RefreshToken);
// If refresh token is available, the user has previously been logged in and we can get a refreshed access token immediately
if (!string.IsNullOrEmpty(refreshToken))
{
var authorizationHeader = await RequestAuthorizationAsync(refreshToken, true);
if (!string.IsNullOrEmpty(authorizationHeader))
{
return(true);
}
}
return(false);
}
public async void OnDialogOpened(IDialogParameters parameters)
{
_fromPage = parameters.GetValue <string>("fromPage");
var listLocJson = await SecureStorage.GetAsync("locations");
if (!string.IsNullOrEmpty(listLocJson))
{
_locations = JsonConvert.DeserializeObject <List <LocationModel> >(listLocJson);
}
else
{
_locations = new List <LocationModel>();
}
MainState = LayoutState.None;
}
private async Task PopulateCoverFlow(bool force = false)
{
images = await App.CarImagesManager.GetCarsImages(_car.Id, force);
soldCar = await App.CarsSoldManager.GetAll(force);
currentCar = soldCar.FirstOrDefault(x => x.CarId == _car.Id);
description.Text = currentCar.LongDescription;
carousel.ItemsSource = images;
BindingContext = _car;
user = await App.UserManager.GetUserById(currentCar.UserId);
var locations = await Geocoding.GetLocationsAsync(user.Address);
var location = locations?.FirstOrDefault();
if (location != null)
{
map.MoveToRegion(
MapSpan.FromCenterAndRadius(new Position(location.Latitude, location.Longitude), Distance.FromMeters(500)));
map.IsVisible = true;
}
var loggedUser = await SecureStorage.GetAsync("UserId");
if (Convert.ToInt32(loggedUser) == user.Id)
{
ToolbarItems.Add(new ToolbarItem("Edit", "edit_car_toolbar", () =>
{
Navigation.PushModalAsync(new SellDetailsModalPage(_car));
}));
ToolbarItems.Add(new ToolbarItem("Delete", "delete_car_toolbar", async() =>
{
var alert = await DisplayAlert("Are you sure?", "Are you sure you want to delete your post? You can always create a new one by going to your cars", "Yes", "No");
if (alert)
{
await App.CarsSoldManager.Delete(currentCar.Id);
await Navigation.PopAsync();
}
}));
}
}
private async Task SetResultAsync(FingerprintAuthenticationResult result)
{
if (result.Authenticated)
{
if (SecureStorage.GetAsync(App.FingerPass).Result == null)
{
if (SecureStorage.GetAsync(App.PasswordPass).Result == null)
{
App.LoginMethod = Enums.LoginMethodEnum.Fingerprint;
CreateButton.IsVisible = false;
await Navigation.PushAsync(new NotePage()).ConfigureAwait(true);
}
else
{
var hash = Crypto.ComputeSHA512Hash(PasswordEntry.Text);
try
{
string savedHash = await SecureStorage.GetAsync(key).ConfigureAwait(true);
if (savedHash == hash)
{
App.PassText = PasswordEntry.Text;
PasswordEntry.Text = "";
App.LoginMethod = Enums.LoginMethodEnum.Fingerprint;
await Navigation.PushAsync(new NotePage()).ConfigureAwait(true);
}
else
{
PasswordEntry.Text = "";
await DisplayAlert("Error", "Please provide correct password", "Ok");
}
}
catch (Exception ex) { }
}
}
else
{
App.LoginMethod = Enums.LoginMethodEnum.Fingerprint;
await Navigation.PushAsync(new NotePage()).ConfigureAwait(true);
}
}
else
{
await DisplayAlert("Finger not found :(", result.ErrorMessage, "Ok");
}
}
public LoginPage() : base()
{
InitializeComponent();
try
{
if (SecureStorage.GetAsync(key).Result != null || SecureStorage.GetAsync(App.FingerPass).Result != null)
{
CreateButton.IsVisible = false;
}
else
{
CreateButton.IsVisible = true;
}
}
catch {}
BindingContext = new LoginViewModel();
}
public async Task Remove_Key(string key, bool emulatePreApi23)
{
#if __ANDROID__
SecureStorage.AlwaysUseAsymmetricKeyStorage = emulatePreApi23;
#else
Utils.Unused(emulatePreApi23);
#endif
await SecureStorage.SetAsync(key, "Irrelevant Data");
var result = SecureStorage.Remove(key);
Assert.True(result);
var v = await SecureStorage.GetAsync(key);
Assert.Null(v);
}
async void SetearUsuaio()
{
var json = await SecureStorage.GetAsync("Usuario");
try
{
// Try to return deserialized of user
User user = JsonConvert.DeserializeObject <User>(json);
Apellidos = user.Apellidos;
Nombre = user.Nombre;
NroMatricula = user.NroMatricula;
Condicion = user.Condicion;
}
catch {
}
}
internal async void Initialize()
{
this.Username = await SecureStorage.GetAsync(LoginViewModel.UsernameKey);
this.Password = await SecureStorage.GetAsync(LoginViewModel.PasswordKey);
if (this.firstOpened)
{
if (!string.IsNullOrEmpty(this.Username) && !string.IsNullOrEmpty(this.Password))
{
App.Client = new Client(new CustomHttpClient(this.Username, this.Password));
await this.Continue();
}
this.firstOpened = false;
}
}
private async Task AddVote(int songId)
{
if (CurrentRoom == null)
{
return;
}
var jwtToken = await SecureStorage.GetAsync("jwtToken");
var client = new RestClient(@"https://partyplaylists.azurewebsites.net");
var request = new RestRequest($@"api/room/{CurrentRoom.Id}/{songId}", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Authorization", $"Bearer {jwtToken}");
var response = await client.ExecuteAsync(request);
}