Verwenden Sie die Google Analytics-API, um Informationen in C # anzuzeigen.

War ich auf der Suche nach einer guten Lösung den ganzen Tag, aber google entwickeln sich so schnell, dass ich nicht finden können, etwas zu arbeiten. Was ich tun möchte, ist, dass, ich habe eine Web-app, die hat ein admin-Abschnitt, wo Benutzer müssen angemeldet sein, um die information zu sehen. In diesem Abschnitt möchte ich zeigen einige Daten aus GA, wie Seitenaufrufe für bestimmte urls. Da es nicht der Benutzer Informationen, die ich zeige, aber die google-analytics-'user ich will schließen Sie die Weitergabe von Informationen (username/Passwort oder APIKey), aber ich kann nicht herausfinden, wie. Alle Beispiel-fand ich verwenden OAuth2 (Hexe, wenn ich verstehe, fragt die Besucher, um sich mit google).

Was ich bisher gefunden :

Google official Client-Bibliothek für .Net : http://code.google.com/p/google-api-dotnet-client/keine Probe für GA
offiziellen Entwickler helfen : https://developers.google.com/analytics/
eine andere Frage, die mit dem code SO : Google Analytics-API Programmgesteuert abrufen Seitenaufrufe im server-Seite aber ich bekomme eine 403, wenn ich versuche, sich zu authentifizieren
einige Quelle, die Zugriff auf die API : http://www.reimers.dk/jacob-reimers-blog/added-google-analytics-reader-for-net heruntergeladen die Quelle, aber ich kann nicht herausfinden, wie es funktioniert
diese andere Frage SO : Google-Analytics-Zugriff mit C# aber es hilft nicht,
beim schreiben dieser Sie schlagen mir vor das 09 alte post Google Analytics-API .Net...

Vielleicht bin ich einfach nur müde und morgen wird es leicht sein, eine Lösung zu finden, aber jetzt brauche ich Hilfe!

Dank

InformationsquelleAutor der Frage VinnyG | 2012-04-24

.net c#google-analytics-api google-api

Ich habe eine Menge von such-und schließlich entweder auf der Suche code aus mehreren Orten und dann packe meine eigenen Schnittstelle um ihn herum kam ich auf die folgende Lösung. Nicht sicher, wenn die Menschen fügen Ihrer ganzen code hier, aber ich denke, warum nicht speichern Sie alle anderen Zeit 🙂

Voraussetzungen, Sie müssen Sie installieren, Google.GData.Client und google.gdata.Analyse-Paket/dll.

Dies ist die Hauptklasse, die die Arbeit macht.

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

- Und dies ist die Schnittstelle und die Implementierung, die ich verwenden, um wickeln Sie es mit.

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

Und nun der rest ist die offensichtliche Zeug - müssen Sie die web.config-Werte für Ihre Anwendung-config oder über webconfig und rufen IPageViewCounter.GetPageViewCount

InformationsquelleAutor der Antwort MoXplod

Es erfordert ein wenig setup auf der google-Seite, aber es ist eigentlich ganz einfach. Ich werde die Liste Schritt für Schritt durch.

Zunächst müssen Sie eine Anwendung erstellen, in der Google cloud console und aktivieren Sie die Analytics-API.

Gehen http://code.google.com/apis/console
Wählen Sie das Dropdown-Menü und erstellen Sie ein Projekt, wenn Sie nicht bereits eine haben,
Sobald das Projekt erstellt wurde, klicken Sie auf Dienste
Aus hier aktivieren Sie die Analytics-API

Jetzt, dass die Analytics-API aktiviert ist, wird der nächste Schritt, um einen Dienst zu aktivieren Konto für den Zugriff auf Ihre gewünschten analytics-profile/- Seiten. Der service-Konto ermöglicht es Ihnen, log-in, ohne Aufforderung einen Benutzer zur Eingabe der Anmeldeinformationen.

Gehen http://code.google.com/apis/console und wählen Sie das Projekt, das Sie
erstellt aus dem drop-down.
Nächsten gehen Sie auf die "API-Zugriff" und klicken Sie auf "Create another client id" - Taste.
In der Create-Client-ID-Fenster, wählen Sie service-Konto und klicken Sie auf
erstellen Sie client-id.
Laden Sie den öffentlichen Schlüssel für dieses Konto, wenn es nicht starten
download automatisch.Sie benötigen diese später, wenn Sie code für
die Autorisierung.
Vor dem beenden kopieren Sie die service-Konten automatisch generierte E-Mail-Adresse, die Sie benötigen diese im nächsten Schritt. Die E-Mail-client sieht aus wie @developer.gserviceaccount.com

Nun haben wir ein service-Konto müssen Sie das Dienstkonto für den Zugriff auf Ihre profile/Seiten in Google Analytics.

Loggen Sie sich in Google Analytics.
Nachdem Sie sich eingeloggt haben klicken Sie auf den Admin-button unten Links auf dem
Bildschirm.
Im Admin klicken Sie auf die Konto-Dropdown-Menü und wählen Sie das Konto/Website, die Sie möchten, dass Ihr service-Konto zugreifen, dann klicken Sie auf "User Management" unter dem Abschnitt Konto.
Geben Sie die E-Mail-Adresse generiert wurde, für Ihr service-Konto und geben Sie es Lesen und analysieren Genehmigung.
Wiederholen Sie diese Schritte für jedes andere Konto/Website, die Sie möchten, dass Ihr service-Zugang zu haben.

Damit ist das setup fertig für das Dienstkonto für den Zugriff von Google Analytics über die API können wir anfangen zu Programmieren.

Holen Sie sich dieses Paket von NuGet:

Google.Apis.Analytics.v3-Client-Bibliothek

Fügen Sie diese aufzuhalten der Benutzung:

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;

Einige Dinge zu beachten sind.

Die keyPath ist der Pfad der Schlüssel-Datei, die Sie heruntergeladen mit ein .p12-Datei-Erweiterung.
Die accountEmailAddress ist die api E-Mail wir haben früher.
Umfang ist ein Enum in der Google.Apis.Analytics.v3.AnalyticService Klasse, die bestimmt, die url zu verwenden, um zu autorisieren (ex: AnalyticsService.Scope.AnalyticsReadonly ).
Application name einen Namen Ihrer Wahl, das sagt die google-api, was drauf zugreift (aka: es kann sein, was auch immer Sie wählen).

Dann den code, um einige grundlegende Aufrufe ist wie folgt.

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

Andere Links, die sich als hilfreich erweisen wird:

Analyse-API-Explorer - API für Abfragen Aus Dem Web

Analyse-API-Explorer-version 2 - API für Abfragen Aus Dem Web

Dimensionen und Metriken Referenz

Ich hoffe, dies hilft, dass jemand versucht, dies in der Zukunft tun.

InformationsquelleAutor der Antwort Logan G.

11

Hoffte ich nur auf einen Kommentar hinzufügen, der die Antwort für die v3 Beta, aber rep-Punkte verhindern. Aber ich dachte, es wäre schön für andere zu haben, diese Informationen, so ist es hier:
```
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using System.Security.Cryptography.X509Certificates;
using Google.Apis.Services;
```
Diese Namensräume werden verwendet, während der code in diesem post. Ich habe immer wünschte, die Menschen würden post-name Leerzeichen häufiger, mir scheint, ich verbringe ein bisschen Zeit mit der Suche für Sie. Ich hoffe das spart einigen Leuten ein paar Minuten Arbeit.

InformationsquelleAutor der Antwort Jereme Guenther

Diese Antwort ist für diejenigen, die möchten, Zugang zu Ihren eigenen Analytics-Konto nutzen möchten und die neue Analytics-Reporting-API v4.

Ich schrieb vor kurzem einen blog-post darüber, wie Sie Google Analytics-Daten mithilfe von C#. Lesen Sie dort alle details.

Müssen Sie zuerst wählen Sie zwischen den Anschluss mit OAuth2 oder einen Service-Account. Ich nehme an Sie besitzen das Analytics-Konto, so müssen Sie erstellen eine "Service-account-key" aus der Google-APIs Anmeldeinformationen Seite.

Wenn Sie zu erstellen, lade die JSON-Datei und legen Sie es in Ihrem Projekt (ich habe mir in meinem App_Data Ordner).

Als Nächstes installieren Sie die Google.Apis.AnalyticsReporting.v4 Nuget-Paket. Auch die Installation der Newtonsoft -Json.NET.

Gehören dieser Klasse, die irgendwo in Ihrem Projekt:

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

Und hier ist, was Sie gewartet haben: ein komplettes Beispiel!

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

Starten wir durch Deserialisieren der service-Konto-Schlüssel-Informationen aus der JSON-Datei und wandeln Sie es in ein PersonalServiceAccountCred Objekt. Dann erstellen wir die ServiceAccountCredential und eine Verbindung zu Google über die AnalyticsReportingService. Mit diesem service, dann bereiten wir einige grundlegende Filter zu passieren, um die API und senden Sie die Anforderung.

Ist es wahrscheinlich am besten, um einen Haltepunkt in der Zeile, wo der response variable deklariert ist, drücken Sie die F10-Taste einmal, dann bewegen Sie den Mauszeiger über die variable, so dass Sie sehen können, welche Daten Sie verwenden in der Antwort.

InformationsquelleAutor der Antwort John Washam

3

Habe ich das setup etwas ziemlich ähnlich wie die obige Antwort in ein nuGet-Paket. Es führt Folgendes aus:
- eine Verbindung zu einem "Service-Konto" eingerichtet, die in der API-Konsole
- Zieht alle Google Analytics-Daten, die Sie möchten
- Zeigt, dass Daten mit Google Charts API
und es tut all dies auf eine sehr einfache Weise ändern. Sehen Sie mehr hier: https://www.nuget.org/packages/GoogleAnalytics.GoogleCharts.NET/.

InformationsquelleAutor der Antwort pharophy

Hoffen, dass google wird eine ordnungsgemäße Dokumentation eines Tages. Hier bin ich mit der Auflistung aller Schritte zur Integration von google analytics server-Seite-Authentifizierung in ASP.NET C#.

Schritt 1: Erstellen eines Projekts in google-Konsole

Goto der link https://console.developers.google.com/iam-admin/projects und erstellen Sie ein Projekt, indem Sie auf "Projekt Erstellen" - button und bieten Projekt-Namen in der pop-up-Fenster aus und senden Sie es ab.

Schritt 2: Erstellen von Anmeldeinformationen und-service Konto

Nach der Erstellung des Projektes, Sie werden weitergeleitet zu "API-Manager" - Seite.
Klicken Sie auf Anmeldeinformationen und drücken Sie die "Anmeldeinformationen Erstellen" - button. wählen Sie "service-Konto-Schlüssel" aus dem dropdown-Sie werden weitergeleitet zur nächsten Seite.
In der service-Konto-drop-down, wählen Sie "Neuer service-Konto". Füllen Sie den Namen des Dienstkontos ein, und laden Sie die p12-Taste. Es wird p12-Erweiterung. Sie erhalten ein popup mit einem Passwort "notasecret", die Standard-und private-key heruntergeladen werden.

Schritt 3: Erstellen 0auth client-ID

klicken Sie auf "Anmeldeinformationen erstellen" - dropdown und wählen Sie "0auth client-ID", die Sie umgeleitet werden "0auth Zustimmung screen" - tab. geben Sie einen beliebigen Namen in das Projekt Textfeld name ein. wählen Sie den Anwendungstyp "Web application" und klicken Sie auf die Schaltfläche erstellen. Kopieren Sie die generierten client-ID in einem Editor.

Schritt 4: Aktivieren der APIs

Auf der linken Seite klicken Sie auf den Reiter "Übersicht" und wählen Sie "Enabled APIs" aus dem horizontalen tab. In der Suchleiste Suche nach "Analytics API" klicken Sie auf die Dropdownliste, und drücken Sie die Schaltfläche "Aktivieren". Jetzt wieder die Suche nach "Analytics Reporting V4" und aktivieren Sie es.

Schritt 5: Installieren Sie nuget-Pakete

In visual studio, Gehen Sie zu Extras > Nuget-Paket-Manager - > Paket-Manager-Konsole.
Kopieren Sie den untenstehenden code in die Konsole zu installieren, die nuget-Pakete.

Install-Package Google.Apis.Analytics.v3

Install-Paket DotNetOpenAuth.Core -Version 4.3.4.13329

Die beiden oben genannten Pakete sind Google analytics und DotNetOpenAuth nuget-Pakete.

Schritt 6: Geben Sie 'Anzeigen und Analysieren' die Berechtigung service account

Gehen Sie zu google analytics-Konto und klicken Sie auf "Admin" - Registerkarte, und wählen Sie "User Management" von Links Menüs,wählen Sie eine Domäne, die Sie zugreifen möchten, analytics-Daten, und legen Sie die service-Konto-E-Mail-id, unter es und wählen Sie "Lesen und Analysieren" - Berechtigung aus der dropdown-Liste. Service-Konto E-Mail-id sieht aus wie ex: [email protected].

Funktionierenden Code

FRONT-END-CODE:

Kopieren und fügen Sie den unten analytics-Skript einbetten in Ihre front-end oder sonst können Sie diesen code von google-analytics-Dokumentation Seite auch.

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

Fügen Sie den folgenden code in den body-tag Ihrer front-end-Seite.

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

Können Sie auch Ihre Anzeigen-ID aus https://ga-dev-tools.appspot.com/account-explorer/

BACK-END-CODE:

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

        }
    }

InformationsquelleAutor der Antwort Rakesh Dadamatti

Anderen Funktionierenden Ansatz

Fügen Sie folgenden code in die 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);

Fügen Sie folgenden code, name spaces und relative Bezüge

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

Fügen Sie diese in der Application_Start() im Globalen.asax

  AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;

InformationsquelleAutor der Antwort Parth Mistry

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.