web-dev-qa-db-fra.com

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

Je cherchais une bonne solution toute la journée, mais Google évolue si rapidement que je ne trouve pas quelque chose qui fonctionne. Ce que je veux faire, c'est que j'ai une application Web qui comporte une section admin où l'utilisateur doit être connecté pour voir les informations. Dans cette section, je souhaite afficher certaines données de l’AG, telles que les pages vues pour certaines URL spécifiques. Étant donné que ce ne sont pas les informations utilisateur que je montre mais les utilisateurs de google analytics que je veux connecter, informations de transmission (nom d'utilisateur/mot de passe ou APIKey), mais je ne peux pas savoir comment. Tous les exemples que j'ai trouvés utilisent OAuth2 (si je comprends bien, le visiteur demandera au visiteur de se connecter à l'aide de 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 le moment j'ai besoin d'aide!

Merci

c#.netgoogle-apigoogle-analytics-api
46
VinnyG

J'ai fait beaucoup de recherches et finalement, soit en recherchant du code à plusieurs endroits, puis en enveloppant ma propre interface, j'ai proposé la solution suivante. Pas sûr que les gens collent tout leur code ici, mais j'imagine pourquoi ne pas gagner du temps pour tous les autres :)

Pré-requis, vous devrez installer Google.GData.Client et le package google.gdata.analytics/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 ceci est l'interface et la mise en œuvre que j'utilise pour conclure.

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 une chose évidente: vous devrez ajouter les valeurs web.config à la configuration de votre application ou à votre configuration Web et appeler IPageViewCounter.GetPageViewCount

31
MoXplod

Cela nécessite un peu d’installation du côté de Google mais c’est en fait assez simple. Je vais énumérer étape par étape. 

Vous devez tout d'abord créer une application dans la console Google Cloud et activer l'API Analytics. 

  • Accédez à http://code.google.com/apis/console
  • Sélectionnez le menu déroulant et créez un projet si vous n'en avez pas déjà un.
  • Une fois le projet créé, cliquez sur les services.
  • À partir de là, activez l'API Analytics

Maintenant que l'API Analytics est activée, l'étape suivante consiste à permettre à un compte de service d'accéder aux profils/sites d'analyse souhaités. Le compte de service vous permettra de vous connecter sans demander à un utilisateur ses informations d'identification.

  • Accédez à http://code.google.com/apis/console et choisissez le projet que vous avez créé à partir du menu déroulant.
  • Ensuite, allez à la section "Accès à l'API" et cliquez sur le bouton "Créer un autre ID client".
  • Dans la fenêtre Créer un ID client, choisissez un compte de service et cliquez sur Créer un ID client.
  • Téléchargez la clé publique de ce compte s'il ne lance pas ledownload automatiquement. Vous en aurez besoin ultérieurement lorsque vous coderez pour l'autorisation
  • Avant de quitter, copiez l'adresse électronique générée automatiquement par les comptes de service, car vous en aurez besoin à l'étape suivante. L'email du client ressemble à @ developer.gserviceaccount.com

Maintenant que nous avons un compte de service, vous devez autoriser ce compte à accéder à vos profils/sites dans Google Analytics. 

  • Connectez-vous à Google Analytics.
  • Une fois connecté, cliquez sur le bouton Admin en bas à gauche de l'écran
  • Dans Admin, cliquez sur le compte déroulant et sélectionnez le compte/le site auquel vous souhaitez que votre compte de service puisse accéder, puis cliquez sur "Gestion des utilisateurs" dans la section du compte.
  • Entrez l'adresse e-mail générée pour votre compte de service et donnez-lui l'autorisation de lire et d'analyser. 
  • Répétez ces étapes pour tout autre compte/site auquel vous souhaitez que votre service ait accès.

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

Obtenez ce paquet de NuGet: 

Bibliothèque cliente Google.Apis.Analytics.v3

Ajoutez ces utilisations:

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;

Certaines choses à noter sont.

  • keyPath est le chemin du fichier de clé que vous avez téléchargé avec une extension de fichier .p12. 
  • La accountEmailAddress est le courrier électronique de l'API que nous avons reçu plus tôt.
  • Scope est un enum dans la classe Google.Apis.Analytics.v3.AnalyticService qui dicte l’URL à utiliser pour autoriser (ex: AnalyticsService.Scope.AnalyticsReadonly).
  • Le nom de l'application est un nom de votre choix qui indique à l'API Google ce qui y accède (c'est-à-dire: il peut correspondre à vos choix).

Ensuite, le code pour faire des appels de base est comme suit.

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

Autres liens utiles:

Analytic API Explorer - API de requête du Web

Analytic API Explorer version 2 - API de requête du Web

Référence Dimensions et métriques

J'espère que cela aidera quelqu'un qui tentera de le faire à l'avenir. 

79
Logan G.

J'espérais juste ajouter un commentaire à la réponse pour la version bêta 3, mais les points de repère l'empêchent. Cependant, j'ai pensé que ce serait bien que d'autres aient cette information, alors la voici:

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

Ces espaces de noms sont utilisés dans tout le code de cet article. Je souhaite toujours que les gens publient des espaces de noms plus souvent, je semble passer beaucoup de temps à les rechercher. J'espère que cela économisera quelques minutes de travail à certaines personnes.

10
Jereme Guenther

Cette réponse s'adresse à ceux d'entre vous qui souhaitent accéder à votre propre compte Analytics et qui souhaitent utiliser la nouvelle Analytics Reporting API v4 .

J'ai récemment écrit un article blog expliquant comment obtenir des données Google Analytics en utilisant C #. Lisez-le pour tous les détails.

Vous devez d’abord choisir de vous connecter à OAuth2 ou à un compte de service. Je présume que vous possédez un compte Google Analytics. Vous devez donc créer une "clé de compte de service" à partir de la page API Google informations d'identification .

Une fois que vous avez créé cela, téléchargez le fichier JSON et placez-le dans votre projet (je mets le mien dans mon dossier App_Data).

Ensuite, installez le package Nuget Google.Apis.AnalyticsReporting.v4 . Installez également Json.NET de Newtonsoft.

Incluez cette classe quelque part dans votre projet:

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

Et voici ce que vous attendiez: un exemple complet!

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

Nous commençons par désérialiser les informations de clé du compte de service à partir du fichier JSON et les convertir en un objet PersonalServiceAccountCred. Ensuite, nous créons la ServiceAccountCredential et nous connectons à Google via la AnalyticsReportingService. À l'aide de ce service, nous préparons ensuite des filtres de base à transmettre à l'API et à envoyer la demande.

Il est probablement préférable de définir un point d'arrêt sur la ligne où la variable response est déclarée, appuyez une fois sur la touche F10, puis passez la souris sur la variable pour que vous puissiez voir quelles données sont disponibles pour vous dans la réponse.

8
John Washam

J'ai mis en place quelque chose d'assez similaire à la réponse ci-dessus dans un paquet nuGet. Il fait ce qui suit: - se connecte à un "compte de service" que vous avez configuré dans la console API - Extrait les données de Google Analytics que vous souhaitez - Affiche ces données à l’aide de l’API des graphiques Google Tout cela de manière très simple à modifier. Vous pouvez en voir plus ici: https://www.nuget.org/packages/GoogleAnalytics.GoogleCharts.NET/ .

3
pharophy

J'espère que Google fournira la documentation appropriée un jour. Ici, je liste toutes les étapes pour intégrer l’authentification côté serveur Google Analytics dans ASP.NET C #.

Etape 1: Créer un projet dans la console Google 

Accédez au lien https://console.developers.google.com/iam-admin/projects et créez un projet en cliquant sur le bouton "Créer un projet". Indiquez le nom du projet dans la fenêtre contextuelle et envoyez-le.

Étape 2: Créer les informations d'identification et le compte de service

Une fois le projet créé, vous serez redirigé vers la page "Gestionnaire d'API" . Cliquez sur les informations d'identification, puis sur le bouton "Créer les informations d'identification". sélectionnez "clé de compte de service" dans la liste déroulante, vous serez redirigé vers la page suivante . Dans la liste déroulante de compte de service, sélectionnez "Nouveau compte de service". Entrez le nom du compte de service et téléchargez la clé p12. Il aura l'extension p12. vous obtiendrez un popup avec un mot de passe "notasecret" qui est le mot de passe par défaut et votre clé privée sera téléchargée.

Étape 3: Créer un identifiant client 0auth

cliquez sur le menu déroulant "Créer les informations d'identification" et sélectionnez "ID client 0auth". Vous serez redirigé vers l'onglet "Écran de consentement 0auth". fournissez un nom aléatoire dans la zone de texte du nom du projet. sélectionnez le type d’application comme "application Web" et cliquez sur le bouton Créer. Copiez l'ID de client généré dans un bloc-notes.

Étape 4: Activer les API

Sur le côté gauche, cliquez sur l'onglet "Présentation" et sélectionnez "API activées" dans l'onglet horizontal. Dans la barre de recherche, recherchez "API Analytics", cliquez sur le menu déroulant et appuyez sur le bouton "Activer". À nouveau, recherchez "Analytics Reporting V4" et activez-le.

Étape 5: Installez les paquets de nuget

Dans Visual Studio, sélectionnez Outils> Gestionnaire de packages Nuget> Console du gestionnaire de packages . Copiez-collez le code ci-dessous dans la console pour installer les packages de nuget.

Paquet d'installation Google.Apis.Analytics.v3

Paquet d'installation DotNetOpenAuth.Core - Version 4.3.4.13329

Les deux packages ci-dessus sont Google Analytics et les packages de nuget DotNetOpenAuth.

Étape 6: Fournissez la permission «Voir et analyser» au compte de service 

Allez sur le compte google analytics et cliquez sur l'onglet "Admin" et sélectionnez "Gestion des utilisateurs" dans les menus de gauche, sélectionnez un domaine dont vous souhaitez accéder aux données analytiques et insérez l'identifiant de messagerie du compte de service et sélectionnez l'autorisation "Lire et analyser". de la liste déroulante. L'identifiant email du compte de service ressemble à ex: [email protected].

Code de travail

CODE AVANT:

Copiez et collez le script d'intégration Analytics ci-dessous dans votre frontal, ou vous pouvez également obtenir ce code à partir de la page de documentation 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>

Collez le code ci-dessous dans la balise body de votre page d’accueil.

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

Vous pouvez également obtenir votre ID de vue à partir de https://ga-dev-tools.appspot.com/account-Explorer/

RETOUR CODE FIN:

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

        }
    }
1
Rakesh Dadamatti

Une autre approche de travail

Ajouter le code ci-dessous dans 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);

Ajouter ci-dessous le code, les espaces de noms et les références relatives

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

Ajoutez ceci dans Application_Start () dans Global.asax 

  AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;
0
Parth Mistry