wake-up-neo.net

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

Ich habe den ganzen Tag nach einer guten Lösung gesucht, aber Google entwickelt sich so schnell, dass ich nichts finden kann, das funktioniert. Was ich tun möchte ist, dass ich eine Web-App mit einem Admin-Bereich habe, in der der Benutzer angemeldet sein muss, um die Informationen anzuzeigen. In diesem Abschnitt möchte ich einige Daten von GA anzeigen, wie beispielsweise Seitenzugriffe für bestimmte URLs. Da es sich nicht um die Benutzerinformationen handelt, sondern um die Google Analytics-Benutzer, möchte ich die übergebenen Informationen (Benutzername/Passwort oder APIKey) verbinden, aber ich kann nicht herausfinden, wie. Alle Proben, die ich gefunden habe, verwenden OAuth2.

Was ich bisher gefunden habe:

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

Vielen Dank

46
VinnyG

Ich habe viel gesucht und schließlich entweder den Code von mehreren Stellen nachgeschlagen und dann meine eigene Schnittstelle damit umwickelt, kam ich zu der folgenden Lösung. Nicht sicher, ob die Leute ihren gesamten Code hier einfügen, aber ich schätze, warum nicht alle anderen Zeit sparen :)

Voraussetzung ist, dass Sie den Google.GData.Client und das Paket google.gdata.analytics/dll installieren.

Dies ist die Hauptklasse, die die Arbeit erledigt.

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 Implementierung, mit der ich es abschließend verwende.

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

Nun ist der Rest das Offensichtliche - Sie müssen die web.config-Werte zu Ihrer Anwendungskonfiguration oder -konfiguration hinzufügen und IPageViewCounter.GetPageViewCount aufrufen

31
MoXplod

Es erfordert ein wenig Setup auf der Google-Seite, aber es ist eigentlich ziemlich einfach. Ich werde Schritt für Schritt auflisten. 

Zuerst müssen Sie eine Anwendung in der Google Cloud-Konsole erstellen und die Analytics-API aktivieren. 

  • Gehen Sie zu http://code.google.com/apis/console
  • Wählen Sie die Dropdown-Liste aus und erstellen Sie ein Projekt, falls Sie noch kein Projekt haben
  • Sobald das Projekt erstellt ist, klicken Sie auf Dienste
  • Hier aktivieren Sie die Analytics-API

Nun, da die Analytics-API aktiviert ist, besteht der nächste Schritt darin, einem Dienstkonto den Zugriff auf die gewünschten Analyseprofile standorte zu ermöglichen. Mit dem Dienstkonto können Sie sich anmelden, ohne einen Benutzer zur Eingabe von Anmeldeinformationen auffordern zu müssen.

  • Rufen Sie/- http://code.google.com/apis/console auf und wählen Sie das von Ihnen erstellte Projekt aus der Dropdown-Liste aus.
  • Gehen Sie als Nächstes zum Abschnitt "API-Zugriff" und klicken Sie auf die Schaltfläche "Andere Client-ID erstellen".
  • Wählen Sie im Fenster "Client-ID erstellen" das Dienstkonto aus und klicken Sie auf Client-ID erstellen.
  • Laden Sie den öffentlichen Schlüssel für dieses Konto herunter, wenn derdownload nicht automatisch gestartet wird. Sie benötigen diesen Code später, wenn Sie für die -Autorisierung codieren.
  • Vor dem Beenden des Vorgangs kopieren Sie die automatisch generierte E-Mail-Adresse des Dienstkontos, da Sie diese im nächsten Schritt benötigen. Die Client-E-Mail sieht wie folgt aus: @ developer.gserviceaccount.com

Jetzt, da wir ein Dienstkonto haben, müssen Sie diesem Dienstkonto den Zugriff auf Ihre Profile/Websites in Google Analytics ermöglichen. 

  • Melden Sie sich bei Google Analytics an.
  • Sobald Sie angemeldet sind, klicken Sie auf die Schaltfläche Admin (Admin) in der linken unteren Ecke des Bildschirms
  • Klicken Sie in Admin auf das Konto-Dropdown-Menü und wählen Sie das Konto/die Site aus, auf das Ihr Dienstkonto zugreifen soll. Klicken Sie dann unter "Konto" auf "Benutzerverwaltung".
  • Geben Sie die E-Mail-Adresse ein, die für Ihr Dienstkonto generiert wurde, und erteilen Sie ihr Leseberechtigung und Analyse. 
  • Wiederholen Sie diese Schritte für alle anderen Konten/Websites, auf die Ihr Service zugreifen soll.

Jetzt, da das Dienstkonto für den Zugriff auf Google Analytics über die API eingerichtet ist, können wir mit dem Code beginnen.

Holen Sie sich dieses Paket von NuGet: 

Google.Apis.Analytics.v3 Client Library

Fügen Sie diese Usings hinzu:

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 Variable keyPath ist der Pfad zu der Schlüsseldatei, die Sie mit der Erweiterung .p12 heruntergeladen haben. 
  • Die accountEmailAddress ist die API-E-Mail, die wir zuvor erhalten haben.
  • Scope ist eine Aufzählung in der Klasse Google.Apis.Analytics.v3.AnalyticService, die die zu autorisierende URL vorschreibt (z. B. AnalyticsService.Scope.AnalyticsReadonly).
  • Der Anwendungsname ist ein Name Ihrer Wahl, der der Google-API angibt, worauf zugegriffen wird (auch bekannt: es kann sein, was Sie wählen).

Der Code für einige grundlegende Anrufe lautet dann 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:

Analytic API Explorer - Abfrage-API aus dem Web

Analytic API Explorer Version 2 - Abfrage-API aus dem Web

Referenz zu Bemaßungen und Metriken

Hoffentlich hilft dies jemandem, der versucht, dies in der Zukunft zu tun. 

79
Logan G.

Ich hatte gehofft, der Antwort für v3 Beta nur einen Kommentar hinzuzufügen, aber Rep-Punkte verhindern das. Ich dachte jedoch, es wäre nett für andere, diese Informationen zu haben, also 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 im gesamten Code in diesem Beitrag verwendet. Ich wünschte immer, die Leute würden häufiger Namensräume posten, ich scheine viel Zeit damit zu verbringen, nach ihnen zu suchen. Ich hoffe, das erspart einigen Leuten ein paar Minuten Arbeit.

10
Jereme Guenther

Diese Antwort ist für diejenigen von Ihnen, die Zugriff auf Ihr eigenes Analytics-Konto haben und die neue Analytics Reporting API v4 verwenden möchten.

Ich habe kürzlich einen blog-Post darüber geschrieben, wie Sie Google Analytics-Daten mithilfe von C # erhalten. Lesen Sie dort für alle Details.

Sie müssen zunächst wählen, ob Sie eine Verbindung mit OAuth2 oder einem Dienstkonto herstellen möchten. Ich gehe davon aus, dass Sie das Analytics-Konto besitzen. Daher müssen Sie auf der Seite Credentials der Google-APIs einen "Dienstkonto-Schlüssel" erstellen.

Sobald Sie das erstellt haben, laden Sie die JSON-Datei herunter und legen Sie sie in Ihrem Projekt ab (ich lege meine in meinen App_Data-Ordner).

Installieren Sie anschließend das Nuget-Paket Google.Apis.AnalyticsReporting.v4 . Installieren Sie auch Newtonsofts Json.NET .

Fügen Sie diese Klasse irgendwo in Ihr Projekt ein:

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 darauf haben Sie gewartet: ein vollständiges 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();
}

Wir deserialisieren zunächst die Dienstkonto-Schlüsselinformationen aus der JSON-Datei und konvertieren sie in ein PersonalServiceAccountCred-Objekt. Dann erstellen wir die ServiceAccountCredential und verbinden uns über die AnalyticsReportingService mit Google. Mit diesem Dienst bereiten wir dann einige grundlegende Filter vor, die an die API übergeben werden, und senden die Anforderung ab.

Es ist wahrscheinlich am besten, einen Haltepunkt in der Zeile festzulegen, in der die Variable response deklariert ist. Drücken Sie einmal die Taste F10 und bewegen Sie den Mauszeiger über die Variable, damit Sie sehen können, welche Daten für die Antwort verfügbar sind.

8
John Washam

Ich habe etwas ähnlich der obigen Antwort in einem nuGet-Paket eingerichtet. Es tut Folgendes: - stellt eine Verbindung zu einem "Dienstkonto" her, das Sie in der API-Konsole eingerichtet haben - Ruft alle Google Analytics-Daten ab, die Sie möchten - Zeigt diese Daten mithilfe der Google Charts-API An, und das alles lässt sich auf sehr einfache Weise ändern. Sie können hier mehr sehen: https://www.nuget.org/packages/GoogleAnalytics.GoogleCharts.NET/ .

3
pharophy

Ich hoffe, Google wird eines Tages die richtige Dokumentation bereitstellen. Hier liste ich alle Schritte auf, um die serverseitige Authentifizierung von Google Analytics in ASP.NET C # zu integrieren.

Schritt 1: Erstellen Sie ein Projekt in der Google-Konsole 

Gehen Sie zum Link https://console.developers.google.com/iam-admin/projects und erstellen Sie ein Projekt, indem Sie auf die Schaltfläche "Projekt erstellen" klicken. Geben Sie den Projektnamen in das Popup-Fenster ein und senden Sie es ab.

Schritt 2: Anmeldeinformationen und Dienstkonto erstellen

Nach der Erstellung des Projekts werden Sie zur Seite "API Manager" weitergeleitet. Klicken Sie auf "Anmeldeinformationen" und klicken Sie auf die Schaltfläche "Anmeldeinformationen erstellen". Wählen Sie "Dienstkontoschlüssel" aus der Dropdown-Liste, werden Sie zur nächsten Seite weitergeleitet . Wählen Sie in der Dropdown-Liste für Dienstkonten "Neues Dienstkonto" aus. Geben Sie den Dienstkontonamen ein und laden Sie den p12-Schlüssel herunter. Es wird eine Erweiterung von p12 haben. Sie erhalten ein Popup mit dem Kennwort "notasecret" (Standardeinstellung) und Ihr privater Schlüssel wird heruntergeladen.

Schritt 3: 0auth-Client-ID erstellen

klicken Sie auf das Dropdown-Menü "Anmeldeinformationen erstellen" und wählen Sie "0auth client ID". Sie werden auf die Registerkarte "0auth-Zustimmungsbildschirm" umgeleitet. Geben Sie einen zufälligen Namen in das Textfeld für den Projektnamen ein. Wählen Sie den Anwendungstyp als "Webanwendung" aus und klicken Sie auf die Schaltfläche "Erstellen". Kopieren Sie die generierte Client-ID in einen Notizblock.

Schritt 4: Aktivieren Sie die APIs

Klicken Sie auf der linken Seite auf die Registerkarte "Übersicht" und wählen Sie auf der horizontalen Registerkarte "Aktivierte APIs" aus. Suchen Sie in der Suchleiste nach "Analytics API" und klicken Sie auf die Schaltfläche "Aktivieren". Suchen Sie nun erneut nach "Analytics Reporting V4" und aktivieren Sie es.

Schritt 5: Nuget-Pakete installieren

Gehen Sie in Visual Studio zu Extras> Nuget Package Manager> Package Manager Console . Kopieren Sie den folgenden Code in die Konsole, um die Nuget-Pakete zu installieren.

Install-Package Google.Apis.Analytics.v3

Install-Package DotNetOpenAuth.Core -Version 4.3.4.13329

Bei den beiden oben genannten Paketen handelt es sich um Google Analytics- und DotNetOpenAuth-Nuget-Pakete.

Schritt 6: Erteilen Sie die Berechtigung zum Anzeigen und Analysieren des Dienstkontos

Gehen Sie zum Google Analytics-Konto, klicken Sie auf die Registerkarte "Admin" und wählen Sie "User Management" aus den linken Menüs. Wählen Sie eine Domäne aus, auf die Sie auf die Analysedaten zugreifen möchten. Fügen Sie die E-Mail-ID des Dienstkontos darunter ein und wählen Sie die Berechtigung "Lesen und Analysieren" aus aus dem Dropdown. Die E-Mail-ID des Dienstkontos sieht folgendermaßen aus: [email protected].

Arbeitscode

FRONT END CODE:

Kopieren Sie das unten stehende Skript zum Einbetten von Analytics in Ihr Frontend. Andernfalls erhalten Sie diesen Code auch von der Google Analytics-Dokumentationsseite.

 <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 das body-Tag Ihrer Front-End-Seite ein.

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

Sie können Ihre Ansichts-ID auch von https://ga-dev-tools.appspot.com/account-Explorer/ erhalten.

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

        }
    }
1

Ein weiterer Arbeitsansatz

Fügen Sie folgenden Code in der ConfigAuth hinzu

  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 unten Code, Namensräume und relative Verweise hinzu

 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 dies in Application.Start () in Global.asax hinzu 

  AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;
0
Parth Mistry