public SpotifyAPI(string clientId, string secretId, string redirectUrl = "http://localhost:4002", Boolean authed = false)
{
_clientId = clientId;
_secretId = secretId;
if (!authed)
{
System.Diagnostics.Debug.WriteLine("Authorizing for the first time");
auth = new AuthorizationCodeAuth(
_clientId,
_secretId,
redirectUrl,
redirectUrl,
Scope.UserReadPrivate | Scope.UserReadCurrentlyPlaying | Scope.UserTopRead | Scope.Streaming | Scope.UserModifyPlaybackState | Scope.UserLibraryModify | Scope.UserReadPlaybackState | Scope.PlaylistReadPrivate | Scope.PlaylistModifyPrivate | Scope.PlaylistModifyPublic | Scope.UserLibraryRead
);
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
token = await auth.ExchangeCode(payload.Code);
api = new SpotifyWebAPI()
{
TokenType = token.TokenType,
AccessToken = token.AccessToken
};
App.Current.Properties["TokenType"] = api.TokenType;
App.Current.Properties["AccessToken"] = api.AccessToken;
};
auth.Start();
auth.OpenBrowser();
authed = true;
}
}
private void connectBtn_Click(object sender2, EventArgs e)
{
String clientId = clientIdTB.Text;
String clientSecret = clientSecretTB.Text;
if (clientId.Length > 0 && clientSecret.Length > 0)
{
AuthorizationCodeAuth auth = new AuthorizationCodeAuth(
clientId,
clientSecret,
"http://localhost:4002",
"http://localhost:4002",
Scope.PlaylistModifyPrivate | Scope.PlaylistModifyPublic | Scope.UserLibraryModify
);
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
SpotifyAPI = new SpotifyWebAPI()
{
TokenType = token.TokenType,
AccessToken = token.AccessToken
};
};
auth.Start(); // Starts an internal HTTP Server
auth.OpenBrowser();
}
else
{
messageLbl.Text = "Need both client secret and client Id. These can be found on your spotify developer page (free to create account).";
}
}
private static string _secretId = ""; //"";
static void Main(string[] args)
{
_clientId = string.IsNullOrEmpty(_clientId)
? System.Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID")
: _clientId;
_secretId = string.IsNullOrEmpty(_secretId)
? System.Environment.GetEnvironmentVariable("SPOTIFY_SECRET_ID")
: _secretId;
Console.WriteLine("####### Spotify API Example #######");
Console.WriteLine("This example uses AuthorizationCodeAuth.");
Console.WriteLine(
"Tip: If you want to supply your ClientID and SecretId beforehand, use env variables (SPOTIFY_CLIENT_ID and SPOTIFY_SECRET_ID)");
AuthorizationCodeAuth auth =
new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative);
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
/* ImplictGrantAuth auth = new ImplictGrantAuth("26d287105e31491889f3cd293d85bfea", "http://localhost:4002", "http://localhost:4002");
* auth.Start();
* auth.OpenBrowser();*/
Console.ReadLine();
auth.Stop(0);
}
private async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
api = new SpotifyWebAPI
{
AccessToken = token.AccessToken,
TokenType = token.TokenType
};
songInfo = await CurrentPlayingsong(api);
if (songInfo == "")
{
return;
}
HappiWebApi happiapi = new HappiWebApi(_HappiapiKey);
GetLyrics(happiapi, songInfo);
}
public SpotifyLoad()
{
auth = new AuthorizationCodeAuth(
_clientId,
_clientSecret,
"http://localhost:4002",
"http://localhost:4002",
Scope.UserReadCurrentlyPlaying | Scope.UserModifyPlaybackState
);
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
token = await auth.ExchangeCode(payload.Code);
api = new SpotifyWebAPI()
{
TokenType = token.TokenType,
AccessToken = token.AccessToken
};
Thread t = new Thread(spotifyDataLoop);
t.Start();
};
auth.Start(); // Starts an internal HTTP Server
auth.OpenBrowser();
}
public async void Init()
{
var _clientId = "4dab4bc197084c7db90f8201c5990abe";
var _secretId = "e5f5c68a50ff48068eb1bfea84cc57a4";
AuthorizationCodeAuth auth =
new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative);
auth.Start(); // Starts an internal HTTP Server
auth.OpenBrowser();
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
SpotifyWebAPI api = new SpotifyWebAPI()
{
TokenType = token.TokenType, AccessToken = token.AccessToken
};
// Do requests with API client
profile = await api.GetPrivateProfileAsync();
if (!profile.HasError())
{
Console.WriteLine(profile.DisplayName);
}
};
}
private static async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
api = new SpotifyWebAPI
{
AccessToken = token.AccessToken,
TokenType = token.TokenType
};
var result = GetsongInfo();
if (!result.IsSuccess)
{
Console.WriteLine("Song Not found.");
return;
}
songinfo = result.Date;
GetLyrics(songinfo);
}
private static async Task <SpotifyWebAPI> AuthSpotifyApi()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.Build();
AuthorizationCodeAuth auth =
new AuthorizationCodeAuth(
config.GetSection("SpotifyApi:ClientId").Value,
config.GetSection("SpotifyApi:ClientSecret").Value,
"http://localhost:6410",
"http://localhost:6410",
SpotifyAPI.Web.Enums.Scope.PlaylistReadCollaborative);
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
_spotifyWeb = new SpotifyWebAPI()
{
TokenType = token.TokenType, AccessToken = token.AccessToken
};
// Do requests with API client
};
auth.Start(); // Starts an internal HTTP Server
auth.OpenBrowser();
return(_spotifyWeb);
}
public async Task ConnectWebApi(bool keepRefreshToken = true)
{
_securityStore = SecurityStore.Load(pluginDirectory);
AuthorizationCodeAuth auth = new AuthorizationCodeAuth(_securityStore.ClientId, _securityStore.ClientSecret, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.UserReadCurrentlyPlaying | Scope.UserReadPlaybackState | Scope.UserModifyPlaybackState | Scope.Streaming | Scope.UserFollowModify);
if (_securityStore.HasRefreshToken && keepRefreshToken)
{
Token token = await auth.RefreshToken(_securityStore.RefreshToken);
_spotifyApi = new SpotifyWebAPI()
{
TokenType = token.TokenType, AccessToken = token.AccessToken
};
}
else
{
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
_securityStore.RefreshToken = token.RefreshToken;
_securityStore.Save(pluginDirectory);
_spotifyApi = new SpotifyWebAPI()
{
TokenType = token.TokenType, AccessToken = token.AccessToken
};
};
auth.Start();
auth.OpenBrowser();
}
}
private static string _secretId = "b482925b5391423d8f2466288819b822"; //"";
/*
* Client ID b2931def6f7a47a981a43ea5c9c20c9e
* Client Secret b482925b5391423d8f2466288819b822
*/
// ReSharper disable once UnusedParameter.Local
public static void Main(string[] args)
{
_clientId = string.IsNullOrEmpty(_clientId) ?
Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID") :
_clientId;
_secretId = string.IsNullOrEmpty(_secretId) ?
Environment.GetEnvironmentVariable("SPOTIFY_SECRET_ID") :
_secretId;
Console.WriteLine("####### Spotify API Example #######");
Console.WriteLine("This example uses AuthorizationCodeAuth.");
Console.WriteLine(
"Tip: If you want to supply your ClientID and SecretId beforehand, use env variables (SPOTIFY_CLIENT_ID and SPOTIFY_SECRET_ID)");
var auth =
new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.PlaylistModifyPrivate | Scope.Streaming | Scope.AppRemoteControl | Scope.PlaylistModifyPublic | Scope.PlaylistReadPrivate | Scope.UserTopRead);
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
Console.ReadLine();
auth.Stop(0);
}
// ReSharper disable once UnusedParameter.Local
static void Main(string[] args)
{
Environment.SetEnvironmentVariable("SPOTIFY_CLIENT_ID", "1f943e38b30c4a378c284f1ba0bafbf9");
Environment.SetEnvironmentVariable("SPOTIFY_SECRET_ID", "7c100ccbb9714e13948a788b943636e8");
_clientId = string.IsNullOrEmpty(_clientId)
? Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID")
: _clientId;
_secretId = string.IsNullOrEmpty(_secretId)
? Environment.GetEnvironmentVariable("SPOTIFY_SECRET_ID")
: _secretId;
Console.WriteLine("####### Spotify API Example #######");
Console.WriteLine("This example uses AuthorizationCodeAuth.");
Console.WriteLine(
"Tip: If you want to supply your ClientID and SecretId beforehand, use env variables (SPOTIFY_CLIENT_ID and SPOTIFY_SECRET_ID)");
AuthorizationCodeAuth auth = new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.AppRemoteControl | Scope.PlaylistModifyPrivate | Scope.PlaylistModifyPublic | Scope.UserReadPrivate | Scope.UserReadEmail | Scope.Streaming
| Scope.UserModifyPlaybackState | Scope.UserReadPlaybackState | Scope.UserReadRecentlyPlayed);
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
while (!end)
{
}
//Thread.Sleep(1000000000);
//Console.ReadLine();
auth.Stop(0);
}
private void iniciarModoStream()
{
try
{
Log.Instance.ImprimirMensaje("Intentando conectar cuenta de Spotify", TipoMensaje.Info, "Spotify.iniciarModoStream()");
Programa.HayInternet(true);
Stopwatch crono = Stopwatch.StartNew();
auth = new AuthorizationCodeAuth(
clavePublica,
clavePrivada,
"http://localhost:4002/",
"http://localhost:4002/",
Scope.UserReadEmail | Scope.UserReadPrivate | Scope.Streaming | Scope.UserReadPlaybackState
);
auth.AuthReceived += (sender, payload) =>
{
auth.Stop();
Token token = auth.ExchangeCode(payload.Code).Result;
tokenActual = token;
_spotify = new SpotifyWebAPI()
{
TokenType = token.TokenType,
AccessToken = token.AccessToken
};
crono.Stop();
if (_spotify.AccessToken != null)
{
cuentaLista = true;
cuentaVinculada = true;
Programa.config.AppSettings.Settings["VinculadoConSpotify"].Value = "true";
Log.Instance.ImprimirMensaje("Conectado sin errores como " + _spotify.GetPrivateProfile().DisplayName, TipoMensaje.Correcto, crono);
}
else
{
cuentaLista = false;
cuentaVinculada = false;
Log.Instance.ImprimirMensaje("Se ha conectado pero el token es nulo", TipoMensaje.Error, crono);
Programa.config.AppSettings.Settings["VinculadoConSpotify"].Value = "false";
}
CodigoRefresco = token.RefreshToken;
Programa.tareaRefrescoToken = new Thread(Programa.Refresco);
Programa.tareaRefrescoToken.Start();
};
auth.Start();
auth.OpenBrowser();
}
catch (NullReferenceException)
{
Programa.HayInternet(false);
Console.WriteLine("Algo fue mal");
System.Windows.Forms.MessageBox.Show(Programa.textosLocal.GetString("error_internet"));
}
catch (HttpRequestException)
{
Programa.HayInternet(false);
Console.WriteLine("No tienes internet");
System.Windows.Forms.MessageBox.Show(Programa.textosLocal.GetString("error_internet"));
}
}
private async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
_authorizationCodeAuth = (AuthorizationCodeAuth)sender;
_authorizationCodeAuth.Stop();
_token = await _authorizationCodeAuth.ExchangeCode(payload.Code);
RenewNextTokenRenewal();
}
private async void AuthOnAuthReceived(object Sender, AuthorizationCode Payload)
{
AuthorizationCodeAuth Auth = (AuthorizationCodeAuth)Sender;
Auth.Stop();
Token ReceivedToken = await Auth.ExchangeCode(Payload.Code);
OnAuthCodeReceived(ReceivedToken.AccessToken, ReceivedToken.TokenType);
}
public void Dispose()
{
lcd.Dispose();
spotTimer.Enabled = false;
spotTimer.Dispose();
spotTimer = null;
lcdTimer.Enabled = false;
lcdTimer.Dispose();
lcdTimer = null;
refreshTimer.Enabled = false;
refreshTimer.Dispose();
refreshTimer = null;
initExcpt = null;
auth.Stop(0);
}
private async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
this.Start(token);
}
private async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
_authorizationCodeAuth = (AuthorizationCodeAuth)sender;
_authorizationCodeAuth.Stop();
_token = await _authorizationCodeAuth.ExchangeCode(payload.Code);
// remember when to renew the 60 minutes token (10 minutes upfront)
_nextTokenRenewal = DateTimeOffset.UtcNow.AddSeconds(_token.ExpiresIn).AddMinutes(-10);
}
private void OnAuthorizationRecieved(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = sender as AuthorizationCodeAuth;
auth.Stop();
SAPIModels.Token token = auth.ExchangeCode(payload.Code).Result;
Analysis.Log($"Gained the initial Spotify authorization at '{token.CreateDate}", Analysis.LogLevel.Vital);
Configure(token, auth);
}
SpotifyConfiguration()
{
bool initialized = false;
var client_id = "7b2f38e47869431caeda389929a1908e";
var secret_id = "c3a86330ef844c16be6cb46d5e285a45";
AuthenFactory = new AuthorizationCodeAuth(
client_id,
secret_id,
"http://localhost:8888",
"http://localhost:8888",
SpotifyAPI.Web.Enums.Scope.AppRemoteControl
);
AuthenFactory.AuthReceived += async(s, p) =>
{
var ath = (AuthorizationCodeAuth)s;
ath.Stop();
var token = await ath.ExchangeCode(p.Code);
initialized = true;
RefreshToken = token.RefreshToken;
if (Client == null)
{
Client = new SpotifyWebAPI()
{
AccessToken = token.AccessToken,
TokenType = "Bearer"
};
}
else
{
Client.AccessToken = token.AccessToken;
}
IsAvailable = true;
};
AuthenFactory.Start();
AuthenFactory.OpenBrowser();
while (!initialized)
{
System.Threading.Thread.Sleep(1000);
}
AuthenFactory.Stop();
_refreshTokenWorker = new Timer();
_refreshTokenWorker.Interval = 30 * (1000 * 60);
_refreshTokenWorker.Elapsed += async(s, e) =>
{
var token = await AuthenFactory.RefreshToken(RefreshToken);
Client.AccessToken = token.AccessToken;
};
_refreshTokenWorker.Start();
}
private static async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
api = new SpotifyWebAPI {
AccessToken = token.AccessToken,
TokenType = token.TokenType
};
}
public static void Run(List <string> trackNames)
{
tracks = trackNames;
AuthorizationCodeAuth auth = new AuthorizationCodeAuth(Credentials.SP_id,
Credentials.SP_key, "http://localhost:4002", "http://localhost:4002", Scope.PlaylistModifyPrivate);
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
Console.ReadLine();
auth.Stop(0);
}
static void Main(string[] args)
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new PlaylistMapper());
});
var serviceProvider = new ServiceCollection()
.AddAutoMapper(typeof(Program))
.AddSingleton <IValidator, Validator>()
.AddSingleton <IProcessFactory, ProcessFactory>()
.AddSingleton <IAPIProcess, ApiProcess>()
.AddSingleton <SpotifyWebAPI>()
.AddTransient <IProcess, GetPlaylistProcess>()
.AddTransient <IProcess, ClearPlaylistProcess>()
.AddTransient <IProcess, ReorderProcess>()
.AddTransient <IServiceCollection, ServiceCollection>()
.BuildServiceProvider();
string _clientId = "eca82f597115423cac9d1125e0fb97c4";
string _secretId = "17a6e5916bb3424eb50f29e4816521a4";
AuthorizationCodeAuth auth = new AuthorizationCodeAuth(
_clientId,
_secretId,
"http://localhost:4200",
"http://localhost:4200",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.PlaylistModifyPrivate | Scope.PlaylistModifyPublic
);
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
var apiProcess = serviceProvider.GetService <IAPIProcess>();
ClearPlaylistRequest request = new ClearPlaylistRequest {
PlaylistUri = "6KPMCEavSTefLEx5JH3edt", Token = token
};
IResponseMessage responseMessage = apiProcess.RunCommand <ClearPlaylistRequest>(request);
};
auth.Start(); // Starts an internal HTTP Server
auth.OpenBrowser();
Console.ReadLine();
}
private async void OnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
Token token;
token = await auth.ExchangeCode(payload.Code);
spotify = new SpotifyWebAPI()
{
TokenType = token.TokenType,
AccessToken = token.AccessToken
};
}
private static async void AuthOnAuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
SpotifyAPI.Web.Models.Token token = await auth.ExchangeCode(payload);
SpotifyWebAPI api = new SpotifyWebAPI
{
AccessToken = token.AccessToken,
TokenType = token.TokenType
};
PrintUsefulData(api);
}
private void AuthorizeSpotifyToken()
{
AuthorizationCodeAuth auth = this.CreateAuthorization();
auth.AuthReceived += async(sender, payload) =>
{
auth.Stop();
Token token = await auth.ExchangeCode(payload.Code);
this.CreateTokenFile(token);
this.isAuthenticated = true;
};
auth.Start();
auth.OpenBrowser();
}
/// <summary>
/// Awaits the intial connection timeout if not recieved within given time
/// </summary>
/// <param name="timeoutSeconds"></param>
/// <param name="auth"></param>
/// <returns></returns>
private System.Collections.IEnumerator AwaitConnectionTimeout(int timeoutSeconds, AuthorizationCodeAuth auth)
{
yield return(new WaitForSeconds(timeoutSeconds));
if (IsConnecting && !IsConnected)
{
Analysis.LogError("Failed to get authentification - Timed out", Analysis.LogLevel.Vital);
auth.Stop();
auth.AuthReceived -= OnAuthorizationRecieved;
IsConnecting = false;
}
m_timeoutRoutine = null;
}
private async void Auth_AuthReceived(object sender, AuthorizationCode payload)
{
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)sender;
auth.Stop();
_token = await auth.ExchangeCode(payload.Code);
_api = new SpotifyWebAPI
{
AccessToken = _token.AccessToken,
TokenType = _token.TokenType
};
RunSpotifyApi();
}
// ReSharper disable once UnusedParameter.Local
static void Main(string[] args)
{
SetApiKeys();
AuthorizationCodeAuth auth =
new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.UserReadCurrentlyPlaying);
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
Timer t = new Timer(TimerCallbackAsync, null, 0, 5000);
Console.ReadLine();
auth.Stop(0);
}
private static string _secretId = "3605d0cde2d74c07822299c0359f840f"; //"";
// ReSharper disable once UnusedParameter.Local
static public void Main()
{
//_clientId = string.IsNullOrEmpty(_clientId)
// ? Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID")
// : _clientId;
//_secretId = string.IsNullOrEmpty(_secretId)
// ? Environment.GetEnvironmentVariable("SPOTIFY_SECRET_ID")
// : _secretId;
//MainWindow mainMenu = new MainWindow();
AuthorizationCodeAuth auth =
new AuthorizationCodeAuth(_clientId, _secretId, "http://localhost:4002", "http://localhost:4002",
Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.UserReadPlaybackState | Scope.UserModifyPlaybackState);
//Scope.UserReadPrivate | Scope.UserReadEmail | Scope.PlaylistReadPrivate | Scope.UserLibraryRead |
//Scope.UserReadPrivate | Scope.UserFollowRead | Scope.UserReadBirthdate | Scope.UserTopRead | Scope.PlaylistReadCollaborative |
//Scope.UserRead+RecentlyPlayed | Scope.UserReadPlaybackState | Scope.UserModifyPlaybackState)
Console.WriteLine("Hello, open Spotify please and start a Playback");
Console.WriteLine("Put the Emotic Epoc+ on your head please and open Emotiv App");
Console.WriteLine("Select your Emotiv epoc+ device and follow the instructions given by the application ");
Console.WriteLine("you must be 100 % of connection for the application work properly ");
Console.WriteLine("Press Enter when you are ready");
Console.ReadLine();
auth.AuthReceived += AuthOnAuthReceived;
auth.Start();
auth.OpenBrowser();
Thread.Sleep(20000);
Console.ReadLine();
auth.Stop(0);
}
/// <summary>
/// Authorize with the Spotify Web API to retrieve a Refresh Token.
/// This token is then to be used for any subsequent calls to <see cref="RunStatus(Status)"/>
/// </summary>
/// <param name="opts_">CLI arguments</param>
/// <returns>1 for errors, 0 otherwise</returns>
static int RunAuthorize(Authorize opts_)
{
SysConsole.WriteLine("Authorizing with SpotifyWebAPI");
Token token = null;
var auth = new AuthorizationCodeAuth(opts_.ClientId, opts_.ClientSecret, "http://localhost:" + opts_.Port, "http://localhost:" + opts_.Port, Scope.UserReadPrivate);
auth.AuthReceived += (object sender_, AuthorizationCode payload_) =>
{
auth.Stop();
var exchange = auth.ExchangeCode(payload_.Code);
exchange.Wait(10000);
if (!exchange.IsCompleted)
{
throw new Exception("Timeout during authorization process!");
}
token = exchange.Result;
};
SysConsole.WriteLine("Starting authorization process");
auth.Start();
auth.OpenBrowser();
SysConsole.Write("Waiting for authorzation to complete...");
while (token == null)
{
SysConsole.Write(".");
Task.Delay(500).Wait();
}
string settings = "ClientId=" + opts_.ClientId + "\r\n";
settings += "ClientSecret=" + opts_.ClientSecret + "\r\n";
settings += "RefreshToken=" + token.RefreshToken + "\r\n";
Clipboard.SetText(settings);
SysConsole.WriteLine("");
SysConsole.WriteLine("Token received. Set the following settings in your web parser parent measure:");
SysConsole.WriteLine("---");
SysConsole.WriteLine(settings);
SysConsole.WriteLine("---");
SysConsole.WriteLine("(the settings have been copied to your clipboard as well)");
return(0);
}
