public YouTubeService NewTestYouTubeService(string accessToken, string refreshToken)
{
var access_token = accessToken;
var refresh_token = refreshToken;
TokenResponse token = new TokenResponse
{
AccessToken = access_token,
RefreshToken = refresh_token
};
var cred = new UserCredential
(new GoogleAuthorizationCodeFlow(
new GoogleAuthorizationCodeFlow.Initializer()
{
ClientSecrets = new ClientSecrets()
{
ClientId = "//clientId",
ClientSecret = "//clientSecret"
}
}
),
"testUser1",
token
);
return new YouTubeService(new BaseClientService.Initializer()
{
ApplicationName = this.GetType().ToString(),
HttpClientInitializer = cred
});
}
public void IsExpired_True()
{
var issued = DateTime.Now;
var newNow = DateTime.Now.AddSeconds(200);
var mockClock = new MockClock()
{
Now = newNow
};
// Issued not set.
var response = new TokenResponse();
Assert.True(response.IsExpired(mockClock));
// ExpiresInSeconds is not set.
response = new TokenResponse() { Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { ExpiresInSeconds = 1, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { ExpiresInSeconds = 100, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { ExpiresInSeconds = 140, Issued = issued };
Assert.True(response.IsExpired(mockClock));
}
private DriveService CreateServie()
{
var tokenResponse = new TokenResponse
{
AccessToken = WebStorageConstants.GoogleDriveAccessToken,
RefreshToken = WebStorageConstants.GoogleRefreshToken,
};
var apiCodeFlow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = WebStorageConstants.GoogleDriveId,
ClientSecret = WebStorageConstants.GoogleDriveSecret
},
Scopes = new[] { DriveService.Scope.Drive },
DataStore = new FileDataStore(WebStorageConstants.GoogleDriveApplicationName)
});
var credential = new UserCredential(apiCodeFlow, WebStorageConstants.GoogleDriveEmail, tokenResponse);
var newService = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = WebStorageConstants.GoogleDriveApplicationName
});
return newService;
}
public void TestConstructor()
{
var response = new TokenResponse();
Assert.Null(response.AccessToken);
Assert.Null(response.ExpiresInSeconds);
Assert.Null(response.RefreshToken);
Assert.Null(response.Scope);
Assert.AreEqual(DateTime.MinValue, response.Issued);
}
public static AuthorizationCodeWebApp.AuthResult checkExpiration(Controller controller, AuthorizationCodeWebApp.AuthResult authorization)
{
if (authorization.Credential.Token.IsExpired(Google.Apis.Util.SystemClock.Default))
{
Google.Apis.Auth.OAuth2.Responses.TokenResponse token = new Google.Apis.Auth.OAuth2.Responses.TokenResponse();
//recreate the token
token = authorization.Credential.Flow.RefreshTokenAsync(
UserAccountsController.getUserId(controller.Session).ToString(),
authorization.Credential.Token.RefreshToken,
CancellationToken.None
).Result;
authorization = getAuthorization(controller);
}
return(authorization);
}
private void EnsureService()
{
if (!_setting.UseGoogleDrive)
{
return;
}
if (_driveService != null)
{
return;
}
if (string.IsNullOrEmpty(_setting.GoogleClientId) || string.IsNullOrEmpty(_setting.GoogleClientSecret) ||
string.IsNullOrEmpty(_setting.GoogleRefreshToken))
{
throw new ApplicationException("Missing google drive configuration");
}
try
{
var initializer = new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = _setting.GoogleClientId,
ClientSecret = _setting.GoogleClientSecret
}
};
var flow = new AuthorizationCodeFlow(initializer);
//flow.RefreshTokenAsync("user", Configuration.GoogleRefreshToken, new CancellationTokenSource().Token);
var tokenResponse = new TokenResponse { RefreshToken = _setting.GoogleRefreshToken };
var userCredential = new UserCredential(flow, _setting.GoogleLocalUserId, tokenResponse);
_driveService = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = userCredential,
ApplicationName = "Jarboo.Admin"
});
}
catch (Exception ex)
{
_driveService = null;
throw;
}
}
public static async Task<DriveService> GetClient(TokenResponse token)
{
var credentials = new UserCredential(
AuthFlow,
null,
token);
var driveInitializer = new BaseClientService.Initializer
{
HttpClientInitializer = credentials,
HttpClientFactory = new GoogleDriveHttpClientFactory(),
ApplicationName = "KeeAnywhere",
};
var client = new DriveService(driveInitializer);
return client;
}
public void IsExpired()
{
var issued = DateTime.Now;
var newNow = DateTime.Now.AddSeconds(100);
var mockClock = new MockClock
{
Now = newNow
};
// Issued not set.
var response = new TokenResponse();
Assert.True(response.IsExpired(mockClock));
// ExpiresInSeconds is not set.
response = new TokenResponse() { Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 1, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 100, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 158, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 159, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 160, Issued = issued };
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 161, Issued = issued };
Assert.False(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 162, Issued = issued };
Assert.False(response.IsExpired(mockClock));
}
public async Task<bool> Claim(Uri uri, string documentTitle)
{
var parts = documentTitle.Split(' ');
if (parts.Length < 1 || parts[0] != "Success")
return false;
var code = parts[1].Split('=')[1];
try
{
_token =
await
GoogleDriveHelper.AuthFlow.ExchangeCodeForTokenAsync(null, code, GoogleDriveHelper.RedirectUri,
CancellationToken.None).ConfigureAwait(false);
return _token != null;
}
catch (TokenResponseException)
{
return false;
}
}
private async Task StoreAuthToken(string userId, string userName, string refreshToken, string accessToken, long expiresIn)
{
var flow = GmailApiComponent.CreateFlow(userId);
var token = await flow.DataStore.GetAsync <TokenResponse>(userName);
if (token == null && string.IsNullOrEmpty(refreshToken))
{
throw new HttpException((int)System.Net.HttpStatusCode.Unauthorized, "No refresh token provided.");
}
if (token == null)
{
token = new Google.Apis.Auth.OAuth2.Responses.TokenResponse
{
RefreshToken = refreshToken
};
}
token.AccessToken = accessToken;
token.ExpiresInSeconds = expiresIn;
token.Issued = flow.Clock.UtcNow;
await flow.DataStore.StoreAsync(userName, token);
}
/// <summary>
/// Asynchronously parses a <see cref="TokenResponse"/> instance from the specified <see cref="HttpResponseMessage"/>.
/// </summary>
/// <param name="response">The http response from which to parse the token.</param>
/// <param name="clock">The clock used to set the <see cref="Issued"/> value of the token.</param>
/// <param name="logger">The logger used to output messages incase of error.</param>
/// <exception cref="TokenResponseException">
/// The response was not successful or there is an error parsing the response into valid <see cref="TokenResponse"/> instance.
/// </exception>
/// <returns>
/// A task containing the <see cref="TokenResponse"/> parsed form the response message.
/// </returns>
public static async Task <TokenResponse> FromHttpResponseAsync(HttpResponseMessage response, IClock clock, ILogger logger)
{
var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var typeName = "";
try
{
if (!response.IsSuccessStatusCode)
{
typeName = nameof(TokenErrorResponse);
var error = NewtonsoftJsonSerializer.Instance.Deserialize <TokenErrorResponse>(content);
throw new TokenResponseException(error, response.StatusCode);
}
TokenResponse newToken;
// GCE's metadata server identity endpoint doesn't return a TokenResponse but the raw
// id_token, so we build a TokenResponse from that.
if (response.RequestMessage?.RequestUri?.AbsoluteUri.StartsWith(GoogleAuthConsts.EffectiveComputeOidcTokenUrl) == true)
{
newToken = new TokenResponse
{
IdToken = content
};
}
else
{
typeName = nameof(TokenResponse);
newToken = NewtonsoftJsonSerializer.Instance.Deserialize <TokenResponse>(content);
}
// We make some modifications to the token before returning, to guarantee consistency
// for our code across endpoint usage.
// We should set issuance ourselves.
newToken.IssuedUtc = clock.UtcNow;
// If no access token was specified, then we're probably receiving
// and OIDC token for IAP. The IdToken is used for access in that case.
newToken.AccessToken ??= newToken.IdToken;
// If no expiry is specified, maybe the IdToken has it specified.
// We can try and get it from there.
if (newToken.ExpiresInSeconds is null && newToken.IdToken != null)
{
// Unpack the IdToken.
var idToken = SignedToken <JsonWebSignature.Header, JsonWebSignature.Payload> .FromSignedToken(newToken.IdToken);
// If no expiry was specified in the ID token, there's nothing we can do.
if (idToken.Payload.ExpirationTimeSeconds.HasValue)
{
var expiration = UnixEpoch.AddSeconds(idToken.Payload.ExpirationTimeSeconds.Value);
newToken.ExpiresInSeconds = (long)(expiration - newToken.IssuedUtc).TotalSeconds;
}
}
return(newToken);
}
catch (Newtonsoft.Json.JsonException ex)
{
logger.Error(ex, $"Exception was caught when deserializing {typeName}. Content is: {content}");
throw new TokenResponseException(new TokenErrorResponse
{
Error = "Server response does not contain a JSON object. Status code is: " + response.StatusCode
}, response.StatusCode);
}
}
/// <summary>Constructs a new credential instance.</summary>
/// <param name="flow">Authorization code flow.</param>
/// <param name="userId">User identifier.</param>
/// <param name="token">An initial token for the user.</param>
public UserCredential(IAuthorizationCodeFlow flow, string userId, TokenResponse token)
{
this.flow = flow;
this.userId = userId;
this.token = token;
}
/// <summary>Verifies that the token response contains the expected data.</summary>
/// <param name="response">The token response</param>
private void SubtestTokenResponse(TokenResponse response)
{
Assert.That(response.RefreshToken, Is.EqualTo("r"));
Assert.That(response.ExpiresInSeconds, Is.EqualTo(100));
Assert.That(response.Scope, Is.EqualTo("b"));
}
/// <summary>
/// Processes the request based on the path.
/// </summary>
/// <param name="context">Contains the request and response.</param>
public void ProcessRequest(HttpContext context)
{
// Redirect base path to signin.
if (context.Request.Path.EndsWith("/"))
{
context.Response.RedirectPermanent("signin.ashx");
}
// This is reached when the root document is passed. Return HTML
// using index.html as a template.
if (context.Request.Path.EndsWith("/signin.ashx"))
{
String state = (String)context.Session["state"];
// Store a random string in the session for verifying
// the responses in our OAuth2 flow.
if (state == null)
{
Random random = new Random((int)DateTime.Now.Ticks);
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 13; i++)
{
builder.Append(Convert.ToChar(
Convert.ToInt32(Math.Floor(
26 * random.NextDouble() + 65))));
}
state = builder.ToString();
context.Session["state"] = state;
}
// Render the templated HTML.
String templatedHTML = File.ReadAllText(
context.Server.MapPath("index.html"));
templatedHTML = Regex.Replace(templatedHTML,
"[{]{2}\\s*APPLICATION_NAME\\s*[}]{2}", APP_NAME);
templatedHTML = Regex.Replace(templatedHTML,
"[{]{2}\\s*CLIENT_ID\\s*[}]{2}", secrets.ClientId);
templatedHTML = Regex.Replace(templatedHTML,
"[{]{2}\\s*STATE\\s*[}]{2}", state);
context.Response.ContentType = "text/html";
context.Response.Write(templatedHTML);
return;
}
if (context.Session["authState"] == null)
{
// The connect action exchanges a code from the sign-in button,
// verifies it, and creates OAuth2 credentials.
if (context.Request.Path.Contains("/connect"))
{
// Get the code from the request POST body.
StreamReader sr = new StreamReader(
context.Request.InputStream);
string code = sr.ReadToEnd();
string state = context.Request["state"];
// Test that the request state matches the session state.
if (!state.Equals(context.Session["state"]))
{
context.Response.StatusCode = 401;
return;
}
// Use the code exchange flow to get an access and refresh token.
IAuthorizationCodeFlow flow =
new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = secrets,
Scopes = SCOPES
});
token = flow.ExchangeCodeForTokenAsync("", code, "postmessage",
CancellationToken.None).Result;
// Create an authorization state from the returned token.
context.Session["authState"] = token;
// Get tokeninfo for the access token if you want to verify.
Oauth2Service service = new Oauth2Service(
new Google.Apis.Services.BaseClientService.Initializer());
Oauth2Service.TokeninfoRequest request = service.Tokeninfo();
request.AccessToken = token.AccessToken;
Tokeninfo info = request.Execute();
string gplus_id = info.UserId;
}
else
{
// No cached state and we are not connecting.
context.Response.StatusCode = 400;
return;
}
}
else if (context.Request.Path.Contains("/connect"))
{
// The user is already connected and credentials are cached.
context.Response.ContentType = "application/json";
context.Response.StatusCode = 200;
context.Response.Write(JsonConvert.SerializeObject("Current user is already connected."));
return;
}
else
{
// Register the authenticator and construct the Plus service
// for performing API calls on behalf of the user.
token = (TokenResponse)context.Session["authState"];
IAuthorizationCodeFlow flow =
new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = secrets,
Scopes = SCOPES
});
UserCredential credential = new UserCredential(flow, "me", token);
bool success = credential.RefreshTokenAsync(CancellationToken.None).Result;
token = credential.Token;
ps = new PlusService(
new Google.Apis.Services.BaseClientService.Initializer()
{
ApplicationName = ".NET Quickstart",
HttpClientInitializer = credential
});
}
// Perform an authenticated API request to retrieve the list of
// people that the user has made visible to the app.
if (context.Request.Path.Contains("/people"))
{
// Get the PeopleFeed for the currently authenticated user.
PeopleFeed pf = ps.People.List("me",
PeopleResource.ListRequest.CollectionEnum.Visible).Execute();
// This JSON, representing the people feed, will later be
// parsed by the JavaScript client.
string jsonContent =
Newtonsoft.Json.JsonConvert.SerializeObject(pf);
context.Response.ContentType = "application/json";
context.Response.Write(jsonContent);
return;
}
// Disconnect the user from the application by revoking the tokens
// and removing all locally stored data associated with the user.
if (context.Request.Path.Contains("/disconnect"))
{
// Perform a get request to the token endpoint to revoke the
// refresh token.
token = (TokenResponse)context.Session["authState"];
string tokenToRevoke = (token.RefreshToken != null) ?
token.RefreshToken : token.AccessToken;
WebRequest request = WebRequest.Create(
"https://accounts.google.com/o/oauth2/revoke?token=" +
tokenToRevoke);
WebResponse response = request.GetResponse();
// Remove the cached credentials.
context.Session["authState"] = null;
// You could reset the state in the session but you must also
// reset the state on the client.
// context.Session["state"] = null;
context.Response.Write(
response.GetResponseStream().ToString().ToCharArray());
return;
}
}
// For more information on configuring authentication, please visit
// http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
// Configure the db context, user manager and signin manager to use a single instance per request.
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
// Enables the application to use a cookie to store information for the signed in user and to use a cookie
// to temporarily store information about a user logging in with a third party login provider.
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login
// to your account.
OnValidateIdentity =
SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Enables the application to temporarily store user information when they are verifying the second factor
// in the two-factor authentication process.
app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Enables the application to remember the second login verification factor such as phone or email.
// Once you check this option, your second step of verification during the login process will be remembered
// on the device where you logged in from. This is similar to the RememberMe option when you log in.
app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
// ***
// Enables logging in with the Google login provider.
var google = new GoogleOAuth2AuthenticationOptions()
{
AccessType = "offline", // Request a refresh token.
ClientId = MyClientSecrets.ClientId,
ClientSecret = MyClientSecrets.ClientSecret,
Provider = new GoogleOAuth2AuthenticationProvider()
{
OnAuthenticated = async context =>
{
var userId = context.Id;
context.Identity.AddClaim(new Claim(MyClaimTypes.GoogleUserId, userId));
var tokenResponse = new TokenResponse() {
AccessToken = context.AccessToken,
RefreshToken = context.RefreshToken,
ExpiresInSeconds = (long)context.ExpiresIn.Value.TotalSeconds,
Issued = DateTime.Now,
};
await dataStore.StoreAsync(userId, tokenResponse);
},
},
};
foreach (var scope in MyRequestedScopes.Scopes)
{
google.Scope.Add(scope);
}
app.UseGoogleAuthentication(google);
}
public void LoadTokenAsync_TokenResponse()
{
TokenResponse response = new TokenResponse
{
AccessToken = "access"
};
TaskCompletionSource<TokenResponse> tcs = new TaskCompletionSource<TokenResponse>();
tcs.SetResult(response);
var result = SubtestLoadTokenAsync(tcs);
Assert.That(result, Is.EqualTo(response));
}
private YouTubeService BuildService()
{
ClientSecrets secrets = new ClientSecrets()
{
ClientId = CLIENT_ID,
ClientSecret = CLIENT_SECRET
};
var token = new TokenResponse { RefreshToken = REFRESH_TOKEN };
var credentials = new UserCredential(new GoogleAuthorizationCodeFlow(
new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = secrets
}),
"user",
token);
var service = new YouTubeService(new BaseClientService.Initializer()
{
HttpClientInitializer = credentials,
ApplicationName = "TestProject"
});
//service.HttpClient.Timeout = TimeSpan.FromSeconds(360); // Choose a timeout to your liking
return service;
}
public void Open(OAuth20Token token)
{
if (IsOpened)
return;
if (token == null) throw new UnauthorizedAccessException("Cannot create GoogleDrive session with given token");
if (token.IsExpired) token = OAuth20TokenHelper.RefreshToken(GoogleUrlToken, token);
_token = token;
var tokenResponse = new TokenResponse
{
AccessToken = _token.AccessToken,
RefreshToken = _token.RefreshToken,
Issued = _token.Timestamp,
ExpiresInSeconds = _token.ExpiresIn,
TokenType = "Bearer"
};
var apiCodeFlow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = _token.ClientID,
ClientSecret = _token.ClientSecret
},
Scopes = new[] { DriveService.Scope.Drive }
});
_driveService = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = new UserCredential(apiCodeFlow, string.Empty, tokenResponse)
});
IsOpened = true;
}
/// <summary>
/// Requests a new token as specified in
/// https://developers.google.com/accounts/docs/OAuth2ServiceAccount#makingrequest.
/// </summary>
/// <param name="taskCancellationToken">Cancellation token to cancel operation.</param>
/// <returns><c>true</c> if a new token was received successfully.</returns>
public async Task<bool> RequestAccessTokenAsync(CancellationToken taskCancellationToken)
{
string serializedHeader = CreateSerializedHeader();
string serializedPayload = GetSerializedPayload();
StringBuilder assertion = new StringBuilder();
assertion.Append(UrlSafeBase64Encode(serializedHeader))
.Append(".")
.Append(UrlSafeBase64Encode(serializedPayload));
// Sign the header and the payload.
var signature = UrlSafeBase64Encode(key.SignData(Encoding.ASCII.GetBytes(assertion.ToString()), "SHA256"));
assertion.Append(".").Append(signature);
// Create the request.
var request = new GoogleAssertionTokenRequest()
{
Assertion = assertion.ToString()
};
Logger.Debug("Request a new access token. Assertion data is: " + request.Assertion);
var newToken = await request.ExecuteAsync(httpClient, tokenServerUrl, taskCancellationToken, Clock)
.ConfigureAwait(false);
Token = newToken;
return true;
}
public void IsExpired()
{
var issued = DateTime.Now;
var newNow = DateTime.Now.AddSeconds(100);
var mockClock = new MockClock
{
Now = newNow
};
// Issued not set.
var response = new TokenResponse();
Assert.True(response.IsExpired(mockClock));
// ExpiresInSeconds is not set.
response = new TokenResponse()
{
Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 1, Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 100, Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 158, Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 159, Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 160, Issued = issued
};
Assert.True(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 161, Issued = issued
};
Assert.False(response.IsExpired(mockClock));
response = new TokenResponse()
{
AccessToken = "a", ExpiresInSeconds = 162, Issued = issued
};
Assert.False(response.IsExpired(mockClock));
}
private static UserCredential GetCredentialWithAccessToken(string refreshToken, string clientID, string clientSecret, string[] scopes)
{
TokenResponse token = new TokenResponse
{
RefreshToken = refreshToken
};
IAuthorizationCodeFlow flow = new AuthorizationCodeFlow(new AuthorizationCodeFlow.Initializer(Google.Apis.Auth.OAuth2.GoogleAuthConsts.AuthorizationUrl, Google.Apis.Auth.OAuth2.GoogleAuthConsts.TokenUrl)
{
ClientSecrets = new ClientSecrets
{
ClientId = clientID,
ClientSecret = clientSecret
},
Scopes = scopes
});
UserCredential credential = new UserCredential(flow, "me", token);
try
{
bool success = credential.RefreshTokenAsync(CancellationToken.None).Result;
}
catch
{
throw;
}
return credential;
}
public static DriveService CreateServie(string applicationName, string clientId, string clientSecret, string accessToken, string refreshToken)
{
var tokenResponse = new TokenResponse
{
AccessToken = accessToken,
RefreshToken = refreshToken,
};
var apiCodeFlow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = clientId,
ClientSecret = clientSecret
},
Scopes = new[]
{
DriveService.Scope.Drive, // view and manage your files and documents
DriveService.Scope.DriveAppdata, // view and manage its own configuration data
DriveService.Scope.DriveAppsReadonly, // view your drive apps
DriveService.Scope.DriveFile, // view and manage files created by this app
DriveService.Scope.DriveMetadataReadonly, // view metadata for files
DriveService.Scope.DriveReadonly, // view files and documents on your drive
DriveService.Scope.DriveScripts
},
DataStore = new FileDataStore(applicationName)
});
var credential = new UserCredential(apiCodeFlow, "*****@*****.**", tokenResponse);
var service = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = applicationName
});
return service;
}
public void IsExpired_False()
{
var issued = DateTime.Now;
var newNow = DateTime.Now.AddSeconds(200);
var mockClock = new MockClock()
{
Now = newNow
};
var response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 141, Issued = issued };
Assert.False(response.IsExpired(mockClock));
response = new TokenResponse() { AccessToken = "a", ExpiresInSeconds = 142, Issued = issued };
Assert.False(response.IsExpired(mockClock));
}
/// <summary>
/// Determines the need for retrieval of a new authorization code, based on the given token and the
/// authorization code flow.
/// </summary>
public bool ShouldRequestAuthorizationCode(TokenResponse token)
{
// TODO: This code should be shared between this class and AuthorizationCodeInstalledApp.
// If the flow includes a parameter that requires a new token, if the stored token is null or it doesn't
// have a refresh token and the access token is expired we need to retrieve a new authorization code.
return Flow.ShouldForceTokenRetrieval() || token == null || (token.RefreshToken == null
&& token.IsExpired(flow.Clock));
}
/// <summary>
/// Refreshes the token by calling to
/// <see cref="Google.Apis.Auth.OAuth2.Flows.IAuthorizationCodeFlow.RefreshTokenAsync"/>.
/// Then it updates the <see cref="TokenResponse"/> with the new token instance.
/// </summary>
/// <param name="taskCancellationToken">Cancellation token to cancel an operation.</param>
/// <returns><c>true</c> if the token was refreshed.</returns>
public async Task<bool> RefreshTokenAsync(CancellationToken taskCancellationToken)
{
if (Token.RefreshToken == null)
{
Logger.Warning("Refresh token is null, can't refresh the token!");
return false;
}
// It's possible that two concurrent calls will be made to refresh the token, in that case the last one
// will win.
var newToken = await flow.RefreshTokenAsync(userId, Token.RefreshToken, taskCancellationToken)
.ConfigureAwait(false);
Logger.Info("Access token was refreshed successfully");
if (newToken.RefreshToken == null)
{
newToken.RefreshToken = Token.RefreshToken;
}
Token = newToken;
return true;
}
/// <summary>Creates a user credential from JSON data.</summary>
private static UserCredential CreateUserCredentialFromJson(JsonCredentialParameters credentialParameters)
{
if (credentialParameters.Type != JsonCredentialParameters.AuthorizedUserCredentialType ||
string.IsNullOrEmpty(credentialParameters.ClientId) ||
string.IsNullOrEmpty(credentialParameters.ClientSecret))
{
throw new InvalidOperationException("JSON data does not represent a valid user credential.");
}
var token = new TokenResponse
{
RefreshToken = credentialParameters.RefreshToken
};
var initializer = new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = credentialParameters.ClientId,
ClientSecret = credentialParameters.ClientSecret
}
};
var flow = new GoogleAuthorizationCodeFlow(initializer);
return new UserCredential(flow, "ApplicationDefaultCredentials", token);
}
private async Task StoreAuthToken(string userId, string userName, string refreshToken, string accessToken, long expiresIn)
{
var flow = GmailApiComponent.CreateFlow(userId);
var token = await flow.DataStore.GetAsync<TokenResponse>(userName);
if (token == null && string.IsNullOrEmpty(refreshToken))
throw new HttpException((int)System.Net.HttpStatusCode.Unauthorized, "No refresh token provided.");
if (token == null)
{
token = new Google.Apis.Auth.OAuth2.Responses.TokenResponse
{
RefreshToken = refreshToken
};
}
token.AccessToken = accessToken;
token.ExpiresInSeconds = expiresIn;
token.Issued = flow.Clock.UtcNow;
await flow.DataStore.StoreAsync(userName, token);
}
private bool IsValidToken(TokenResponse token)
{
// If the token is expired but we have a non-null RefreshToken, we can assume the token will be
// automatically refreshed when we query Google Blogger and is therefore valid.
return token != null && (!token.IsExpired(SystemClock.Default) || token.RefreshToken != null);
}
/// <summary>Stores the token in the <see cref="DataStore"/>.</summary>
/// <param name="userId">User identifier.</param>
/// <param name="token">Token to store.</param>
/// <param name="taskCancellationToken">Cancellation token to cancel operation.</param>
private async Task StoreTokenAsync(string userId, TokenResponse token, CancellationToken taskCancellationToken)
{
taskCancellationToken.ThrowIfCancellationRequested();
if (DataStore != null)
{
await DataStore.StoreAsync<TokenResponse>(userId, token).ConfigureAwait(false);
}
}
/// <summary>
/// Metoda wypełniająca wszystkie niezbędne dane do autoryzacji w usłudze Google Calendar.
/// </summary>
private bool SetUserCalendarAuthData()
{
Logs.WriteErrorLog("SetUserCalendarAuthData");
Logs.WriteErrorLog("ClientCredentials.ClientId: " + ClientCredentials.ClientId.ToString() + "ClientCredentials.ClientSecret: " + ClientCredentials.ClientSecret);
Flow = new GoogleAuthorizationCodeFlow(
new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets()
{
ClientId = ClientCredentials.ClientId,
ClientSecret = ClientCredentials.ClientSecret
}
});
Logs.WriteErrorLog("UserIdInDatabase: ");
Logs.WriteErrorLog(UserIdInDatabase.ToString());
var tokenFromWs = GetTokenFromWebService.GetTokenFromDatabase(UserIdInDatabase).Result;
if (tokenFromWs == null)
{
IsCalendarAuthorized = false;
return false;
}
Token = new TokenResponse
{
RefreshToken = tokenFromWs
};
IsCalendarAuthorized = true;
return true;
}
private DriveService CreateDriveService(GoogleCredentials googleCredentials)
{
var authorizationCodeFlowInitializer = new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = googleCredentials.ClientId,
ClientSecret = googleCredentials.ClientSecret
}
};
var googleAuthorizationCodeFlow = new GoogleAuthorizationCodeFlow(authorizationCodeFlowInitializer);
var token = new TokenResponse { RefreshToken = googleCredentials.RefreshToken };
var credentials = new UserCredential(googleAuthorizationCodeFlow, "user", token);
var initializer = new BaseClientService.Initializer
{
ApplicationName = "Emby",
HttpClientInitializer = credentials
};
return new DriveService(initializer)
{
HttpClient = { Timeout = TimeSpan.FromHours(1) }
};
}