Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
48 changes: 48 additions & 0 deletions .github/workflows/prove.yml
Original file line number Diff line number Diff line change
@@ -0,0 +1,48 @@
# Ogni pull request: si compila l'app e si fanno le prove, su Windows. Se sono rosse non si unisce.
# Il menu di Windows 11 (Zig) lo compila il flusso di rilascio: qui, se la DLL non c'è, quella prova esce da sola.
name: Prove

on:
pull_request:
workflow_dispatch:

jobs:
prove:
runs-on: windows-latest
steps:
- uses: actions/checkout@v4

- uses: actions/setup-dotnet@v4
with:
dotnet-version: 10.0.x

- uses: actions/setup-node@v4
with:
node-version: 22

- name: FFmpeg
shell: pwsh
run: ./scripts/prendi-ffmpeg.ps1

- name: 7-Zip
shell: pwsh
run: ./scripts/prendi-7zip.ps1

- name: Interfaccia
shell: pwsh
working-directory: ui
run: |
if (-not (Test-Path node_modules)) {
npm ci --no-audit --no-fund
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
}
npm run build
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

- name: App
shell: pwsh
run: dotnet build src/DaPConvertitore/DaPConvertitore.csproj -c Release -nologo

- name: Prove
shell: pwsh
run: dotnet test test/DaPConvertitore.Prove -c Release -nologo
12 changes: 2 additions & 10 deletions .github/workflows/rilascio.yml
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
# Ogni volta che su main arriva una versione nuova (il <Version> di Directory.Build.props) GitHub fa le prove,
# compila, impacchetta con Velopack e pubblica la release vX.Y.Z con Setup.exe, portatile e i pacchetti per gli
# aggiornamenti automatici. Le prove girano ma non fermano la release (come in DaProd Video): i runner di GitHub
# non hanno LibreOffice né le estensioni HEIF, quindi qualche prova lì può dire cose che sul PC vero non succedono.
# aggiornamenti automatici. Le prove devono passare: se sono rosse la release non esce. LibreOffice e le estensioni
# HEIF sui runner non ci sono: quelle prove, se il pezzo manca, escono da sole (non sono un fallimento).
name: Rilascio

on:
Expand Down Expand Up @@ -61,17 +61,9 @@ jobs:
run: ./scripts/compila-menu.ps1

- name: Prove
id: prove
continue-on-error: true
shell: pwsh
run: dotnet test test/DaPConvertitore.Prove -nologo

- name: Esito delle prove
if: steps.prove.outcome == 'failure'
shell: pwsh
run: |
Write-Host "::warning title=Prove::Qualche prova non è passata, guarda il passo Prove (la release esce lo stesso)"

- name: Pacchetto
if: steps.versione.outputs.esiste == 'no'
shell: pwsh
Expand Down
16 changes: 16 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,22 @@

Le novità di ogni versione, dette come stanno. La più nuova sta in alto.

## 2.2.6 — 3 novembre 2026

- **Le miniature dei documenti Word non vanno più in errore.** Disegnando la pagina si chiedeva «zero righe» di testo e Windows rifiutava
(nel registro, ArgumentOutOfRangeException, sei volte su un `.docx`). Ora si disegnano le righe che ci stanno. Vale anche per le diapositive.
- **«Scegli il personaggio» si chiude senza errore.** Chiudendo la finestrella, la chiusura richiamava se stessa e Windows rispondeva che la
finestra era già in chiusura (InvalidOperationException).
- **Gli aggiornamenti non si pestano i piedi, e un 403 di GitHub non è più un errore rosso.** Due controlli insieme litigavano per il
lucchetto di Velopack («Failed to acquire exclusive lock»): ora ne parte uno alla volta. Il controllo legge il file della release
(`releases.win.json`), non l'API di GitHub, che senza accesso si ferma dopo poche richieste. Se la rete manca, o se GitHub chiede comunque
di aspettare, si riprova più tardi (dopo un limite, dopo ore, non ogni 20 minuti) e nel registro non finisce come errore. L'avviso resta
nella barra in alto; dopo l'aggiornamento le novità si aprono da sole, come prima.
- **Spostare lo slider del peso di una foto non scrive più un errore.** La stima vecchia si ferma quando ne parte una nuova: era una
cancellazione normale e finiva nel registro come TaskCanceledException.
- **Trascinare un file dentro non può più far cadere il programma** se qualcosa va storto in quel passaggio.
- **Le prove fermano la release** se sono rosse, e ogni pull request le fa girare (prima partivano solo su main e un rosso non bloccava niente).

## 2.2.5 — 29 ottobre 2026

- **App predefinite: ora si capisce cosa succede.** Windows applica la regola «apri tutto con DaProd» solo **all'accesso**: finché non ti
Expand Down
2 changes: 1 addition & 1 deletion Directory.Build.props
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@
<!-- La versione sta solo qui. Si alza di 0.0.1 e si scrive la voce nel CHANGELOG:
la CI la legge da questo file e pubblica la release da sola. -->
<PropertyGroup>
<Version>2.2.5</Version>
<Version>2.2.6</Version>
<Authors>DaProd</Authors>
<Company>DaProdProduzioni</Company>
<Product>DaP Convertitore</Product>
Expand Down
10 changes: 10 additions & 0 deletions src/DaPConvertitore.Motore/EccezioniPonte.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,10 @@
namespace DaP.Convertitore;

/// <summary>
/// Cosa il ponte fra la pagina e il motore deve scrivere nel registro.
/// Una stima annullata perché ne è partita un'altra (lo slider della foto) non è un errore.
/// </summary>
public static class EccezioniPonte
{
public static bool DaRegistro(Exception e) => e is not OperationCanceledException;
}
50 changes: 50 additions & 0 deletions src/DaPConvertitore.Motore/EsitoAggiornamento.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
using System.Net;
using System.Net.Http;

namespace DaP.Convertitore;

/// <summary>
/// Come è andato un controllo aggiornamenti. Il limite di GitHub e il lucchetto di Velopack
/// (due controlli insieme) non sono un guasto: si riprova più tardi, senza scriverli come errore.
/// </summary>
public static class EsitoAggiornamento
{
public enum Tipo { Fatto, Presto, Tardi, Guasto }

public static Tipo Di(Exception e)
{
Tipo? rete = null;
for (Exception? x = e; x is not null; x = x.InnerException)
{
var nome = x.GetType().Name;
var msg = x.Message ?? "";
if (nome.Contains("AcquireLock", StringComparison.Ordinal)
|| msg.Contains("exclusive lock", StringComparison.OrdinalIgnoreCase)
|| msg.Contains(".velopack_lock", StringComparison.OrdinalIgnoreCase))
return Tipo.Presto;
if (x is HttpRequestException http)
{
if (http.StatusCode is HttpStatusCode.Forbidden or HttpStatusCode.TooManyRequests) return Tipo.Tardi;
if (http.StatusCode is HttpStatusCode.NotFound) return Tipo.Guasto;
rete ??= Tipo.Presto;
}
if (msg.Contains("rate limit", StringComparison.OrdinalIgnoreCase) || ÈCodice(msg, 403) || ÈCodice(msg, 429))
return Tipo.Tardi;
if (ÈCodice(msg, 404)) return Tipo.Guasto;
if (nome is "SocketException" or "TimeoutException" or "WebException") rete ??= Tipo.Presto;
}
return rete ?? Tipo.Guasto;
}

/// <summary>La riga nel registro, per i casi che non sono un errore dell'app.</summary>
public static string Nota(Tipo tipo) => tipo switch
{
Tipo.Tardi => "GitHub ha chiesto di aspettare, riprovo più tardi",
Tipo.Presto => "lo riprovo fra un po' (rete o un altro controllo già in corso)",
Tipo.Fatto => "fatto",
_ => "è andato storto",
};

static bool ÈCodice(string msg, int codice) =>
msg.Contains("status code", StringComparison.OrdinalIgnoreCase) && msg.Contains(codice.ToString(), StringComparison.Ordinal);
}
14 changes: 14 additions & 0 deletions src/DaPConvertitore.Motore/FonteAggiornamenti.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
namespace DaP.Convertitore;

/// <summary>
/// Da dove arrivano gli aggiornamenti. Non è l'API di GitHub (<c>api.github.com</c>): senza token
/// quella si ferma dopo 60 richieste l'ora e risponde 403. Si legge il file <c>releases.win.json</c>
/// allegato alla release, lo stesso che pubblica Velopack.
/// </summary>
public static class FonteAggiornamenti
{
public const string Repo = "https://github.com/cammo22/DaP-Convertitore";

/// <summary>La cartella della release: ci stanno <c>releases.win.json</c> e i pacchetti.</summary>
public static Uri Pacchetti { get; } = new(Repo + "/releases/latest/download/");
}
11 changes: 11 additions & 0 deletions src/DaPConvertitore.Motore/RigheTesto.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
namespace DaP.Convertitore;

/// <summary>
/// Quante righe di testo sta in una miniatura. <c>FormattedText.MaxLineCount</c> di WPF
/// lancia ArgumentOutOfRangeException se gli si dà 0 o meno (è successo con i .docx):
/// 0 qui vuol dire «quante ce ne stanno nell'altezza», che per WPF è <see cref="int.MaxValue"/>.
/// </summary>
public static class RigheTesto
{
public static int Massimo(int richiesto) => richiesto > 0 ? richiesto : int.MaxValue;
}
28 changes: 28 additions & 0 deletions src/DaPConvertitore.Motore/UnoAllaVolta.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,28 @@
namespace DaP.Convertitore;

/// <summary>
/// Un lavoro per volta: il secondo aspetta che il primo abbia finito.
/// Gli aggiornamenti ne hanno bisogno, perché Velopack tiene un lucchetto
/// (<c>.velopack_lock</c>) e il secondo controllo fallisce se il primo è ancora dentro.
/// </summary>
public sealed class UnoAllaVolta
{
readonly SemaphoreSlim porta = new(1, 1);

public async Task<T> Esegui<T>(Func<Task<T>> lavoro, CancellationToken ct = default)
{
await porta.WaitAsync(ct).ConfigureAwait(false);
try { return await lavoro().ConfigureAwait(false); }
finally { porta.Release(); }
}

public async Task Esegui(Func<Task> lavoro, CancellationToken ct = default)
{
await Esegui(async () => { await lavoro().ConfigureAwait(false); return 0; }, ct).ConfigureAwait(false);
}

/// <summary>Entra se la porta si libera entro <paramref name="attesa"/>; poi va chiamato <see cref="Esci"/>.</summary>
public bool Prova(TimeSpan attesa) => porta.Wait(attesa);

public void Esci() => porta.Release();
}
Loading
Loading