Лабораторная работа №2

2024-12-18 20:45:44 +04:00 · 2024-12-18 20:45:44 +04:00 · c743df6789
commit c743df6789
parent 9e34a23907
10 changed files with 527 additions and 15 deletions
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Program.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Program.cs
@ -1,6 +1,11 @@
 using ProjectPatientAccounting.Repositories.Implementations;
 using ProjectPatientAccounting.Repositories;
 using Unity;
+using Unity.Lifetime;
+using Unity.Microsoft.Logging;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Serilog;

 namespace ProjectPatientAccounting;

@ -21,13 +26,27 @@ internal static class Program
    private static IUnityContainer CreateContainer()
    {
        var container = new UnityContainer();
+        container.AddExtension(new LoggingExtension(CreateLoggerFactory()));

        container.RegisterType<IDoctorRepository, DoctorRepository>();
        container.RegisterType<IMedicamentRepository, MedicamentRepository>();
        container.RegisterType<IPatientDiagnosisRepository, PatientDiagnosisRepository>();
        container.RegisterType<IPatientRepository, PatientRepository>();
        container.RegisterType<IReceptionRepository, ReceptionRepository>();
+        container.RegisterType<IConnectionString, ConnectionString>(new SingletonLifetimeManager());

        return container;
    }
+
+    private static LoggerFactory CreateLoggerFactory()
+    {
+        var loggerFactory = new LoggerFactory();
+        loggerFactory.AddSerilog(new LoggerConfiguration()
+        .ReadFrom.Configuration(new ConfigurationBuilder()
+        .SetBasePath(Directory.GetCurrentDirectory())
+        .AddJsonFile("appsettings.json")
+        .Build())
+        .CreateLogger());
+        return loggerFactory;
+    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/ProjectPatientAccounting.csproj
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/ProjectPatientAccounting.csproj
@ -9,7 +9,19 @@
  </PropertyGroup>

  <ItemGroup>
+    <PackageReference Include="Dapper" Version="2.1.35" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Npgsql" Version="9.0.2" />
+    <PackageReference Include="Serilog" Version="4.2.0" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.0" />
+    <PackageReference Include="Serilog.Settings.Configuration" Version="9.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="System.Data.SqlClient" Version="4.9.0" />
    <PackageReference Include="Unity" Version="5.11.10" />
+    <PackageReference Include="Unity.Microsoft.Logging" Version="5.11.1" />
  </ItemGroup>

  <ItemGroup>
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/IConnectionString.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/IConnectionString.cs
@ -0,0 +1,6 @@
+namespace ProjectPatientAccounting.Repositories;
+
+public interface IConnectionString
+{
+    public string ConnectionString { get; }
+}
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/ConnectionString.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/ConnectionString.cs
@ -0,0 +1,6 @@
+namespace ProjectPatientAccounting.Repositories.Implementations;
+
+public class ConnectionString : IConnectionString
+{
+    string IConnectionString.ConnectionString => "Host=localhost;Port=5432;Database=patient_accounting;Username=postgres;Password=postgres";
+}
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/DoctorRepository.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/DoctorRepository.cs
@ -1,28 +1,120 @@
-using ProjectPatientAccounting.Entities.Enums;
-using ProjectPatientAccounting.Entities;
+using ProjectPatientAccounting.Entities;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Npgsql;
+using Dapper;
 namespace ProjectPatientAccounting.Repositories.Implementations;

 public class DoctorRepository : IDoctorRepository
 {
+    private readonly IConnectionString _connectionString;
+    private readonly ILogger<DoctorRepository> _logger;
+
+    public DoctorRepository(IConnectionString connectionString, ILogger<DoctorRepository> logger)
+    {
+        _connectionString = connectionString;
+        _logger = logger;
+    }
+
    public void CreateDoctor(Doctor doctor)
    {
+        _logger.LogInformation("Добавление объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(doctor));
+
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryInsert = @"
+            INSERT INTO Doctors (Name, Surname, DoctorArea)
+               VALUES (@Name, @Surname, @DoctorArea)";
+            connection.Execute(queryInsert, doctor);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при добавлении объекта");
+            throw;
+        }
    }

    public void DeleteDoctor(int id)
    {
+        _logger.LogInformation("Удаление объекта");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryDelete = @"
+                DELETE FROM Doctors
+                WHERE Id=@id";
+            connection.Execute(queryDelete, new { id });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при удалении объекта");
+            throw;
+        }
    }

    public Doctor ReadDoctorById(int id)
    {
-        return Doctor.CreateEntity(0, string.Empty, string.Empty, Area.None);
+        _logger.LogInformation("Получение объекта по идентификатору");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = @"
+                SELECT * FROM Doctors
+                WHERE Id=@id";
+            var doctor = connection.QueryFirst<Doctor>(querySelect, new { id });
+            _logger.LogDebug("Найденный объект: {json}", JsonConvert.SerializeObject(doctor));
+            return doctor;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при поиске объекта");
+            throw;
+        }
    }

    public IEnumerable<Doctor> ReadDoctors()
    {
-        return [];
+        _logger.LogInformation("Получение всех объектов");
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = "SELECT * FROM Doctors";
+            var doctors = connection.Query<Doctor>(querySelect);
+            _logger.LogDebug("Полученные объекты: {json}",
+            JsonConvert.SerializeObject(doctors));
+            return doctors;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при чтении объектов");
+            throw;
+        }
    }

    public void UpdateDoctor(Doctor doctor)
    {
+        _logger.LogInformation("Редактирование объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(doctor));
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryUpdate = @"
+                UPDATE Doctors
+                SET
+                Name=@Name,
+                Surname=@Surname,
+                DoctorArea=@DoctorArea
+                WHERE Id=@Id";
+            connection.Execute(queryUpdate, doctor);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при редактировании объекта");
+            throw;
+        }
    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/MedicamentRepository.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/MedicamentRepository.cs
@ -1,28 +1,121 @@
 using ProjectPatientAccounting.Entities.Enums;
 using ProjectPatientAccounting.Entities;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Npgsql;
+using Dapper;
 namespace ProjectPatientAccounting.Repositories.Implementations;

 public class MedicamentRepository : IMedicamentRepository
 {
+    private readonly IConnectionString _connectionString;
+    private readonly ILogger<MedicamentRepository> _logger;
+
+    public MedicamentRepository(IConnectionString connectionString, ILogger<MedicamentRepository> logger)
+    {
+        _connectionString = connectionString;
+        _logger = logger;
+    }
+
    public void CreateMedicament(Medicament medicament)
    {
+        _logger.LogInformation("Добавление объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(medicament));
+
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryInsert = @"
+            INSERT INTO Medicaments (Name, Description, TypeMedicament)
+               VALUES (@Name, @Description, @TypeMedicament)";
+            connection.Execute(queryInsert, medicament);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при добавлении объекта");
+            throw;
+        }
    }

    public void DeleteMedicament(int id)
    {
+        _logger.LogInformation("Удаление объекта");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryDelete = @"
+                DELETE FROM Medicaments
+                WHERE Id=@id";
+            connection.Execute(queryDelete, new { id });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при удалении объекта");
+            throw;
+        }
    }

    public Medicament ReadMedicamentById(int id)
    {
-        return Medicament.CreateEntity(0, string.Empty, string.Empty, TypeMedicament.None);
+        _logger.LogInformation("Получение объекта по идентификатору");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = @"
+                SELECT * FROM Medicaments
+                WHERE Id=@id";
+            var medicament = connection.QueryFirst<Medicament>(querySelect, new { id });
+            _logger.LogDebug("Найденный объект: {json}", JsonConvert.SerializeObject(medicament));
+            return medicament;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при поиске объекта");
+            throw;
+        }
    }

    public IEnumerable<Medicament> ReadMedicaments()
    {
-        return [];
+        _logger.LogInformation("Получение всех объектов");
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = "SELECT * FROM Medicaments";
+            var medicaments = connection.Query<Medicament>(querySelect);
+            _logger.LogDebug("Полученные объекты: {json}",
+            JsonConvert.SerializeObject(medicaments));
+            return medicaments;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при чтении объектов");
+            throw;
+        }
    }

    public void UpdateMedicament(Medicament medicament)
    {
+        _logger.LogInformation("Редактирование объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(medicament));
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryUpdate = @"
+                UPDATE Medicaments
+                SET
+                Name=@Name,
+                Description=@Description,
+                TypeMedicament=@TypeMedicament
+                WHERE Id=@Id";
+            connection.Execute(queryUpdate, medicament);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при редактировании объекта");
+            throw;
+        }
    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/PatientDiagnosisRepository.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/PatientDiagnosisRepository.cs
@ -1,28 +1,120 @@
-using ProjectPatientAccounting.Entities.Enums;
-using ProjectPatientAccounting.Entities;
+using ProjectPatientAccounting.Entities;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Npgsql;
+using Dapper;

 namespace ProjectPatientAccounting.Repositories.Implementations;
 public class PatientDiagnosisRepository : IPatientDiagnosisRepository
 {
+    private readonly IConnectionString _connectionString;
+    private readonly ILogger<PatientDiagnosisRepository> _logger;
+
+    public PatientDiagnosisRepository(IConnectionString connectionString, ILogger<PatientDiagnosisRepository> logger)
+    {
+        _connectionString = connectionString;
+        _logger = logger;
+    }
+
    public void CreateDiagnosis(PatientDiagnosis diagnosis)
    {
+        _logger.LogInformation("Добавление объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(diagnosis));
+
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryInsert = @"
+            INSERT INTO PatientDiagnosises (Name, DiagnosisCode, PatientDiagnosisStatus)
+               VALUES (@Name, @DiagnosisCode, @PatientDiagnosisStatus)";
+            connection.Execute(queryInsert, diagnosis);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при добавлении объекта");
+            throw;
+        }
    }

    public void DeleteDiagnosis(int id)
    {
+        _logger.LogInformation("Удаление объекта");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryDelete = @"
+                DELETE FROM PatientDiagnosises
+                WHERE Id=@id";
+            connection.Execute(queryDelete, new { id });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при удалении объекта");
+            throw;
+        }
    }

    public PatientDiagnosis ReadDiagnosisById(int id)
    {
-        return PatientDiagnosis.CreateEntity(0, string.Empty, 0, PatientDiagnosisStatus.None);
+        _logger.LogInformation("Получение объекта по идентификатору");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = @"
+                SELECT * FROM PatientDiagnosises
+                WHERE Id=@id";
+            var diagnosis = connection.QueryFirst<PatientDiagnosis>(querySelect, new { id });
+            _logger.LogDebug("Найденный объект: {json}", JsonConvert.SerializeObject(diagnosis));
+            return diagnosis;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при поиске объекта");
+            throw;
+        }
    }

    public IEnumerable<PatientDiagnosis> ReadDiagnosises()
    {
-        return [];
+        _logger.LogInformation("Получение всех объектов");
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = "SELECT * FROM PatientDiagnosises";
+            var diagnosises = connection.Query<PatientDiagnosis>(querySelect);
+            _logger.LogDebug("Полученные объекты: {json}",
+            JsonConvert.SerializeObject(diagnosises));
+            return diagnosises;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при чтении объектов");
+            throw;
+        }
    }

    public void UpdateDiagnosis(PatientDiagnosis diagnosis)
    {
+        _logger.LogInformation("Редактирование объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(diagnosis));
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryUpdate = @"
+                UPDATE PatientDiagnosises
+                SET
+                Name=@Name,
+                DiagnosisCode=@DiagnosisCode,
+                PatientDiagnosisStatus=@PatientDiagnosisStatus
+                WHERE Id=@Id";
+            connection.Execute(queryUpdate, diagnosis);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при редактировании объекта");
+            throw;
+        }
    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/PatientRepository.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/PatientRepository.cs
@ -1,27 +1,121 @@
-using ProjectPatientAccounting.Entities;
+using Dapper;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Npgsql;
+using ProjectPatientAccounting.Entities;
 namespace ProjectPatientAccounting.Repositories.Implementations;

 public class PatientRepository : IPatientRepository
 {
+    private readonly IConnectionString _connectionString;
+    private readonly ILogger<PatientRepository> _logger;
+
+    public PatientRepository(IConnectionString connectionString, ILogger<PatientRepository> logger)
+    {
+        _connectionString = connectionString;
+        _logger = logger;
+    }
+
    public void CreatePatient(Patient patient)
    {
+        _logger.LogInformation("Добавление объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(patient));
+
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryInsert = @"
+            INSERT INTO Patients (Name, Surname, Telephone, NumMedCard)
+               VALUES (@Name, @Surname, @Telephone, @NumMedCard)";
+            connection.Execute(queryInsert, patient);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при добавлении объекта");
+            throw;
+        }
    }

    public void DeletePatient(int id)
    {
+        _logger.LogInformation("Удаление объекта");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryDelete = @"
+                DELETE FROM Patients
+                WHERE Id=@id";
+            connection.Execute(queryDelete, new { id });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при удалении объекта");
+            throw;
+        }
    }

    public Patient ReadPatientById(int id)
    {
-        return Patient.CreateEntity(0, string.Empty, string.Empty, string.Empty, 0);
+        _logger.LogInformation("Получение объекта по идентификатору");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = @"
+                SELECT * FROM Patients
+                WHERE Id=@id";
+            var patient = connection.QueryFirst<Patient>(querySelect, new { id });
+            _logger.LogDebug("Найденный объект: {json}", JsonConvert.SerializeObject(patient));
+            return patient;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при поиске объекта");
+            throw;
+        }
    }

    public IEnumerable<Patient> ReadPatients()
    {
-        return [];
+        _logger.LogInformation("Получение всех объектов");
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = "SELECT * FROM Patients";
+            var patients = connection.Query<Patient>(querySelect);
+            _logger.LogDebug("Полученные объекты: {json}",
+            JsonConvert.SerializeObject(patients));
+            return patients;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при чтении объектов");
+            throw;
+        }
    }

    public void UpdatePatient(Patient patient)
    {
+        _logger.LogInformation("Редактирование объекта");
+        _logger.LogDebug("Объект: {json}", JsonConvert.SerializeObject(patient));
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var queryUpdate = @"
+                UPDATE Patients
+                SET
+                Name=@Name,
+                Surname=@Surname,
+                Telephone=@Telephone,
+                NumMedCard = @NumMedCard
+                WHERE Id=@Id";
+            connection.Execute(queryUpdate, patient);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при редактировании объекта");
+            throw;
+        }
    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/ReceptionRepository.cs
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/Repositories/Implementations/ReceptionRepository.cs
@ -1,18 +1,101 @@
-using ProjectPatientAccounting.Entities;
+using Dapper;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Npgsql;
+using ProjectPatientAccounting.Entities;
 namespace ProjectPatientAccounting.Repositories.Implementations;

 public class ReceptionRepository : IReceptionRepository
 {
+    private readonly IConnectionString _connectionString;
+    private readonly ILogger<ReceptionRepository> _logger;
+
+    public ReceptionRepository(IConnectionString connectionString, ILogger<ReceptionRepository> logger)
+    {
+        _connectionString = connectionString;
+        _logger = logger;
+    }
+
    public void CreateReception(Reception reception)
    {
+        _logger.LogInformation("Добавление объекта");
+        _logger.LogDebug("Объект: {json}",
+        JsonConvert.SerializeObject(reception));
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            connection.Open();
+            using var transaction = connection.BeginTransaction();
+            var queryInsert = @"
+                INSERT INTO Receptions (PatientId, DoctorId, DiagnosisId, ReceptionDate, NumTicket)
+                VALUES (@PatientId, @DoctorId, @DiagnosisId, @ReceptionDate, @NumTicket);
+                SELECT MAX(Id) FROM Receptions";
+            var receptionId = connection.QueryFirst<int>(queryInsert, reception, transaction);
+            var querySubInsert = @"
+                INSERT INTO MedicamentReceptions (ReceptionId, MedicamentId, Dosage)
+                VALUES (@ReceptionId,@MedicamentId, @Dosage)";
+            foreach (var elem in reception.MedicamentReceptions)
+            {
+                connection.Execute(querySubInsert, new
+                {
+                    receptionId,
+                    elem.MedicamentId,
+                    elem.Dosage
+                }, transaction);
+            }
+            transaction.Commit();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при добавлении объекта");
+            throw;
+        }
    }

    public void DeleteReception(int id)
    {
+        _logger.LogInformation("Удаление объекта");
+        _logger.LogDebug("Объект: {id}", id);
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            connection.Open();
+            using var transaction = connection.BeginTransaction();
+            var queryDelete = @"
+                DELETE FROM MedicamentReceptions
+                WHERE ReceptionId = @id";
+
+            var queryDeleteReceptions = @"
+                DELETE FROM Receptions
+                WHERE Id=@id";
+            connection.Execute(queryDelete, new { id });
+            connection.Execute(queryDeleteReceptions, new { id });
+            transaction.Commit();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при удалении объекта");
+            throw;
+        }
    }

    public IEnumerable<Reception> ReadReceptions(DateTime? dateFrom = null, DateTime? dateTo = null, int? patientId = null, int? diagnosisId = null, int? doctorId = null)
    {
-        return [];
+        _logger.LogInformation("Получение всех объектов");
+        try
+        {
+            using var connection = new NpgsqlConnection(_connectionString.ConnectionString);
+            var querySelect = @"SELECT * FROM Receptions";
+            var receptions =
+            connection.Query<Reception>(querySelect);
+            _logger.LogDebug("Полученные объекты: {json}",
+            JsonConvert.SerializeObject(receptions));
+            return receptions;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Ошибка при чтении объектов");
+            throw;
+        }
    }
 }
--- a/ProjectPatientAccounting/ProjectPatientAccounting/appsettings.json
+++ b/ProjectPatientAccounting/ProjectPatientAccounting/appsettings.json
@ -0,0 +1,15 @@
+{
+  "Serilog": {
+    "Using": [ "Serilog.Sinks.File" ],
+    "MinimumLevel": "Debug",
+    "WriteTo": [
+      {
+        "Name": "File",
+        "Args": {
+          "path": "Logs/patientaccounting_log.txt",
+          "rollingInterval": "Day"
+        }
+      }
+    ]
+  }
+}