refactor: Enhancements to Query Management and Consistency in SQL Que…

…ries (#297) * Rewrite queries to use raw strings * Refactor additional queries * Update readme
kgrzybek · Dec 23, 2023 · 7bf832a · 7bf832a
1 parent f04bd59
commit 7bf832a
Show file tree

Hide file tree

Showing 59 changed files with 691 additions and 533 deletions.
diff --git a/README.md b/README.md
@@ -457,13 +457,15 @@ internal class GetAllMeetingGroupsQueryHandler : IQueryHandler<GetAllMeetingGrou
     {
         var connection = _sqlConnectionFactory.GetOpenConnection();
 
-        const string sql = "SELECT " +
-                           "[MeetingGroup].[Id], " +
-                           "[MeetingGroup].[Name], " +
-                           "[MeetingGroup].[Description], " +
-                           "[MeetingGroup].[LocationCountryCode], " +
-                           "[MeetingGroup].[LocationCity]" +
-                           "FROM [meetings].[v_MeetingGroups] AS [MeetingGroup]";
+        const string sql = $"""
+                           SELECT 
+                                [MeetingGroup].[Id] as [{nameof(MeetingGroupDto.Id)}] , 
+                                [MeetingGroup].[Name] as [{nameof(MeetingGroupDto.Name)}], 
+                                [MeetingGroup].[Description] as [{nameof(MeetingGroupDto.Description)}] 
+                                [MeetingGroup].[LocationCountryCode] as [{nameof(MeetingGroupDto.LocationCountryCode)}],
+                                [MeetingGroup].[LocationCity] as [{nameof(MeetingGroupDto.LocationCity)}]
+                           FROM [meetings].[v_MeetingGroups] AS [MeetingGroup]
+                           """;
         var meetingGroups = await connection.QueryAsync<MeetingGroupDto>(sql);
 
         return meetingGroups.AsList();

diff --git a/...tion/MeetingGroupProposals/GetMeetingGroupProposal/GetMeetingGroupProposalQueryHandler.cs b/...tion/MeetingGroupProposals/GetMeetingGroupProposal/GetMeetingGroupProposalQueryHandler.cs
@@ -17,21 +17,23 @@ public async Task<MeetingGroupProposalDto> Handle(GetMeetingGroupProposalQuery q
         {
             var connection = _sqlConnectionFactory.GetOpenConnection();
 
-            string sql = "SELECT " +
-                         $"[MeetingGroupProposal].[Id] AS [{nameof(MeetingGroupProposalDto.Id)}], " +
-                         $"[MeetingGroupProposal].[Name] AS [{nameof(MeetingGroupProposalDto.Name)}], " +
-                         $"[MeetingGroupProposal].[ProposalUserId] AS [{nameof(MeetingGroupProposalDto.ProposalUserId)}], " +
-                         $"[MeetingGroupProposal].[LocationCity] AS [{nameof(MeetingGroupProposalDto.LocationCity)}], " +
-                         $"[MeetingGroupProposal].[LocationCountryCode] AS [{nameof(MeetingGroupProposalDto.LocationCountryCode)}], " +
-                         $"[MeetingGroupProposal].[Description] AS [{nameof(MeetingGroupProposalDto.Description)}], " +
-                         $"[MeetingGroupProposal].[ProposalDate] AS [{nameof(MeetingGroupProposalDto.ProposalDate)}], " +
-                         $"[MeetingGroupProposal].[StatusCode] AS [{nameof(MeetingGroupProposalDto.StatusCode)}], " +
-                         $"[MeetingGroupProposal].[DecisionDate] AS [{nameof(MeetingGroupProposalDto.DecisionDate)}], " +
-                         $"[MeetingGroupProposal].[DecisionUserId] AS [{nameof(MeetingGroupProposalDto.DecisionUserId)}], " +
-                         $"[MeetingGroupProposal].[DecisionCode] AS [{nameof(MeetingGroupProposalDto.DecisionCode)}], " +
-                         $"[MeetingGroupProposal].[DecisionRejectReason] AS [{nameof(MeetingGroupProposalDto.DecisionRejectReason)}] " +
-                         "FROM [administration].[v_MeetingGroupProposals] AS [MeetingGroupProposal] " +
-                         "WHERE [MeetingGroupProposal].[Id] = @MeetingGroupProposalId";
+            const string sql = $"""
+                         SELECT 
+                             [MeetingGroupProposal].[Id] AS [{nameof(MeetingGroupProposalDto.Id)}], 
+                             [MeetingGroupProposal].[Name] AS [{nameof(MeetingGroupProposalDto.Name)}], 
+                             [MeetingGroupProposal].[ProposalUserId] AS [{nameof(MeetingGroupProposalDto.ProposalUserId)}], 
+                             [MeetingGroupProposal].[LocationCity] AS [{nameof(MeetingGroupProposalDto.LocationCity)}], 
+                             [MeetingGroupProposal].[LocationCountryCode] AS [{nameof(MeetingGroupProposalDto.LocationCountryCode)}], 
+                             [MeetingGroupProposal].[Description] AS [{nameof(MeetingGroupProposalDto.Description)}], 
+                             [MeetingGroupProposal].[ProposalDate] AS [{nameof(MeetingGroupProposalDto.ProposalDate)}], 
+                             [MeetingGroupProposal].[StatusCode] AS [{nameof(MeetingGroupProposalDto.StatusCode)}], 
+                             [MeetingGroupProposal].[DecisionDate] AS [{nameof(MeetingGroupProposalDto.DecisionDate)}], 
+                             [MeetingGroupProposal].[DecisionUserId] AS [{nameof(MeetingGroupProposalDto.DecisionUserId)}], 
+                             [MeetingGroupProposal].[DecisionCode] AS [{nameof(MeetingGroupProposalDto.DecisionCode)}], 
+                             [MeetingGroupProposal].[DecisionRejectReason] AS [{nameof(MeetingGroupProposalDto.DecisionRejectReason)}] 
+                         FROM [administration].[v_MeetingGroupProposals] AS [MeetingGroupProposal]
+                         WHERE [MeetingGroupProposal].[Id] = @MeetingGroupProposalId
+                         """;
 
             return await connection.QuerySingleAsync<MeetingGroupProposalDto>(sql, new { query.MeetingGroupProposalId });
         }

diff --git a/...on/MeetingGroupProposals/GetMeetingGroupProposals/GetMeetingGroupProposalsQueryHandler.cs b/...on/MeetingGroupProposals/GetMeetingGroupProposals/GetMeetingGroupProposalsQueryHandler.cs
@@ -18,20 +18,22 @@ public async Task<List<MeetingGroupProposalDto>> Handle(GetMeetingGroupProposals
         {
             var connection = _sqlConnectionFactory.GetOpenConnection();
 
-            string sql = "SELECT " +
-                         $"[MeetingGroupProposal].[Id] AS [{nameof(MeetingGroupProposalDto.Id)}], " +
-                         $"[MeetingGroupProposal].[Name] AS [{nameof(MeetingGroupProposalDto.Name)}], " +
-                         $"[MeetingGroupProposal].[ProposalUserId] AS [{nameof(MeetingGroupProposalDto.ProposalUserId)}], " +
-                         $"[MeetingGroupProposal].[LocationCity] AS [{nameof(MeetingGroupProposalDto.LocationCity)}], " +
-                         $"[MeetingGroupProposal].[LocationCountryCode] AS [{nameof(MeetingGroupProposalDto.LocationCountryCode)}], " +
-                         $"[MeetingGroupProposal].[Description] AS [{nameof(MeetingGroupProposalDto.Description)}], " +
-                         $"[MeetingGroupProposal].[ProposalDate] AS [{nameof(MeetingGroupProposalDto.ProposalDate)}], " +
-                         $"[MeetingGroupProposal].[StatusCode] AS [{nameof(MeetingGroupProposalDto.StatusCode)}], " +
-                         $"[MeetingGroupProposal].[DecisionDate] AS [{nameof(MeetingGroupProposalDto.DecisionDate)}], " +
-                         $"[MeetingGroupProposal].[DecisionUserId] AS [{nameof(MeetingGroupProposalDto.DecisionUserId)}], " +
-                         $"[MeetingGroupProposal].[DecisionCode] AS [{nameof(MeetingGroupProposalDto.DecisionCode)}], " +
-                         $"[MeetingGroupProposal].[DecisionRejectReason] AS [{nameof(MeetingGroupProposalDto.DecisionRejectReason)}] " +
-                         "FROM [administration].[v_MeetingGroupProposals] AS [MeetingGroupProposal] ";
+            const string sql = $"""
+                                SELECT
+                                    [MeetingGroupProposal].[Id] AS [{nameof(MeetingGroupProposalDto.Id)}],
+                                    [MeetingGroupProposal].[Name] AS [{nameof(MeetingGroupProposalDto.Name)}],
+                                    [MeetingGroupProposal].[ProposalUserId] AS [{nameof(MeetingGroupProposalDto.ProposalUserId)}],
+                                    [MeetingGroupProposal].[LocationCity] AS [{nameof(MeetingGroupProposalDto.LocationCity)}],
+                                    [MeetingGroupProposal].[LocationCountryCode] AS [{nameof(MeetingGroupProposalDto.LocationCountryCode)}],
+                                    [MeetingGroupProposal].[Description] AS [{nameof(MeetingGroupProposalDto.Description)}],
+                                    [MeetingGroupProposal].[ProposalDate] AS [{nameof(MeetingGroupProposalDto.ProposalDate)}],
+                                    [MeetingGroupProposal].[StatusCode] AS [{nameof(MeetingGroupProposalDto.StatusCode)}],
+                                    [MeetingGroupProposal].[DecisionDate] AS [{nameof(MeetingGroupProposalDto.DecisionDate)}],
+                                    [MeetingGroupProposal].[DecisionUserId] AS [{nameof(MeetingGroupProposalDto.DecisionUserId)}],
+                                    [MeetingGroupProposal].[DecisionCode] AS [{nameof(MeetingGroupProposalDto.DecisionCode)}],
+                                    [MeetingGroupProposal].[DecisionRejectReason] AS [{nameof(MeetingGroupProposalDto.DecisionRejectReason)}]
+                                FROM [administration].[v_MeetingGroupProposals] AS [MeetingGroupProposal]
+                                """;
 
             return (await connection.QueryAsync<MeetingGroupProposalDto>(sql)).AsList();
         }

diff --git a/src/Modules/Administration/Application/Members/GetMember/GetMemberQueryHandler.cs b/src/Modules/Administration/Application/Members/GetMember/GetMemberQueryHandler.cs
@@ -16,16 +16,17 @@ public GetMemberQueryHandler(ISqlConnectionFactory sqlConnectionFactory)
         public async Task<MemberDto> Handle(GetMemberQuery query, CancellationToken cancellationToken)
         {
             var connection = _sqlConnectionFactory.GetOpenConnection();
-
-            var sql = "SELECT " +
-                      $"[Member].[Id] AS [{nameof(MemberDto.Id)}], " +
-                      $"[Member].[Login] AS [{nameof(MemberDto.Login)}], " +
-                      $"[Member].[Email] AS [{nameof(MemberDto.Email)}], " +
-                      $"[Member].[FirstName] AS [{nameof(MemberDto.FirstName)}], " +
-                      $"[Member].[LastName] AS [{nameof(MemberDto.LastName)}], " +
-                      $"[Member].[Name] AS [{nameof(MemberDto.Name)}] " +
-                      "FROM [administration].[v_Members] AS [Member] " +
-                      "WHERE [Member].[Id] = @MemberId";
+            const string sql = $"""
+                               SELECT
+                                  [Member].[Id] AS [{nameof(MemberDto.Id)}],
+                                  [Member].[Login] AS [{nameof(MemberDto.Login)}],
+                                  [Member].[Email] AS [{nameof(MemberDto.Email)}],
+                                  [Member].[FirstName] AS [{nameof(MemberDto.FirstName)}],
+                                  [Member].[LastName] AS [{nameof(MemberDto.LastName)}],
+                                  [Member].[Name] AS [{nameof(MemberDto.Name)}]
+                               FROM [administration].[v_Members] AS [Member]
+                               WHERE [Member].[Id] = @MemberId   
+                              """;
 
             return await connection.QuerySingleAsync<MemberDto>(sql, new { query.MemberId });
         }

diff --git a/...dministration/Infrastructure/Configuration/Processing/Inbox/ProcessInboxCommandHandler.cs b/...dministration/Infrastructure/Configuration/Processing/Inbox/ProcessInboxCommandHandler.cs
@@ -20,19 +20,23 @@ public ProcessInboxCommandHandler(IMediator mediator, ISqlConnectionFactory sqlC
         public async Task Handle(ProcessInboxCommand command, CancellationToken cancellationToken)
         {
             var connection = this._sqlConnectionFactory.GetOpenConnection();
-            string sql = "SELECT " +
-                         $"[InboxMessage].[Id] AS [{nameof(InboxMessageDto.Id)}], " +
-                         $"[InboxMessage].[Type] AS [{nameof(InboxMessageDto.Type)}], " +
-                         $"[InboxMessage].[Data] AS [{nameof(InboxMessageDto.Data)}] " +
-                         "FROM [administration].[InboxMessages] AS [InboxMessage] " +
-                         "WHERE [InboxMessage].[ProcessedDate] IS NULL " +
-                         "ORDER BY [InboxMessage].[OccurredOn]";
+            const string sql = $"""
+                               SELECT 
+                                   [InboxMessage].[Id] AS [{nameof(InboxMessageDto.Id)}], 
+                                   [InboxMessage].[Type] AS [{nameof(InboxMessageDto.Type)}], 
+                                   [InboxMessage].[Data] AS [{nameof(InboxMessageDto.Data)}] 
+                               FROM [administration].[InboxMessages] AS [InboxMessage] 
+                               WHERE [InboxMessage].[ProcessedDate] IS NULL 
+                               ORDER BY [InboxMessage].[OccurredOn]
+                               """;
 
             var messages = await connection.QueryAsync<InboxMessageDto>(sql);
 
-            const string sqlUpdateProcessedDate = "UPDATE [administration].[InboxMessages] " +
-                                                  "SET [ProcessedDate] = @Date " +
-                                                  "WHERE [Id] = @Id";
+            const string sqlUpdateProcessedDate = """
+                                                  UPDATE [administration].[InboxMessages] 
+                                                  SET [ProcessedDate] = @Date 
+                                                  WHERE [Id] = @Id
+                                                  """;
 
             foreach (var message in messages)
             {

diff --git a/...ucture/Configuration/Processing/InternalCommands/ProcessInternalCommandsCommandHandler.cs b/...ucture/Configuration/Processing/InternalCommands/ProcessInternalCommandsCommandHandler.cs
@@ -25,13 +25,15 @@ public async Task Handle(ProcessInternalCommandsCommand command, CancellationTok
         {
             var connection = this._sqlConnectionFactory.GetOpenConnection();
 
-            string sql = "SELECT " +
-                               $"[Command].[Id] AS [{nameof(InternalCommandDto.Id)}], " +
-                               $"[Command].[Type] AS [{nameof(InternalCommandDto.Type)}], " +
-                               $"[Command].[Data] AS [{nameof(InternalCommandDto.Data)}] " +
-                               "FROM [administration].[InternalCommands] AS [Command] " +
-                               "WHERE [Command].[ProcessedDate] IS NULL " +
-                               "ORDER BY [Command].[EnqueueDate]";
+            const string sql = $"""
+                          SELECT
+                              [Command].[Id] AS [{nameof(InternalCommandDto.Id)}], 
+                              [Command].[Type] AS [{nameof(InternalCommandDto.Type)}], 
+                              [Command].[Data] AS [{nameof(InternalCommandDto.Data)}] 
+                          FROM [administration].[InternalCommands] AS [Command] 
+                          WHERE [Command].[ProcessedDate] IS NULL 
+                          ORDER BY [Command].[EnqueueDate]
+                          """;
 
             var commands = await connection.QueryAsync<InternalCommandDto>(sql);
 

diff --git a/...inistration/Infrastructure/Configuration/Processing/Outbox/ProcessOutboxCommandHandler.cs b/...inistration/Infrastructure/Configuration/Processing/Outbox/ProcessOutboxCommandHandler.cs
@@ -32,13 +32,15 @@ internal class ProcessOutboxCommandHandler : ICommandHandler<ProcessOutboxComman
         public async Task Handle(ProcessOutboxCommand command, CancellationToken cancellationToken)
         {
             var connection = this._sqlConnectionFactory.GetOpenConnection();
-            string sql = "SELECT " +
-                               $"[OutboxMessage].[Id] AS [{nameof(OutboxMessageDto.Id)}], " +
-                               $"[OutboxMessage].[Type] AS [{nameof(OutboxMessageDto.Type)}], " +
-                               $"[OutboxMessage].[Data] AS [{nameof(OutboxMessageDto.Data)}] " +
-                               "FROM [administration].[OutboxMessages] AS [OutboxMessage] " +
-                               "WHERE [OutboxMessage].[ProcessedDate] IS NULL " +
-                               "ORDER BY [OutboxMessage].[OccurredOn]";
+            const string sql = $"""
+                                SELECT
+                                    [OutboxMessage].[Id] AS [{nameof(OutboxMessageDto.Id)}],
+                                    [OutboxMessage].[Type] AS [{nameof(OutboxMessageDto.Type)}],
+                                    [OutboxMessage].[Data] AS [{nameof(OutboxMessageDto.Data)}]
+                                FROM [administration].[OutboxMessages] AS [OutboxMessage]
+                                WHERE [OutboxMessage].[ProcessedDate] IS NULL
+                                ORDER BY [OutboxMessage].[OccurredOn]
+                                """;
 
             var messages = await connection.QueryAsync<OutboxMessageDto>(sql);
             var messagesList = messages.AsList();

diff --git a/src/Modules/Administration/Tests/IntegrationTests/SeedWork/OutboxMessagesHelper.cs b/src/Modules/Administration/Tests/IntegrationTests/SeedWork/OutboxMessagesHelper.cs
@@ -12,12 +12,14 @@ public class OutboxMessagesHelper
     {
         public static async Task<List<OutboxMessageDto>> GetOutboxMessages(IDbConnection connection)
         {
-            const string sql = "SELECT " +
-                               "[OutboxMessage].[Id], " +
-                               "[OutboxMessage].[Type], " +
-                               "[OutboxMessage].[Data] " +
-                               "FROM [administration].[OutboxMessages] AS [OutboxMessage] " +
-                               "ORDER BY [OutboxMessage].[OccurredOn]";
+            const string sql = """
+                               SELECT 
+                                   [OutboxMessage].[Id], 
+                                   [OutboxMessage].[Type], 
+                                   [OutboxMessage].[Data] 
+                               FROM [administration].[OutboxMessages] AS [OutboxMessage] 
+                               ORDER BY [OutboxMessage].[OccurredOn]
+                               """;
 
             var messages = await connection.QueryAsync<OutboxMessageDto>(sql);
             return messages.AsList();

diff --git a/src/Modules/Meetings/Application/Countries/GetAllCountriesQueryHandler.cs b/src/Modules/Meetings/Application/Countries/GetAllCountriesQueryHandler.cs
@@ -17,11 +17,14 @@ public async Task<List<CountryDto>> Handle(GetAllCountriesQuery query, Cancellat
         {
             var connection = _sqlConnectionFactory.GetOpenConnection();
 
-            return (await connection.QueryAsync<CountryDto>(
-                "SELECT " +
-                $"[Country].[Code] AS [{nameof(CountryDto.Code)}], " +
-                $"[Country].[Name] AS [{nameof(CountryDto.Name)}] " +
-                "FROM [meetings].[v_Countries] AS [Country]")).AsList();
+            const string sql = $"""
+                               SELECT
+                                   [Country].[Code] AS [{nameof(CountryDto.Code)}],
+                                   [Country].[Name] AS [{nameof(CountryDto.Name)}]
+                               FROM [meetings].[v_Countries] AS [Country]
+                               """;
+
+            return (await connection.QueryAsync<CountryDto>(sql)).AsList();
         }
     }
 }
diff --git a/...ations/GetMeetingCommentingConfiguration/GetMeetingCommentingConfigurationQueryHandler.cs b/...ations/GetMeetingCommentingConfiguration/GetMeetingCommentingConfigurationQueryHandler.cs
@@ -17,11 +17,13 @@ public async Task<MeetingCommentingConfigurationDto> Handle(GetMeetingCommenting
         {
             var connection = _sqlConnectionFactory.GetOpenConnection();
 
-            string sql = "SELECT " +
-                         $"[MeetingCommentingConfiguration].[MeetingId] AS [{nameof(MeetingCommentingConfigurationDto.MeetingId)}], " +
-                         $"[MeetingCommentingConfiguration].[IsCommentingEnabled] AS [{nameof(MeetingCommentingConfigurationDto.IsCommentingEnabled)}] " +
-                         "FROM [meetings].[MeetingCommentingConfigurations] AS [MeetingCommentingConfiguration] " +
-                         "WHERE [MeetingCommentingConfiguration].[MeetingId] = @MeetingId";
+            const string sql = $"""
+                                SELECT
+                                    [MeetingCommentingConfiguration].[MeetingId] AS [{nameof(MeetingCommentingConfigurationDto.MeetingId)}],
+                                    [MeetingCommentingConfiguration].[IsCommentingEnabled] AS [{nameof(MeetingCommentingConfigurationDto.IsCommentingEnabled)}]
+                                FROM [meetings].[MeetingCommentingConfigurations] AS [MeetingCommentingConfiguration]
+                                WHERE [MeetingCommentingConfiguration].[MeetingId] = @MeetingId
+                                """;
 
             return await connection.QuerySingleOrDefaultAsync<MeetingCommentingConfigurationDto>(sql, new { query.MeetingId });
         }