# Ajout d'un paquet Nuget de suivi du client Umami

<!--category-- ASP.NET, Umami, Nuget -->
<datetime class="hidden">2024-08-28T02:00</datetime>

# Introduction

Maintenant, j’ai le client Umami; Je dois l’emballer et la rendre disponible comme un paquet Nuget. Ce processus est assez simple mais il y a quelques choses à prendre en considération .

[TOC]

# Création du paquet Nuget

## Versionnement

J'ai décidé de copier [Khalid](https://khalidabuhakmeh.com/) et utiliser l'excellent paquet minver à la version de mon Nuget package. Il s'agit d'un paquet simple qui utilise le tag git pour déterminer le numéro de version.

Pour l'utiliser, j'ai simplement ajouté ce qui suit à mon `Umami.Net.csproj` fichier:

```xml
    <PropertyGroup>
    <MinVerTagPrefix>v</MinVerTagPrefix>
</PropertyGroup>
```

De cette façon, je peux étiqueter ma version avec un `v` et le paquet sera correctement modifié.

```bash
 git tag v0.0.8       
 git push origin v0.0.8

```

Je vais pousser ce tag, alors j'ai une configuration d'action GitHub pour attendre ce tag et construire le paquet Nuget.

## Établissement du Nuget Package

J’ai une action GitHub qui construit le paquet Nuget et l’envoie au répertoire des paquets de Git Hub. C’est un processus simple qui utilise `dotnet pack` la commande de construire le paquet et ensuite `dotnet nuget push` commande pour le pousser au repos nuget.

```yaml
name: Publish Umami.NET
on:
  push:
    tags:
      - 'v*.*.*'  # This triggers the action for any tag that matches the pattern v1.0.0, v2.1.3, etc.

jobs:
  publish:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.x' # Specify the .NET version you need

    - name: Restore dependencies
      run: dotnet restore ./Umami.Net/Umami.Net.csproj

    - name: Build project
      run: dotnet build --configuration Release ./Umami.Net/Umami.Net.csproj --no-restore

    - name: Pack project
      run: dotnet pack --configuration Release ./Umami.Net/Umami.Net.csproj --no-build --output ./nupkg

    - name: Publish to NuGet
      run: dotnet nuget push ./nupkg/*.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.UMAMI_NUGET_API_KEY }}
      env:
        NUGET_API_KEY: ${{ secrets.UMAMI_NUGET_API_KEY }}
```

### Ajouter Readme et Icon

C’est assez simple, Je ajoute un `README.md` le fichier à la source du projet et un `icon.png` le fichier à la source du projet. Le `README.md` le fichier est utilisé comme description du paquet et `icon.png` le fichier est utilisé comme icône du paquet.

```xml
    <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <LangVersion>12</LangVersion>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>

        <IsPackable>true</IsPackable>
        <PackageId>Umami.Net</PackageId>
        <Authors>Scott Galloway</Authors>
        <PackageIcon>icon.png</PackageIcon>
        <RepositoryUrl>https://github.com/scottgal/mostlylucidweb/tree/main/Umami.Net</RepositoryUrl>
        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageTags>web</PackageTags>
        <PackageReadmeFile>README.md</PackageReadmeFile>
        <Description>
           Adds a simple Umami endpoint to your ASP.NET Core application.
        </Description>
    </PropertyGroup>
```

Dans mon fichier README.md, j'ai un lien vers le répertoire GitHub et une description du paquet.

Reproduit ci-dessous:

# Umami.Net

Il s'agit d'un .NET Core client pour l'API de suivi Umami.
Il est fondé sur le client du node Umami, ,. [ici](https://github.com/umami-software/node).

Vous pouvez voir comment installer Umami en tant que conteneur de docker [ici](https://www.mostlylucid.net/blog/usingumamiforlocalanalytics).
Vous pouvez lire plus de détails sur sa création' dans mon blog [ici](https://www.mostlylucid.net/blog/addingumamitrackingclientfollowup).

Pour utiliser ce client, vous avez besoin des paramètres suivants.json configuration:

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

Où `UmamiPath` est le chemin vers votre instance Umami et `WebsiteId` est l'ID du site Web que vous voulez suivre.

Pour utiliser le client, vous devez ajouter ce qui suit à votre `Program.cs`:

```csharp
using Umami.Net;

services.SetupUmamiClient(builder.Configuration);
```

Cela ajoutera le client Umami à la collection de services.

Vous pouvez ensuite utiliser le client de deux façons:

1. Injectez le `UmamiClient` et appelez le `Track` méthode:

```csharp
 // Inject UmamiClient umamiClient
 await umamiClient.Track("Search", new UmamiEventData(){{"query", encodedQuery}});
```

2. Utilisez le `UmamiBackgroundSender` pour suivre les événements dans le contexte (il s'agit d'un `IHostedService` pour envoyer des événements dans l'arrière-plan):

```csharp
 // Inject UmamiBackgroundSender umamiBackgroundSender
await umamiBackgroundSender.Track("Search", new UmamiEventData(){{"query", encodedQuery}});
```

Le client envoiera l’événement à la API Umami et il sera entreposé.

L'article 5 de la Loi sur l'immigration et le statut des réfugiés `UmamiEventData` est un dictionnaire des paires de valeurs clés qui seront envoyées à l’API Umami comme données d’événement.

Il existe en outre d’autres méthodes de faible niveau qui peuvent être utilisées pour envoyer des événements à l’API Umami.

Sur les deux `UmamiClient` et `UmamiBackgroundSender` Vous pouvez appeler la méthode suivante.

```csharp


 Send(UmamiPayload? payload = null, UmamiEventData? eventData = null,
        string eventType = "event")
```

Si vous ne passez pas dans un `UmamiPayload` object, le client créera un pour vous en utilisant `WebsiteId` à partir des paramètres de l'appareil.

```csharp
    public  UmamiPayload GetPayload(string? url = null, UmamiEventData? data = null)
    {
        var httpContext = httpContextAccessor.HttpContext;
        var request = httpContext?.Request;

        var payload = new UmamiPayload
        {
            Website = settings.WebsiteId,
            Data = data,
            Url = url ?? httpContext?.Request?.Path.Value,
            IpAddress = httpContext?.Connection?.RemoteIpAddress?.ToString(),
            UserAgent = request?.Headers["User-Agent"].FirstOrDefault(),
            Referrer = request?.Headers["Referer"].FirstOrDefault(),
           Hostname = request?.Host.Host,
        };
        
        return payload;
    }

```

Vous pouvez voir que cette étude `UmamiPayload` objet avec le `WebsiteId` à partir des appsettings.json, `Url`, `IpAddress`, `UserAgent`, `Referrer` et `Hostname` de la `HttpContext`.

NOTE: eventType ne peut être que M SK1event" ou "identifyMSC4 selon l'API de Umami

# En conclusion

Ainsi, vous pouvez maintenant installer Umami.Net à partir de Nuget et l’utiliser dans votre ASPM SK2NET Core application. J’espère que vous le trouvez utile . IMSC5 Je continuerai de tweaking et d’ajouter des tests dans les prochains articles.