# Using Umami Data for Website Stats

<!--category-- ASP.NET, Umami -->
<datetime class="hidden">2024-09-05T23:45</datetime>

# Esitys

Yksi hankkeistani tämän blogin perustamisen jälkeen on lähes pakkomielteinen toive seurata, kuinka monet käyttäjät katsovat verkkosivustoani. Tätä varten käytän Umamia ja minulla on [POSTI-Yhdyskunta](/blog/category/Umami) Umamin käytön ja perustamisen osalta. Minulla on myös Nuget-paketti, joka mahdollistaa ASP: n tietojen seurannan

Nyt olen lisännyt uuden palvelun, jonka avulla voitte vetää tietoja Umamista takaisin C-käyttöön. Tämä on yksinkertainen palvelu, joka käyttää Umami API:ta pull data from your Umami instance and use it on your website.

Kuten tavallista, tähän voidaan löytää kaikki lähdekoodi [GitHubissa](https://github.com/scottgal/mostlylucidweb/tree/main/Umami.Net) Tämän sivuston osalta.

[TOC]

# Asetus

Tämä on jo Umami.Net Nuget-paketissa, asentaa se seuraavalla käännöksellä

```bash
dotnet add package Umami.Net
```

Sen jälkeen on perustettava palvelu omassa `Program.cs` asiakirja:

```csharp
    services.SetupUmamiData(config);
```

Siinä käytetään `Analytics' element from your `ohjelmien asentaminen.json`tietokantaM SK2

```json
 "Analytics":{
   "UmamiPath" : "https://umamilocal.mostlylucid.net",
   "WebsiteId" : "32c2aa31-b1ac-44c0-b8f3-ff1f50403bee",
    "UmamiScript" : "getinfo",
   "UserName": "admin",
   "Password": ""
 }
```

Tässä `UmamiScript` on käännös, jota käytetään Umami ( -järjestelmässä Client-puolen seurantaan.[ks.](/blog/usingumamiforlocalanalytics) sen määrittelystä ).
Euroopan unionin `WebSiteId` on teidän Umami instancessanne luomanne verkkosivuston ID.
`UmamiPath` on tie Umamiin tilanteeseenne.

Euroopan unionin `UserName` ja `Password` ( tässä tapauksessa käytän Admin-passiaM SK1

# Käytäntö

Nyt teillä on `UmamiDataService` omassa palvelukertomuksessanne voit aloittaa sen käytön!

## Menetelmät

Kaikki menetelmät ovat Umami API:n määritelmän mukaisia, ja ne ovat luettavissa täällä:
https://umami .is/docsM SK3apiMSC4websiteMST5stats

Kaikki palautukset wrapped in a `UmamiResults<T>` väline, jolla on `Success` omaisuus ja `Result` omaisuus. `Result` property on Umami API:sta palautettu väline.

```csharp
public record UmamiResult<T>(HttpStatusCode Status, string Message, T? Data);
```

Kaikki pyynnöt lukuun ottamatta `ActiveUsers` on perustapyynnön kohde, jolla on kaksi pakollista ominaisuuksia. Lisäsin perustapyyynnoksen kohdeon mukavuuden DateTimes, jotta alku- ja loppupäivämäärät voidaan asettaa helpommin

```csharp
public class BaseRequest
{
    [QueryStringParameter("startAt", isRequired: true)]
    public long StartAt => StartAtDate.ToMilliseconds(); // Timestamp (in ms) of starting date
    [QueryStringParameter("endAt", isRequired: true)]
    public long EndAt => EndAtDate.ToMilliseconds(); // Timestamp (in ms) of end date
    public DateTime StartAtDate { get; set; }
    public DateTime EndAtDate { get; set; }
}
```

Palvelussa on seuraavat menetelmät:

### Aktiiviset käyttäjät

Tämä vain saa tilalla olevien aktiivisten käyttäjien kokonaismäärän

```csharp
public async Task<UmamiResult<ActiveUsersResponse>> GetActiveUsers()
```

### Tilastot

Tämä palauttaa joukon tilastoja sivustosta.

```csharp
public async Task<UmamiResult<StatsResponseModels>> GetStats(StatsRequest statsRequest)    
```

Voitte asettaa joukon parametreja API:sta palautettujen tietojen filtroimiseksi.. `url` palauttaa tietyn URL:n tilastot.

<details>
<summary>StatsRequest object</summary>

```csharp
public class StatsRequest : BaseRequest
{
    [QueryStringParameter("url")]
    public string? Url { get; set; } // Name of URL
    
    [QueryStringParameter("referrer")]
    public string? Referrer { get; set; } // Name of referrer
    
    [QueryStringParameter("title")]
    public string? Title { get; set; } // Name of page title
    
    [QueryStringParameter("query")]
    public string? Query { get; set; } // Name of query
    
    [QueryStringParameter("event")]
    public string? Event { get; set; } // Name of event
    
    [QueryStringParameter("host")]
    public string? Host { get; set; } // Name of hostname
    
    [QueryStringParameter("os")]
    public string? Os { get; set; } // Name of operating system
    
    [QueryStringParameter("browser")]
    public string? Browser { get; set; } // Name of browser
    
    [QueryStringParameter("device")]
    public string? Device { get; set; } // Name of device (e.g., Mobile)
    
    [QueryStringParameter("country")]
    public string? Country { get; set; } // Name of country
    
    [QueryStringParameter("region")]
    public string? Region { get; set; } // Name of region/state/province
    
    [QueryStringParameter("city")]
    public string? City { get; set; } // Name of city
}
```

</details>
JSON-objekti Umami palaa seuraavasti.

```json
{
  "pageviews": { "value": 5, "change": 5 },
  "visitors": { "value": 1, "change": 1 },
  "visits": { "value": 3, "change": 2 },
  "bounces": { "value": 0, "change": 0 },
  "totaltime": { "value": 4, "change": 4 }
}
```

Tämä on wrapped inside my `StatsResponseModel` object.

```csharp
namespace Umami.Net.UmamiData.Models.ResponseObjects;

public class StatsResponseModels
{
    public Pageviews pageviews { get; set; }
    public Visitors visitors { get; set; }
    public Visits visits { get; set; }
    public Bounces bounces { get; set; }
    public Totaltime totaltime { get; set; }


    public class Pageviews
    {
        public int value { get; set; }
        public int prev { get; set; }
    }

    public class Visitors
    {
        public int value { get; set; }
        public int prev { get; set; }
    }

    public class Visits
    {
        public int value { get; set; }
        public int prev { get; set; }
    }

    public class Bounces
    {
        public int value { get; set; }
        public int prev { get; set; }
    }

    public class Totaltime
    {
        public int value { get; set; }
        public int prev { get; set; }
    }
}
```

### Metriksi

Umamia koskevat mittarit antavat mahdollisuuden tarkastella tiettyjen ominaisuuksien tyyppiä.

#### Tapahtumat

Yksi esimerkki näistä on tapahtumat`:

'Events' Umamissa on tiettyjä asioita, jotka voidaan seurata sivustollaM SK2 Kun seuraatte Umamia käyttäen tapahtumia .Netissä voitte asettaa useita ominaisuuksia, joita seurataan tapahtuman nimelläMSC4 Esimerkiksi täällä seuraan `Search` pyyntöjä, joissa on URL ja hakusana.

```csharp
       await  umamiBackgroundSender.Track( "searchEvent", eventData: new UmamiEventData(){{"query", encodedQuery}});
```

Jotta saataisiin tietoja tästä tapahtumasta, käytettäisiin `Metrics` menetelmä:

```csharp
public async Task<UmamiResult<MetricsResponseModels[]>> GetMetrics(MetricsRequest metricsRequest)
```

Kuten muissakin menetelmissä, tämä hyväksyy `MetricsRequest` kohde ( pakollisella `BaseRequest` properties) ja joukko valinnaisia ominaisuuksia tietojen filtroimiseksi

<details>
<summary>MetricsRequest object</summary>

```csharp
public class MetricsRequest : BaseRequest
{
    [QueryStringParameter("type", isRequired: true)]
    public MetricType Type { get; set; } // Metrics type

    [QueryStringParameter("url")]
    public string? Url { get; set; } // Name of URL
    
    [QueryStringParameter("referrer")]
    public string? Referrer { get; set; } // Name of referrer
    
    [QueryStringParameter("title")]
    public string? Title { get; set; } // Name of page title
    
    [QueryStringParameter("query")]
    public string? Query { get; set; } // Name of query
    
    [QueryStringParameter("host")]
    public string? Host { get; set; } // Name of hostname
    
    [QueryStringParameter("os")]
    public string? Os { get; set; } // Name of operating system
    
    [QueryStringParameter("browser")]
    public string? Browser { get; set; } // Name of browser
    
    [QueryStringParameter("device")]
    public string? Device { get; set; } // Name of device (e.g., Mobile)
    
    [QueryStringParameter("country")]
    public string? Country { get; set; } // Name of country
    
    [QueryStringParameter("region")]
    public string? Region { get; set; } // Name of region/state/province
    
    [QueryStringParameter("city")]
    public string? City { get; set; } // Name of city
    
    [QueryStringParameter("language")]
    public string? Language { get; set; } // Name of language
    
    [QueryStringParameter("event")]
    public string? Event { get; set; } // Name of event
    
    [QueryStringParameter("limit")]
    public int? Limit { get; set; } = 500; // Number of events returned (default: 500)
}
```

</details>
Huomaatte, että pyyntöön sisältyy useita ominaisuuksia, joiden avulla voidaan määritellä, mitä metriikkaa halutaan palauttaa.

Voitte myös asettaa `Limit` property, jolla rajoitetaan palautettujen tulosten määrää.

Esimerkiksi mainitsemani edellisen päivän tapahtuman saamiseksi käyttäisitte seuraavaa pyyntöä:

```csharp
var metricsRequest = new MetricsRequest
{
    StartAtDate = DateTime.Now.AddDays(-1),
    EndAtDate = DateTime.Now,
    Type = MetricType.@event,
    Event = "searchEvent"
};
```

JSON-objekti palautettiin API:sta seuraavasti:

```json
[
  { "x": "searchEvent", "y": 46 }
]
```

Ja jälleen kerran kätken tämän `MetricsResponseModels` object.

```csharp
public class MetricsResponseModels
{
    public string x { get; set; }
    public int y { get; set; }
}
```

Kun x on tapahtuman nimi ja y on se, kuinka monta kertaa se on aktivoitu.

#### Luettelo sivuista

Yksi hyödyllisimmistä mittatekijöistä on sivukatsauksen määrä. Tämä on se, kuinka monta kertaa sivua on katsottu sivustollaM SK1 jäljempänä on testi, jota käytän saadakseni sivukatsomusten määrän kuluneen vuoden aikana. `Type` parametri asetetaan seuraavasti: `MetricType.url` Tämä on kuitenkin myös standardiarvo, joten sitä ei tarvitse asettaa.

```csharp
  [Fact]
    public async Task Metrics_StartEnd()
    {
        var setup = new SetupUmamiData();
        var serviceProvider = setup.Setup();
        var websiteDataService = serviceProvider.GetRequiredService<UmamiDataService>();
        
        var metrics = await websiteDataService.GetMetrics(new MetricsRequest()
        {
            StartAtDate = DateTime.Now.AddDays(-30),
            EndAtDate = DateTime.Now,
            Type = MetricType.url,
            Limit = 500
        });
        Assert.NotNull(metrics);
        Assert.Equal( HttpStatusCode.OK, metrics.Status);

    }
```

Tämä palaa `MetricsResponse` objekti, jolla on seuraava JSON-rakenne:

```json
[
  {
    "x": "/",
    "y": 1
  },
  {
    "x": "/blog",
    "y": 1
  },
  {
    "x": "/blog/usingumamidataforwebsitestats",
    "y": 1
  }
]
```

Missä `x` on URL ja `y` on nähty monta kertaa.

### Luettelo sivuista

Tämä vastaa tiettyjen URL:ien sivukatsauksen määrään.

Tässä taas testi, jota käytän tähän menetelmään:

```csharp
    [Fact]
    public async Task PageViews_StartEnd_Day_Url()
    {
        var setup = new SetupUmamiData();
        var serviceProvider = setup.Setup();
        var websiteDataService = serviceProvider.GetRequiredService<UmamiDataService>();
    
        var pageViews = await websiteDataService.GetPageViews(new PageViewsRequest()
        {
            StartAtDate = DateTime.Now.AddDays(-7),
            EndAtDate = DateTime.Now,
            Unit = Unit.day,
            Url = "/blog"
        });
        Assert.NotNull(pageViews);
        Assert.Equal( HttpStatusCode.OK, pageViews.Status);

    }
```

Tämä palaa `PageViewsResponse` objekti, jolla on seuraava JSON-rakenne:

```json
[
  {
    "date": "2024-09-06 00:00",
    "value": 1
  }
]
```

Missä `date` on päivämäärä ja `value` on sivukatsauksen määrä, tämä toistetaan joka päivä erikseen määriteltyjen rajojen mukaisesti M SK1tai tunti `Unit` omaisuus).

Kuten muissakin menetelmissä, tämä hyväksyy `PageViewsRequest` kohde ( pakollisella `BaseRequest` properties) ja joukko valinnaisia ominaisuuksia tietojen filtroimiseksi

<details>
<summary>PageViewsRequest object</summary>

```csharp
public class PageViewsRequest : BaseRequest
{
    // Required properties

    [QueryStringParameter("unit", isRequired: true)]
    public Unit Unit { get; set; } = Unit.day; // Time unit (year | month | hour | day)
    
    [QueryStringParameter("timezone")]
    [TimeZoneValidator]
    public string Timezone { get; set; }

    // Optional properties
    [QueryStringParameter("url")]
    public string? Url { get; set; } // Name of URL
    [QueryStringParameter("referrer")]
    public string? Referrer { get; set; } // Name of referrer
    [QueryStringParameter("title")]
    public string? Title { get; set; } // Name of page title
    [QueryStringParameter("host")]
    public string? Host { get; set; } // Name of hostname
    [QueryStringParameter("os")]
    public string? Os { get; set; } // Name of operating system
    [QueryStringParameter("browser")]
    public string? Browser { get; set; } // Name of browser
    [QueryStringParameter("device")]
    public string? Device { get; set; } // Name of device (e.g., Mobile)
    [QueryStringParameter("country")]
    public string? Country { get; set; } // Name of country
    [QueryStringParameter("region")]
    public string? Region { get; set; } // Name of region/state/province
    [QueryStringParameter("city")]
    public string? City { get; set; } // Name of city
}
```

</details>
Kuten muissakin menetelmissä, voitte asettaa tiettyjä ominaisuuksia, joiden avulla voidaan filtroida API:sta palautettuja tietoja.
`Country` omaisuus saada tiettyjen maiden sivukatsauksen määrä.

# Palvelun käyttö

Tässä sivustossa minulla on jonkinlainen koodi, joka antaa minulle käyttää tätä palvelua saada kukin blogin sivulla olevat näkökohdat. Alku- ja loppupäivämäärää ja prefixiä otan jäljempänä olevaan koodiin M SK1, joka on `/blog` omassa tapauksessani) ja saada kutakin sivua koskevat tarkistukset blogissa.

Sen jälkeen säilytän nämä tiedot tunniksi, niin ettei minun tarvitse enää palauttaa Umami API:ta.

```csharp
public class UmamiDataSortService(
    UmamiDataService dataService,
    IMemoryCache cache)
{
    public async Task<List<MetricsResponseModels>?> GetMetrics(DateTime startAt, DateTime endAt, string prefix="" )
    {
        using var activity = Log.Logger.StartActivity("GetMetricsWithPrefix");
        try
        {
            var cacheKey = $"Metrics_{startAt}_{endAt}_{prefix}";
            if (cache.TryGetValue(cacheKey, out List<MetricsResponseModels>? metrics))
            {
                activity?.AddProperty("CacheHit", true);
                return metrics;
            }
            activity?.AddProperty("CacheHit", false);
            var metricsRequest = new MetricsRequest()
            {
                StartAtDate = startAt,
                EndAtDate = endAt,
                Type = MetricType.url,
                Limit = 500
            };
            var metricRequest = await dataService.GetMetrics(metricsRequest);

            if(metricRequest.Status != HttpStatusCode.OK)
            {
                return null;
            }
            var filteredMetrics = metricRequest.Data.Where(x => x.x.StartsWith(prefix)).ToList();
            cache.Set(cacheKey, filteredMetrics, TimeSpan.FromHours(1));
            activity?.AddProperty("MetricsCount", filteredMetrics?.Count()?? 0);
            activity?.Complete();
            return filteredMetrics;
        }
        catch (Exception e)
        {
            activity?.Complete(LogEventLevel.Error, e);
         
            return null;
        }
    }

```

# Päätelmissä

Tämä on yksinkertainen palvelu, joka mahdollistaa Umamista peräisin olevien tietojen vetämisen ja sen käytön omassa sovelluksessanne.. Käytän tätä saadakseni kutakin blogin sivua koskevat tarkistukset ja esittelemään ne sivussa.