public List<object[]> ObterDados(string dimensao, string metrica, string ordernarPor, int? limiteResultados = null)
        {
            var query = new DataQuery(_feedURL);

            query.Ids = _ids;
            query.GAStartDate = DataInicio.ToString("yyyy-MM-dd");
            query.GAEndDate = DataTermino.ToString("yyyy-MM-dd");

            query.Dimensions = dimensao;
            query.Metrics = metrica;
            query.Sort = ordernarPor;

            if (limiteResultados != null)
                query.ExtraParameters = "max-results=" + limiteResultados;

            var dataFeed = _service.Query(query);
            var resultados = new List<object[]>();

            foreach (DataEntry item in dataFeed.Entries)
            {
                var resultado = new object[2];

                resultado[0] = item.Dimensions[0].Value;
                resultado[1] = item.Metrics[0].Value;

                resultados.Add(resultado);
            }

            return resultados;
        }
Example #2
0
        private void PageviewFeed()
        {
            string userName = this.Username.Text;
            string passWord = this.Password.Text;
            string profileId = this.ProfileIds.SelectedItems[0].SubItems[1].Text;
            const string dataFeedUrl = "https://www.google.com/analytics/feeds/data";

            AnalyticsService service = new AnalyticsService("AnalyticsSampleApp");
            if (!string.IsNullOrEmpty(userName))
            {
                service.setUserCredentials(userName, passWord);
            }

            DataQuery query = new DataQuery(dataFeedUrl);
            query.Ids = profileId;
            query.Metrics = "ga:pageviews";
            query.Dimensions = "ga:browser";
            query.Sort = "ga:browser,ga:pageviews";
            query.GAStartDate = DateTime.Now.AddDays(-14).ToString("yyyy-MM-dd");
            query.GAEndDate = DateTime.Now.AddDays(-2).ToString("yyyy-MM-dd");

            DataFeed dataFeed = service.Query(query);
            foreach (DataEntry entry in dataFeed.Entries)
            {
                ListViewItem item = new ListViewItem(entry.Title.Text);
                item.SubItems.Add(entry.Metrics[0].Value);
                this.ListPageviews.Items.Add(item);
            }
        }
Example #3
0
		public ReadOnlyCollection<Region> GetRegionInfo()
		{
			var dataQuery = new DataQuery(_profileId, DateTime.Today - TimeSpan.FromDays(30), DateTime.Today, "ga:visitors", "ga:region,ga:operatingSystem", "-ga:visitors");

			return _service.Query(dataQuery).Entries
				.Cast<DataEntry>()
				.Select(
					entry => new Region(entry.Dimensions[0].Value) 
					{
						MacUsers = entry.Dimensions[1].Value == "Macintosh" ? entry.Metrics[0].IntegerValue : 0,
						WindowsUsers = entry.Dimensions[1].Value == "Windows" ? entry.Metrics[0].IntegerValue : 0,
					})
				.Aggregate(new Dictionary<string, Region>(),
					(dict, region) =>
					{
						Region existing;
						if (!dict.TryGetValue(region.Name, out existing))
						{
							existing = new Region(region.Name);
							dict[region.Name] = existing;
						}
						existing.MacUsers += region.MacUsers;
						existing.WindowsUsers += region.WindowsUsers;
						return dict;
					},
					dict => dict.Values.ToList().AsReadOnly());
		}
Example #4
0
        /// <summary>
        /// Runs a Query against the Google Analytics provider - AnalyticsService
        /// </summary>
        /// <param name="dimensions">multiple dimensions separated by a comma: ga:dimensionName, ga:dimensionName</param>
        /// <param name="metrics">multiple metrics separated by a comma: ga:metricName, ga:metricName</param>
        /// <param name="numberToRetrieve">the max number of entries to return</param>
        public void RunQuery(string dimensions, string metrics, int numberToRetrieve = default(int))
        {
            try
            {
                // GA Data Feed query uri.
                DataQuery query = new DataQuery(_baseUrl);
                query.Ids = GaProfileId;
                query.Dimensions = dimensions; //"ga:date";
                query.Metrics = metrics; //"ga:visitors, ga:newVisits, ga:bounces";
                //query.Segment = "gaid::-11";
                //query.Filters = "ga:medium==referral";
                //query.Sort = "-ga:visits";
                //query.NumberToRetrieve = 5;
                if (numberToRetrieve != default(int))
                {
                    query.NumberToRetrieve = numberToRetrieve;
                }
                query.GAStartDate = DateAsGAString(StartDate);
                query.GAEndDate = DateAsGAString(EndDate);
                Uri url = query.Uri;

                // Send our request to the Analytics API and wait for the results to
                // come back.
                queryResults = AnalyticsService.Query(query);
            }
            catch (AuthenticationException ex)
            {
                throw new Exception("Authentication failed : " + ex.Message);
            }
            catch (Google.GData.Client.GDataRequestException ex)
            {
                throw new Exception("Authentication failed : " + ex.Message);
            }
        }
        private static void GetPageViews(AtomEntry Account)
        {
            string ProfileID = Account.Id.AbsoluteUri.Substring(47);
            DataFeedUrl = "https://www.google.com/analytics/feeds/data";

            DataQuery PageViewQuery = new DataQuery(DataFeedUrl)
            {
                Ids = ProfileID,
                Dimensions = "ga:date",
                Metrics = "ga:pageviews",
                Sort = "ga:date",
                GAStartDate = (DateTime.Now).AddDays(-7).ToString("yyyy-MM-dd"),
                GAEndDate = (DateTime.Now).ToString("yyyy-MM-dd")
            };

            DataFeed Results = Service.Query(PageViewQuery);

            foreach (AtomEntry Result in Results.Entries)
            {
                DataEntry Entry = (DataEntry)Result;

                Console.WriteLine(String.Format("{0}\t{1}",
                    Entry.Title.Text.Split('=')[1],
                    Entry.Metrics[0].Value));
            }
        }
Example #6
0
    /**
     * Creates a new service object, attempts to authorize using the Client Login
     * authorization mechanism and requests data from the Google Analytics API.
     */
    public DataFeedExample()
    {

      // Configure GA API.
      AnalyticsService asv = new AnalyticsService("gaExportAPI_acctSample_v2.0");

      // Client Login Authorization.
      asv.setUserCredentials(CLIENT_USERNAME, CLIENT_PASS);

      // GA Data Feed query uri.
      String baseUrl = "https://www.google.com/analytics/feeds/data";

      DataQuery query = new DataQuery(baseUrl);
      query.Ids = TABLE_ID;
      query.Dimensions = "ga:source,ga:medium";
      query.Metrics = "ga:visits,ga:bounces";
      query.Segment = "gaid::-11";
      query.Filters = "ga:medium==referral";
      query.Sort = "-ga:visits";
      query.NumberToRetrieve = 5;
      query.GAStartDate = "2010-03-01";
      query.GAEndDate = "2010-03-15";
      Uri url = query.Uri;
      Console.WriteLine("URL: " + url.ToString());


      // Send our request to the Analytics API and wait for the results to
      // come back.

      feed = asv.Query(query);


    }
Example #7
0
 public void DimensionPropertyTest()
 {
     DataQuery target = new DataQuery();
     const string expected = "ga:productCategory,ga:productName";
     target.Dimensions = expected;
     string actual = target.Dimensions;
     Assert.AreEqual(expected, actual);
 }
Example #8
0
 public void MetricParseTest()
 {
     const string expected = "ga:itemRevenue,ga:itemQuantity";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?metrics=" + expected);
     string actual = target.Metrics;
     Assert.AreEqual(expected, actual);
 }
Example #9
0
 public void DimensionParseTest()
 {
     const string expected = "ga:productCategory,ga:productName";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?dimensions=" + expected);
     string actual = target.Dimensions;
     Assert.AreEqual(expected, actual);
 }
        private DataFeed UseGoogleAnalyticsApiToReturnInSearchKeywordDataFeed(string profileId)
        {

            var dataQuery = new DataQuery("https://www.google.com/analytics/feeds/data")
            {
                Ids = profileId,
                Dimensions = "ga:searchKeyword",
                Metrics = "ga:pageviews",
                Sort = "-ga:pageviews",
                GAStartDate = DateTime.Now.AddDays(-30).ToString("yyyy-MM-dd"),
                GAEndDate = DateTime.Now.ToString("yyyy-MM-dd"),
                NumberToRetrieve = 10000
            };

            return ReturnGoogleAnalyticsDataFeed(dataQuery);


        }
        private const String TABLE_ID = "ga:37386554"; //"INSERT_TABLE_ID_HERE";

        #endregion Fields

        #region Constructors

        public DataFeed_DirectTraffic(DateTime Start, DateTime Finish, string GALogin, string GAPassword, string ids)
        {
            string start = Start.ToString("yyyy-MM-dd");
            AnalyticsService asv = new AnalyticsService("gaExportAPI_acctSample_v2.0");

            asv.setUserCredentials(GALogin, GAPassword);

            String baseUrl = "https://www.google.com/analytics/feeds/data";

            DataQuery query = new DataQuery(baseUrl);
            query.Ids = "ga:" + ids;
            query.Dimensions = "ga:eventLabel";
              //  query.Metrics = "ga:timeOnSite, ga:newVisits";
            query.Metrics = "ga:visits";
            query.Segment = "gaid::-7";
            query.GAStartDate = Start.ToString("yyyy-MM-dd");
            query.NumberToRetrieve = 10000;
            query.GAEndDate = Finish.ToString("yyyy-MM-dd");
            feed = asv.Query(query);
        }
        private DataFeed ReturnGoogleAnalyticsDataFeed(DataQuery dataQuery)
        {
            string userName = ConfigurationManager.AppSettings["GoogleUsername"];
            string passWord = ConfigurationManager.AppSettings["GooglePassword"];

            var service = new AnalyticsService(ConfigurationManager.AppSettings["ApplicationName"]);

            GDataRequestFactory f = new GDataRequestFactory(ConfigurationManager.AppSettings["UserAgent"]);
            if (_proxyProvider != null)
            {
                var proxy = _proxyProvider.CreateProxy();
                f.Proxy = proxy;
            }

            service.RequestFactory = f;

            service.setUserCredentials(userName, passWord);

            return service.Query(dataQuery);

        }
		public static Int64 GetVisitors(string tableId, DateTime gaStartDate, DateTime gaEndDate)
		{
			if (_asv == null)
			{
				_asv = new AnalyticsService("gaExportAPI_acctSample_v2.0");
				_asv.setUserCredentials(CLIENT_USERNAME, CLIENT_PASS);
			}
			String baseUrl = "https://www.google.com/analytics/feeds/data";
			DataQuery query = new DataQuery(baseUrl);
			query.Ids = tableId;
			query.Metrics = "ga:visits";
			query.GAStartDate = gaStartDate.ToString("yyyy'-'MM'-'dd");
			query.GAEndDate = gaEndDate.ToString("yyyy'-'MM'-'dd");
			Uri url = query.Uri;			
			DataFeed feed;
			try
			{
				feed = _asv.Query(query);
			}
			catch { return -1; }
			//var singleEntry = feed.Entries.Single() as DataEntry;
			//return Convert.ToInt64(singleEntry.Metrics.Single().Value);
			return Convert.ToInt64(feed.Aggregates.Metrics[0].Value);
		}
Example #14
0
 public void GAEndDateParseTest()
 {
     const string expected = "2009-04-25";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?end-date=" + expected);
     string actual = target.GAEndDate;
     Assert.AreEqual(expected, actual);
 }
Example #15
0
 public void FeedQueryConstructorTest()
 {
     const string baseUri = "http://www.test.com/";
     DataQuery target = new DataQuery(baseUri);
     Assert.AreEqual(target.Uri, new Uri(baseUri));
 }
Example #16
0
 /// <summary>
 /// overloaded to create typed version of Query
 /// </summary>
 /// <param name="feedQuery"></param>
 /// <returns>DataFeed</returns>
 public DataFeed Query(DataQuery feedQuery)
 {
     return(base.Query(feedQuery) as DataFeed);
 }
Example #17
0
 public void EndDateTest()
 {
     DataQuery target = new DataQuery();
     DateTime expected = DateTime.Now;
     DateTime actual;
     target.EndDate = expected;
     actual = target.EndDate;
     Assert.AreEqual(expected, actual);
 }
Example #18
0
 public void DataQueryConstructorTest1()
 {
     DataQuery target = new DataQuery();
     Assert.IsNotNull(target);
 }
Example #19
0
 public void ExtraParametersTest()
 {
     DataQuery target = new DataQuery();
     string expected = "TestValue";
     string actual;
     target.ExtraParameters = expected;
     actual = target.ExtraParameters;
     Assert.AreEqual(expected, actual);
 }
Example #20
0
 public void NumberToRetrieveTest()
 {
     DataQuery target = new DataQuery();
     int expected = 12;
     int actual;
     target.NumberToRetrieve = expected;
     actual = target.NumberToRetrieve;
     Assert.AreEqual(expected, actual);
 }
Example #21
0
 public void FiltersParseTest()
 {
     const string expected = "ga:country%3D%3DCanada";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?filters=" + expected);
     string actual = target.Filters;
     Assert.AreEqual(expected, actual);
 }
        private DataFeed getGADataFeed(Site site,
            DateTime fromDay,
            DateTime toDay,
            string dimensions,
            string metrics,
            string filters,
            string sort,
            int startIndex)
        {
            AnalyticsService asv = new AnalyticsService(applicationName);
            asv.setUserCredentials(userId, password);

            DataQuery query = new DataQuery(analyticsApiURL);
            query.Ids = site.account;
            query.Dimensions = dimensions;
            query.Metrics = metrics;
            query.Filters = filters;
            query.Sort = sort;
            query.NumberToRetrieve = numberOfGARecordsToRetrievePerRequest;
            query.StartIndex = startIndex;
            query.GAStartDate = String.Format("{0:yyyy-MM-dd}", fromDay);
            query.GAEndDate = String.Format("{0:yyyy-MM-dd}", toDay);

            log.Debug("Querying Google API : " + query.Uri.ToString());

            DataFeed feed = asv.Query(query);

            System.Threading.Thread.Sleep(requestPause); // wait between requests

            return feed;
        }
Example #23
0
 public void SortParseTest()
 {
     const string expected = "ga:productCategory";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?sort=" + expected);
     string actual = target.Sort;
     Assert.AreEqual(expected, actual);
 }
Example #24
0
 public void IdsParseTest()
 {
     const string expected = "ga:1234";
     DataQuery target = new DataQuery();
     //Force expected to be parsed
     target.Uri = new Uri("http://test.com?ids=" + expected);
     string actual = target.Ids;
     Assert.AreEqual(expected, actual);
 }
Example #25
0
        public void ParseTest()
        {
            const string dimensionExpected = "ga:productCategory,ga:productName";
            const string metricExpected = "ga:itemRevenue,ga:itemQuantity";
            const string idsExpected = "ga:1234";
            const string filtersExpected = "ga:country%3D%3DCanada";
            const string sortExpected = "ga:productCategory";
            const string startDateExpected = "2009-04-1";
            const string endDateExpected = "2009-04-25";
            DataQuery target = new DataQuery();

            target.Uri = new Uri(string.Format("http://test.com?ids={0}&dimensions={1}&metrics={2}&filters={3}&sort={4}&start-date={5}&end-date={6}", idsExpected, dimensionExpected, metricExpected, filtersExpected, sortExpected, startDateExpected, endDateExpected));
            Assert.AreEqual("http://test.com/", target.BaseAddress);
            Assert.AreEqual(dimensionExpected, target.Dimensions);
            Assert.AreEqual(metricExpected, target.Metrics);
            Assert.AreEqual(idsExpected, target.Ids);
            Assert.AreEqual(filtersExpected, target.Filters);
            Assert.AreEqual(sortExpected, target.Sort);
            Assert.AreEqual(startDateExpected, target.GAStartDate);
            Assert.AreEqual(endDateExpected, target.GAEndDate);
        }
 /// <summary>
 /// overloaded to create typed version of Query
 /// </summary>
 /// <param name="feedQuery"></param>
 /// <returns>DataFeed</returns>
 public DataFeed Query(DataQuery feedQuery) {
     return base.Query(feedQuery) as DataFeed;
 }
Example #27
0
        public void CalculateQueryTest()
        {
            const string baseUrlExpected = "http://test.com/";
            const string dimensionExpected = "ga:productCategory,ga:productName";
            const string metricExpected = "ga:itemRevenue,ga:itemQuantity";
            const string idsExpected = "ga:1234";
            const string filtersExpected = "ga:country%3D%3DCanada";
            const string sortExpected = "ga:productCategory";
            const string startDateExpected = "2009-04-1";
            const string endDateExpected = "2009-04-25";
            DataQuery target = new DataQuery();

            target.BaseAddress = baseUrlExpected;
            target.Dimensions = dimensionExpected;
            target.Metrics = metricExpected;
            target.Ids = idsExpected;
            target.Filters = filtersExpected;
            target.Sort = sortExpected;
            target.GAStartDate = startDateExpected;
            target.GAEndDate = endDateExpected;

            Uri expectedResult = new Uri(string.Format("http://test.com?dimensions={0}&end-date={1}&filters={2}&ids={3}&metrics={4}&sort={5}&start-date={6}", Utilities.UriEncodeReserved(dimensionExpected), Utilities.UriEncodeReserved(endDateExpected), Utilities.UriEncodeReserved(filtersExpected), Utilities.UriEncodeReserved(idsExpected), Utilities.UriEncodeReserved(metricExpected), Utilities.UriEncodeReserved(sortExpected), Utilities.UriEncodeReserved(startDateExpected)));

            Assert.AreEqual(expectedResult.AbsoluteUri, target.Uri.AbsoluteUri);
        }
        /// <summary>
        /// Gets the data feed.
        /// </summary>
        /// <param name="start">The start.</param>
        /// <param name="end">The end.</param>
        /// <param name="dimensionVariables">The dimension variables.</param>
        /// <param name="metricVariables">The metric variables.</param>
        /// <param name="sortByVariables">The sort by variables.</param>
        /// <returns></returns>
        public DataFeed GetDataFeed(DateTime start, DateTime end, 
            string dimensionVariables, string metricVariables, string sortByVariables)
        {
            // Configure GA API.
            AnalyticsService asv =
                new AnalyticsService(Constants.Service.ApplicationName);

            // Client Login Authorization.
            asv.setUserCredentials(userName, password);

            // GA Data Feed query uri.
            String baseUrl = Constants.Service.QueryUrl;

            DataQuery query = new DataQuery(baseUrl);
            query.Ids = tableId;

            //query.Segment = "gaid::-1";
            //query.Filters = "ga:medium==referral";
            //query.NumberToRetrieve = 5;

            query.Dimensions = dimensionVariables;
            query.Metrics = metricVariables;
            query.Sort = sortByVariables;
            query.GAStartDate = start.ToString("yyyy-MM-dd");
            query.GAEndDate = end.ToString("yyyy-MM-dd");

            //Uri url = query.Uri;
            //Console.WriteLine("URL: " + url.ToString());

            // Send our request to the Analytics API and wait for the results to
            // come back.

            DataFeed feed = asv.Query(query);

            return feed;
        }
Example #29
0
 public void UriTest()
 {
     DataQuery target = new DataQuery();
     Uri expected = new Uri("http://www.test.com/");
     Uri actual;
     target.Uri = expected;
     actual = target.Uri;
     Assert.AreEqual(expected, actual);
 }
        public ActionResult Analytics(int? duration)
        {
            CacheContext.InvalidateOn(TriggerFrom.Any<SiteSettings>());

            var settings = _siteSettingsService.GetSettings();

            if (string.IsNullOrEmpty(settings.AnalyticsToken))
            {
                const string scope = "https://www.google.com/analytics/feeds/";
                var next = Url.Absolute(Url.Admin().Home().AuthResponse());
                var auth = new AnalyticsAuthorize
                    {
                        Url = AuthSubUtil.getRequestUrl(next, scope, false, true)
                    };
                return View("AnalyticsAuthorize", auth);
            }

            if (string.IsNullOrEmpty(settings.AnalyticsProfileId))
            {
                var config = new AnalyticsConfig
                    {
                        Accounts = GetAccounts(settings),
                        Profiles = GetProfiles(settings)
                    };

                return View("AnalyticsConfig", config);
            }

            duration = duration ?? 30;
            var model = new Analytics
                            {
                                Duration = duration.Value,
                                Start = DateTime.Today.AddDays(-1 * duration.Value),
                                End = DateTime.Now,
                         		Visits = new Dictionary<DateTime, int>(),
                                PageViews = new Dictionary<string, int>(),
                                PageTitles = new Dictionary<string, string>(),
                                TopReferrers = new Dictionary<string, int>(),
                                TopSearches = new Dictionary<string, int>()
                            };
            if (model.Start > model.End)
            {
                var tempDate = model.Start;
                model.Start = model.End;
                model.End = tempDate;
            }

            var profiles = GetProfiles(settings);
            var profile = profiles.SingleOrDefault(x => x.Id == settings.AnalyticsProfileId);
            if (profile == null)
                throw new Exception("Unable to find the specified analytics profile: " + settings.AnalyticsProfileId);
            model.Profile = profile;

            var authFactory = new GAuthSubRequestFactory("analytics", "MvcKickstart")
                                {
                                    Token = settings.AnalyticsToken
                                };

            var analytics = new AnalyticsService(authFactory.ApplicationName) { RequestFactory = authFactory };

            var profileId = "ga:" + settings.AnalyticsProfileId;

            // Get from All Visits
            var visits = new DataQuery(profileId, model.Start, model.End)
                            {
                                Metrics = "ga:visits",
                                Dimensions = "ga:date",
                                Sort = "ga:date"
                            };
            var count = 0;
            foreach (DataEntry entry in analytics.Query(visits).Entries)
            {
                var value = entry.Metrics.First().IntegerValue;

                model.Visits.Add(model.Start.AddDays(count++), value);
            }

            // Get Site Usage
            var siteUsage = new DataQuery(profileId, model.Start, model.End)
                            {
                                Metrics = "ga:visits,ga:pageviews,ga:percentNewVisits,ga:avgTimeOnSite,ga:entranceBounceRate,ga:exitRate,ga:pageviewsPerVisit,ga:avgPageLoadTime"
                            };
            var siteUsageResult = (DataEntry)analytics.Query(siteUsage).Entries.FirstOrDefault();
            if (siteUsageResult != null)
            {
                foreach (var metric in siteUsageResult.Metrics)
                {
                    switch (metric.Name)
                    {
                        case "ga:visits":
                            model.TotalVisits = metric.IntegerValue;
                            break;
                        case "ga:pageviews":
                            model.TotalPageViews = metric.IntegerValue;
                            break;
                        case "ga:percentNewVisits":
                            model.PercentNewVisits = metric.FloatValue;
                            break;
                        case "ga:avgTimeOnSite":
                            model.AverageTimeOnSite = TimeSpan.FromSeconds(metric.FloatValue);
                            break;
                        case "ga:entranceBounceRate":
                            model.EntranceBounceRate = metric.FloatValue;
                            break;
                        case "ga:exitRate":
                            model.PercentExitRate = metric.FloatValue;
                            break;
                        case "ga:pageviewsPerVisit":
                            model.PageviewsPerVisit = metric.FloatValue;
                            break;
                        case "ga:avgPageLoadTime":
                            model.AveragePageLoadTime = TimeSpan.FromSeconds(metric.FloatValue);
                            break;
                    }
                }
            }

            // Get Top Pages
            var topPages = new DataQuery(profileId, model.Start, model.End)
                            {
                                Metrics = "ga:pageviews",
                                Dimensions = "ga:pagePath,ga:pageTitle",
                                Sort = "-ga:pageviews",
                                NumberToRetrieve = 20
                            };
            foreach (DataEntry entry in analytics.Query(topPages).Entries)
            {
                var value = entry.Metrics.First().IntegerValue;
                var url = entry.Dimensions.Single(x => x.Name == "ga:pagePath").Value.ToLowerInvariant();
                var title = entry.Dimensions.Single(x => x.Name == "ga:pageTitle").Value;

                if (!model.PageViews.ContainsKey(url))
                    model.PageViews.Add(url, 0);
                model.PageViews[url] += value;

                if (!model.PageTitles.ContainsKey(url))
                    model.PageTitles.Add(url, title);
            }

            // Get Top Referrers
            var topReferrers = new DataQuery(profileId, model.Start, model.End)
                            {
                                Metrics = "ga:visits",
                                Dimensions = "ga:source,ga:medium",
                                Sort = "-ga:visits",
                                Filters = "ga:medium==referral",
                                NumberToRetrieve = 5
                            };
            foreach (DataEntry entry in analytics.Query(topReferrers).Entries)
            {
                var visitCount = entry.Metrics.First().IntegerValue;
                var source = entry.Dimensions.Single(x => x.Name == "ga:source").Value.ToLowerInvariant();

                model.TopReferrers.Add(source, visitCount);
            }

            // Get Top Searches
            var topSearches = new DataQuery(profileId, model.Start, model.End)
                            {
                                Metrics = "ga:visits",
                                Dimensions = "ga:keyword",
                                Sort = "-ga:visits",
                                Filters = "ga:keyword!=(not set);ga:keyword!=(not provided)",
                                NumberToRetrieve = 5
                            };
            foreach (DataEntry entry in analytics.Query(topSearches).Entries)
            {
                var visitCount = entry.Metrics.First().IntegerValue;
                var source = entry.Dimensions.Single(x => x.Name == "ga:keyword").Value.ToLowerInvariant();

                model.TopSearches.Add(source, visitCount);
            }

            return View(model);
        }
Example #31
0
 public void QueryTest()
 {
     DataQuery target = new DataQuery();
     string expected = "TestValue";
     string actual;
     target.Query = expected;
     actual = target.Query;
     Assert.AreEqual(expected, actual);
 }