public BlogBrowserTest()
 {
     mBrowser          = new TransitBrowser();
     mBrowser.Name     = Guid.NewGuid().ToString();
     mBrowser.Platform = Guid.NewGuid().ToString();
     mBrowser.Version  = "1.0";
 }
Esempio n. 2
0
        public void CreateOrUpdateStatsTest()
        {
            TransitReferrerHost host = new TransitReferrerHost();

            host.LastSource   = Guid.NewGuid().ToString();
            host.LastUrl      = Guid.NewGuid().ToString();
            host.Name         = Guid.NewGuid().ToString();
            host.RequestCount = 1;
            host.Id           = Blog.CreateOrUpdateReferrerHost(Ticket, host);

            TransitBrowser browser = new TransitBrowser();

            browser.Name     = Guid.NewGuid().ToString();
            browser.Platform = Guid.NewGuid().ToString();
            browser.Version  = Guid.NewGuid().ToString().Substring(0, 10);
            browser.Id       = Blog.CreateOrUpdateBrowser(Ticket, browser);

            TransitReferrerSearchQuery query = new TransitReferrerSearchQuery();

            query.RequestCount = 1;
            query.SearchQuery  = Guid.NewGuid().ToString();
            query.Id           = Blog.CreateOrUpdateReferrerSearchQuery(Ticket, query);

            List <TransitReferrerHost> hosts = new List <TransitReferrerHost>();

            hosts.Add(host);

            List <TransitBrowser> browsers = new List <TransitBrowser>();

            browsers.Add(browser);

            List <TransitReferrerSearchQuery> queries = new List <TransitReferrerSearchQuery>();

            queries.Add(query);

            int result = Blog.CreateOrUpdateStats(Ticket, browsers.ToArray(), hosts.ToArray(), queries.ToArray());

            Assert.AreEqual(result, Math.Max(Math.Max(browsers.Count, hosts.Count), queries.Count));

            Blog.DeleteReferrerHost(Ticket, host.Id);
            Blog.DeleteBrowser(Ticket, browser.Id);
            Blog.DeleteReferrerSearchQuery(Ticket, query.Id);
        }
Esempio n. 3
0
    public void Flush(SessionManager manager)
    {
        if (mRequests == null)
        {
            return;
        }

        List <TransitBrowser>             browsers = new List <TransitBrowser>();
        List <TransitReferrerHost>        rhs      = new List <TransitReferrerHost>();
        List <TransitReferrerSearchQuery> rsqs     = new List <TransitReferrerSearchQuery>();

        // TODO: use a unique sorted collection

        foreach (HttpRequest request in mRequests)
        {
            try
            {
                if (request.Browser != null)
                {
                    TransitBrowser browser = new TransitBrowser();
                    browser.Name     = request.Browser.Browser;
                    browser.Platform = request.Browser.Platform;
                    browser.Version  = request.Browser.Version;
                    browsers.Add(browser);
                }

                string host = string.Empty;
                try
                {
                    host = request.Url.Host;
                }
                catch (ArgumentException)
                {
                    // host isn't available on localhost
                }

                string urlreferrer = string.Empty;
                try
                {
                    if (request.UrlReferrer != null)
                    {
                        urlreferrer = request.UrlReferrer.Host;
                    }
                }
                catch (ArgumentException)
                {
                    // referrer host not available
                }

                // don't track navigation between pages
                if (!string.IsNullOrEmpty(urlreferrer) && urlreferrer != host)
                {
                    TransitReferrerHost rh = new TransitReferrerHost();
                    rh.Name         = request.UrlReferrer.Host;
                    rh.LastSource   = request.UrlReferrer.ToString();
                    rh.LastUrl      = request.RawUrl;
                    rh.RequestCount = 1;
                    rhs.Add(rh);

                    string q = request.QueryString["q"];
                    if (string.IsNullOrEmpty(q))
                    {
                        q = request.QueryString["s"];
                    }
                    if (string.IsNullOrEmpty(q))
                    {
                        q = request.QueryString["search"];
                    }
                    if (string.IsNullOrEmpty(q))
                    {
                        q = request.QueryString["query"];
                    }

                    if (!string.IsNullOrEmpty(q))
                    {
                        TransitReferrerSearchQuery trsq = new TransitReferrerSearchQuery();
                        trsq.RequestCount = 1;
                        trsq.SearchQuery  = q;
                        rsqs.Add(trsq);
                    }
                }
            }
            catch (Exception ex)
            {
                manager.BlogService.EventLogWriteEntry(string.Format("CreateOrUpdateStats for a single request failed. {0}",
                                                                     ex.Message), EventLogEntryType.Warning);
            }
        }

        try
        {
            manager.BlogService.CreateOrUpdateStats(
                manager.Ticket, browsers.ToArray(), rhs.ToArray(), rsqs.ToArray());
        }
        catch (Exception ex)
        {
            manager.BlogService.EventLogWriteEntry(string.Format("CreateOrUpdateStats failed. {0}",
                                                                 ex.Message), EventLogEntryType.Error);
        }

        mRequests = new List <HttpRequest>();

        try
        {
            manager.BlogService.IncrementPostCounters(manager.Ticket, mPostCounters.ToArray());
        }
        catch (Exception ex)
        {
            manager.BlogService.EventLogWriteEntry(string.Format("IncrementPostCounters failed. {0}",
                                                                 ex.Message), EventLogEntryType.Error);
        }

        mPostCounters = new List <int>();

        try
        {
            manager.BlogService.IncrementImageCounters(manager.Ticket, mImageCounters.ToArray());
        }
        catch (Exception ex)
        {
            manager.BlogService.EventLogWriteEntry(string.Format("IncrementImageCounters failed. {0}",
                                                                 ex.Message), EventLogEntryType.Error);
        }

        mImageCounters = new List <int>();

        LastFlush = DateTime.UtcNow;
    }