WPF

<TextBox Grid.Row="1" 
            Grid.Column="0"
            Text="{Binding Customer.CustomerName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnNotifyDataErrors=True}"
            IsEnabled="{Binding AreFieldsEnabled}">

<pre>
<Validation.ErrorTemplate>
    <ControlTemplate>
        <StackPanel>
            <AdornedElementPlaceholder/>
            <ItemsControl ItemsSource="{Binding}">
                <ItemsControl.ItemTemplate>
                    <DataTemplate>
                        <TextBlock Text="{Binding ErrorContent}" Foreground="Red" />
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
        </StackPanel>
    </ControlTemplate>
</Validation.ErrorTemplate>

private void Customer_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    IsChanged = true;

    ValidateCustomerName();
}

private void ValidateCustomerName()
{
    ClearErrors(nameof(Customer.CustomerName));

    if (string.IsNullOrWhiteSpace(Customer.CustomerName))
    {
        AddError(nameof(Customer.CustomerName), "The Customer Name cannot be empty.");
    }
}

Quote:

GetErrors method returns an IEnumerable that contains validation errors for the specified property (when the propertyName parameter isn’t equal to null or empty string) or for the entire entity (when the propertyName parameter is equal to null or empty string)

Evilfish2000 wrote:

How can I make the button work on my progress bar, and still have the IsHitTestVisible="False" on the ListView?

AppHost = Host.CreateDefaultBuilder()
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddDbContext<MooseDBContext>(options =>
                    {
                        options.UseSqlServer(_connString);
                    });

                    services.AddSingleton<IEventAggregator, EventAggregator>();
                    services.AddSingleton<IApplicationSecurity, ApplicationSecurity>();
                    services.AddSingleton<MainWindowViewModel>();
                    services.AddSingleton<MainWindowView>();
                    services.AddSingleton<LoginViewModel>();
                    services.AddSingleton<LoginView>();
                })
                .Build();
}

// ApplicationSecurity assembly:
public interface IApplicationSecurityContext
{
    DbSet<YourEntityType> YourEntityTypes { get; }
}

public class ApplicationSecurity : IApplicationSecurity
{
    public ApplicationSecurity(IApplicationSecurityContext context)
    {
        ArgumentNullException.ThrowIfNull(context);
        Context = context;
    }
    
    private IApplicationSecurityContext Context { get; }
    ...
}

// MooseDBContext assembly:
public class MooseDBContext : DbContext, IApplicationSecurityContext
{
    ...
}

services.AddDbContext<MooseDBContext>(options =>
{
    options.UseSqlServer(_connString);
});

// When we request the IApplicationSecurityContext service,
// return the registered MooseDBContext service:
services.AddScoped<IApplicationSecurityContext>(sp => sp.GetRequiredService<MooseDBContext>());

public static IServiceCollection AddContextInterfaces<TContext>(this IServiceCollection services) where TContext : DbContext
{
    ArgumentNullException.ThrowIfNull(services);
    
    foreach (Type t in typeof(TContext).GetInterfaces().Except(typeof(DbContext).GetInterfaces()))
    {
        services.AddScoped(t, sp => sp.GetRequiredService<TContext>());
    }
    
    return services;
}

...

services.AddDbContext<MooseDBContext>(options =>
{
    options.UseSqlServer(_connString);
});

services.AddContextInterfaces<MooseDBContext>();

using Marois.Framework.Core.AppSecurity.Repository;
using Marois.Framework.Core.Crypto;
using Marois.Framework.Core.Shared;
using Microsoft.EntityFrameworkCore;

namespace Marois.Framework.Core.AppSecurity.Service
{
    public class ApplicationSecurity : IApplicationSecurity
    {
        #region Private Fields
        private IApplicationSecurityContext _context { get; }
        #endregion

        #region CTOR
        public ApplicationSecurity(IApplicationSecurityContext context)
        {
            ArgumentNullException.ThrowIfNull(nameof(context));

            _context = context;
        }
        #endregion

        #region Public Methods
        public Task<UserEntity> LoginAsync(CredentialsEntity credentials)
        {
            UserEntity? results = null;

            ArgumentNullException.ThrowIfNull(nameof(credentials));

            var t = Task.Run(() =>
            {
                var userRepo = new AppSecurityRepository<UserEntity>((DbContext)_context);

                var user = userRepo.Find(x => x.UserName == credentials.UserName);

                if (Cryptography.VerifyHash(credentials.Password, user.Password, user.Hash))
                {
                    results = user;
                }

                return results;
            });

            return t;
        }
        #endregion
    }
}

public class ApplicationSecurity : IApplicationSecurity
{
    private AppSecurityRepository<UserEntity> _userRepo { get; }

    public ApplicationSecurity(AppSecurityRepository<UserEntity> userRepo)
    {
        ArgumentNullException.ThrowIfNull(nameof(userRepo));
        _userRepo = userRepo;
    }

    public async Task<UserEntity> LoginAsync(CredentialsEntity credentials)
    {
        var user = await _userRepo.FindAsync(x => x.UserName == credentials.UserName);
        if (user is null) return null;
        
        return Cryptography.VerifyHash(credentials.Password, user.Password, user.Hash) ? user : null;
    }
}