Local Data, Settings & Files

using System;
using System.IO;

namespace Bookshelf.Core;

/// <summary>Resolves the folders the application is allowed to write to.</summary>
public interface IAppPaths
{
    /// <summary>Per-user, per-machine data: database, caches, logs.</summary>
    string DataDirectory { get; }

    /// <summary>User settings file.</summary>
    string SettingsFile { get; }

    /// <summary>Default folder suggested for exports.</summary>
    string ExportsDirectory { get; }
}

public sealed class AppPaths : IAppPaths
{
    private const string AppFolderName = "Bookshelf";

    public AppPaths()
    {
        var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
        if (string.IsNullOrEmpty(local))
        {
            throw new InvalidOperationException("The local application data folder is not available.");
        }

        DataDirectory = Path.Combine(local, AppFolderName);
        SettingsFile = Path.Combine(DataDirectory, "settings.json");
        ExportsDirectory = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), AppFolderName);

        Directory.CreateDirectory(DataDirectory);
    }

    public string DataDirectory { get; }
    public string SettingsFile { get; }
    public string ExportsDirectory { get; }
}

using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;

namespace Bookshelf.Core;

/// <summary>Preferences the user can change. Add members; never rename without a migration.</summary>
public sealed record UserSettings
{
    public int Version { get; init; } = 2;
    public string Theme { get; init; } = "System";
    public string LastExportDirectory { get; init; } = "";
    public bool ShowOnlyFavorites { get; init; }
    public double WindowWidth { get; init; } = 1100;
    public double WindowHeight { get; init; } = 720;
}

[JsonSourceGenerationOptions(WriteIndented = true, ReadCommentHandling = JsonCommentHandling.Skip,
    AllowTrailingCommas = true)]
[JsonSerializable(typeof(UserSettings))]
internal sealed partial class SettingsJsonContext : JsonSerializerContext;

public interface ISettingsService
{
    UserSettings Current { get; }
    Task LoadAsync(CancellationToken cancellationToken = default);
    Task UpdateAsync(Func<UserSettings, UserSettings> change, CancellationToken cancellationToken = default);
}

public sealed class JsonSettingsService(IAppPaths paths) : ISettingsService
{
    private readonly SemaphoreSlim _gate = new(1, 1);

    public UserSettings Current { get; private set; } = new();

    public async Task LoadAsync(CancellationToken cancellationToken = default)
    {
        await _gate.WaitAsync(cancellationToken);
        try
        {
            if (!File.Exists(paths.SettingsFile))
            {
                return;
            }

            await using var stream = new FileStream(
                paths.SettingsFile, FileMode.Open, FileAccess.Read, FileShare.Read,
                bufferSize: 4096, useAsync: true);
            var loaded = await JsonSerializer.DeserializeAsync(
                stream, SettingsJsonContext.Default.UserSettings, cancellationToken);
            Current = loaded ?? new UserSettings();
        }
        catch (JsonException)
        {
            // A hand-edited or truncated file must not stop the app: keep the defaults.
            Current = new UserSettings();
        }
        catch (IOException)
        {
            Current = new UserSettings();
        }
        finally
        {
            _gate.Release();
        }
    }

    public async Task UpdateAsync(Func<UserSettings, UserSettings> change, CancellationToken cancellationToken = default)
    {
        await _gate.WaitAsync(cancellationToken);
        try
        {
            var updated = change(Current);
            await AtomicFile.WriteAsync(
                paths.SettingsFile,
                (stream, ct) => JsonSerializer.SerializeAsync(
                    stream, updated, SettingsJsonContext.Default.UserSettings, ct),
                cancellationToken);
            Current = updated;
        }
        finally
        {
            _gate.Release();
        }
    }
}

using System.Threading.Tasks;
using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class SettingsViewModel(ISettingsService settings) : ObservableObject
{
    [ObservableProperty]
    public partial string Theme { get; set; } = settings.Current.Theme;

    [ObservableProperty]
    public partial bool ShowOnlyFavorites { get; set; } = settings.Current.ShowOnlyFavorites;

    [RelayCommand]
    private Task SaveAsync() =>
        settings.UpdateAsync(s => s with { Theme = Theme, ShowOnlyFavorites = ShowOnlyFavorites });
}

using System;
using Bookshelf.Core;
using Microsoft.EntityFrameworkCore;

namespace Bookshelf.Data;

public sealed class BookEntity
{
    public int Id { get; set; }
    public string Title { get; set; } = "";
    public string Author { get; set; } = "";
    public int Year { get; set; }
    public decimal Price { get; set; }
    public string? Isbn { get; set; }

    /// <summary>Application-managed concurrency token (SQLite has no native one).</summary>
    public Guid Version { get; set; } = Guid.NewGuid();

    public Book ToBook() => new(Id, Title, Author, Year, Price, Isbn);

    public static BookEntity FromBook(Book book) => new()
    {
        Id = book.Id,
        Title = book.Title,
        Author = book.Author,
        Year = book.Year,
        Price = book.Price,
        Isbn = book.Isbn,
    };

    public void CopyFrom(Book book)
    {
        Title = book.Title;
        Author = book.Author;
        Year = book.Year;
        Price = book.Price;
        Isbn = book.Isbn;
        Version = Guid.NewGuid();
    }
}

public sealed class BookshelfDbContext(DbContextOptions<BookshelfDbContext> options) : DbContext(options)
{
    public DbSet<BookEntity> Books => Set<BookEntity>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<BookEntity>(entity =>
        {
            entity.ToTable("Books");
            entity.HasKey(b => b.Id);
            entity.Property(b => b.Title).IsRequired().HasMaxLength(300);
            entity.Property(b => b.Author).IsRequired().HasMaxLength(200);
            entity.Property(b => b.Isbn).HasMaxLength(20);

            // SQLite stores decimal as text; ordering or comparing it runs on the client.
            // Keep the C# type and store a double instead (see the pitfalls table).
            entity.Property(b => b.Price).HasConversion<double>();

            entity.Property(b => b.Version).IsConcurrencyToken();
            entity.HasIndex(b => b.Title);
            entity.HasIndex(b => b.Isbn).IsUnique();
        });
    }
}

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Bookshelf.Core;

public interface IBookRepository
{
    Task<IReadOnlyList<Book>> GetAllAsync(CancellationToken cancellationToken);
    Task<Book?> GetByIdAsync(int id, CancellationToken cancellationToken);
    Task<Book> AddAsync(Book book, CancellationToken cancellationToken);
    Task UpdateAsync(Book book, CancellationToken cancellationToken);
    Task DeleteAsync(int id, CancellationToken cancellationToken);
}

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Bookshelf.Core;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace Bookshelf.Data;

public sealed class SqliteBookRepository(
    IDbContextFactory<BookshelfDbContext> factory,
    ILogger<SqliteBookRepository> logger) : IBookRepository
{
    public async Task<IReadOnlyList<Book>> GetAllAsync(CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        var rows = await db.Books
            .AsNoTracking()
            .OrderBy(b => b.Title)
            .ToListAsync(cancellationToken);
        return rows.Select(r => r.ToBook()).ToList();
    }

    public async Task<Book?> GetByIdAsync(int id, CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        var row = await db.Books
            .AsNoTracking()
            .FirstOrDefaultAsync(b => b.Id == id, cancellationToken);
        return row?.ToBook();
    }

    public async Task<Book> AddAsync(Book book, CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        var entity = BookEntity.FromBook(book);
        entity.Id = 0; // the database assigns the key
        db.Books.Add(entity);
        await db.SaveChangesAsync(cancellationToken);
        logger.LogInformation("Added book {BookId}", entity.Id);
        return entity.ToBook();
    }

    public async Task UpdateAsync(Book book, CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        var entity = await db.Books.FirstOrDefaultAsync(b => b.Id == book.Id, cancellationToken)
            ?? throw new KeyNotFoundException($"Book {book.Id} no longer exists.");
        entity.CopyFrom(book);
        await db.SaveChangesAsync(cancellationToken);
    }

    public async Task DeleteAsync(int id, CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        await db.Books.Where(b => b.Id == id).ExecuteDeleteAsync(cancellationToken);
    }
}

dotnet ef migrations add InitialCreate --project src/Bookshelf.Data --startup-project src/Bookshelf.Desktop
dotnet ef migrations add AddBookVersion --project src/Bookshelf.Data --startup-project src/Bookshelf.Desktop

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace Bookshelf.Data;

public sealed partial class DatabaseInitializer(
    IDbContextFactory<BookshelfDbContext> factory,
    ILogger<DatabaseInitializer> logger) : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await using var db = await factory.CreateDbContextAsync(cancellationToken);
        try
        {
            await db.Database.MigrateAsync(cancellationToken);
            LogReady(db.Database.GetDbConnection().DataSource);
        }
        catch (Exception ex)
        {
            LogFailed(ex);
            throw; // let the app show a clear start-up error instead of a half-working UI
        }
    }

    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;

    [LoggerMessage(Level = LogLevel.Information, Message = "Database ready at {Path}")]
    private partial void LogReady(string path);

    [LoggerMessage(Level = LogLevel.Critical, Message = "Could not migrate the database")]
    private partial void LogFailed(Exception exception);
}

using Bookshelf.Core;
using Bookshelf.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Data.Sqlite;

namespace Bookshelf.Data;

public static class DataServiceCollectionExtensions
{
    public static IServiceCollection AddBookshelfData(this IServiceCollection services)
    {
        services.AddSingleton<IAppPaths, AppPaths>();
        services.AddSingleton<ISettingsService, JsonSettingsService>();

        services.AddDbContextFactory<BookshelfDbContext>((provider, options) =>
        {
            var paths = provider.GetRequiredService<IAppPaths>();
            var connectionString = new SqliteConnectionStringBuilder
            {
                DataSource = System.IO.Path.Combine(paths.DataDirectory, "bookshelf.db"),
                Mode = SqliteOpenMode.ReadWriteCreate,
                ForeignKeys = true,
            }.ToString();
            options.UseSqlite(connectionString);
        });

        services.AddSingleton<IBookRepository, SqliteBookRepository>();
        services.AddHostedService<DatabaseInitializer>();
        return services;
    }
}

using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class BooksViewModel(IBookRepository repository, IDialogService dialogs) : ObservableObject
{
    public ObservableCollection<BookViewModel> Books { get; } = [];

    [ObservableProperty]
    public partial string StatusMessage { get; set; } = "";

    [RelayCommand(IncludeCancelCommand = true)]
    private async Task LoadAsync(CancellationToken cancellationToken)
    {
        StatusMessage = "Loading...";

        // The data call and the mapping run on a thread-pool thread...
        var books = await Task.Run(
            async () => (await repository.GetAllAsync(cancellationToken))
                .Select(b => new BookViewModel(b))
                .ToList(),
            cancellationToken);

        // ...and this continuation is back on the UI thread.
        Books.Clear();
        foreach (var book in books)
        {
            Books.Add(book);
        }

        StatusMessage = $"{Books.Count} books";
    }
}

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

namespace Bookshelf.Data;

public static class ConcurrencyExtensions
{
    /// <summary>Saves, and if another writer got there first, keeps the database values (client loses).</summary>
    public static async Task<bool> SaveKeepingDatabaseValuesAsync(
        this DbContext db, CancellationToken cancellationToken)
    {
        try
        {
            await db.SaveChangesAsync(cancellationToken);
            return true;
        }
        catch (DbUpdateConcurrencyException ex)
        {
            foreach (var entry in ex.Entries)
            {
                var databaseValues = await entry.GetDatabaseValuesAsync(cancellationToken);
                if (databaseValues is null)
                {
                    entry.State = EntityState.Detached; // the row was deleted by somebody else
                }
                else
                {
                    entry.OriginalValues.SetValues(databaseValues);
                    entry.CurrentValues.SetValues(databaseValues);
                }
            }

            return false;
        }
    }
}

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace Bookshelf.Core;

public static class FileOpening
{
    /// <summary>Opens a file for reading, retrying briefly while another process (an editor, an antivirus scan) holds it.</summary>
    public static async Task<FileStream> OpenReadWithRetryAsync(
        string path, int attempts = 5, TimeSpan? delay = null, CancellationToken cancellationToken = default)
    {
        var wait = delay ?? TimeSpan.FromMilliseconds(100);
        for (var attempt = 1; ; attempt++)
        {
            try
            {
                return new FileStream(
                    path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete,
                    bufferSize: 4096, useAsync: true);
            }
            catch (IOException e) when (IsSharingViolation(e) && attempt < attempts)
            {
                await Task.Delay(wait, cancellationToken);
            }
        }
    }

    private static bool IsSharingViolation(IOException e) => (e.HResult & 0x0000FFFF) == 32;
}

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace Bookshelf.Core;

public static class AtomicFile
{
    /// <summary>
    /// Writes <paramref name="path"/> without ever leaving it half written: the content goes to a temporary
    /// file next to it first, then File.Replace swaps it in and keeps the previous version as ".bak".
    /// </summary>
    public static async Task WriteAsync(
        string path,
        Func<Stream, CancellationToken, Task> write,
        CancellationToken cancellationToken = default)
    {
        var directory = Path.GetDirectoryName(path)
            ?? throw new ArgumentException("The path has no directory.", nameof(path));
        Directory.CreateDirectory(directory);

        var temp = Path.Combine(directory, Path.GetFileName(path) + "." + Guid.NewGuid().ToString("N") + ".tmp");
        try
        {
            await using (var stream = new FileStream(
                temp, FileMode.CreateNew, FileAccess.Write, FileShare.None,
                bufferSize: 4096, useAsync: true))
            {
                await write(stream, cancellationToken);
                await stream.FlushAsync(cancellationToken);
                stream.Flush(flushToDisk: true);
            }

            if (File.Exists(path))
            {
                File.Replace(temp, path, path + ".bak");
            }
            else
            {
                File.Move(temp, path);
            }
        }
        finally
        {
            if (File.Exists(temp))
            {
                File.Delete(temp);
            }
        }
    }
}

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Bookshelf.Core;

namespace Bookshelf.Desktop;

public static class BookExporter
{
    public static Task ExportCsvAsync(
        IReadOnlyCollection<Book> books, string path, CancellationToken cancellationToken) =>
        AtomicFile.WriteAsync(path, async (stream, ct) =>
        {
            await using var writer = new StreamWriter(stream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: true), leaveOpen: true);
            await writer.WriteLineAsync("Id,Title,Author,Year,Price,Isbn".AsMemory(), ct);
            foreach (var b in books.OrderBy(b => b.Title))
            {
                var line = string.Join(',', b.Id, Quote(b.Title), Quote(b.Author), b.Year,
                    b.Price.ToString(System.Globalization.CultureInfo.InvariantCulture), b.Isbn ?? "");
                await writer.WriteLineAsync(line.AsMemory(), ct);
            }
        }, cancellationToken);

    private static string Quote(string value) => "\"" + value.Replace("\"", "\"\"") + "\"";
}

using System.Threading;
using System.Threading.Tasks;
using Microsoft.Data.Sqlite;

namespace Bookshelf.Data;

public static class DatabaseBackup
{
    public static async Task BackupAsync(string databasePath, string backupPath, CancellationToken cancellationToken)
    {
        await using var source = new SqliteConnection($"Data Source={databasePath};Mode=ReadOnly");
        await source.OpenAsync(cancellationToken);

        await using var destination = new SqliteConnection($"Data Source={backupPath}");
        await destination.OpenAsync(cancellationToken);

        source.BackupDatabase(destination); // synchronous: call it from a background thread
    }
}