Refactor DapperHelper to use SqlConnection and async methods for database operations

nitin27may · nitin27may · commit f804087a882b · 2025-03-16T00:40:11.000-04:00
diff --git a/backend/src/Contact.Infrastructure/Persistence/Helper/DapperHelper.cs b/backend/src/Contact.Infrastructure/Persistence/Helper/DapperHelper.cs
@@ -17,7 +17,7 @@ public DapperHelper(IOptions<AppSettings> myConfigValue, ILogger<DapperHelper> l
             _logger = logger;
         }
 
-        public IDbConnection GetConnection()
+        public SqlConnection GetConnection()
         {
             _logger.LogInformation("Connection String: {connectionString}", myConfig.ConnectionStrings.DefaultConnection);  
             return new SqlConnection(myConfig.ConnectionStrings.DefaultConnection);
@@ -30,115 +30,115 @@ public void Dispose()
 
         public async Task<int> Execute(string sp, object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)
         { 
-            var db = transaction?.Connection ?? GetConnection();
+            var db = transaction?.Connection as SqlConnection ?? GetConnection();
             try
             {
                 if (db.State == ConnectionState.Closed)
-                    db.Open();
+                    await db.OpenAsync();
 
                 var resultObj = await db.ExecuteAsync(sp, parms, commandType: commandType, transaction: transaction);
                 if (transaction == null)
-                    db.Close();
+                    await db.CloseAsync();
                 return resultObj;
             }
             catch (Exception exception)
             {
                 if (transaction == null && db?.State == ConnectionState.Open)
-                    db.Close();
+                    await db.CloseAsync();
                 _logger.LogInformation("SQL DB error exception: {error}", exception.Message);
-                throw exception;
+                throw;
             }
         }
 
-        public async Task<T> Get<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction transaction = null)
+        public async Task<T> Get<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)
         {
             T result;
-            var db = transaction?.Connection ?? GetConnection();
+            var db = transaction?.Connection as SqlConnection ?? GetConnection();
             try
             {
                 if (db.State == ConnectionState.Closed)
-                    db.Open();
+                    await db.OpenAsync();
 
                 var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);
                 result = resultObj;
                 if (transaction == null)
-                    db.Close();
+                    await db.CloseAsync();
                 return result;
             }
             catch (Exception exception)
             {
                 if (transaction == null && db?.State == ConnectionState.Open)
-                    db.Close();
+                    await db.CloseAsync();
                 _logger.LogInformation("SQL DB error exception: {error}", exception.Message);
-                throw exception;
+                throw;
             }
         }
 
         public async Task<IEnumerable<T>> GetAll<T>(string sp, Object parms, CommandType commandType = CommandType.Text)
         {
             try
             {
-                using (IDbConnection db = GetConnection())
+                using (var db = GetConnection())
                 {
+                    await db.OpenAsync();
                     var result = await db.QueryAsync<T>(sp, parms, commandType: commandType);
+                    await db.CloseAsync();
                     return result.ToList();
                 }
             }
             catch (Exception ex)
             {
                 _logger.LogInformation("SQL DB error exception: {error}", ex.Message);
-               
-                throw ex;
+                throw;
             }
         }
 
-        public async Task<T> Insert<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction transaction = null)
+        public async Task<T> Insert<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)
         {
             T result;
-            var db = transaction?.Connection ?? GetConnection();
+            var db = transaction?.Connection as SqlConnection ?? GetConnection();
             try
             {
                 if (db.State == ConnectionState.Closed)
-                    db.Open();
+                    await db.OpenAsync();
 
                 var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);
                 result = resultObj;
                 if (transaction == null)
-                    db.Close();
+                    await db.CloseAsync();
                 return result;
             }
             catch (Exception exception)
             {
                 if (transaction == null && db?.State == ConnectionState.Open)
-                    db.Close();
+                    await db.CloseAsync();
                 _logger.LogInformation("SQL DB error exception: {error}", exception.Message);
-                throw exception;
+                throw;
             }
         }
 
         public async Task<T> Update<T>(string sp, object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)
         {
             T result;
-            var db = transaction?.Connection ?? GetConnection();
+            var db = transaction?.Connection as SqlConnection ?? GetConnection();
             try
             {
                 if (db.State == ConnectionState.Closed)
-                    db.Open();
+                    await db.OpenAsync();
 
                 var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);
                 result = resultObj;
                 if (transaction == null)
-                    db.Close();
+                    await db.CloseAsync();
                 return result;
             }
             catch (Exception ex)
             {
                 if (transaction == null && db?.State == ConnectionState.Open)
-                    db.Close();
+                    await db.CloseAsync();
                 _logger.LogInformation("SQL DB error exception: {error}", ex.Message);
-                throw ex;
+                throw;
             }
-
         }
     }
-}
+}
diff --git a/backend/src/Contact.Infrastructure/Persistence/Helper/IDapperHelper.cs b/backend/src/Contact.Infrastructure/Persistence/Helper/IDapperHelper.cs
@@ -1,10 +1,11 @@
 ﻿using System.Data;
+using Microsoft.Data.SqlClient;
 
 namespace Contact.Infrastructure.Persistence.Helper;
 
 public interface IDapperHelper : IDisposable
 {
-    IDbConnection GetConnection();
+    SqlConnection GetConnection();
     Task<T> Get<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null);
     Task<IEnumerable<T>> GetAll<T>(string sp, Object parms, CommandType commandType = CommandType.Text);
     Task<int> Execute(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null);

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public DapperHelper(IOptions<AppSettings> myConfigValue, ILogger<DapperHelper> l`
`17`	`17`	`_logger = logger;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public IDbConnection GetConnection()`
	`20`	`+ public SqlConnection GetConnection()`
`21`	`21`	`{`
`22`	`22`	`_logger.LogInformation("Connection String: {connectionString}", myConfig.ConnectionStrings.DefaultConnection);`
`23`	`23`	`return new SqlConnection(myConfig.ConnectionStrings.DefaultConnection);`
`@@ -30,115 +30,115 @@ public void Dispose()`
`30`	`30`
`31`	`31`	`public async Task<int> Execute(string sp, object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)`
`32`	`32`	`{`
`33`		`- var db = transaction?.Connection ?? GetConnection();`
	`33`	`+ var db = transaction?.Connection as SqlConnection ?? GetConnection();`
`34`	`34`	`try`
`35`	`35`	`{`
`36`	`36`	`if (db.State == ConnectionState.Closed)`
`37`		`- db.Open();`
	`37`	`+ await db.OpenAsync();`
`38`	`38`
`39`	`39`	`var resultObj = await db.ExecuteAsync(sp, parms, commandType: commandType, transaction: transaction);`
`40`	`40`	`if (transaction == null)`
`41`		`- db.Close();`
	`41`	`+ await db.CloseAsync();`
`42`	`42`	`return resultObj;`
`43`	`43`	`}`
`44`	`44`	`catch (Exception exception)`
`45`	`45`	`{`
`46`	`46`	`if (transaction == null && db?.State == ConnectionState.Open)`
`47`		`- db.Close();`
	`47`	`+ await db.CloseAsync();`
`48`	`48`	`_logger.LogInformation("SQL DB error exception: {error}", exception.Message);`
`49`		`- throw exception;`
	`49`	`+ throw;`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`		`- public async Task<T> Get<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction transaction = null)`
	`53`	`+ public async Task<T> Get<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)`
`54`	`54`	`{`
`55`	`55`	`T result;`
`56`		`- var db = transaction?.Connection ?? GetConnection();`
	`56`	`+ var db = transaction?.Connection as SqlConnection ?? GetConnection();`
`57`	`57`	`try`
`58`	`58`	`{`
`59`	`59`	`if (db.State == ConnectionState.Closed)`
`60`		`- db.Open();`
	`60`	`+ await db.OpenAsync();`
`61`	`61`
`62`	`62`	`var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);`
`63`	`63`	`result = resultObj;`
`64`	`64`	`if (transaction == null)`
`65`		`- db.Close();`
	`65`	`+ await db.CloseAsync();`
`66`	`66`	`return result;`
`67`	`67`	`}`
`68`	`68`	`catch (Exception exception)`
`69`	`69`	`{`
`70`	`70`	`if (transaction == null && db?.State == ConnectionState.Open)`
`71`		`- db.Close();`
	`71`	`+ await db.CloseAsync();`
`72`	`72`	`_logger.LogInformation("SQL DB error exception: {error}", exception.Message);`
`73`		`- throw exception;`
	`73`	`+ throw;`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`public async Task<IEnumerable<T>> GetAll<T>(string sp, Object parms, CommandType commandType = CommandType.Text)`
`78`	`78`	`{`
`79`	`79`	`try`
`80`	`80`	`{`
`81`		`- using (IDbConnection db = GetConnection())`
	`81`	`+ using (var db = GetConnection())`
`82`	`82`	`{`
	`83`	`+ await db.OpenAsync();`
`83`	`84`	`var result = await db.QueryAsync<T>(sp, parms, commandType: commandType);`
	`85`	`+ await db.CloseAsync();`
`84`	`86`	`return result.ToList();`
`85`	`87`	`}`
`86`	`88`	`}`
`87`	`89`	`catch (Exception ex)`
`88`	`90`	`{`
`89`	`91`	`_logger.LogInformation("SQL DB error exception: {error}", ex.Message);`
`90`		`-`
`91`		`- throw ex;`
	`92`	`+ throw;`
`92`	`93`	`}`
`93`	`94`	`}`
`94`	`95`
`95`		`- public async Task<T> Insert<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction transaction = null)`
	`96`	`+ public async Task<T> Insert<T>(string sp, Object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)`
`96`	`97`	`{`
`97`	`98`	`T result;`
`98`		`- var db = transaction?.Connection ?? GetConnection();`
	`99`	`+ var db = transaction?.Connection as SqlConnection ?? GetConnection();`
`99`	`100`	`try`
`100`	`101`	`{`
`101`	`102`	`if (db.State == ConnectionState.Closed)`
`102`		`- db.Open();`
	`103`	`+ await db.OpenAsync();`
`103`	`104`
`104`	`105`	`var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);`
`105`	`106`	`result = resultObj;`
`106`	`107`	`if (transaction == null)`
`107`		`- db.Close();`
	`108`	`+ await db.CloseAsync();`
`108`	`109`	`return result;`
`109`	`110`	`}`
`110`	`111`	`catch (Exception exception)`
`111`	`112`	`{`
`112`	`113`	`if (transaction == null && db?.State == ConnectionState.Open)`
`113`		`- db.Close();`
	`114`	`+ await db.CloseAsync();`
`114`	`115`	`_logger.LogInformation("SQL DB error exception: {error}", exception.Message);`
`115`		`- throw exception;`
	`116`	`+ throw;`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`
`119`	`120`	`public async Task<T> Update<T>(string sp, object parms, CommandType commandType = CommandType.Text, IDbTransaction? transaction = null)`
`120`	`121`	`{`
`121`	`122`	`T result;`
`122`		`- var db = transaction?.Connection ?? GetConnection();`
	`123`	`+ var db = transaction?.Connection as SqlConnection ?? GetConnection();`
`123`	`124`	`try`
`124`	`125`	`{`
`125`	`126`	`if (db.State == ConnectionState.Closed)`
`126`		`- db.Open();`
	`127`	`+ await db.OpenAsync();`
`127`	`128`
`128`	`129`	`var resultObj = await db.QueryFirstOrDefaultAsync<T>(sp, parms, commandType: commandType, transaction: transaction);`
`129`	`130`	`result = resultObj;`
`130`	`131`	`if (transaction == null)`
`131`		`- db.Close();`
	`132`	`+ await db.CloseAsync();`
`132`	`133`	`return result;`
`133`	`134`	`}`
`134`	`135`	`catch (Exception ex)`
`135`	`136`	`{`
`136`	`137`	`if (transaction == null && db?.State == ConnectionState.Open)`
`137`		`- db.Close();`
	`138`	`+ await db.CloseAsync();`
`138`	`139`	`_logger.LogInformation("SQL DB error exception: {error}", ex.Message);`
`139`		`- throw ex;`
	`140`	`+ throw;`
`140`	`141`	`}`
`141`		`-`
`142`	`142`	`}`
`143`	`143`	`}`
`144`		`-}`
	`144`	`+}`