Add DBHelper class and route all database calls through it.

BulkPrinting/BulkPrinting/BatchForm.cs

         {
             Dictionary<int, BatchEvent> BatchEvents = new Dictionary<int, BatchEvent>();
             string Sql = "Select COUNT(v.BatchId) AS Total, v.BatchId,l.EventType,l.Retry FROM Voucher v LEFT JOIN Logs l on v.Id = l.VoucherId WHERE l.EventType in (@printevent,@exportevent) GROUP BY v.BatchId,l.EventType,l.Retry ORDER BY BatchId";
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            using (var Command = Globals.DB.CreateCommand(Sql,
+                new SQLiteParameter("@printevent", VendorEvent.VendorEventType.PrintVoucher),
+                new SQLiteParameter("@exportevent", VendorEvent.VendorEventType.ExportVoucher)))
             {
-                Command.Parameters.AddWithValue("@printevent", VendorEvent.VendorEventType.PrintVoucher);
-                Command.Parameters.AddWithValue("@exportevent", VendorEvent.VendorEventType.ExportVoucher);
                 using (SQLiteDataReader read = Command.ExecuteReader())
                 {
                     while (read.Read())
             //dgvBatches.Columns.Add("VoucherCount", "Voucher Count");
 
 
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            CultureInfo IVC = CultureInfo.InvariantCulture;
+            using (var Command = Globals.DB.CreateCommand(Sql,
+                new SQLiteParameter("@startdate", dtpFilterStartDate.Value.Date.ToString("yyyy-MM-dd 00:00:00", IVC)),
+                new SQLiteParameter("@enddate", dtpFilterEndDate.Value.Date.ToString("yyyy-MM-dd 23:59:59", IVC))))
             {
-                CultureInfo IVC = CultureInfo.InvariantCulture;
-                Command.Parameters.AddWithValue("@startdate", dtpFilterStartDate.Value.Date.ToString("yyyy-MM-dd 00:00:00", IVC));
-                Command.Parameters.AddWithValue("@enddate", dtpFilterEndDate.Value.Date.ToString("yyyy-MM-dd 23:59:59", IVC));
-
                 lblLoading.Hide();
                 using (SQLiteDataReader read = Command.ExecuteReader())
                 {
 
             LoadingThread = new Thread(LoadingThreadWorker);
             LoadingThread.Start();
-            Utility.InitialiseUserLimits(Globals.DBConnection);
+            Utility.InitialiseUserLimits(Globals.DB);
             ReSyncTimer.Enabled = true;
         }
 
         private void LoadingThreadWorker()
         {
             const int voucherPageSize = 5000;
-            var conn = Globals.DBConnection;
-            //using (var conn = Utility.OpenDBConnection())
+            var db = Globals.DB;
+            //using (var db = Utility.OpenDBConnection())
             {
                 Invoke(new Action(() =>
                 {
                     PopulateGrid();
                 }));
 
-                var lastSyncedBatchId = Utility.GetSavedParameterAsInt(conn, "LastSyncedBatchId");
+                var lastSyncedBatchId = Utility.GetSavedParameterAsInt(db, "LastSyncedBatchId");
 
                 bool skipNewBatchCheck = false;
                 while (true)
                                         foreach (var batch in BatchPage.Items)
                                         {
                                             refreshGrid = true;
-                                            Utility.SaveBatch(conn, batch);
+                                            Utility.SaveBatch(db, batch);
                                             lastSyncedBatchId = batch.Id;
-                                            if (!Utility.UpdateSavedParameter(conn, "LastSyncedBatchId", lastSyncedBatchId))
+                                            if (!Utility.UpdateSavedParameter(db, "LastSyncedBatchId", lastSyncedBatchId))
                                             {
                                                 // Shouldn't happen.
                                                 throw new Exception("Failed to update LastSyncedBatchId");
                         // Continue downloading incomplete batches if any.
                         try
                         {
-                            using (var command = new SQLiteCommand(
-                                "SELECT Id FROM Batch WHERE Downloaded=0 ORDER BY Downloaded, Id",
-                                conn))
+                            using (var command = db.CreateCommand("SELECT Id FROM Batch WHERE Downloaded=0 ORDER BY Downloaded, Id"))
                             {
                                 using (SQLiteDataReader row = command.ExecuteReader())
                                 {
                                             if (Utility.RESTRequest(ref batch, String.Format("/api/batches/{0}", batchId)))
                                             {
                                                 refreshGrid = true;
-                                                Utility.SaveBatch(conn, batch);
+                                                Utility.SaveBatch(db, batch);
 
                                                 if (batch.ReadyForDownload)
                                                 {
-                                                    long result = (long)Utility.DBExecuteScalar(conn,
+                                                    long result = (long)db.ExecuteScalar(
                                                         "SELECT COUNT(*) FROM Voucher WHERE BatchId=@BatchId",
                                                         new SQLiteParameter("@BatchId", batchId));
                                                     int voucherCount = (int)result;
 
                                                         Log.Debug("Downloaded vouchers for batch {0} ({1} so far)", batchId, voucherCount);
 
-                                                        lock (Globals.DBWriteLock)
+                                                        lock (db.WriteLock)
                                                         {
-                                                            using (var trans = conn.BeginTransaction())
+                                                            using (var trans = db.BeginTransaction())
                                                             {
-                                                                using (var insert = new SQLiteCommand(
+                                                                using (var insert = db.CreateCommand(
                                                                     "INSERT INTO Voucher (Id, SequenceNumber, ExpiryDate, Serial, EncryptedPIN, BatchId)" +
                                                                                  "VALUES (@Id,@SequenceNumber,@ExpiryDate,@Serial,@EncryptedPin,@BatchId)",
-                                                                    conn, trans))
+                                                                    trans))
                                                                 {
                                                                     for (var i = offset; i < voucherPage.Items.Count; i++)
                                                                     {
                                                     {
                                                         Log.Debug("Batch {0} complete", batchId);
 
-                                                        Utility.DBExecuteNonQuery(conn,
+                                                        db.ExecuteNonQuery(
                                                             "UPDATE Batch SET Downloaded=1 WHERE Id=@BatchId",
                                                             new SQLiteParameter("@BatchId", batchId));
                                                     }
                                                 // Batch will only be null if we got a 404.
                                                 Log.Debug("Removing deleted batch {0}", batchId);
 
-                                                Utility.DBExecuteNonQuery(conn,
+                                                db.ExecuteNonQuery(
                                                     "DELETE FROM Voucher WHERE BatchId=@BatchId",
                                                     new SQLiteParameter("@BatchId", batchId));
 
-                                                Utility.DBExecuteNonQuery(conn,
+                                                db.ExecuteNonQuery(
                                                     "DELETE FROM Batch WHERE Id=@BatchId",
                                                     new SQLiteParameter("@BatchId", batchId));
 
             }
 
             int DeliveredVoucherCount = (int)dgvBatches.SelectedRows[0].Cells[dgvBatches.Columns["DeliveredQuantity"].Index].Value;
-            int DownloadedVoucherCount = Convert.ToInt32(Utility.DBExecuteScalar(Globals.DBConnection,
+            int DownloadedVoucherCount = Convert.ToInt32(Globals.DB.ExecuteScalar(
                 "SELECT COUNT(*) FROM Voucher WHERE BatchId=@id",
                 new SQLiteParameter("@id", BatchID)));
             if (DownloadedVoucherCount < DeliveredVoucherCount) {
                 MessageBox.Show("This batch has been exported previously. Exported batches cannot be printed.", "Cannot print batch", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                 return;
             }
-            int PrintCount = int.Parse(Utility.DBExecuteScalar(Globals.DBConnection,
+            int PrintCount = int.Parse(Globals.DB.ExecuteScalar(
                 "SELECT COUNT(*) FROM Voucher v LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype WHERE l.VoucherId IS NOT NULL AND v.BatchId=@batchid AND Retry=0",
                 new SQLiteParameter("@batchid", BatchID),
                 new SQLiteParameter("@eventtype", VendorEvent.VendorEventType.PrintVoucher)).ToString());
             }
 
             int DeliveredVoucherCount = (int)dgvBatches.SelectedRows[0].Cells[dgvBatches.Columns["DeliveredQuantity"].Index].Value;
-            int DownloadedVoucherCount = Convert.ToInt32(Utility.DBExecuteScalar(Globals.DBConnection,
+            int DownloadedVoucherCount = Convert.ToInt32(Globals.DB.ExecuteScalar(
                 "SELECT COUNT(*) FROM Voucher WHERE BatchId=@id",
                 new SQLiteParameter("@id", BatchID)));
             if (DownloadedVoucherCount < DeliveredVoucherCount)

BulkPrinting/BulkPrinting/BulkPrinting.csproj

   </ItemGroup>
   <ItemGroup>
     <Compile Include="Configuration.cs" />
+    <Compile Include="DBHelper.cs" />
     <Compile Include="ExportForm.cs">
       <SubType>Form</SubType>
     </Compile>

BulkPrinting/BulkPrinting/DBHelper.cs

+using System;
+using System.Data.SQLite;
+
+namespace BulkPrinting
+{
+    public class DBHelper: IDisposable
+    {
+        private SQLiteConnection _connection;
+        private object _writeLock = new object();
+        private bool isDisposed = false;
+
+        public DBHelper(string dataSource, byte[] password)
+        {
+            _connection = new SQLiteConnection(dataSource);
+            _connection.SetPassword(password);
+            _connection.Open();
+        }
+
+        public SQLiteTransaction BeginTransaction()
+        {
+            return _connection.BeginTransaction();
+        }
+
+        public void Close()
+        {
+            _connection.Close();
+        }
+
+        public SQLiteCommand CreateCommand()
+        {
+            return new SQLiteCommand(_connection);
+        }
+
+        public SQLiteCommand CreateCommand(SQLiteTransaction transaction, params SQLiteParameter[] parameters)
+        {
+            var command = new SQLiteCommand();
+            command.Transaction = transaction;
+            foreach (var parameter in parameters)
+            {
+                command.Parameters.Add(parameter);
+            }
+            return command;
+        }
+
+        public SQLiteCommand CreateCommand(string commandText, SQLiteTransaction transaction = null)
+        {
+            return new SQLiteCommand(commandText, _connection, transaction);
+        }
+
+        public SQLiteCommand CreateCommand(string commandText, params SQLiteParameter[] parameters)
+        {
+            var command = new SQLiteCommand(commandText, _connection);
+            foreach (var parameter in parameters)
+            {
+                command.Parameters.Add(parameter);
+            }
+            return command;
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (isDisposed)
+                return;
+
+            if (disposing)
+            {
+                if (_connection != null)
+                {
+                    _connection.Dispose();
+                    _connection = null;
+                }
+            }
+
+            isDisposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        public int ExecuteNonQuery(string commandText, params SQLiteParameter[] parameters)
+        {
+            lock (_writeLock)
+            {
+                using (var command = new SQLiteCommand(commandText, _connection))
+                {
+                    foreach (var parameter in parameters)
+                    {
+                        command.Parameters.Add(parameter);
+                    }
+                    return command.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public object ExecuteScalar(string commandText, params SQLiteParameter[] parameters)
+        {
+            using (var command = new SQLiteCommand(commandText, _connection))
+            {
+                foreach (var parameter in parameters)
+                {
+                    command.Parameters.Add(parameter);
+                }
+                return command.ExecuteScalar();
+            }
+        }
+
+        public object WriteLock { get { return _writeLock; } }
+    }
+}

BulkPrinting/BulkPrinting/ExportForm.cs

                 Sql += " AND b.NetworkName=@networkname";
             }
             Sql += " GROUP BY b.Id,b.FaceValue,b.ProductDescription,b.DeliveredQuantity";
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            using (var Command = Globals.DB.CreateCommand(Sql))
             {
                 if (cmbNetwork.SelectedItem.ToString() != "All")
                 {
                 lblBatchType.Text = "Previously Exported Batches";
             }
             string Sql = "SELECT DISTINCT NetworkName FROM Batch";
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            using (var Command = Globals.DB.CreateCommand(Sql))
             {
                 cmbNetwork.Items.Clear();
                 cmbNetwork.Items.Add("All");
                     List<EventLog> LogEvents = new List<EventLog>();
 
                     string Sql = "SELECT v.Id,v.ExpiryDate,v.Serial,v.EncryptedPIN,b.FaceValue,v.BatchId,v.SequenceNumber,b.ProductDescription,COUNT(l.Id) AS Exports FROM Voucher v LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType=@eventtype LEFT JOIN Batch b ON v.BatchId=b.Id WHERE BatchId=@batchid GROUP BY v.Id,v.ExpiryDate,v.Serial,v.EncryptedPIN,b.FaceValue,v.BatchId,v.SequenceNumber,b.ProductDescription";
-                    using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+                    using (var Command = Globals.DB.CreateCommand(Sql))
                     {
                         foreach (BatchItem ExportBatch in lstSelectedBatches.Items)
                         {
                             }
                         }
                     }
-                    Utility.LogBulkEvents(Globals.DBConnection, LogEvents);
+                    Utility.LogBulkEvents(Globals.DB, LogEvents);
                 }
                 MessageBox.Show("Vouchers Exported");
                 this.Close();

BulkPrinting/BulkPrinting/Globals.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Data.SQLite;
+using System.Collections.Generic;
 using System.Threading;
 
 namespace BulkPrinting
     {
         public static string MaxDBPath;
         public static string MaxDBFilePath;
-        public static readonly object DBWriteLock = new object();
+        public static DBHelper DB;
         public static SessionModes SessionMode;
         public static OKResponse SessionData;
         public static string HDDSerialNumber;
         public static byte[] SessionVoucherKey;
         public static byte[] SessionSalt;
         public static int SessionIterations;
-        public static SQLiteConnection DBConnection;
         public static Printer MaxPrinter;
         public static List<int> OpenBatches;
         public static UserLimits UserCurrentUsage;

BulkPrinting/BulkPrinting/Migrations.cs

 using System;
-using System.Data.SQLite;
-using System.IO;
 
 namespace BulkPrinting
 {
     class Migrations
     {
-        public static void CheckMigrations(SQLiteConnection conn) {
-            var result = Utility.DBExecuteScalar(conn, "SELECT Value FROM Parameters WHERE Key = 'Migration'");
+        public static void CheckMigrations(DBHelper db) {
+            var result = db.ExecuteScalar("SELECT Value FROM Parameters WHERE Key = 'Migration'");
             int startingMigration;
             if (result == null)
             {
                 throw new Exception("Database is for a newer version of this application. Please upgrade and try again.");
             }
             if (startingMigration < 1) {
-                Migration1(conn);
+                Migration1(db);
             }
             if (startingMigration < 2)
             {
-                Migration2(conn);
+                Migration2(db);
             }
             //Add further migration executions here - Migration = '1', '2', '3' etc
 
             return;
         }
 
-        private static bool ApplyMigrationQueries(SQLiteConnection conn, params string[] queries)
+        private static bool ApplyMigrationQueries(DBHelper db, params string[] queries)
         {
-            lock (Globals.DBWriteLock)
+            lock (db.WriteLock)
             {
-                using (var trans = conn.BeginTransaction())
+                using (var trans = db.BeginTransaction())
                 {
                     foreach (var query in queries)
                     {
-                        using (var command = new SQLiteCommand(query, conn, trans))
+                        using (var command = db.CreateCommand(query, trans))
                         {
                             command.ExecuteNonQuery();
                         }
             return true;
         }
 
-        public static bool InitialVersion(SQLiteConnection conn) {
+        public static bool InitialVersion(DBHelper db) {
             return ApplyMigrationQueries(
-                conn,
+                db,
                 "CREATE TABLE Batch (" +
                     "Id INT," +
                     "OrderDate DATETIME," +
             );
         }
 
-        public static bool Migration1 (SQLiteConnection conn){
+        public static bool Migration1 (DBHelper db){
             return ApplyMigrationQueries(
-                conn,
+                db,
                 "ALTER TABLE Orders ADD COLUMN InternalReference VARCHAR(32)",
                 "ALTER TABLE Batch ADD COLUMN InternalReference VARCHAR(32)",
                 "INSERT INTO Parameters (Key, Value) VALUES ('Migration','1')"
             );
         }
 
-        public static bool Migration2(SQLiteConnection conn)
+        public static bool Migration2(DBHelper db)
         {
             return ApplyMigrationQueries(
-                conn,
+                db,
                 "ALTER TABLE Batch ADD COLUMN Downloaded BOOLEAN",
                 "CREATE UNIQUE INDEX Batch_Id ON Batch(Id)",
                 "CREATE INDEX Batch_OrderDate ON Batch(OrderDate)",

BulkPrinting/BulkPrinting/OrderForm.cs

             DialogResult PlaceOrder = MessageBox.Show(OrderReviewMessage, "Proceed?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
             if (PlaceOrder == DialogResult.Yes) {
                 string InternalReference = Utility.GetNextInternalReference();
-                Utility.DBExecuteNonQuery(Globals.DBConnection,
+                Globals.DB.ExecuteNonQuery(
                     "INSERT INTO Orders (UserId,UserName,OrderDate,OrderCost,BalanceAfterOrder,InternalReference) VALUES (@userid,@username,datetime('now'),@ordercost,@balanceafterorder,@internalreference)",
-                        new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id),
-                        new SQLiteParameter("@username", Globals.SessionData.Credentials.Payload.User.FirstName + " " + Globals.SessionData.Credentials.Payload.User.Surname),
-                        new SQLiteParameter("@ordercost", TotalCost),
-                        new SQLiteParameter("@balanceafterorder", Globals.SessionData.Credentials.Payload.User.Account.Balance - TotalCost),
-                        new SQLiteParameter("@internalreference", InternalReference));
+                    new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id),
+                    new SQLiteParameter("@username", Globals.SessionData.Credentials.Payload.User.FirstName + " " + Globals.SessionData.Credentials.Payload.User.Surname),
+                    new SQLiteParameter("@ordercost", TotalCost),
+                    new SQLiteParameter("@balanceafterorder", Globals.SessionData.Credentials.Payload.User.Account.Balance - TotalCost),
+                    new SQLiteParameter("@internalreference", InternalReference));
 
-                int OrderId = int.Parse(Utility.DBExecuteScalar(Globals.DBConnection, "SELECT MAX(Id) FROM Orders").ToString());
+                int OrderId = int.Parse(Globals.DB.ExecuteScalar("SELECT MAX(Id) FROM Orders").ToString());
 
-                lock (Globals.DBWriteLock)
+                lock (Globals.DB.WriteLock)
                 {
-                    using (var trans = Globals.DBConnection.BeginTransaction())
+                    using (var trans = Globals.DB.BeginTransaction())
                     {
                         var Sql = "INSERT INTO OrderedItems (OrderId,Cost,Quantity,Description,ProductId) VALUES (@orderId,@cost,@quantity,@description,@productid)";
-                        using (var Command = new SQLiteCommand(Sql, Globals.DBConnection, trans))
+                        using (var Command = Globals.DB.CreateCommand(Sql, trans))
                         {
                             for (int i = 0; i < this.SelectedProducts.Count; i++)
                             {
                 ProgressDialog Progress = new ProgressDialog();
                 Progress.Show();
                 Thread t = new Thread(() => {
-                    var conn = Globals.DBConnection;
-                    //using (var conn = Utility.OpenDBConnection())
+                    var db = Globals.DB;
+                    //using (var db = Utility.OpenDBConnection())
                     {
                         Progress.UpdateProgressText("Please wait...");
                         Progress.UpdateProgressBar(0);
                                 continue;
                             }
                             //TODO: Handle failed order
-                            Utility.SaveBatch(conn, OrderedBatch.Batch);
+                            Utility.SaveBatch(db, OrderedBatch.Batch);
                             SourceForm.NewBatchAvailable();
                             Globals.SessionData.Credentials.Payload.User.Account.Balance = OrderedBatch.RemainingBalance;
-                            Utility.AddUserUsage(conn, UserLimits.UserLimitTypes.BulkOrder, OrderedBatch.Batch.Cost);
+                            Utility.AddUserUsage(db, UserLimits.UserLimitTypes.BulkOrder, OrderedBatch.Batch.Cost);
                             Progress.UpdateProgressBar((int)Math.Round(100 * (((decimal)i + 1) / (decimal)SelectedProducts.Count)));
                             Thread.Sleep(50);
                         }

BulkPrinting/BulkPrinting/OrderReport.cs

             dgvOrderReport.Columns.Add("DeliveredQuantity", "Delivered Quantity");
             string Sql = "Select o.Id,o.InternalReference,o.UserId,o.UserName,o.OrderDate,oi.Description,o.OrderCost,o.BalanceAfterOrder,oi.Cost,b.RequestedQuantity,b.DeliveredQuantity From Orders o LEFT JOIN OrderedItems oi on oi.OrderId = o.Id LEFT JOIN Batch b ON b.InternalReference = o.InternalReference AND b.ProductId = oi.ProductId WHERE o.OrderDate BETWEEN @startdate AND @enddate";
 
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            CultureInfo IVC = CultureInfo.InvariantCulture;
+            using (var Command = Globals.DB.CreateCommand(Sql,
+                new SQLiteParameter("@startdate", dtpStartDate.Value.ToString("yyyy-MM-dd 00:00:00", IVC)),
+                new SQLiteParameter("@enddate", dtpEndDate.Value.ToString("yyyy-MM-dd 23:59:59", IVC))))
             {
-                CultureInfo IVC = CultureInfo.InvariantCulture;
-                Command.Parameters.AddWithValue("@startdate", dtpStartDate.Value.ToString("yyyy-MM-dd 00:00:00", IVC));
-                Command.Parameters.AddWithValue("@enddate", dtpEndDate.Value.ToString("yyyy-MM-dd 23:59:59", IVC));
 
                 using (SQLiteDataReader read = Command.ExecuteReader())
                 {
         private void btnPrint_Click(object sender, EventArgs e)
         {
             string Sql = "Select o.Id,o.OrderDate,o.InternalReference,o.UserName,o.OrderCost,o.BalanceAfterOrder,oi.Description,oi.Cost,b.RequestedQuantity,b.DeliveredQuantity From Orders o LEFT JOIN OrderedItems oi on oi.OrderId = o.Id LEFT JOIN Batch b ON b.InternalReference = o.InternalReference AND b.ProductId = oi.ProductId WHERE o.OrderDate BETWEEN @startdate AND @enddate ORDER BY o.Id";
-            using (var Command = new SQLiteCommand(Sql, Globals.DBConnection))
+            CultureInfo IVC = CultureInfo.InvariantCulture;
+            using (var Command = Globals.DB.CreateCommand(Sql,
+                new SQLiteParameter("@startdate", dtpStartDate.Value.ToString("yyyy-MM-dd 00:00:00", IVC)),
+                new SQLiteParameter("@enddate", dtpEndDate.Value.ToString("yyyy-MM-dd 23:59:59", IVC))))
             {
-                CultureInfo IVC = CultureInfo.InvariantCulture;
-                Command.Parameters.AddWithValue("@startdate", dtpStartDate.Value.ToString("yyyy-MM-dd 00:00:00", IVC));
-                Command.Parameters.AddWithValue("@enddate", dtpEndDate.Value.ToString("yyyy-MM-dd 23:59:59", IVC));
-
                 int CurrentId;
                 int LastId = -1;
                 List<OrderList> Orders = new List<OrderList>();

BulkPrinting/BulkPrinting/PrintAlignmentDialog.cs

             }
             else if (NumVouchers != null)
             {
-                FirstVoucherSequenceNumber = Convert.ToInt32(Utility.DBExecuteScalar(Globals.DBConnection,
+                FirstVoucherSequenceNumber = Convert.ToInt32(Globals.DB.ExecuteScalar(
                     "SELECT MIN(v.SequenceNumber) FROM Voucher v " +
                         "LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype " +
                         "WHERE v.BatchId = @batchid AND l.id IS NULL",
             this.Enabled = false;
             Thread t = new Thread(() =>
             {
-                var conn = Globals.DBConnection;
-                //using (var conn = Utility.OpenDBConnection())
+                var db = Globals.DB;
+                //using (var db = Utility.OpenDBConnection())
                 {
-                    Utility.PrintVouchers(conn, BatchID, FirstVoucherSequenceNumber, LastVoucherSequenceNumber);
+                    Utility.PrintVouchers(db, BatchID, FirstVoucherSequenceNumber, LastVoucherSequenceNumber);
                     Globals.OpenBatches.Remove(BatchID);
                     this.Invoke((Action)(() =>
                     {

BulkPrinting/BulkPrinting/PrintForm.cs

             }
 
             VoucherCount = numNumVouchers.Value;
-            decimal TotalVoucherValue = VoucherCount * (decimal)Utility.DBExecuteScalar(Globals.DBConnection,
+            decimal TotalVoucherValue = VoucherCount * (decimal)Globals.DB.ExecuteScalar(
                 "SELECT FaceValue FROM Batch WHERE Id = @id",
                 new SQLiteParameter("@id", BatchID));
 

BulkPrinting/BulkPrinting/ReprintForm.cs

             lblFaceValue.Text = FaceValue;
             lblVoucherType.Text = VoucherTypeName;
             lblNetwork.Text = NetworkName;
-            using (var Command = new SQLiteCommand("SELECT MIN(v.SequenceNumber), MAX(v.SequenceNumber) FROM Voucher v LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype WHERE l.VoucherId IS NOT NULL AND v.BatchId=@batchid AND Retry=0", Globals.DBConnection))
+            using (var Command = Globals.DB.CreateCommand(
+                "SELECT MIN(v.SequenceNumber), MAX(v.SequenceNumber) FROM Voucher v LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype WHERE l.VoucherId IS NOT NULL AND v.BatchId=@batchid AND Retry=0",
+                new SQLiteParameter("@batchid", BatchID),
+                new SQLiteParameter("@eventtype", VendorEvent.VendorEventType.PrintVoucher)))
             {
-                Command.Parameters.AddWithValue("@batchid", BatchID);
-                Command.Parameters.AddWithValue("@eventtype", VendorEvent.VendorEventType.PrintVoucher);
                 using (SQLiteDataReader read = Command.ExecuteReader())
                 {
                     read.Read();
                 SelectedRangeEnd = (int)numLastSeqNum.Value;
             }
             else if (rdoSerial.Checked) {
-                int PrintCount = int.Parse(Utility.DBExecuteScalar(Globals.DBConnection,
+                int PrintCount = int.Parse(Globals.DB.ExecuteScalar(
                     "SELECT Count(*) FROM Logs l left join Voucher v on l.VoucherId=v.id WHERE v.Serial=@serialnum and l.EventType=@eventtype and Retry=0",
                     new SQLiteParameter("@serialnum", txtSerialNum.Text),
                     new SQLiteParameter("@eventtype", VendorEvent.VendorEventType.PrintVoucher)).ToString());
             }
 
             VoucherCount = SelectedRangeEnd - SelectedRangeStart + 1;
-            decimal VoucherFaceValue = (decimal)Utility.DBExecuteScalar(Globals.DBConnection,
+            decimal VoucherFaceValue = (decimal)Globals.DB.ExecuteScalar(
                 "SELECT FaceValue FROM Batch WHERE Id=@id",
                 new SQLiteParameter("@id", BatchID));
 
-            int UnprintedVouchersInRange = int.Parse(Utility.DBExecuteScalar(Globals.DBConnection,
+            int UnprintedVouchersInRange = int.Parse(Globals.DB.ExecuteScalar(
                 "SELECT COUNT(v.ID) FROM Voucher v LEFT JOIN Logs l ON v.Id=l.VoucherId AND l.EventType=@event WHERE v.BatchId=@batchid AND v.SequenceNumber BETWEEN @startseq AND @endseq AND l.id IS NULL",
                 new SQLiteParameter("@event", (int) VendorEvent.VendorEventType.PrintVoucher),
                 new SQLiteParameter("@batchid", BatchID),

BulkPrinting/BulkPrinting/UserLoginForm.cs

                 }
                 else
                 {
-                    Globals.DBConnection = Utility.OpenDBConnection();
+                    Globals.DB = Utility.OpenDBConnection();
                     //Test login success
                     Globals.SessionMode = SessionModes.Offline;
-                    Globals.SessionData = JsonConvert.DeserializeObject<OKResponse>(Convert.ToString(Utility.DBExecuteScalar(
-                        Globals.DBConnection, "SELECT Value FROM SessionData WHERE Key = 'SessionDataJson'")));
+                    Globals.SessionData = JsonConvert.DeserializeObject<OKResponse>(Convert.ToString(Globals.DB.ExecuteScalar(
+                        "SELECT Value FROM SessionData WHERE Key = 'SessionDataJson'")));
                     Globals.SessionVoucherKey = Utility.AesDecryptBytes(Globals.SessionData.Credentials.Payload.EncryptedVoucherKey, userKey);
                     DateTime ServerDate = Globals.SessionData.Credentials.Payload.Date;
                     DateTime Today = DateTime.Now;
                         MessageBox.Show("It looks like this user hasn't performed an online login today or since the application started. You must perform an online login at least once during the day to use the offline feature. To use offline mode, please remember not to close the application after each session.", "Cannot perform offline login", MessageBoxButtons.OK, MessageBoxIcon.Error);
                         return;
                     }
-                    Utility.LogEvent(Globals.DBConnection, VendorEvent.VendorEventType.OfflineLogin);
+                    Utility.LogEvent(Globals.DB, VendorEvent.VendorEventType.OfflineLogin);
                     LoginSuccessful = true;
                 }
             }
                                 Directory.CreateDirectory(Globals.MaxDBPath);
                             }
                             SQLiteConnection.CreateFile(Globals.MaxDBFilePath);
-                            Globals.DBConnection = Utility.OpenDBConnection();
-                            Migrations.InitialVersion(Globals.DBConnection);
+                            Globals.DB = Utility.OpenDBConnection();
+                            Migrations.InitialVersion(Globals.DB);
                         }
                         else
                         {
-                            Globals.DBConnection = Utility.OpenDBConnection();
+                            Globals.DB = Utility.OpenDBConnection();
                         }
-                        Migrations.CheckMigrations(Globals.DBConnection);
-                        Utility.CheckLogSynchronisation(Globals.DBConnection);
+                        Migrations.CheckMigrations(Globals.DB);
+                        Utility.CheckLogSynchronisation(Globals.DB);
                         Utility.TriggerLogDownload();
                         Utility.TriggerLogUpload();
                     }
                 Globals.SessionData.Credentials.Payload.User.OnlineReprintValue = 0;
                 Globals.SessionData.Credentials.Payload.User.OfflineReprintValue = 0;
                 */
-                Utility.DBExecuteNonQuery(Globals.DBConnection, "DELETE FROM SessionData"); //Destroy stored session data on login - keep in memory until logout
+                Globals.DB.ExecuteNonQuery("DELETE FROM SessionData"); //Destroy stored session data on login - keep in memory until logout
                 Globals.MaxPrinter = new Printer();
                 this.txtPassword.Text = "";
                 this.Hide();

BulkPrinting/BulkPrinting/Utility.cs

             return result.Length > 15 ? result.Substring(result.Length - 15, 15) : result;
         }
 
-        public static SQLiteConnection OpenDBConnection()
+        public static DBHelper OpenDBConnection()
         {
-            var conn = new SQLiteConnection(String.Format("Data Source={0};", Globals.MaxDBFilePath));
-            conn.SetPassword(Globals.SessionDatabasePassword);
-            conn.Open();
-            return conn;
-        }
-
-        public static int DBExecuteNonQuery(SQLiteConnection conn, string query, params SQLiteParameter[] queryParams)
-        {
-            lock (Globals.DBWriteLock)
-            {
-                using (var command = new SQLiteCommand(query, conn))
-                {
-                    foreach (var param in queryParams)
-                    {
-                        command.Parameters.Add(param);
-                    }
-                    return command.ExecuteNonQuery();
-                }
-            }
-        }
-
-        public static object DBExecuteScalar(SQLiteConnection conn, string query, params SQLiteParameter[] queryParams)
-        {
-            using (var command = new SQLiteCommand(query, conn))
-            {
-                foreach (var param in queryParams)
-                {
-                    command.Parameters.Add(param);
-                }
-                return command.ExecuteScalar();
-            }
+            return new DBHelper(String.Format("Data Source={0};", Globals.MaxDBFilePath), Globals.SessionDatabasePassword);
         }
 
         public static bool Login(LoginData UserLoginData, bool Offline, bool RememberMe) {
             return InternalReferenceRequest.InternalReference;
         }
 
-        public static void SaveBatch(SQLiteConnection conn, Batch batch)
+        public static void SaveBatch(DBHelper db, Batch batch)
         {
-            lock (Globals.DBWriteLock)
+            lock (db.WriteLock)
             {
-                using (var trans = conn.BeginTransaction())
+                using (var trans = db.BeginTransaction())
                 {
-                    using (var command = new SQLiteCommand(conn))
+                    using (var command = db.CreateCommand(trans))
                     {
-                        command.Transaction = trans;
-
                         command.Parameters.AddWithValue("@Id", batch.Id);
                         command.Parameters.AddWithValue("@OrderDate", batch.OrderDate);
                         command.Parameters.AddWithValue("@OrderGuid", batch.OrderGuid);
             }
         }
 
-        public static string GetSavedParameter(SQLiteConnection conn, string key)
+        public static string GetSavedParameter(DBHelper db, string key)
         {
-            return (string)DBExecuteScalar(conn, "SELECT Value FROM Parameters WHERE Key=@Key",
+            return (string)db.ExecuteScalar("SELECT Value FROM Parameters WHERE Key=@Key",
                 new SQLiteParameter("@Key", key));
         }
 
-        public static int GetSavedParameterAsInt(SQLiteConnection conn, string key)
+        public static int GetSavedParameterAsInt(DBHelper db, string key)
         {
-            return Convert.ToInt32(GetSavedParameter(conn, key));
+            return Convert.ToInt32(GetSavedParameter(db, key));
         }
 
-        public static bool GetSavedParameterAsBoolean(SQLiteConnection conn, string key)
+        public static bool GetSavedParameterAsBoolean(DBHelper db, string key)
         {
-            return Convert.ToBoolean(GetSavedParameter(conn, key));
+            return Convert.ToBoolean(GetSavedParameter(db, key));
         }
 
-        public static bool UpdateSavedParameter(SQLiteConnection conn, string key, object value)
+        public static bool UpdateSavedParameter(DBHelper db, string key, object value)
         {
-            return DBExecuteNonQuery(conn,
+            return db.ExecuteNonQuery(
                 "UPDATE Parameters SET Value=@Value WHERE Key=@Key",
                 new SQLiteParameter("@Key", key),
                 new SQLiteParameter("@Value", Convert.ToString(value))) > 0;
         }
 
-        public static void PrintVouchers(SQLiteConnection conn, int BatchId, int StartSeqNo, int EndSeqNo)
+        public static void PrintVouchers(DBHelper db, int BatchId, int StartSeqNo, int EndSeqNo)
         {
 
             int VoucherCount = 0;
             List<EventLog> LogEvents = new List<EventLog>();
 
             IList<PrintVoucher> VoucherRow = new List<PrintVoucher>();
-            using (var Command = new SQLiteCommand("SELECT DISTINCT v.Id,v.SequenceNumber,v.Serial,v.EncryptedPIN,v.BatchId,b.ProductDescription,l.VoucherId From Voucher v LEFT JOIN Batch b on v.BatchId = b.Id LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype WHERE v.BatchId=@batch_id AND v.SequenceNumber BETWEEN @seqstartno AND @seqendno ORDER BY v.SequenceNumber", conn))
+            using (var Command = db.CreateCommand("SELECT DISTINCT v.Id,v.SequenceNumber,v.Serial,v.EncryptedPIN,v.BatchId,b.ProductDescription,l.VoucherId From Voucher v LEFT JOIN Batch b on v.BatchId = b.Id LEFT JOIN Logs l ON v.Id = l.VoucherId AND l.EventType = @eventtype WHERE v.BatchId=@batch_id AND v.SequenceNumber BETWEEN @seqstartno AND @seqendno ORDER BY v.SequenceNumber",
+                new SQLiteParameter("@batch_id", BatchId),
+                new SQLiteParameter("@eventtype", VendorEvent.VendorEventType.PrintVoucher),
+                new SQLiteParameter("@seqstartno", StartSeqNo),
+                new SQLiteParameter("@seqendno", EndSeqNo)))
             {
-                Command.Parameters.AddWithValue("@batch_id", BatchId);
-                Command.Parameters.AddWithValue("@eventtype", VendorEvent.VendorEventType.PrintVoucher);
-                Command.Parameters.AddWithValue("@seqstartno", StartSeqNo);
-                Command.Parameters.AddWithValue("@seqendno", EndSeqNo);
-
                 using (SQLiteDataReader read = Command.ExecuteReader())
                 {
                     int JobID = Globals.MaxPrinter.Open("Vouchers");
                     Globals.MaxPrinter.Close();
                 }
             }
-            LogBulkEvents(conn, LogEvents);
+            LogBulkEvents(db, LogEvents);
         }
 
         public enum UserPermissions {
         public static void Logout() {
             if (Globals.SessionData != null)
             {
-                DBExecuteNonQuery(Globals.DBConnection, "DELETE FROM SessionData"); //Destroy stored session data
+                Globals.DB.ExecuteNonQuery("DELETE FROM SessionData"); //Destroy stored session data
                 string SessionDataJson = JsonConvert.SerializeObject(Globals.SessionData);
-                DBExecuteNonQuery(Globals.DBConnection,
+                Globals.DB.ExecuteNonQuery(
                     "INSERT INTO SessionData (Key,Value) VALUES (@key,@value)",
                     new SQLiteParameter("@key", "SessionDataJson"),
                     new SQLiteParameter("@value", SessionDataJson));
-                LogEvent(Globals.DBConnection, VendorEvent.VendorEventType.Logout);
+                LogEvent(Globals.DB, VendorEvent.VendorEventType.Logout);
 
                 CancelLogUploadWorker();
                 CancelLogDownloadWorker();
                 }
 
                 Globals.UploadNewLogs = false;
+                Globals.LogUploadThreadCancelled = false;
+                Globals.LogDownloadThreadCancelled = false;
 
-                Globals.DBConnection.Close();
+                Globals.DB.Close();
+                Globals.DB.Dispose();
+                Globals.DB = null;
                 Globals.SessionData = null;
                 Globals.SessionDatabasePassword = null;
                 Globals.SessionVoucherKey = null;
             return (int)MetaData.LastVendorEventRemoteId;
         }
 
-        public static void CheckLogSynchronisation(SQLiteConnection conn)
+        public static void CheckLogSynchronisation(DBHelper db)
         {
-            if (!GetSavedParameterAsBoolean(conn, "LoggingInitialised"))
+            if (!GetSavedParameterAsBoolean(db, "LoggingInitialised"))
             {
                 var lastSyncedLogId = GetLastSyncedLogID();
 
                 // If we already have logs then there is no need to synchronise.
                 // NOTE: logs are synchronised in reverse from SyncBackwardsFromLogId downwards
-                if ((long)DBExecuteScalar(conn, "SELECT COUNT(*) FROM Logs") == 0)
+                if ((long)db.ExecuteScalar("SELECT COUNT(*) FROM Logs") == 0)
                 {
-                    UpdateSavedParameter(conn, "SyncBackwardsFromLogId", lastSyncedLogId);
+                    UpdateSavedParameter(db, "SyncBackwardsFromLogId", lastSyncedLogId);
                 }
 
                 // If there are logs on the server then ensure that the log autoincrement value is set to the last
                 // log ID received by the server so new local logs don't clash with existing log entries on the server.
                 if (lastSyncedLogId != 0)
                 {
-                    lock (Globals.DBWriteLock)
+                    lock (db.WriteLock)
                     {
-                        using (var trans = conn.BeginTransaction())
+                        using (var trans = db.BeginTransaction())
                         {
-                            using (var command = new SQLiteCommand(conn))
+                            using (var command = db.CreateCommand(trans, new SQLiteParameter("@Id", lastSyncedLogId)))
                             {
-                                command.Transaction = trans;
-                                command.Parameters.AddWithValue("@Id", lastSyncedLogId);
-
                                 command.CommandText = "UPDATE sqlite_sequence SET seq=CASE WHEN IFNULL(seq, 0)<@Id THEN @Id ELSE seq END WHERE name='Logs'";
                                 if (command.ExecuteNonQuery() == 0)
                                 {
                     }
                 }
 
-                UpdateSavedParameter(conn, "LoggingInitialised", true);
+                UpdateSavedParameter(db, "LoggingInitialised", true);
             }
         }
 
             const int vendorEventPageSize = 1000;
             const int retryInterval = 30000;
 
-            var conn = Globals.DBConnection;
-            //using (var conn = OpenDBConnection())
+            var db = Globals.DB;
+            //using (var db = OpenDBConnection())
             {
                 bool cancelled = false;
-                int maxRemoteId = GetSavedParameterAsInt(conn, "SyncBackwardsFromLogId");
+                int maxRemoteId = GetSavedParameterAsInt(db, "SyncBackwardsFromLogId");
                 while (!cancelled && (maxRemoteId > 0))
                 {
                     var EventPage = new Page<VendorEvent>();
                     if (RESTRequest(ref EventPage, String.Format("/api/vendorevents/?maxRemoteId={0}&pageSize={1}", maxRemoteId, vendorEventPageSize)))
                     {
-                        lock (Globals.DBWriteLock)
+                        lock (db.WriteLock)
                         {
-                            using (var trans = conn.BeginTransaction())
+                            using (var trans = db.BeginTransaction())
                             {
-                                using (var insertCommand = new SQLiteCommand(
+                                using (var insertCommand = db.CreateCommand(
                                     "INSERT INTO Logs (Id,  UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
                                               "VALUES (@id, @userid, @voucherid, @eventdate, @eventtype, @retry)",
-                                    conn, trans))
-                                using (var updateCommand = new SQLiteCommand(
-                                    "UPDATE Parameters SET Value=@Value WHERE Key='SyncBackwardsFromLogId'",
-                                    conn, trans))
+                                    trans))
+                                using (var updateCommand = db.CreateCommand(
+                                    "UPDATE Parameters SET Value=@Value WHERE Key='SyncBackwardsFromLogId'", trans))
                                 {
                                     foreach (VendorEvent Event in EventPage.Items)
                                     {
             const int uploadPageSize = 1000;
             var retryInterval = 30000;
 
-            var conn = Globals.DBConnection;
-            //using (var conn = OpenDBConnection())
+            var db = Globals.DB;
+            //using (var db = OpenDBConnection())
             {
                 var cancelled = false;
                 while (! cancelled)
                     var uploadFailed = false;
                     int lastSyncedLogId = GetLastSyncedLogID();
 
-                    var result = DBExecuteScalar(conn, "SELECT MAX(Id) FROM Logs")?.ToString() ?? "0";
+                    var result = db.ExecuteScalar("SELECT MAX(Id) FROM Logs")?.ToString() ?? "0";
                     if (string.IsNullOrWhiteSpace(result))
                     {
                         result = "0";
                     {
                         List<RemoteVendorEvent> eventList = new List<RemoteVendorEvent>();
                         int counter = 0;
-                        using (var Command = new SQLiteCommand("Select Id,UserId,VoucherId,EventDate,EventType From Logs WHERE Id > @id", conn))
+                        using (var Command = db.CreateCommand("Select Id,UserId,VoucherId,EventDate,EventType From Logs WHERE Id > @id",
+                            new SQLiteParameter("@id", lastSyncedLogId)))
                         {
-                            Command.Parameters.AddWithValue("@id", lastSyncedLogId);
                             using (SQLiteDataReader read = Command.ExecuteReader())
                             {
                                 while (read.Read())
                                 if (counter > 0)
                                 {
                                     var response = new RemoteVendorEventResponse();
-                                    if (! RESTRequest(eventList, ref response, "/api/vendorevents/"))
+                                    if (!RESTRequest(eventList, ref response, "/api/vendorevents/"))
                                     {
                                         uploadFailed = true;
                                     }
             }
         }
 
-        public static void LogBulkEvents(SQLiteConnection conn, List<EventLog> EventLogs)
+        public static void LogBulkEvents(DBHelper db, List<EventLog> EventLogs)
         {
             string Sql = "INSERT INTO Logs (UserId, VoucherId, EventDate, EventType, Retry) VALUES (@userid, @voucherid, @eventdate, @eventtype, @retry)";
 
-            lock (Globals.DBWriteLock)
+            lock (db.WriteLock)
             {
-                using (var trans = conn.BeginTransaction())
+                using (var trans = db.BeginTransaction())
                 {
-                    using (var Command = new SQLiteCommand(Sql, conn, trans))
+                    using (var Command = db.CreateCommand(Sql, trans))
                     {
                         foreach (var EventLog in EventLogs)
                         {
             }
         }
 
-        public static void LogEvent(SQLiteConnection conn, VendorEvent.VendorEventType EventType, int? VoucherId = null, bool Retry = false)
+        public static void LogEvent(DBHelper db, VendorEvent.VendorEventType EventType, int? VoucherId = null, bool Retry = false)
         {
-            DBExecuteNonQuery(conn,
+            db.ExecuteNonQuery(
                 "INSERT INTO Logs (UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
                           "VALUES (@userid, @voucherid, @eventdate, @eventtype, @retry)",
                 new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id),
             }
         }
 
-        private static void SaveCurrentUserUsage(SQLiteConnection conn) {
-            DBExecuteNonQuery(conn,
+        private static void SaveCurrentUserUsage(DBHelper db) {
+            db.ExecuteNonQuery(
                 "DELETE FROM AccessControlTracking WHERE UserID = @userid",
                 new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id));
 
-            DBExecuteNonQuery(conn,
+            db.ExecuteNonQuery(
                 "INSERT INTO AccessControlTracking (UserID, Date, Permission, CurrentUsage) VALUES " +
                     "(@userid, datetime('now'), 'OfflinePrint', @offlineprintvalue)," +
                     "(@userid, datetime('now'), 'OfflineReprint', @offlinereprintvalue)," +
                 new SQLiteParameter("@bulkexport", Globals.UserCurrentUsage.BulkExportValue));
         }
 
-        public static void AddUserUsage(SQLiteConnection conn, UserLimits.UserLimitTypes UserLimitType, decimal Value) {
+        public static void AddUserUsage(DBHelper db, UserLimits.UserLimitTypes UserLimitType, decimal Value) {
             DateTime ServerDate = Globals.SessionData.Credentials.Payload.Date;
             DateTime Today = DateTime.Now;
             if (ServerDate.Date != Today.Date) //prevent system time tampering
             }
 
             //Immediately write to db to avoid cheating
-            SaveCurrentUserUsage(conn);
+            SaveCurrentUserUsage(db);
         }
 
         public static Boolean IsValueWithinRemainingUserLimit(UserLimits.UserLimitTypes UserLimitType, decimal Value) {
             return 0;
         }
 
-        private static int GetVoucherPrintCountFromLogs(SQLiteConnection conn, int VoucherId)
+        private static int GetVoucherPrintCountFromLogs(DBHelper db, int VoucherId)
         {
-            return int.Parse(DBExecuteScalar(conn,
+            return int.Parse(db.ExecuteScalar(
                 "SELECT COUNT(*) FROM Logs WHERE VoucherId=@voucherid AND EventType=@eventtype",
                 new SQLiteParameter("@voucherid", VoucherId),
                 new SQLiteParameter("@eventtype", (int)VendorEvent.VendorEventType.PrintVoucher)).ToString());
         }
 
-        private static DateTime GetVoucherFirstPrintDateFromLogs(SQLiteConnection conn, int VoucherId)
+        private static DateTime GetVoucherFirstPrintDateFromLogs(DBHelper db, int VoucherId)
         {
-            return (DateTime)DBExecuteScalar(conn,
+            return (DateTime)db.ExecuteScalar(
                 "SELECT MIN(EventDate) FROM Logs WHERE VoucherId=@voucherid AND EventType=@eventtype",
                 new SQLiteParameter("@voucherid", VoucherId),
                 new SQLiteParameter("@eventtype", (int)VendorEvent.VendorEventType.PrintVoucher));
         }
 
-        private static decimal GetVoucherFaceValue(SQLiteConnection conn, int VoucherId)
+        private static decimal GetVoucherFaceValue(DBHelper db, int VoucherId)
         {
-            return (decimal)DBExecuteScalar(conn,
+            return (decimal)db.ExecuteScalar(
                 "SELECT b.FaceValue FROM Voucher v LEFT JOIN Batch b on v.BatchId = b.Id WHERE v.Id=@voucherid",
                 new SQLiteParameter("@voucherid", VoucherId));
         }
 
 
-        private static UserLimits CalculateUsageFromLogs(SQLiteConnection conn) {
+        private static UserLimits CalculateUsageFromLogs(DBHelper db) {
             UserLimits CalculateUsage = new UserLimits();
             CalculateUsage.OfflinePrintValue = 0;
             CalculateUsage.OfflineReprintValue = 0;
             var CurrentDate = DateTime.Today.Date;
             CultureInfo IVC = CultureInfo.InvariantCulture;
             string Sql = "SELECT VoucherId FROM Logs WHERE UserId=@userid AND EventDate BETWEEN @eventdatea AND @eventdateb AND EventType=@eventtype";
-            using (var Command = new SQLiteCommand(Sql, conn))
+            using (var Command = db.CreateCommand(Sql,
+                new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id),
+                new SQLiteParameter("@eventdatea", CurrentDate.ToString("yyyy-MM-dd 00:00:00", IVC)),
+                new SQLiteParameter("@eventdateb", CurrentDate.ToString("yyyy-MM-dd 23:59:59", IVC)),
+                new SQLiteParameter("@eventtype", (int)VendorEvent.VendorEventType.PrintVoucher)))
             {
-                Command.Parameters.AddWithValue("@userid", Globals.SessionData.Credentials.Payload.User.Id);
-                Command.Parameters.AddWithValue("@eventdatea", CurrentDate.ToString("yyyy-MM-dd 00:00:00", IVC));
-                Command.Parameters.AddWithValue("@eventdateb", CurrentDate.ToString("yyyy-MM-dd 23:59:59", IVC));
-                Command.Parameters.AddWithValue("@eventtype", (int)VendorEvent.VendorEventType.PrintVoucher);
                 int VoucherId;
                 decimal VoucherFaceValue;
                 using (SQLiteDataReader read = Command.ExecuteReader())
                     while (read.Read())
                     {
                         VoucherId = read.GetInt32(0);
-                        VoucherFaceValue = GetVoucherFaceValue(conn, VoucherId);
+                        VoucherFaceValue = GetVoucherFaceValue(db, VoucherId);
                         //Don't distinguish between online and offline usage for log recalculations
                         CalculateUsage.OfflinePrintValue += VoucherFaceValue;
                         CalculateUsage.OnlinePrintValue += VoucherFaceValue;
-                        if (GetVoucherPrintCountFromLogs(conn, VoucherId) > 1)
+                        if (GetVoucherPrintCountFromLogs(db, VoucherId) > 1)
                         { //For reprinted vouchers just assume all prints were reprints - log recalculations should be stricter to prevent cheating
                             CalculateUsage.OfflineReprintValue += VoucherFaceValue;
                             CalculateUsage.OnlineReprintValue += VoucherFaceValue;
             return CalculateUsage;
         }
 
-        public static void InitialiseUserLimits(SQLiteConnection conn)
+        public static void InitialiseUserLimits(DBHelper db)
         {
             Globals.UserCurrentUsage = new UserLimits();
             UserLimits CurrentUserLimits = new UserLimits();
 
-            int Result = int.Parse(DBExecuteScalar(conn,
+            int Result = int.Parse(db.ExecuteScalar(
                 "SELECT COUNT(*) FROM AccessControlTracking WHERE UserID = @userid",
                 new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id)).ToString());
 
-            object ResultDate = DBExecuteScalar(conn,
+            object ResultDate = db.ExecuteScalar(
                 "SELECT Date FROM AccessControlTracking WHERE UserID = @userid",
                 new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id));
 
             }
             if (DatePassed)
             { //Fresh day since last db write or data missing - fetch usage from logs incase of tampering
-                Globals.UserCurrentUsage = CalculateUsageFromLogs(conn);
-                SaveCurrentUserUsage(conn); //Immediately write calculated usage to DB
+                Globals.UserCurrentUsage = CalculateUsageFromLogs(db);
+                SaveCurrentUserUsage(db); //Immediately write calculated usage to DB
             }
             else
             {
                 if (Result == 6)
                 {
                     var Sql = "SELECT UserID, Permission, CurrentUsage FROM AccessControlTracking WHERE UserID = @userid";
-                    using (var Command = new SQLiteCommand(Sql, conn))
+                    using (var Command = db.CreateCommand(Sql,
+                        new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id)))
                     {
-                        Command.Parameters.AddWithValue("@userid", Globals.SessionData.Credentials.Payload.User.Id);
                         using (SQLiteDataReader read = Command.ExecuteReader())
                         {
                             while (read.Read())
                 }
                 else
                 {
-                    Globals.UserCurrentUsage = CalculateUsageFromLogs(conn);
-                    SaveCurrentUserUsage(conn); //Immediately write calculated usage to DB
+                    Globals.UserCurrentUsage = CalculateUsageFromLogs(db);
+                    SaveCurrentUserUsage(db); //Immediately write calculated usage to DB
                 }
             }
         }
 
-        public static int GetNumberOfUnprintedVouchersInRange(SQLiteConnection conn, int StartSeqNo, int EndSeqNo, int BatchId) {
+        public static int GetNumberOfUnprintedVouchersInRange(DBHelper db, int StartSeqNo, int EndSeqNo, int BatchId) {
             int UnprintedVouchers = 0;
             int VoucherId;
             string Sql = "SELECT Id FROM Voucher WHERE SequenceNumber=@sequencenumber AND BatchId=@batchid";
-            using (var Command = new SQLiteCommand(Sql, conn))
+            using (var Command = db.CreateCommand(Sql))
             {
                 for (int SeqNo = StartSeqNo; SeqNo <= EndSeqNo; SeqNo++)
                 {
                     Command.Parameters.AddWithValue("@sequencenumber", SeqNo);
                     Command.Parameters.AddWithValue("@batchid", BatchId);
                     VoucherId = int.Parse(Command.ExecuteScalar().ToString());
-                    int NumPrintedVouchers = GetVoucherPrintCountFromLogs(conn, VoucherId);
+                    int NumPrintedVouchers = GetVoucherPrintCountFromLogs(db, VoucherId);
                     if (NumPrintedVouchers == 0)
                     {
                         UnprintedVouchers++;

BulkPrinting/BulkPrinting/VoucherForm.cs

 
         private void btnSearch_Click(object sender, EventArgs e)
         {
-            using (var Command = new SQLiteCommand(Globals.DBConnection))
+            using (var Command = Globals.DB.CreateCommand())
             {
                 if (rdoPrintDate.Checked)
                 {