c# - example - googlewebauthorizationbroker

API de.NET de Google: ¿cualquier otro DataStore que no sea FileDataStore?

Question

Estoy usando la API de .NET de Google para obtener datos analíticos de Google Analytics.

Este es mi código para iniciar la autenticación:

IAuthorizationCodeFlow flow =
new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = googleApiClientId,
ClientSecret = googleApiClientSecret
},
Scopes = new[] {
Google.Apis.Analytics.v3.AnalyticsService.Scope.AnalyticsReadonly
},
DataStore = new Google.Apis.Util.Store.FileDataStore("Test_GoogleApi")
});

utiliza el FileDataStore que almacena en el perfil de usuario local como un archivo. Estoy ejecutando este código dentro de una aplicación ASP.NET, así que realmente no puedo usar FileDataStore, así que lo que necesitaré es otra forma de obtener los datos.

Google.Apis.Util.Store solo contiene FileDataStore y una interfaz de IDataStore. Antes de ir e implementar mi propio DataStore, ¿hay otros objetos DataStore disponibles para descargar?

Gracias

Answer 1

Básicamente necesitas crear tu propia imitación de Idatastore y luego usar eso.

IDataStore StoredRefreshToken = new myDataStore();
// Oauth2 Autentication.
using (var stream = new System.IO.FileStream("client_secret.json", System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
new[] { AnalyticsService.Scope.AnalyticsReadonly },
"user", CancellationToken.None, StoredRefreshToken).Result;
}

Consulte aquí un ejemplo básico de una imitación de Idatastore. Google Oauth cargando token de actualización almacenado

Actualizar:

Se pueden encontrar varias versiones de esto en mi proyecto de ejemplo de autenticación en GitHub Google-Dotnet-Samples / Authentication / Diamto.Google.Authentication

Answer 2

Hay implementaciones para aplicaciones de Windows 8 y Windows Phone disponibles aquí:

• WP Data Store
• WinRT Data Store

Vea el siguiente hilo Implementando ASP.NET en la nube de Windows Azure, la aplicación genera errores cuando se ejecuta en la nube antes de implementar su propio DataStore.

En el futuro también podríamos tener un DataStore EF. Recuerde que es un proyecto de código abierto para que pueda implementarlo y enviarlo a revisión :) Consulte nuestra página de contribución ( https://code.google.com/p/google-api-dotnet-client/wiki/BecomingAContributor )

Answer 3

La fuente de FileDataStore de Google está disponible here .

He escrito una implementación simple de Entity Framework (versión 6) de IDataStore como se muestra a continuación.

Si está buscando poner esto en un proyecto separado, al igual que EF, necesitará el paquete Google.Apis.Core nuget instalado.

public class Item
{
[Key]
[MaxLength(100)]
public string Key { get; set; }
[MaxLength(500)]
public string Value { get; set; }
}
public class GoogleAuthContext : DbContext
{
public DbSet<Item> Items { get; set; }
}
public class EFDataStore : IDataStore
{
public async Task ClearAsync()
{
using (var context = new GoogleAuthContext())
{
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
await objectContext.ExecuteStoreCommandAsync("TRUNCATE TABLE [Items]");
}
}
public async Task DeleteAsync<T>(string key)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Key MUST have a value");
}
using (var context = new GoogleAuthContext())
{
var generatedKey = GenerateStoredKey(key, typeof(T));
var item = context.Items.FirstOrDefault(x => x.Key == generatedKey);
if (item != null)
{
context.Items.Remove(item);
await context.SaveChangesAsync();
}
}
}
public Task<T> GetAsync<T>(string key)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Key MUST have a value");
}
using (var context = new GoogleAuthContext())
{
var generatedKey = GenerateStoredKey(key, typeof(T));
var item = context.Items.FirstOrDefault(x => x.Key == generatedKey);
T value = item == null ? default(T) : JsonConvert.DeserializeObject<T>(item.Value);
return Task.FromResult<T>(value);
}
}
public async Task StoreAsync<T>(string key, T value)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Key MUST have a value");
}
using (var context = new GoogleAuthContext())
{
var generatedKey = GenerateStoredKey(key, typeof (T));
string json = JsonConvert.SerializeObject(value);
var item = await context.Items.SingleOrDefaultAsync(x => x.Key == generatedKey);
if (item == null)
{
context.Items.Add(new Item { Key = generatedKey, Value = json});
}
else
{
item.Value = json;
}
await context.SaveChangesAsync();
}
}
private static string GenerateStoredKey(string key, Type t)
{
return string.Format("{0}-{1}", t.FullName, key);
}
}

Answer 4

Nuestra aplicación web está alojada en Azure, así que necesitaba crear un IDataStore para eso.

Usé Azure Table Storage como nuestro almacén de datos.

Aquí hay un resumen de mi intento

Comentarios y sugerencias son bienvenidos

Answer 5

Sé que esta pregunta fue respondida hace algún tiempo, sin embargo, pensé que sería un buen lugar para compartir mis conclusiones para aquellos que tienen dificultades similares para encontrar ejemplos. Me ha resultado difícil encontrar documentación / ejemplos sobre el uso de la biblioteca .Net de Google API para una aplicación web de escritorio o MVC. Finalmente encontré un buen ejemplo en el ejemplo de tareas que puede encontrar en el repositorio de muestras en el sitio de Google Project here <- Eso realmente me ayudó.

Terminé enganchando la fuente de here creé una clase de AppDataStore y la coloqué en mi carpeta App_Code. Puede encontrar la fuente here , aunque en realidad fue un simple cambio: cambiar la carpeta para que apunte a ~ / App_Data en su lugar.

La última pieza del rompecabezas que estoy investigando es obtener el token offline_access.

Edición: Aquí está el código para su conveniencia:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Google.Apis.Util.Store;
using Google.Apis.Json;
namespace Google.Apis.Util.Store {
public class AppDataFileStore : IDataStore {
readonly string folderPath;
/// <summary>Gets the full folder path.</summary>
public string FolderPath { get { return folderPath; } }
/// <summary>
/// Constructs a new file data store with the specified folder. This folder is created (if it doesn''t exist
/// yet) under <see cref="Environment.SpecialFolder.ApplicationData"/>.
/// </summary>
/// <param name="folder">Folder name.</param>
public AppDataFileStore(string folder) {
folderPath = Path.Combine(HttpContext.Current.Server.MapPath("~/App_Data/"), folder);
if (!Directory.Exists(folderPath)) {
Directory.CreateDirectory(folderPath);
}
}
/// <summary>
/// Stores the given value for the given key. It creates a new file (named <see cref="GenerateStoredKey"/>) in
/// <see cref="FolderPath"/>.
/// </summary>
/// <typeparam name="T">The type to store in the data store.</typeparam>
/// <param name="key">The key.</param>
/// <param name="value">The value to store in the data store.</param>
public Task StoreAsync<T>(string key, T value) {
if (string.IsNullOrEmpty(key)) {
throw new ArgumentException("Key MUST have a value");
}
var serialized = NewtonsoftJsonSerializer.Instance.Serialize(value);
var filePath = Path.Combine(folderPath, GenerateStoredKey(key, typeof(T)));
File.WriteAllText(filePath, serialized);
return TaskEx.Delay(0);
}
/// <summary>
/// Deletes the given key. It deletes the <see cref="GenerateStoredKey"/> named file in
/// <see cref="FolderPath"/>.
/// </summary>
/// <param name="key">The key to delete from the data store.</param>
public Task DeleteAsync<T>(string key) {
if (string.IsNullOrEmpty(key)) {
throw new ArgumentException("Key MUST have a value");
}
var filePath = Path.Combine(folderPath, GenerateStoredKey(key, typeof(T)));
if (File.Exists(filePath)) {
File.Delete(filePath);
}
return TaskEx.Delay(0);
}
/// <summary>
/// Returns the stored value for the given key or <c>null</c> if the matching file (<see cref="GenerateStoredKey"/>
/// in <see cref="FolderPath"/> doesn''t exist.
/// </summary>
/// <typeparam name="T">The type to retrieve.</typeparam>
/// <param name="key">The key to retrieve from the data store.</param>
/// <returns>The stored object.</returns>
public Task<T> GetAsync<T>(string key) {
if (string.IsNullOrEmpty(key)) {
throw new ArgumentException("Key MUST have a value");
}
TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
var filePath = Path.Combine(folderPath, GenerateStoredKey(key, typeof(T)));
if (File.Exists(filePath)) {
try {
var obj = File.ReadAllText(filePath);
tcs.SetResult(NewtonsoftJsonSerializer.Instance.Deserialize<T>(obj));
}
catch (Exception ex) {
tcs.SetException(ex);
}
}
else {
tcs.SetResult(default(T));
}
return tcs.Task;
}
/// <summary>
/// Clears all values in the data store. This method deletes all files in <see cref="FolderPath"/>.
/// </summary>
public Task ClearAsync() {
if (Directory.Exists(folderPath)) {
Directory.Delete(folderPath, true);
Directory.CreateDirectory(folderPath);
}
return TaskEx.Delay(0);
}
/// <summary>Creates a unique stored key based on the key and the class type.</summary>
/// <param name="key">The object key.</param>
/// <param name="t">The type to store or retrieve.</param>
public static string GenerateStoredKey(string key, Type t) {
return string.Format("{0}-{1}", t.FullName, key);
}
}
}

Tuve que configurar la solicitud de aprobación para forzar para obtener el token de acceso sin conexión.

var req = HttpContext.Current.Request;
var oAuthUrl = Flow.CreateAuthorizationCodeRequest(new UriBuilder(req.Url.Scheme, req.Url.Host, req.Url.Port, GoogleCalendarUtil.CallbackUrl).Uri.ToString()) as GoogleAuthorizationCodeRequestUrl;
oAuthUrl.Scope = string.Join(" ", new[] { CalendarService.Scope.CalendarReadonly });
oAuthUrl.ApprovalPrompt = "force";
oAuthUrl.State = AuthState;