# Hybridisen lähestymistavan käyttäminen Blogging-toimintaan

# Esitys

I've [monet bloggoivat](/blog/category/Markdown) monia kertoja siitä, miten käytän Markdownia luomaan blog-postejani.; Pidän todellakin tästä lähestymistavasta, mutta sillä on yksi suuri haittapuoli. - se tarkoittaa, että minun on tehtävä Dockerin kokoussykli, jotta voin päivittää postin.
Näin ollen olen nyt lisännyt blogilleni uuden osan toiminnallisuudesta, jonka ansiosta voin tehdä juuri sen.

<!--category-- ASP.NET, Markdown -->
<datetime class="hidden">2024-09-14T00:30</datetime>

[TOC]

# Hybridinen lähestymistapa

Tällä lähestymistavalla tarkoitan tätä elinkaaria, joka on jälleen kerran melko yksinkertaista mutta jokseenkin häpeällistä.

Näin ollen se on melko yksinkertainen

1. Kirjoitan uuden blogin postin Markdownissa, ja talletan sen paikalliseen koneeseeni
2. liittää se verkkosivulleni.
3. FileWatcher tunnistaa uudet luvut ja käsittelee niitä.
4. Posti siirretään tietokantaan
5. käännökset keskeytetään.
6. Kun käännökset on saatettu päätökseen, posti on päivitetty verkkosivuilla.

Tämä antaa minulle mahdollisuuden jatkaa Riderin käyttämistä paikallisesti blogien laatimiseen. ( Tulevaisuudessa IM SK1 siirtyn todennäköisesti siihen, että tämä tapahtuu myös itse sivustolla. ), kaikki käännökset tapahtuvat dynaamisesti itse sivustossa ja voin päivittää postit tekemättä täysimääräistä rakentamiskierrystä.

```mermaid

graph LR;
    A(Write new .md file)--> B[Upload using WinSCP];
    B --> C[New File Detected];
    C --> D(Process Markdown);
    D --> E[Insert into Database];
    E --> F(Kick off translations);
    F-->G[Add Translations to Database];
    G-->H[/Update Website/];

```

# Luettelo

Tämä on YET ANOTHER -koodi `IHostedService`, tällä kertaa se käyttää `FileSystemWatcher` luokka, jolla seurataan luetteloa uusista toimituksista. Kun uusi asiakirja on havaittavissa, se lukee sen, käsittelee sitä ja siirtää sen tietokantaanM SK2 tai jos poistan englanninkielisen artikkelin, se poistaa myös kaikki kyseisen artikkelin käännöksetMSC3

Koko koodi on jäljempänä, mutta aion jakaa sen hieman seuraavaksi.

<details>
<summary>MarkdownDirectoryWatcherService.cs</summary>

```csharp
using Mostlylucid.Config.Markdown;
using Polly;
using Serilog.Events;

namespace Mostlylucid.Blog.WatcherService;

public class MarkdownDirectoryWatcherService(MarkdownConfig markdownConfig, IServiceScopeFactory serviceScopeFactory,
    ILogger<MarkdownDirectoryWatcherService> logger)
    : IHostedService
{
    private Task _awaitChangeTask = Task.CompletedTask;
    private FileSystemWatcher _fileSystemWatcher;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _fileSystemWatcher = new FileSystemWatcher
        {
            Path = markdownConfig.MarkdownPath,
            NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime |
                           NotifyFilters.Size,
            Filter = "*.md", // Watch all markdown files
            IncludeSubdirectories = true // Enable watching subdirectories
        };
        // Subscribe to events
        _fileSystemWatcher.EnableRaisingEvents = true;

        _awaitChangeTask = Task.Run(()=> AwaitChanges(cancellationToken));
        logger.LogInformation("Started watching directory {Directory}", markdownConfig.MarkdownPath);
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // Stop watching
        _fileSystemWatcher.EnableRaisingEvents = false;
        _fileSystemWatcher.Dispose();

        Console.WriteLine($"Stopped watching directory: {markdownConfig.MarkdownPath}");

        return Task.CompletedTask;
    }

    private async Task AwaitChanges(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            var fileEvent = _fileSystemWatcher.WaitForChanged(WatcherChangeTypes.All);
            if (fileEvent.ChangeType == WatcherChangeTypes.Changed ||
                fileEvent.ChangeType == WatcherChangeTypes.Created)
            {
                await OnChangedAsync(fileEvent);
            }
            else if (fileEvent.ChangeType == WatcherChangeTypes.Deleted)
            {
                OnDeleted(fileEvent);
            }
            else if (fileEvent.ChangeType == WatcherChangeTypes.Renamed)
            {
               
            }
        }
    }

    private async Task OnChangedAsync(WaitForChangedResult e)
    {
        if (e.Name == null) return;

        var activity = Log.Logger.StartActivity("Markdown File Changed {Name}", e.Name);
        var retryPolicy = Policy
            .Handle<IOException>() // Only handle IO exceptions (like file in use)
            .WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromMilliseconds(500 * retryAttempt), 
                (exception, timeSpan, retryCount, context) =>
                {
                    activity?.Activity?.SetTag("Retry Attempt", retryCount);
                    // Log the retry attempt
                    logger.LogWarning("File is in use, retrying attempt {RetryCount} after {TimeSpan}", retryCount, timeSpan);
                });

        try
        {
            var fileName = e.Name;
            var isTranslated = Path.GetFileNameWithoutExtension(e.Name).Contains(".");
            var language = MarkdownBaseService.EnglishLanguage;
            var directory = markdownConfig.MarkdownPath;

            if (isTranslated)
            {
                language = Path.GetFileNameWithoutExtension(e.Name).Split('.').Last();
                fileName = Path.GetFileName(fileName);
                directory = markdownConfig.MarkdownTranslatedPath;
            }

            var filePath = Path.Combine(directory, fileName);
            var scope = serviceScopeFactory.CreateScope();
            var markdownBlogService = scope.ServiceProvider.GetRequiredService<IMarkdownBlogService>();

            // Use the Polly retry policy for executing the operation
            await retryPolicy.ExecuteAsync(async () =>
            {
                var blogModel = await markdownBlogService.GetPage(filePath);
                activity?.Activity?.SetTag("Page Processed", blogModel.Slug);
                blogModel.Language = language;

                var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
                await blogService.SavePost(blogModel);
                if (language == MarkdownBaseService.EnglishLanguage)
                {
                    var translateService = scope.ServiceProvider.GetRequiredService<BackgroundTranslateService>();
                    await translateService.TranslateForAllLanguages(
                        new PageTranslationModel(){OriginalFileName = filePath, OriginalMarkdown = blogModel.Markdown,Persist = true});
                }
                activity?.Activity?.SetTag("Page Saved", blogModel.Slug);
            });

            activity?.Complete();
        }
        catch (Exception exception)
        {
            activity?.Complete(LogEventLevel.Error, exception);
        }
    }

    private void OnDeleted(WaitForChangedResult e)
    {
        if(e.Name == null) return;
        var isTranslated = Path.GetFileNameWithoutExtension(e.Name).Contains(".");
        var language = MarkdownBaseService.EnglishLanguage;
        var slug = Path.GetFileNameWithoutExtension(e.Name);
        if (isTranslated)
        {
            var name = Path.GetFileNameWithoutExtension(e.Name).Split('.');
            language = name.Last();
            slug = name.First();
            
        }
        else
        {
            var translatedFiles = Directory.GetFiles(markdownConfig.MarkdownTranslatedPath, $"{slug}.*.*");
            _fileSystemWatcher.EnableRaisingEvents = false;
            foreach (var file in translatedFiles)
            {
                File.Delete(file);
            }
            _fileSystemWatcher.EnableRaisingEvents = true;
        }
        var scope = serviceScopeFactory.CreateScope();
        var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
        blogService.Delete(slug, language);
   
    }

    private void OnRenamed(object sender, RenamedEventArgs e)
    {
        Console.WriteLine($"File renamed: {e.OldFullPath} to {e.FullPath}");
    }
}
```

</details>
## Aloittaminen

Se vain käynnistää uuden tehtävän, jossa käytetään `FileSystemWatcher` sen sisällä `StartAsync` menetelmä. `IHostedService` tämä on ASP.NET Core -puite, jota käytetään palvelun käynnistämiseen

```csharp
    private FileSystemWatcher _fileSystemWatcher;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _fileSystemWatcher = new FileSystemWatcher
        {
            Path = markdownConfig.MarkdownPath,
            NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime |
                           NotifyFilters.Size,
            Filter = "*.md", // Watch all markdown files
            IncludeSubdirectories = true // Enable watching subdirectories
        };
        // Subscribe to events
        _fileSystemWatcher.EnableRaisingEvents = true;

        _awaitChangeTask = Task.Run(()=> AwaitChanges(cancellationToken));
        logger.LogInformation("Started watching directory {Directory}", markdownConfig.MarkdownPath);
        return Task.CompletedTask;
    }
```

Minulla on tehtävä, joka on paikallista palvelulle ja josta aktivoin muutoksen ketjun

```csharp
private Task _awaitChangeTask = Task.CompletedTask;
 _awaitChangeTask = Task.Run(()=> AwaitChanges(cancellationToken));
   
```

Tämä on tärkeää, sillä muutoin se tulee estämään., teidän on varmistettava, että tämä toimii taustalla.

Tässä olemme perustaneet `FileSystemWatcher` kuunnella tapahtumia Markdownin luettelossani. (mapattu vastaanottajaluetteloon syistä, joita me näemme myöhemmin.

```csharp
 _fileSystemWatcher = new FileSystemWatcher
        {
            Path = markdownConfig.MarkdownPath,
            NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime |
                           NotifyFilters.Size,
            Filter = "*.md", // Watch all markdown files
            IncludeSubdirectories = true // Enable watching subdirectories
        };
        // Subscribe to events
        _fileSystemWatcher.EnableRaisingEvents = true;
```

Voitte nähdä, että I'm tarkkailee `FileName`, `LastWrite`, `CreationTime` ja `Size` muutoksista. Tämä johtuu siitä, että haluan tietää, onko asiakirja laadittu.

Minulla on myös `Filter` asetetaan `*.md` Näin ollen katson vain merkitsemisohjelmia ja ilmoitan, että haluan myös katsoa alahakemuksia. (tuloksia varten

## Muutosketju

Siihen sisältyy muutoskierre, joka odottaa muutoksia tiedostojärjestelmään.
Huomauttakaa, että voitte myös vain liittyä muutoksen tapahtumiin täällä, mutta tämä vaikutti minusta puhtaammalta.

```csharp
    private async Task AwaitChanges(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            var fileEvent = _fileSystemWatcher.WaitForChanged(WatcherChangeTypes.All);
            if (fileEvent.ChangeType == WatcherChangeTypes.Changed ||
                fileEvent.ChangeType == WatcherChangeTypes.Created)
            {
                await OnChangedAsync(fileEvent);
            }
            else if (fileEvent.ChangeType == WatcherChangeTypes.Deleted)
            {
                OnDeleted(fileEvent);
            }
            else if (fileEvent.ChangeType == WatcherChangeTypes.Renamed)
            {
               
            }
        }
    }
```

Jälleen kerran varsin yksinkertainen, kaikki, mitä se tekee on odottaa muutoksen tapahtumaa ja sitten kutsuu `OnChangedAsync` menetelmä. tai jos asiakirja poistetaan, se kutsuu `OnDeleted` menetelmä.

## OnChangedAsync

Tämä on se paikka, jossa 'magic' tapahtuu
Sen tehtävänä on kuunnella muutoksen tapahtumaa. Sen jälkeen se käsittelee Markdown-ファイルä käyttäen pipelineäni ( saadakseen HTML-kategoriatM SK2 päivämäärä, otsikko ja niin edelleen) ja sisällyttää sen tietokantaanMSC5 Sitten se tunnistaa, onko asiakirja englanninkielinen MST6 joten kirjoitin sen mST7 ja jos se on, se käynnistää käännösprosessinMst8 Katso [Tämä ilmoitus](/blog/backgroundtranslationspt2) miten tämä toimii.

```csharp
   await retryPolicy.ExecuteAsync(async () =>
            {
                var blogModel = await markdownBlogService.GetPage(filePath);
                activity?.Activity?.SetTag("Page Processed", blogModel.Slug);
                blogModel.Language = language;

                var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
                await blogService.SavePost(blogModel);
                if (language == MarkdownBaseService.EnglishLanguage)
                {
                    var translateService = scope.ServiceProvider.GetRequiredService<BackgroundTranslateService>();
                    await translateService.TranslateForAllLanguages(
                        new PageTranslationModel(){OriginalFileName = filePath, OriginalMarkdown = blogModel.Markdown,Persist = true});
                }
                activity?.Activity?.SetTag("Page Saved", blogModel.Slug);
            });
```

Huomauttakaa, että käytän `Polly` Here to handle the file processing; tämä varmistaa, että ファイル on todella laadittu / tallennettu ennen kuin se yrittää käsitellä sitä

```csharp
      var retryPolicy = Policy
            .Handle<IOException>() // Only handle IO exceptions (like file in use)
            .WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromMilliseconds(500 * retryAttempt), 
                (exception, timeSpan, retryCount, context) =>
                {
                    activity?.Activity?.SetTag("Retry Attempt", retryCount);
                    // Log the retry attempt
                    logger.LogWarning("File is in use, retrying attempt {RetryCount} after {TimeSpan}", retryCount, timeSpan);
                });
```

Käytän myös `SerilogTracing` toiminnot, jotka auttavat minua löytämään ongelmia, kun se' on helpommin M SK1tuotannossa [on olemassa artikkeli](/blog/selfhostingseqpt2) myös siitä!).

```mermaid
flowchart LR
    A[Start OnChangedAsync] --> B{Is e.Name null}
    B -- Yes --> C[Return]
    B -- No --> D[Start Activity and Set File Parameters]

    D --> E[Execute retryPolicy]

    E --> F[Process and Save Markdown File]
    
    F --> G{Is language English}
    G -- Yes --> H[Kick off Translation]
    G -- No --> I[Skip Translation]

    H --> J[Complete Activity]
    I --> J

    J --> K[Handle Errors]

```

<details>
<summary>OnChangedAsync</summary>

```csharp
   private async Task OnChangedAsync(WaitForChangedResult e)
    {
        if (e.Name == null) return;

        var activity = Log.Logger.StartActivity("Markdown File Changed {Name}", e.Name);
        var retryPolicy = Policy
            .Handle<IOException>() // Only handle IO exceptions (like file in use)
            .WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromMilliseconds(500 * retryAttempt), 
                (exception, timeSpan, retryCount, context) =>
                {
                    activity?.Activity?.SetTag("Retry Attempt", retryCount);
                    // Log the retry attempt
                    logger.LogWarning("File is in use, retrying attempt {RetryCount} after {TimeSpan}", retryCount, timeSpan);
                });

        try
        {
            var fileName = e.Name;
            var isTranslated = Path.GetFileNameWithoutExtension(e.Name).Contains(".");
            var language = MarkdownBaseService.EnglishLanguage;
            var directory = markdownConfig.MarkdownPath;

            if (isTranslated)
            {
                language = Path.GetFileNameWithoutExtension(e.Name).Split('.').Last();
                fileName = Path.GetFileName(fileName);
                directory = markdownConfig.MarkdownTranslatedPath;
            }

            var filePath = Path.Combine(directory, fileName);
            var scope = serviceScopeFactory.CreateScope();
            var markdownBlogService = scope.ServiceProvider.GetRequiredService<IMarkdownBlogService>();

            // Use the Polly retry policy for executing the operation
            await retryPolicy.ExecuteAsync(async () =>
            {
                var blogModel = await markdownBlogService.GetPage(filePath);
                activity?.Activity?.SetTag("Page Processed", blogModel.Slug);
                blogModel.Language = language;

                var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
                await blogService.SavePost(blogModel);
                if (language == MarkdownBaseService.EnglishLanguage)
                {
                    var translateService = scope.ServiceProvider.GetRequiredService<BackgroundTranslateService>();
                    await translateService.TranslateForAllLanguages(
                        new PageTranslationModel(){OriginalFileName = filePath, OriginalMarkdown = blogModel.Markdown,Persist = true});
                }
                activity?.Activity?.SetTag("Page Saved", blogModel.Slug);
            });

            activity?.Complete();
        }
        catch (Exception exception)
        {
            activity?.Complete(LogEventLevel.Error, exception);
        }
    }
```

</details>
## Poistettu

Tämä on todella yksinkertainen, se havaitsee vain, milloin asiakirja poistetaan ja poistaa sen tietokannasta ; käytän tätä pääasiassa idioottina- todistetoimenpiteenä, koska olen valmis laatimaan artiklat ja heti huomaan, että niissä on virheitäM SK4 Kuten voitte nähdä, se testaa nähdäkseen, onko asiakirja käännetty, ja jos se on, se poistaa kaikki kyseisen asiakirjan käännökset

```mermaid
flowchart LR
A[Start OnDeleted] --> B{Is e.Name null}
B -- Yes --> C[Return]
B -- No --> D[Start Activity and Set Parameters: isTranslated, language, slug]

    D --> E{Is file translated}
    E -- Yes --> F[Set language and slug for translation]
    E -- No --> G[Delete all translated files]

    F --> H[Create DI Scope and Get IBlogService]
    G --> H

    H --> I[Delete Post from Database]

    I --> J[Complete Activity]
    J --> K[Handle Errors if any]

```

```csharp
 private void OnDeleted(WaitForChangedResult e)
    {
        if (e.Name == null) return;
        var activity = Log.Logger.StartActivity("Markdown File Deleting {Name}", e.Name);
        try
        {
            var isTranslated = Path.GetFileNameWithoutExtension(e.Name).Contains(".");
            var language = MarkdownBaseService.EnglishLanguage;
            var slug = Path.GetFileNameWithoutExtension(e.Name);
            if (isTranslated)
            {
                var name = Path.GetFileNameWithoutExtension(e.Name).Split('.');
                language = name.Last();
                slug = name.First();
            }
            else
            {
                var translatedFiles = Directory.GetFiles(markdownConfig.MarkdownTranslatedPath, $"{slug}.*.*");
                _fileSystemWatcher.EnableRaisingEvents = false;
                foreach (var file in translatedFiles)
                {
                    File.Delete(file);
                }

                _fileSystemWatcher.EnableRaisingEvents = true;
            }

            var scope = serviceScopeFactory.CreateScope();
            var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
            blogService.Delete(slug, language);
            activity?.Activity?.SetTag("Page Deleted", slug);
            activity?.Complete();
            logger.LogInformation("Deleted blog post {Slug} in {Language}", slug, language);
        }
        catch (Exception exception)
        {
            activity?.Complete(LogEventLevel.Error, exception);
            logger.LogError("Error deleting blog post {Slug}", e.Name);
        }
    }

```

# Laaditaan tiedostoja

Käytän WinSCP:tä, jotta voin ladata asiakirjat verkkosivuilleni. `FileSystemWatcher` katsoo. Tulevaisuudessa lisään tähän myös näyttöä laajentavat mahdollisuudetM SK2 siellä lisään joitakin entiseen käsittelyyn ja suurempien ohjelmien käsittelyyn .

![WinSCP](winscp.png)

# Päätelmissä

Näin ollen tämä on melko yksinkertainen tapa lisätä uusia blog-osoituksia verkkosivuilleni tekemättä täytäntöönpanojaksoa. Tässä artikkelissa esitin, miten käyttää `FileSystemWatcher` havaita muutokset luetteloon ja käsitellä niitä. osoitin myös, miten käyttää `Polly` käsitellä uudelleenkäyntejä ja `Serilog` prosessin logging.