CleanCode_ExampleTask21-27.cs

using System.Data;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;

namespace PassportService
{
    internal class Program
    {
        static void Main()
        {
            string databasePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "db.sqlite");

            IPassportView view = new PassportView();

            FactoryPresenter presenterFactory = new FactoryPresenter();

            IPassportPresenter presenter = presenterFactory.CreatePresenter(view, databasePath);

            try
            {
                view.Run();
            }
            finally
            {
                if (presenter is PassportPresenter passportPresenter)
                {
                    passportPresenter.Unsubscribe();
                }
            }
        }
    }

    public enum PassportCheckResult
    {
        InvalidFormat,
        AccessGranted,
        AccessDenied,
        NotFound
    }

    public interface IPassportView
    {
        event EventHandler CheckPassportClicked;

        string PassportNumber { get; }

        void ShowMessage(string message);
        void ShowError(string errorMessage);
        void Run();
    }

    public interface IPassportPresenter
    {
        void OnCheckPassportClicked(object sender, EventArgs eventArgs);
    }

    public interface IPassportService
    {
        Citizen VerifyPassportAccess(Passport passport);
    }

    public interface IDatabaseContext
    {
        Citizen GetCitizenByPassportHash(string passportHash);
    }

    public interface IDatabase
    {
        DataTable ExecuteQuery(string query);
    }

    public class PassportView : IPassportView
    {
        public event EventHandler CheckPassportClicked;

        public string PassportNumber { get; private set; }

        public void Run()
        {
            Console.WriteLine("Введите серию и номер паспорта:");

            PassportNumber = Console.ReadLine();

            CheckPassportClicked?.Invoke(this, EventArgs.Empty);
        }

        public void ShowMessage(string message)
        {
            Console.WriteLine(message);
        }

        public void ShowError(string errorMessage)
        {
            Console.WriteLine("Ошибка: " + errorMessage);
        }
    }

    public class FactoryPresenter
    {
        public IPassportPresenter CreatePresenter(IPassportView view, string databasePath)
        {
            var database = new Database(databasePath);
            var databaseContext = new DatabaseContext(database);
            var hashingService = new HashingService();
            var service = new PassportService(databaseContext, hashingService);
            var presenter = new PassportPresenter(view, service);

            return presenter;
        }
    }

    public class PassportPresenter : IPassportPresenter
    {
        private readonly IPassportView _view;
        private readonly IPassportService _service;

        public PassportPresenter(IPassportView view, IPassportService service)
        {
            _view = view ?? throw new ArgumentNullException(nameof(view));
            _service = service ?? throw new ArgumentNullException(nameof(service));

            _view.CheckPassportClicked += OnCheckPassportClicked;
        }

        public void Unsubscribe()
        {
            _view.CheckPassportClicked -= OnCheckPassportClicked;
        }

        public void OnCheckPassportClicked(object sender, EventArgs eventArgs)
        {
            try
            {
                var passport = new Passport(_view.PassportNumber);

                Citizen citizen = _service.VerifyPassportAccess(passport);

                if (citizen != null)
                {
                    if (citizen.HasAccess)
                    {
                        _view.ShowMessage($"По паспорту «{passport.Number}» доступ ПРЕДОСТАВЛЕН.");
                    }
                    else
                    {
                        _view.ShowMessage($"По паспорту «{passport.Number}» доступ НЕ ПРЕДОСТАВЛЕН.");
                    }
                }
                else
                {
                    _view.ShowMessage($"Паспорт «{passport.Number}» в списке НЕ НАЙДЕН.");
                }
            }
            catch (ArgumentException exception)
            {
                _view.ShowError(exception.Message);
            }
            catch (FileNotFoundException)
            {
                _view.ShowError("Файл базы данных не найден.");
            }
            catch (Exception)
            {
                _view.ShowError("Произошла непредвиденная ошибка.");
            }
        }
    }

    public class Passport
    {
        private const int PassportSymbolsLength = 10;

        public string Number { get; }

        public Passport(string passportNumber)
        {
            Number = CleanPassportNumber(passportNumber) ?? throw new ArgumentNullException(nameof(passportNumber));

            if (IsValidFormat(Number) == false)
            {
                throw new ArgumentException("Неверный формат серии или номера паспорта.", nameof(passportNumber));
            }
        }

        private bool IsValidFormat(string passportNumber)
        {
            return string.IsNullOrWhiteSpace(passportNumber) == false && passportNumber.Length == PassportSymbolsLength;
        }

        private string CleanPassportNumber(string passportNumber)
        {
            return passportNumber.Trim().Replace(" ", string.Empty);
        }
    }

    public class Citizen
    {
        public bool HasAccess { get; }

        public Citizen(bool hasAccess)
        {
            HasAccess = hasAccess;
        }
    }

    public class PassportService : IPassportService
    {
        private readonly IDatabaseContext _databaseContext;
        private readonly HashingService _hashingService;

        public PassportService(IDatabaseContext databaseContext, HashingService hashingService)
        {
            _databaseContext = databaseContext ?? throw new ArgumentNullException(nameof(databaseContext));
            _hashingService = hashingService ?? throw new ArgumentNullException(nameof(hashingService));
        }

        public Citizen VerifyPassportAccess(Passport passport)
        {
            string hashedPassport = _hashingService.ComputeSha256Hash(passport.Number);

            Citizen citizen = _databaseContext.GetCitizenByPassportHash(hashedPassport);

            return citizen;
        }
    }

    public class HashingService
    {
        public string ComputeSha256Hash(string rawData)
        {
            if (rawData == null)
            {
                throw new ArgumentNullException(nameof(rawData));
            }

            using (SHA256 sha256Hash = SHA256.Create())
            {
                byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(rawData));

                StringBuilder builder = new StringBuilder();

                foreach (byte @byte in bytes)
                {
                    builder.Append(@byte.ToString("x2"));
                }

                return builder.ToString();
            }
        }
    }

    public class DatabaseContext : IDatabaseContext
    {
        private const string AccessColumnName = "access";
        private const int ColumnNumber = 0;

        private readonly IDatabase _database;

        public DatabaseContext(IDatabase database)
        {
            _database = database ?? throw new ArgumentNullException(nameof(database));
        }

        public Citizen GetCitizenByPassportHash(string passportHash)
        {
            string query = $"SELECT * FROM passports WHERE num='{passportHash}' LIMIT 1;";

            DataTable dataTable = _database.ExecuteQuery(query);

            if (dataTable.Rows.Count > 0)
            {
                bool accessGranted = Convert.ToBoolean(dataTable.Rows[ColumnNumber][AccessColumnName]);

                return new Citizen(accessGranted);
            }
            else
            {
                return null;
            }
        }
    }

    public class Database : IDatabase
    {
        private const int SqLiteErrorCode = 1;

        private readonly string _connectionString;

        public Database(string databasePath)
        {
            _connectionString = $"Data Source={databasePath ?? throw new ArgumentNullException(nameof(databasePath))}";
        }

        public DataTable ExecuteQuery(string query)
        {
            try
            {
                using (var connection = new System.Data.SQLite.SQLiteConnection(_connectionString))
                {
                    connection.Open();

                    using (var command = new System.Data.SQLite.SQLiteCommand(query, connection))
                    {
                        using (var adapter = new System.Data.SQLite.SQLiteDataAdapter(command))
                        {
                            DataTable dataTable = new DataTable();

                            adapter.Fill(dataTable);

                            return dataTable;
                        }
                    }
                }
            }
            catch (System.Data.SQLite.SQLiteException exception)
            {
                if (exception.ErrorCode == SqLiteErrorCode)
                {
                    throw new FileNotFoundException("Файл базы данных не найден.", exception);
                }

                throw new Exception("Ошибка работы с базой данных.", exception);
            }
        }
    }
}