51 votes

Utiliser l'API de Google Analytics pour afficher des informations en C#

J'ai été à la recherche d'une bonne solution de tous les jours, mais google évoluent tellement vite que je ne peux pas trouver quelque chose qui marche. Ce que je veux faire, c'est que, j'ai une application Web qui a un admin de la section où l'utilisateur devez être connecté pour voir les informations. Dans cette section, je veux vous montrer quelques données de GA, comme le nombre de pages vues pour certains des url spécifiques. Puisqu'il n'est pas à l'utilisateur des informations que je vous montre, mais le google analytics usager je veux me connecter en transmettant les informations (nom d'utilisateur/mot de passe ou APIKey) mais je ne peux pas savoir comment. Tous les exemples que j'ai trouvé l'utilisation OAuth2 (sorcière, si je comprends bien, va demander au visiteur de se connecter en utilisant google).

Ce que j'ai trouvé jusqu'à présent :

Peut-être que je suis juste fatigué et que demain, il sera facile de trouver une solution mais pour l'instant, j'ai besoin d'aide!

Merci

92voto

LiquaFoo Points 737

Il nécessite un peu de configuration sur le côté de google, mais il est en fait assez simple. Je vais étape par étape.

D'abord, vous aurez besoin de créer une application dans le Google cloud console et activer l'analyse de l'API.

  • Aller à http://code.google.com/apis/console
  • Sélectionnez la liste déroulante, et de créer un projet si vous ne possédez pas déjà un
  • Une fois le projet créé, cliquez sur services
  • À partir d'ici de permettre à l'Analytics API

Maintenant que l'analyse de l'API est activé, la prochaine étape sera de permettre à un compte de service pour l'accès de votre choix profils google analytics/sites. Le compte de service vous permet de vous connecter sans avoir à inviter un utilisateur à des informations d'identification.

  • Aller à http://code.google.com/apis/console et choisissez le projet que vous créé à partir de la liste déroulante.
  • Ensuite, allez dans "API Access" et cliquez sur "Créer un autre client id" bouton.
  • Dans la création de l'IDENTIFIANT Client windows choisir le compte de service et cliquez sur créer un identifiant client.
  • Télécharger la clé publique de ce compte s'il ne démarre pas le télécharger automatiquement.Vous en aurez besoin plus tard, lorsque vous code pour d'autorisation.
  • Avant de sortir de copier les comptes de service' auto généré adresse email car vous en aurez besoin à l'étape suivante. Le client e-mail ressemble à @developer.gserviceaccount.com

Maintenant que nous avons un compte de service que vous aurez besoin pour permettre à ce service compte pour accéder à vos profils de vos sites dans Google Analytics.

  • Connectez-vous à Google Analytics.
  • Une fois connecté, cliquez sur l'Admin bouton dans le coin supérieur droit sur la de l'écran.
  • Dans l'Admin, cliquez sur le compte du menu déroulant et sélectionnez le compte/site que vous souhaitez que votre compte de service pour être en mesure d'accéder, puis cliquez sur "Gestion des Utilisateurs" dans la section compte.
  • Saisissez l'adresse email qui a été généré pour votre compte de service et de lui donner la lecture et l'analyse de l'autorisation.
  • Répétez ces étapes pour tous les autres compte/de site que vous voulez à votre service pour avoir accès à l'.

Maintenant que la configuration est faite pour le compte de service pour accéder à Google Analytics via l'API, nous pouvons commencer à coder.

Obtenir ce package de NuGet:

Google.Les api.Google Analytics.v3 de la Bibliothèque du Client

Ajouter de l'usage:

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;

Quelques choses à noter.

  • L' keyPath est le chemin d'accès est la clé du fichier que vous avez téléchargé avec un .p12 fichier de l'extension.
  • L' accountEmailAddress est l'api email que nous avons reçu plus tôt.
  • La portée est un Enum dans l' Google.Apis.Analytics.v3.AnalyticService classe qui dicte l'url à utiliser pour autoriser (ex: AnalyticsService.Scope.AnalyticsReadonly ).
  • Nom de l'Application est un nom de votre choix qui raconte l'api google ce qui est d'y accéder (aka: il peut être ce que jamais vous choisissez).

Ensuite le code pour faire quelques appels de base est la suivante.

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; }
    }
}

D'autres Liens qui vous seront utiles:

Analytique de l'Explorateur de l'API - API de Requêtes à Partir Du Web

Analytique de l'API Explorer version 2 - Requête API Du Web

Les Dimensions et les mesures de Référence

Espérons que cela aide quelqu'un à essayer de le faire dans l'avenir.

31voto

MoXplod Points 1379

J'ai fait beaucoup de recherche et, enfin, soit à la recherche de code à partir de plusieurs endroits, puis enveloppant ma propre interface autour d'elle que je suis venu avec la solution suivante. Vous ne savez pas si les gens pâte toute leur code ici, mais je suppose que pourquoi ne pas sauver tout le monde le reste du temps :)

Pré-requis, vous aurez besoin d'installer Google.GData.Client et google.gdata.package d'analyse/dll.

C'est la classe principale qui fait le travail.

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;
        }
    }
}

Et c'est l'interface et la mise en œuvre que j'utilise pour l'envelopper avec.

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
    }
}

Et maintenant, le reste est à l'évidence de trucs, vous aurez à ajouter sur le web.config valeurs de votre demande de config ou webconfig et appel IPageViewCounter.GetPageViewCount

10voto

Jereme Guenther Points 48

J'espérais juste à ajouter un commentaire à la réponse pour le v3 Beta, mais des points de rep les en empêcher. Cependant, j'ai pensé qu'il serait sympa pour les autres d'avoir cette information si elle est ici:

using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using System.Security.Cryptography.X509Certificates;
using Google.Apis.Services;

Ces espaces de nom sont utilisés dans tout le code dans ce post. J'ai toujours souhaite que les gens poste des espaces de noms plus souvent, j'ai l'impression de passer un bon peu de temps à la recherche pour eux. J'espère que cela permet d'économiser quelques personnes à quelques minutes de travail.

3voto

pharophy Points 153

J'ai configuré quelque chose d'assez semblable à la réponse ci-dessus dans un package nuGet. Il effectue les opérations suivantes: - se connecte à un "Compte de Service" que vous avez défini dans l'API Console - Extrait toutes les données Google Analytics vous souhaitez - Affiche les données à l'aide de Google Graphiques de l'API et il fait tout cela dans un très facile à modifier manière. Vous pouvez en voir plus ici: https://www.nuget.org/packages/GoogleAnalytics.GoogleCharts.NET/.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X