# वेबसाइट सांख्यिकी के लिए उमामी डाटा का उपयोग

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

# परिचय

इस ब्लॉग शुरू करने के बाद से मेरी एक परियोजनाओं में से एक लगभग आवेशपूर्ण इच्छा है कि कितनी उपयोगकर्ता मेरे वेबसाइट पर देख रहे हैं ट्रैक करें [पदों का बंड](/blog/category/Umami) Umami के उपयोग और सेटअप के बारे में मैं भी एक Nuget पैकेज है जो एक ASP से डेटा ट्रैक करने के लिए संभव करता है

अब मैं एक नया सेवा जोड़ा है जो आपको Umami से डेटा वापस लेने की अनुमति देता है एक C के अनुप्रयोग में खींचने के लिए।

सामान्य रूप से इस के लिए सभी स्रोत कोड पाया जा सकता है [मेरी GitHub पर](https://github.com/scottgal/mostlylucidweb/tree/main/Umami.Net) इस साइट के लिए.

[TOC]

# संस्थापन

यह पहले से ही Umami में है।

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

फिर आप अपने में सेवा सेटअप करने की जरूरत है `Program.cs` फ़ाइल:

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

यह उपयोग करता है `Analytics' element from your `अनुप्रयोग विन्यास

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

यहाँ `UmamiScript` यह स्क्रिप्ट है जिसे आप Umami ( में क्लाइंट पक्ष ट्रैकिंग के लिए प्रयोग करते हैं[यहाँ देखें](/blog/usingumamiforlocalanalytics) कि कैसे सेटअप करने के लिए ).
 `WebSiteId` आपके उमामी इंस्टैंस में बनाया गया वेबसाइट के लिए आईडी है
`UmamiPath` आपके उमामी इंस्टैंस के लिए पथ है

 `UserName` और `Password` Umami इंस्टैंस के लिए प्रमाण पत्र हैं (इस मामले में मैं प्रशासन पासवर्ड का उपयोग करता हूँ

# उपयोग

अब आपके पास है `UmamiDataService` अपने सेवा संग्रह में आप इसे उपयोग शुरू कर सकते हैं

## विधि

विधियां सभी उमामी API परिभाषा से हैं आप उनके बारे में यहाँ पढ़ सकते है
@item: inlistbox Spelling dictionary

सभी वापसी एक में wrapped हैं `UmamiResults<T>` वस्तु है जो एक `Success` संपत्ति और एक `Result` संपत्ति. `Result` गुण Umami API से लौटा हुआ वस्तु है

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

सभी अनुरोधों के अलावा `ActiveUsers` दो अनिवार्य गुणों के साथ एक आधार अनुरोध ऑब्जेक्ट है

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

सेवा में निम्नलिखित विधियां हैं:

### सक्रिय उपयोक्ता

यह सिर्फ साइट पर मौजूदा सक्रिय उपयोगकर्ताओं की कुल संख्या प्राप्त करता है

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

### सांख्यिकी

यह साइट के बारे में सांख्यिकी का एक गुच्छा लौटाता है

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

आप API से लौटाए गए डेटा को फिल्टर करने के लिए कई पैरामीटर सेट कर सकते हैं `url` एक विशिष्ट यूआरएल के लिए आँकड़े लौटाएगा

<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 ऑब्जेक्ट उममी का परिणाम इस प्रकार है.

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

यह मेरे अंदर wrapped है `StatsResponseModel` वस्तु.

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

### मैट्रिक्स

यूमामी मेट्रिक्स आपको विशिष्ट प्रकार के गुणों के लिए दृश्य की संख्या प्रदान करता है

#### घटनाएँ

इनमें से एक उदाहरण है घटनाएँ

'Events' Umami में विशिष्ट वस्तुएं हैं जिन्हें आप किसी साइट पर ट्रैक कर सकते है। `Search` यूआरएल और खोज शब्द के साथ अनुरोध

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

इस घटना के बारे में डेटा लाने के लिए आप उपयोग करेंगे `Metrics` विधि

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

जैसा कि अन्य विधियों के साथ यह स्वीकार करता है `MetricsRequest` वस्तु ( अनिवार्य के साथ `BaseRequest` गुणों) और डेटा को फिल्टर करने के लिए वैकल्पिक गुणों की संख्या

<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>
यहाँ आप यह देख सकते हैं कि आप अनुरोध तत्व में गुणों की एक संख्या निर्दिष्ट कर सकते है जो वे मापदंड बताने के लिए आप चाहते हैं

आप एक भी सेट कर सकते हैं `Limit` परिणामों की संख्या को सीमित करने के लिए गुण लौटा

उदाहरण के लिए पिछले दिन मैं ऊपर उल्लेखित घटना प्राप्त करने के लिए आप निम्नलिखित अनुरोध उपयोग करेगा:

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

API से वापस JSON ऑब्जेक्ट निम्नानुसार है:

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

और फिर मैं अपने में यह wrap `MetricsResponseModels` वस्तु.

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

जहाँ x घटना नाम है और y बार यह ट्रिगर किया गया है की संख्या है

#### पृष्ठ दृश्य

सबसे उपयोगी मापदंडों में से एक पृष्ठ दृश्य की संख्या है। `Type` पैरामीटर इस रूप में सेट है `MetricType.url` हालांकि यह भी तयशुदा मान है तो आप इसे सेट करने की जरूरत नहीं है

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

    }
```

यह एक वापस करता है `MetricsResponse` वस्तु जो निम्नलिखित JSON संरचना है:

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

कहाँ `x` यूआरएल है और `y` कितनी बार देखा गया है

### पृष्ठ दृश्य

यह एक विशिष्ट यूआरएल के लिए पृष्ठ दृश्यों की संख्या लौटाता है

एक बार फिर यहाँ एक परीक्षण मैं इस विधि के लिए उपयोग करता है

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

    }
```

यह एक वापस करता है `PageViewsResponse` वस्तु जो निम्नलिखित JSON संरचना है:

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

कहाँ `date` तिथि है और `value` पृष्ठ दृश्यों की संख्या है, यह निर्दिष्ट दायरे में प्रत्येक दिन के लिए दोहराया जाता है `Unit` संपत्ति

जैसा कि अन्य विधियों के साथ यह स्वीकार करता है `PageViewsRequest` वस्तु ( अनिवार्य के साथ `BaseRequest` गुणों) और डेटा को फिल्टर करने के लिए वैकल्पिक गुणों की संख्या

<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>
जैसे अन्य विधियों के साथ आप API से लौटाए गए डेटा फ़िल्टर करने के लिए गुणों की एक संख्या सेट कर सकते हैं
`Country` विशेष देश से पृष्ठ दृश्यों की संख्या प्राप्त करने के लिए संपत्ति.

# सेवा का उपयोग

इस साइट में मैं कुछ कोड है जो मुझे इस सेवा का उपयोग करने के लिए अनुमति देता है प्रत्येक ब्लॉग पृष्ठ दृश्यों की संख्या प्राप्त करता है। `/blog` मेरे मामले में) और ब्लॉग में प्रत्येक पृष्ठ के लिए दृश्यों की संख्या प्राप्त करें

तब मैं एक घंटे के लिए इस डेटा को कैश करता हूँ ताकि मुझे Umami API hitting जारी रखने की जरूरत नहीं है

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

```

# अंत में

यह एक सरल सेवा है जो आपको Umami से डेटा खींचने और अपने अनुप्रयोग में उपयोग करने के लिए अनुमति देता है।