c# - sessions - google analytics tools
Use la API de Google Analytics para mostrar información en C# (7)
Esta respuesta es para aquellos de ustedes que desean acceder a su propia cuenta de Analytics y desean utilizar la nueva API de informes de Analytics v4 .
Hace poco escribí una publicación de blog sobre cómo obtener datos de Google Analytics usando C #. Lee allí para todos los detalles.
Primero debe elegir entre conectarse con OAuth2 o una cuenta de servicio. Asumiré que es el propietario de la cuenta de Analytics, por lo que debe crear una "Clave de cuenta de servicio" en la página Credentials API de Google.
Una vez que lo cree, descargue el archivo JSON y póngalo en su proyecto (puse el mío en mi carpeta App_Data ).
Luego, instale el paquete Google.Apis.AnalyticsReporting.v4 Nuget. Instale también Json.NET de Json.NET .
Incluye esta clase en algún lugar de tu proyecto:
public class PersonalServiceAccountCred
{
public string type { get; set; }
public string project_id { get; set; }
public string private_key_id { get; set; }
public string private_key { get; set; }
public string client_email { get; set; }
public string client_id { get; set; }
public string auth_uri { get; set; }
public string token_uri { get; set; }
public string auth_provider_x509_cert_url { get; set; }
public string client_x509_cert_url { get; set; }
}
Y esto es lo que has estado esperando: ¡un ejemplo completo!
string keyFilePath = Server.MapPath("~/App_Data/Your-API-Key-Filename.json");
string json = System.IO.File.ReadAllText(keyFilePath);
var cr = JsonConvert.DeserializeObject(json);
var xCred = new ServiceAccountCredential(new ServiceAccountCredential.Initializer(cr.client_email)
{
Scopes = new[] {
AnalyticsReportingService.Scope.Analytics
}
}.FromPrivateKey(cr.private_key));
using (var svc = new AnalyticsReportingService(
new BaseClientService.Initializer
{
HttpClientInitializer = xCred,
ApplicationName = "[Your Application Name]"
})
)
{
// Create the DateRange object.
DateRange dateRange = new DateRange() { StartDate = "2017-05-01", EndDate = "2017-05-31" };
// Create the Metrics object.
Metric sessions = new Metric { Expression = "ga:sessions", Alias = "Sessions" };
//Create the Dimensions object.
Dimension browser = new Dimension { Name = "ga:browser" };
// Create the ReportRequest object.
ReportRequest reportRequest = new ReportRequest
{
ViewId = "[A ViewId in your account]",
DateRanges = new List() { dateRange },
Dimensions = new List() { browser },
Metrics = new List() { sessions }
};
List requests = new List();
requests.Add(reportRequest);
// Create the GetReportsRequest object.
GetReportsRequest getReport = new GetReportsRequest() { ReportRequests = requests };
// Call the batchGet method.
GetReportsResponse response = svc.Reports.BatchGet(getReport).Execute();
}
Comenzamos por deserializar la información de la clave de la cuenta de servicio del archivo JSON y convertirla en un objeto PersonalServiceAccountCred . Luego, creamos ServiceAccountCredential y nos conectamos a Google a través de AnalyticsReportingService . Al usar ese servicio, preparamos algunos filtros básicos para pasar a la API y enviar la solicitud.
Probablemente sea mejor establecer un punto de interrupción en la línea donde se declara la variable de response , presionar F10 una vez, luego colocar el cursor sobre la variable, para que pueda ver qué datos hay disponibles para su uso en la respuesta.
He estado buscando una buena solución todo el día, pero google evoluciona tan rápido que no puedo encontrar algo que funcione. Lo que quiero hacer es eso, tengo una aplicación web que tiene una sección de administrador donde el usuario debe iniciar sesión para ver la información. En esta sección, quiero mostrar algunos datos de GA, como vistas de página para algunas URL específicas. Dado que no es la información del usuario que estoy mostrando, sino el usuario de Google Analytics, quiero conectar la información de paso (nombre de usuario / contraseña o APIKey) pero no puedo averiguar cómo. Toda la muestra que encontré usa OAuth2 (la bruja, si lo entiendo, le pedirá al visitante que inicie sesión usando google).
Lo que encontré hasta ahora:
- Biblioteca oficial de clientes de Google para .Net: http://code.google.com/p/google-api-dotnet-client/ , sin muestra para GA
- los desarrolladores oficiales ayudan: https://developers.google.com/analytics/
- otra pregunta con código en SO: API de Google Analytics - Obtenga de forma programática vistas de página en el lado del servidor, pero obtengo un 403 cuando intento autenticar
- Algunas fuentes que acceden a la API: http://www.reimers.dk/jacob-reimers-blog/added-google-analytics-reader-for-net descargaron la fuente pero no entiendo cómo funciona
- esta otra pregunta en SO: Google Analytics Access con C # pero no ayuda
- mientras escribo esto, me sugieren esta 09 antigua API de Google Analytics y .Net ...
Tal vez estoy cansado y que mañana será fácil encontrar una solución, ¡pero ahora necesito ayuda!
Gracias
He configurado algo muy similar a la respuesta anterior en un paquete nuGet. Hace lo siguiente: - se conecta a una "Cuenta de servicio" configurada en la consola API - Extrae los datos de Google Analytics que desee - Muestra los datos usando la API de gráficos de Google y hace todo esto de una manera muy fácil de modificar . Puede ver más aquí: https://www.nuget.org/packages/GoogleAnalytics.GoogleCharts.NET/ .
Hice una gran búsqueda y, finalmente, o bien buscando código de varios lugares y luego envolviendo mi propia interfaz, se me ocurrió la siguiente solución. No estoy seguro si las personas pegan todo el código aquí, pero supongo que por qué no le salvas a todos el tiempo :)
Requisitos previos, deberá instalar Google.GData.Client y google.gdata.analytics package / dll.
Esta es la clase principal que hace el trabajo.
namespace Utilities.Google
{
public class Analytics
{
private readonly String ClientUserName;
private readonly String ClientPassword;
private readonly String TableID;
private AnalyticsService analyticsService;
public Analytics(string user, string password, string table)
{
this.ClientUserName = user;
this.ClientPassword = password;
this.TableID = table;
// Configure GA API.
analyticsService = new AnalyticsService("gaExportAPI_acctSample_v2.0");
// Client Login Authorization.
analyticsService.setUserCredentials(ClientUserName, ClientPassword);
}
/// <summary>
/// Get the page views for a particular page path
/// </summary>
/// <param name="pagePath"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="isPathAbsolute">make this false if the pagePath is a regular expression</param>
/// <returns></returns>
public int GetPageViewsForPagePath(string pagePath, DateTime startDate, DateTime endDate, bool isPathAbsolute = true)
{
int output = 0;
// GA Data Feed query uri.
String baseUrl = "https://www.google.com/analytics/feeds/data";
DataQuery query = new DataQuery(baseUrl);
query.Ids = TableID;
//query.Dimensions = "ga:source,ga:medium";
query.Metrics = "ga:pageviews";
//query.Segment = "gaid::-11";
var filterPrefix = isPathAbsolute ? "ga:pagepath==" : "ga:pagepath=~";
query.Filters = filterPrefix + pagePath;
//query.Sort = "-ga:visits";
//query.NumberToRetrieve = 5;
query.GAStartDate = startDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
query.GAEndDate = endDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
Uri url = query.Uri;
DataFeed feed = analyticsService.Query(query);
output = Int32.Parse(feed.Aggregates.Metrics[0].Value);
return output;
}
public Dictionary<string, int> PageViewCounts(string pagePathRegEx, DateTime startDate, DateTime endDate)
{
// GA Data Feed query uri.
String baseUrl = "https://www.google.com/analytics/feeds/data";
DataQuery query = new DataQuery(baseUrl);
query.Ids = TableID;
query.Dimensions = "ga:pagePath";
query.Metrics = "ga:pageviews";
//query.Segment = "gaid::-11";
var filterPrefix = "ga:pagepath=~";
query.Filters = filterPrefix + pagePathRegEx;
//query.Sort = "-ga:visits";
//query.NumberToRetrieve = 5;
query.GAStartDate = startDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
query.GAEndDate = endDate.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
Uri url = query.Uri;
DataFeed feed = analyticsService.Query(query);
var returnDictionary = new Dictionary<string, int>();
foreach (var entry in feed.Entries)
returnDictionary.Add(((DataEntry)entry).Dimensions[0].Value, Int32.Parse(((DataEntry)entry).Metrics[0].Value));
return returnDictionary;
}
}
}
Y esta es la interfaz y la implementación que uso para concluir.
namespace Utilities
{
public interface IPageViewCounter
{
int GetPageViewCount(string relativeUrl, DateTime startDate, DateTime endDate, bool isPathAbsolute = true);
Dictionary<string, int> PageViewCounts(string pagePathRegEx, DateTime startDate, DateTime endDate);
}
public class GooglePageViewCounter : IPageViewCounter
{
private string GoogleUserName
{
get
{
return ConfigurationManager.AppSettings["googleUserName"];
}
}
private string GooglePassword
{
get
{
return ConfigurationManager.AppSettings["googlePassword"];
}
}
private string GoogleAnalyticsTableName
{
get
{
return ConfigurationManager.AppSettings["googleAnalyticsTableName"];
}
}
private Analytics analytics;
public GooglePageViewCounter()
{
analytics = new Analytics(GoogleUserName, GooglePassword, GoogleAnalyticsTableName);
}
#region IPageViewCounter Members
public int GetPageViewCount(string relativeUrl, DateTime startDate, DateTime endDate, bool isPathAbsolute = true)
{
int output = 0;
try
{
output = analytics.GetPageViewsForPagePath(relativeUrl, startDate, endDate, isPathAbsolute);
}
catch (Exception ex)
{
Logger.Error(ex);
}
return output;
}
public Dictionary<string, int> PageViewCounts(string pagePathRegEx, DateTime startDate, DateTime endDate)
{
var input = analytics.PageViewCounts(pagePathRegEx, startDate, endDate);
var output = new Dictionary<string, int>();
foreach (var item in input)
{
if (item.Key.Contains(''&''))
{
string[] key = item.Key.Split(new char[] { ''?'', ''&'' });
string newKey = key[0] + "?" + key.FirstOrDefault(k => k.StartsWith("p="));
if (output.ContainsKey(newKey))
output[newKey] += item.Value;
else
output[newKey] = item.Value;
}
else
output.Add(item.Key, item.Value);
}
return output;
}
#endregion
}
}
Y ahora el resto es lo obvio: tendrá que agregar los valores de web.config a su configuración de aplicación o webconfig y llamar a IPageViewCounter.GetPageViewCount
Hope google proporcionará la documentación adecuada algún día. Aquí estoy enumerando todos los pasos para integrar la autenticación del lado del servidor de Google Analytics en ASP.NET C #.
Paso 1: crea un proyecto en la consola de Google
Vaya al enlace https://console.developers.google.com/iam-admin/projects y cree un proyecto haciendo clic en el botón "Crear proyecto" y proporcione el nombre del proyecto en la ventana emergente y envíelo.
Paso 2: crea credenciales y cuenta de servicio
Después de la creación del proyecto, serás redirigido a la página "Administrador de API". Haga clic en las credenciales y presione el botón "Crear credenciales". seleccione "clave de cuenta de servicio" en el menú desplegable y será redireccionado a la página siguiente. En la lista desplegable de la cuenta de servicio, seleccione "Nueva cuenta de servicio". Complete el nombre de la cuenta de servicio y descargue la clave p12. Tendrá extensión p12. obtendrá una ventana emergente con una contraseña " notasecret " que es la predeterminada y se descargará su clave privada.
Paso 3: crea la ID del cliente 0auth
haga clic en el menú desplegable "Crear credenciales" y seleccione "0auth client ID", se lo redirigirá a la pestaña "0auth consent screen". proporcione un nombre al azar en el cuadro de texto del nombre del proyecto. seleccione el tipo de aplicación como "Aplicación web" y haga clic en el botón crear. Copie la ID del cliente generado en un bloc de notas.
Paso 4: habilite las API
En el lado izquierdo, haga clic en la pestaña "Descripción general" y seleccione "API habilitadas" en la pestaña horizontal. En la barra de búsqueda, busque "API de análisis", haga clic en el menú desplegable y presione el botón "Habilitar". Ahora nuevamente busque "Analytics Reporting V4" y habilítelo.
Paso 5: Instalar paquetes nuget
En Visual Studio, vaya a Herramientas> Administrador de paquetes Nuget> Consola de administrador de paquetes. Copie y pegue el siguiente código en la consola para instalar los paquetes nuget.
Install-Package Google.Apis.Analytics.v3
Install-Package DotNetOpenAuth.Core-Version 4.3.4.13329
Los dos paquetes anteriores son Google Analytics y DotNetOpenAuth nuget packages.
Paso 6: Proporcionar el permiso ''Ver y analizar'' a la cuenta de servicio
Vaya a la cuenta de Google Analytics y haga clic en la pestaña "Administrador" y seleccione "Gestión de usuarios" en los menús de la izquierda, seleccione el dominio del que desea acceder a los datos de análisis e inserte el ID de correo electrónico de la cuenta de servicio debajo de él y seleccione el permiso "Leer y analizar" del menú desplegable. La ID de correo electrónico de la cuenta de servicio parece ex: [email protected] .
Código de trabajo
CÓDIGO DELANTERO:
Copie y pegue la secuencia de comandos de inserción de analítica a continuación en su interfaz o, de lo contrario, también puede obtener este código de la página de documentación de Google Analytics.
<script>
(function (w, d, s, g, js, fs) {
g = w.gapi || (w.gapi = {}); g.analytics = { q: [], ready: function (f) { this.q.push(f); } };
js = d.createElement(s); fs = d.getElementsByTagName(s)[0];
js.src = ''https://apis.google.com/js/platform.js'';
fs.parentNode.insertBefore(js, fs); js.onload = function () { g.load(''analytics''); };
}(window, document, ''script''));</script>
Pegue el siguiente código en la etiqueta del cuerpo de su página de inicio.
<asp:HiddenField ID="accessToken" runat="server" />
<div id="chart-1-container" style="width:600px;border:1px solid #ccc;"></div>
<script>
var access_token = document.getElementById(''<%= accessToken.ClientID%>'').value;
gapi.analytics.ready(function () {
/**
* Authorize the user with an access token obtained server side.
*/
gapi.analytics.auth.authorize({
''serverAuth'': {
''access_token'': access_token
}
});
/**
* Creates a new DataChart instance showing sessions.
* It will be rendered inside an element with the id "chart-1-container".
*/
var dataChart1 = new gapi.analytics.googleCharts.DataChart({
query: {
''ids'': ''ga:53861036'', // VIEW ID <-- Goto your google analytics account and select the domain whose analytics data you want to display on your webpage. From the URL ex: a507598w53044903p53861036. Copy the digits after "p". It is your view ID
''start-date'': ''2016-04-01'',
''end-date'': ''2016-04-30'',
''metrics'': ''ga:sessions'',
''dimensions'': ''ga:date''
},
chart: {
''container'': ''chart-1-container'',
''type'': ''LINE'',
''options'': {
''width'': ''100%''
}
}
});
dataChart1.execute();
/**
* Creates a new DataChart instance showing top 5 most popular demos/tools
* amongst returning users only.
* It will be rendered inside an element with the id "chart-3-container".
*/
});
</script>
También puede obtener su ID de vista desde https://ga-dev-tools.appspot.com/account-explorer/
VOLVER CÓDIGO FINAL:
using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.Script.Serialization;
using System.Net;
using System.Text;
using Google.Apis.Analytics.v3;
using Google.Apis.Analytics.v3.Data;
using Google.Apis.Services;
using System.Security.Cryptography.X509Certificates;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Util;
using DotNetOpenAuth.OAuth2;
using System.Security.Cryptography;
namespace googleAnalytics
{
public partial class api : System.Web.UI.Page
{
public const string SCOPE_ANALYTICS_READONLY = "https://www.googleapis.com/auth/analytics.readonly";
string ServiceAccountUser = "[email protected]"; //service account email ID
string keyFile = @"D:/key.p12"; //file link to downloaded key with p12 extension
protected void Page_Load(object sender, EventArgs e)
{
string Token = Convert.ToString(GetAccessToken(ServiceAccountUser, keyFile, SCOPE_ANALYTICS_READONLY));
accessToken.Value = Token;
var certificate = new X509Certificate2(keyFile, "notasecret", X509KeyStorageFlags.Exportable);
var credentials = new ServiceAccountCredential(
new ServiceAccountCredential.Initializer(ServiceAccountUser)
{
Scopes = new[] { AnalyticsService.Scope.AnalyticsReadonly }
}.FromCertificate(certificate));
var service = new AnalyticsService(new BaseClientService.Initializer()
{
HttpClientInitializer = credentials,
ApplicationName = "Google Analytics API"
});
string profileId = "ga:53861036";
string startDate = "2016-04-01";
string endDate = "2016-04-30";
string metrics = "ga:sessions,ga:users,ga:pageviews,ga:bounceRate,ga:visits";
DataResource.GaResource.GetRequest request = service.Data.Ga.Get(profileId, startDate, endDate, metrics);
GaData data = request.Execute();
List<string> ColumnName = new List<string>();
foreach (var h in data.ColumnHeaders)
{
ColumnName.Add(h.Name);
}
List<double> values = new List<double>();
foreach (var row in data.Rows)
{
foreach (var item in row)
{
values.Add(Convert.ToDouble(item));
}
}
values[3] = Math.Truncate(100 * values[3]) / 100;
txtSession.Text = values[0].ToString();
txtUsers.Text = values[1].ToString();
txtPageViews.Text = values[2].ToString();
txtBounceRate.Text = values[3].ToString();
txtVisits.Text = values[4].ToString();
}
public static dynamic GetAccessToken(string clientIdEMail, string keyFilePath, string scope)
{
// certificate
var certificate = new X509Certificate2(keyFilePath, "notasecret");
// header
var header = new { typ = "JWT", alg = "RS256" };
// claimset
var times = GetExpiryAndIssueDate();
var claimset = new
{
iss = clientIdEMail,
scope = scope,
aud = "https://accounts.google.com/o/oauth2/token",
iat = times[0],
exp = times[1],
};
JavaScriptSerializer ser = new JavaScriptSerializer();
// encoded header
var headerSerialized = ser.Serialize(header);
var headerBytes = Encoding.UTF8.GetBytes(headerSerialized);
var headerEncoded = Convert.ToBase64String(headerBytes);
// encoded claimset
var claimsetSerialized = ser.Serialize(claimset);
var claimsetBytes = Encoding.UTF8.GetBytes(claimsetSerialized);
var claimsetEncoded = Convert.ToBase64String(claimsetBytes);
// input
var input = headerEncoded + "." + claimsetEncoded;
var inputBytes = Encoding.UTF8.GetBytes(input);
// signature
var rsa = certificate.PrivateKey as RSACryptoServiceProvider;
var cspParam = new CspParameters
{
KeyContainerName = rsa.CspKeyContainerInfo.KeyContainerName,
KeyNumber = rsa.CspKeyContainerInfo.KeyNumber == KeyNumber.Exchange ? 1 : 2
};
var aescsp = new RSACryptoServiceProvider(cspParam) { PersistKeyInCsp = false };
var signatureBytes = aescsp.SignData(inputBytes, "SHA256");
var signatureEncoded = Convert.ToBase64String(signatureBytes);
// jwt
var jwt = headerEncoded + "." + claimsetEncoded + "." + signatureEncoded;
var client = new WebClient();
client.Encoding = Encoding.UTF8;
var uri = "https://accounts.google.com/o/oauth2/token";
var content = new NameValueCollection();
content["assertion"] = jwt;
content["grant_type"] = "urn:ietf:params:oauth:grant-type:jwt-bearer";
string response = Encoding.UTF8.GetString(client.UploadValues(uri, "POST", content));
var result = ser.Deserialize<dynamic>(response);
object pulledObject = null;
string token = "access_token";
if (result.ContainsKey(token))
{
pulledObject = result[token];
}
//return result;
return pulledObject;
}
private static int[] GetExpiryAndIssueDate()
{
var utc0 = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
var issueTime = DateTime.UtcNow;
var iat = (int)issueTime.Subtract(utc0).TotalSeconds;
var exp = (int)issueTime.AddMinutes(55).Subtract(utc0).TotalSeconds;
return new[] { iat, exp };
}
}
}
Requiere un poco de configuración en el lado de google, pero en realidad es bastante simple. Voy a enumerar paso a paso.
Primero, deberá crear una aplicación en la consola de la nube de Google y habilitar la API de Analytics.
- Vaya a http://code.google.com/apis/console
- Seleccione el menú desplegable y cree un proyecto si aún no tiene uno
- Una vez que se crea el proyecto, haga clic en servicios
- Desde aquí habilita la API de Analytics
Ahora que la API de Analytics está habilitada, el siguiente paso será habilitar una cuenta de servicio para acceder a los perfiles / sitios analíticos que desee. La cuenta de servicio le permitirá iniciar sesión sin tener que solicitar credenciales al usuario.
- Vaya a http://code.google.com/apis/console y elija el proyecto que creó desde el menú desplegable.
- A continuación, vaya a la sección "Acceso a la API" y haga clic en el botón "Crear otra identificación de cliente".
- En la ventana Crear ID de cliente, seleccione la cuenta de servicio y haga clic en crear ID de cliente.
- Descargue la clave pública para esta cuenta si no inicia la descarga automáticamente. Lo necesitará más adelante cuando codifique la autorización.
- Antes de salir, copie las cuentas de servicio de la dirección de correo electrónico generada automáticamente, ya que las necesitará en el siguiente paso. El correo electrónico del cliente se ve como @ developer.gserviceaccount.com
Ahora que tenemos una cuenta de servicio, deberá permitir que esta cuenta de servicio acceda a sus perfiles / sitios en Google Analytics.
- Inicie sesión en Google Analytics.
- Una vez que haya iniciado sesión, haga clic en el botón Admin al bottem que queda en la pantalla.
- En Admin, haga clic en el menú desplegable de la cuenta y seleccione la cuenta / sitio al que le gustaría que su cuenta de servicio pueda acceder, luego haga clic en "Administración de usuarios" en la sección de cuenta.
- Ingrese la dirección de correo electrónico que se generó para su cuenta de servicio y dele permiso de lectura y análisis.
- Repita estos pasos para cualquier otra cuenta / sitio al que desee que tenga acceso su servicio.
Ahora que la configuración está hecha para que la cuenta de servicio acceda a Google Analytics a través de la API, podemos comenzar a codificar.
Obtenga este paquete de NuGet:
Google.Apis.Analytics.v3 Client Library
Agregue estos usos:
using Google.Apis.Analytics.v3;
using Google.Apis.Analytics.v3.Data;
using Google.Apis.Services;
using System.Security.Cryptography.X509Certificates;
using Google.Apis.Auth.OAuth2;
using System.Collections.Generic;
using System.Linq;
Algunas cosas para notar son
-
keyPathes la ruta al archivo de clave que descargó con una extensión de archivo .p12. - La cuenta
accountEmailAddresses el correo electrónico que recibimos antes. - El alcance es un Enum en la clase
Google.Apis.Analytics.v3.AnalyticServiceque dicta la url a utilizar para autorizar (por ejemplo:AnalyticsService.Scope.AnalyticsReadonly). - El nombre de la aplicación es el nombre que usted elige y le dice a la API de Google qué es lo que está accediendo (también conocido como: puede ser lo que elija).
Entonces el código para hacer algunas llamadas básicas es el siguiente.
public class GoogleAnalyticsAPI
{
public AnalyticsService Service { get; set; }
public GoogleAnalyticsAPI(string keyPath, string accountEmailAddress)
{
var certificate = new X509Certificate2(keyPath, "notasecret", X509KeyStorageFlags.Exportable);
var credentials = new ServiceAccountCredential(
new ServiceAccountCredential.Initializer(accountEmailAddress)
{
Scopes = new[] { AnalyticsService.Scope.AnalyticsReadonly }
}.FromCertificate(certificate));
Service = new AnalyticsService(new BaseClientService.Initializer()
{
HttpClientInitializer = credentials,
ApplicationName = "WorthlessVariable"
});
}
public AnalyticDataPoint GetAnalyticsData(string profileId, string[] dimensions, string[] metrics, DateTime startDate, DateTime endDate)
{
AnalyticDataPoint data = new AnalyticDataPoint();
if (!profileId.Contains("ga:"))
profileId = string.Format("ga:{0}", profileId);
//Make initial call to service.
//Then check if a next link exists in the response,
//if so parse and call again using start index param.
GaData response = null;
do
{
int startIndex = 1;
if (response != null && !string.IsNullOrEmpty(response.NextLink))
{
Uri uri = new Uri(response.NextLink);
var paramerters = uri.Query.Split(''&'');
string s = paramerters.First(i => i.Contains("start-index")).Split(''='')[1];
startIndex = int.Parse(s);
}
var request = BuildAnalyticRequest(profileId, dimensions, metrics, startDate, endDate, startIndex);
response = request.Execute();
data.ColumnHeaders = response.ColumnHeaders;
data.Rows.AddRange(response.Rows);
} while (!string.IsNullOrEmpty(response.NextLink));
return data;
}
private DataResource.GaResource.GetRequest BuildAnalyticRequest(string profileId, string[] dimensions, string[] metrics,
DateTime startDate, DateTime endDate, int startIndex)
{
DataResource.GaResource.GetRequest request = Service.Data.Ga.Get(profileId, startDate.ToString("yyyy-MM-dd"),
endDate.ToString("yyyy-MM-dd"), string.Join(",", metrics));
request.Dimensions = string.Join(",", dimensions);
request.StartIndex = startIndex;
return request;
}
public IList<Profile> GetAvailableProfiles()
{
var response = Service.Management.Profiles.List("~all", "~all").Execute();
return response.Items;
}
public class AnalyticDataPoint
{
public AnalyticDataPoint()
{
Rows = new List<IList<string>>();
}
public IList<GaData.ColumnHeadersData> ColumnHeaders { get; set; }
public List<IList<string>> Rows { get; set; }
}
}
Otros enlaces que serán útiles:
Analytic API Explorer - API de consulta de la Web
Analytic API Explorer versión 2 - API de consulta de la Web
Referencia de dimensiones y métricas
Espero que esto ayude a alguien a tratar de hacer esto en el futuro.
Tenía la esperanza de agregar un comentario a la respuesta para v3 Beta, pero los puntos de repetición lo impiden. Sin embargo, pensé que sería bueno para otros tener esta información, así que aquí está:
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using System.Security.Cryptography.X509Certificates;
using Google.Apis.Services;
Estos espacios de nombre se utilizan en todo el código en esa publicación. Siempre me gustaría que las personas publicaran espacios con nombres más a menudo, me parece que paso un buen rato buscándolos. Espero que esto ahorre algunas personas unos minutos de trabajo.
Otro enfoque de trabajo
Agregue el código siguiente en ConfigAuth
var googleApiOptions = new GoogleOAuth2AuthenticationOptions()
{
AccessType = "offline", // can use only if require
ClientId = ClientId,
ClientSecret = ClientSecret,
Provider = new GoogleOAuth2AuthenticationProvider()
{
OnAuthenticated = context =>
{
context.Identity.AddClaim(new Claim("Google_AccessToken", context.AccessToken));
if (context.RefreshToken != null)
{
context.Identity.AddClaim(new Claim("GoogleRefreshToken", context.RefreshToken));
}
context.Identity.AddClaim(new Claim("GoogleUserId", context.Id));
context.Identity.AddClaim(new Claim("GoogleTokenIssuedAt", DateTime.Now.ToBinary().ToString()));
var expiresInSec = 10000;
context.Identity.AddClaim(new Claim("GoogleTokenExpiresIn", expiresInSec.ToString()));
return Task.FromResult(0);
}
},
SignInAsAuthenticationType = DefaultAuthenticationTypes.ApplicationCookie
};
googleApiOptions.Scope.Add("openid"); // Need to add for google+
googleApiOptions.Scope.Add("profile");// Need to add for google+
googleApiOptions.Scope.Add("email");// Need to add for google+
googleApiOptions.Scope.Add("https://www.googleapis.com/auth/analytics.readonly");
app.UseGoogleAuthentication(googleApiOptions);
Agregue código a continuación, espacios de nombre y referencias relativas
using Google.Apis.Analytics.v3;
using Google.Apis.Analytics.v3.Data;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Auth.OAuth2.Flows;
using Google.Apis.Auth.OAuth2.Responses;
using Google.Apis.Services;
using Microsoft.AspNet.Identity;
using Microsoft.Owin.Security;
using System;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;
public class HomeController : Controller
{
AnalyticsService service;
public IAuthenticationManager AuthenticationManager
{
get
{
return HttpContext.GetOwinContext().Authentication;
}
}
public async Task<ActionResult> AccountList()
{
service = new AnalyticsService(new BaseClientService.Initializer()
{
HttpClientInitializer = await GetCredentialForApiAsync(),
ApplicationName = "Analytics API sample",
});
//Account List
ManagementResource.AccountsResource.ListRequest AccountListRequest = service.Management.Accounts.List();
//service.QuotaUser = "MyApplicationProductKey";
Accounts AccountList = AccountListRequest.Execute();
return View();
}
private async Task<UserCredential> GetCredentialForApiAsync()
{
var initializer = new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = ClientId,
ClientSecret = ClientSecret,
},
Scopes = new[] { "https://www.googleapis.com/auth/analytics.readonly" }
};
var flow = new GoogleAuthorizationCodeFlow(initializer);
var identity = await AuthenticationManager.GetExternalIdentityAsync(DefaultAuthenticationTypes.ApplicationCookie);
if (identity == null)
{
Redirect("/Account/Login");
}
var userId = identity.FindFirstValue("GoogleUserId");
var token = new TokenResponse()
{
AccessToken = identity.FindFirstValue("Google_AccessToken"),
RefreshToken = identity.FindFirstValue("GoogleRefreshToken"),
Issued = DateTime.FromBinary(long.Parse(identity.FindFirstValue("GoogleTokenIssuedAt"))),
ExpiresInSeconds = long.Parse(identity.FindFirstValue("GoogleTokenExpiresIn")),
};
return new UserCredential(flow, userId, token);
}
}
Agregue esto en Application_Start () en Global.asax
AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;