Add log summarisation functionality so that we can avoid so many queries on the entire Logs table.

Speed up PopulateGrid() dramatically by making use of summarised log information.
Add SIMULATE_HDD_SERIAL conditional compilation blocks.
Fix 'Retry' log field not being uploaded to server.
Better HTTP error handling.

BulkPrinting/BulkPrinting/BatchDownloader.cs

 
         private DBHelper _db;
         private Action _refreshAction;
+        private Action _downloadLogSummarisationAction;
         private bool _checkForNewBatches;
 
-        public BatchDownloader(DBHelper db, Action refreshAction)
+        public BatchDownloader(DBHelper db, Action refreshAction, Action downloadedLogSummarisationAction)
         {
             _db = db;
             _refreshAction = refreshAction;
+            _downloadLogSummarisationAction = downloadedLogSummarisationAction;
         }
 
         public void CheckForNewBatches()
             {
                 if (Globals.SessionMode == SessionModes.Online)
                 {
+                    var gotErrors = false;
+
                     Log.Debug("Checking for downloads");
 
                     // Check for new batches if required.
                             else
                             {
                                 // Error, so leave skipNewBatchCheck unchanged.
+                                gotErrors = true;
                                 break;
                             }
 
                     }
                     catch (Exception e)
                     {
+                        gotErrors = true;
                         Log.Error(e, "Error while downloading batch list");
                     }
 
-                    // TODO: throttle or detect changes better
+                    // TODO: throttle
                     if (!isCancelled && doRefresh)
                     {
                         doRefresh = false;
 
                                             doRefresh = true;
                                         }
-                                        // else retry later
+                                        else
+                                        {
+                                            gotErrors = true;
+                                        }
                                     }
                                     catch (Exception e)
                                     {
+                                        gotErrors = true;
                                         Log.Error(e, "Error while downloading vouchers for batch {0}", batchId);
                                     }
 
-                                    /* TODO: throttle or detect changes better
+                                    // TODO: throttle
                                     if (!isCancelled && doRefresh)
                                     {
                                         doRefresh = false;
                                         _refreshAction();
                                     }
-                                    */
 
                                     lock(_lock)
                                     {
                     }
                     catch (Exception e)
                     {
+                        gotErrors = true;
                         Log.Error(e, "Error while downloading vouchers");
                     }
 
-                    // TODO: throttle or detect changes better
-                    if (!isCancelled && doRefresh)
+                    if (! isCancelled && ! gotErrors)
                     {
-                        doRefresh = false;
-                        _refreshAction();
+                        Log.Debug("Up to date");
+
+                        // If we weren't cancelled and didn't get any errors then we should be synchronised with the server,
+                        // so it is now safe to summarise any downloaded logs as the corresponding batches and vouchers should
+                        // all be present.
+                        _downloadLogSummarisationAction();
                     }
                 }
                 else

BulkPrinting/BulkPrinting/BatchForm.cs

     public partial class BatchForm : ObservedForm
     {
         private BatchDownloader BatchDownloader;
+        private DownloadedLogSummariser DownloadedLogSummariser;
 
         public BatchForm()
         {
 
         public void PopulateGrid()
         {
-            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 = Globals.DB.CreateCommand(Sql,
-                new SQLiteParameter("@printevent", VendorEvent.VendorEventType.PrintVoucher),
-                new SQLiteParameter("@exportevent", VendorEvent.VendorEventType.ExportVoucher)))
-            {
-                using (SQLiteDataReader read = Command.ExecuteReader())
-                {
-                    while (read.Read())
-                    {
-                        int BatchId = int.Parse(read["BatchId"].ToString());
-                        if (!BatchEvents.ContainsKey(BatchId))
-                        {
-                            BatchEvents.Add(BatchId, new BatchEvent());
-                        }
-                        if (read["EventType"].ToString() == "6")
-                        {
-                            if (read["Retry"].ToString() == "True")
-                            {
-                                BatchEvents[BatchId].ReprintCount += int.Parse(read["Total"].ToString());
-                            }
-                            else
-                            {
-                                BatchEvents[BatchId].PrintCount += int.Parse(read["Total"].ToString());
-                            }
-                        }
-                        else if (read["EventType"].ToString() == "8")
-                        {
-                            BatchEvents[BatchId].ExportCount += int.Parse(read["Total"].ToString());
-                        }
-                    }
-                }
-            }
             bool CanOrder = Utility.CheckUserAccess(Utility.UserPermissions.BulkOrder);
             bool CanExport = Utility.CheckUserAccess(Utility.UserPermissions.BulkExport);
             dgvBatches.Rows.Clear();
             dgvBatches.Columns.Add("Downloaded", "Downloaded");
             dgvBatches.Columns.Add("PrintedQuantity", "Quantity Printed");
             if (CanExport) dgvBatches.Columns.Add("Exported", "Exported Batch");
-            Sql = "Select Id,OrderDate,OrderReference,InternalReference,NetworkName,ProductDescription,VoucherType,FaceValue,RequestedQuantity,DeliveredQuantity,ReadyForDownload,Downloaded From Batch WHERE OrderDate BETWEEN @startdate AND @enddate";
+            var Sql = "Select Id,OrderDate,OrderReference,InternalReference,NetworkName,ProductDescription,VoucherType,FaceValue,RequestedQuantity,DeliveredQuantity,ReadyForDownload,Downloaded,PrintCount,ReprintCount,ExportCount,ReExportCount From Batch WHERE OrderDate BETWEEN @startdate AND @enddate";
 
             //Sql = "Select Id,OrderDate,OrderReference,InternalReference,NetworkName,ProductDescription,VoucherType,FaceValue,RequestedQuantity,DeliveredQuantity,ReadyForDownload,Downloaded,(SELECT COUNT(*) FROM Voucher WHERE Voucher.BatchId=Batch.Id) AS VoucherCount From Batch WHERE OrderDate BETWEEN @startdate AND @enddate";
             //dgvBatches.Columns.Add("VoucherCount", "Voucher Count");
 
-
             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)),
                     while (read.Read())
                     {
                         int BatchId = int.Parse(read["Id"].ToString());
-                        if (!BatchEvents.ContainsKey(BatchId))
-                        { //For batches with no events
-                            BatchEvents.Add(BatchId, new BatchEvent());
-                        }
                         int DeliveredQuantity = int.Parse(read["DeliveredQuantity"].ToString());
+                        int PrintCount = (int)read["PrintCount"];
+                        int ReprintCount = (int)read["ReprintCount"];
+                        int ExportCount = (int)read["ExportCount"];
+                        int ReExportCount = (int)read["ReExportCount"];
+
 
                         //Filters to exclude rows that don't match
                         if (rdoFilterPrinted.Checked)
                         {
-                            if (BatchEvents[BatchId].PrintCount == 0)
+                            if (PrintCount == 0)
                             {
                                 continue;
                             }
                         }
                         if (rdoFilterUnprinted.Checked)
                         {
-                            if (BatchEvents[BatchId].PrintCount >= DeliveredQuantity)
+                            if (PrintCount >= DeliveredQuantity)
                             {
                                 continue;
                             }
                         }
                         if (rdoFilterReprinted.Checked)
                         {
-                            if (BatchEvents[BatchId].ReprintCount == 0)
+                            if (ReprintCount == 0)
                             {
                                 continue;
                             }
                         }
                         if (rdoFilterExported.Checked)
                         {
-                            if (BatchEvents[BatchId].ExportCount == 0)
+                            if (ExportCount == 0)
                             {
                                 continue;
                             }
                         }
                         else
                         {
-                            if (BatchEvents[BatchId].ExportCount > 0)
+                            if (ExportCount > 0)
                             {
                                 continue;
                             }
                             BatchRow.Add(((bool)read["ReadyForDownload"] == true ? "Yes" : "No"));
 
                         BatchRow.Add((bool)read["Downloaded"] ? "Yes" : "No");
-                        BatchRow.Add((object)BatchEvents[BatchId].PrintCount);
+                        BatchRow.Add(PrintCount);
 
                         if (CanExport)
-                            BatchRow.Add((BatchEvents[BatchId].ExportCount > 0 ? "Exported" : ""));
+                            BatchRow.Add(ExportCount > 0 ? "Exported" : "");
 
                         //BatchRow.Add(read["VoucherCount"]);
 
             Globals.OpenBatches = new List<int>();
 
             var hwnd = new System.Runtime.InteropServices.HandleRef(this, Handle);
-            BatchDownloader = new BatchDownloader(Globals.DB, () =>
-            {
-                // DO NOT use Invoke as this can cause a deadlock if we are attempting to join the BatchDownloader after a cancel.
-                // Also, use PostMessage rather than SendMessage as PostMessage doesn't wait for the message to be processed and
-                // therefore won't block.
-                Utility.PostMessage(hwnd, Utility.WM_USER, IntPtr.Zero, IntPtr.Zero);
-            });
+            BatchDownloader = new BatchDownloader(
+                Globals.DB,
+                () =>
+                {
+                    // Refresh grid
+
+                    // DO NOT use Invoke as this can cause a deadlock if we are attempting to join the BatchDownloader after a cancel.
+                    // Also, use PostMessage rather than SendMessage as PostMessage doesn't wait for the message to be processed and
+                    // therefore won't block.
+                    Utility.PostMessage(hwnd, Utility.WM_USER, IntPtr.Zero, IntPtr.Zero);
+                },
+                () =>
+                {
+                    // Trigger download log summarisation
+                    Utility.PostMessage(hwnd, Utility.WM_USER + 1, IntPtr.Zero, IntPtr.Zero);
+                });
             BatchDownloader.Start();
 
             Utility.InitialiseUserLimits(Globals.DB);
                 PopulateGrid();
                 return;
             }
+            else if (m.Msg == Utility.WM_USER + 1)
+            {
+                TriggerDownloadedLogSummarisation();
+                return;
+            }
             base.WndProc(ref m);
         }
 
+        private void TriggerDownloadedLogSummarisation()
+        {
+            if (DownloadedLogSummariser == null)
+            {
+                var hwnd = new System.Runtime.InteropServices.HandleRef(this, Handle);
+
+                DownloadedLogSummariser = new DownloadedLogSummariser(
+                    Globals.DB,
+                    () =>
+                    {
+                        // Refresh grid
+
+                        // DO NOT use Invoke as this can cause a deadlock if we are attempting to join the BatchDownloader after a cancel.
+                        // Also, use PostMessage rather than SendMessage as PostMessage doesn't wait for the message to be processed and
+                        // therefore won't block.
+                        Utility.PostMessage(hwnd, Utility.WM_USER, IntPtr.Zero, IntPtr.Zero);
+                    });
+
+                DownloadedLogSummariser.Start();
+            }
+        }
+
         public void NewBatchAvailable()
         {
             BatchDownloader.CheckForNewBatches();
             if (BatchDownloader != null)
             {
                 BatchDownloader.Cancel();
+            }
+            if (DownloadedLogSummariser != null)
+            {
+                DownloadedLogSummariser.Cancel();
+            }
+
+            if (BatchDownloader != null)
+            {
                 BatchDownloader.Join();
             }
+            if (DownloadedLogSummariser != null)
+            {
+                DownloadedLogSummariser.Join();
+            }
 
             Utility.Logout();
         }

BulkPrinting/BulkPrinting/BulkPrinting.csproj

   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
     <DebugType>full</DebugType>
     <PlatformTarget>x86</PlatformTarget>
     <ErrorReport>prompt</ErrorReport>
     <Compile Include="BatchDownloader.cs" />
     <Compile Include="Configuration.cs" />
     <Compile Include="DBHelper.cs" />
+    <Compile Include="DownloadedLogSummariser.cs" />
     <Compile Include="ExportForm.cs">
       <SubType>Form</SubType>
     </Compile>

BulkPrinting/BulkPrinting/DownloadedLogSummariser.cs

+using System;
+using System.Threading;
+
+namespace BulkPrinting
+{
+    public class DownloadedLogSummariser : ThreadHelper
+    {
+        private const int _retryInterval = 30000;
+
+        private DBHelper _db;
+        private Action _refreshAction;
+
+        public DownloadedLogSummariser(DBHelper db, Action refreshAction)
+        {
+            _db = db;
+            _refreshAction = refreshAction;
+        }
+
+        protected override void Run()
+        {
+            bool isCancelled = false;
+            while (!isCancelled)
+            {
+                bool doRefresh = false;
+
+                while (!isCancelled)
+                {
+                    lock (_db.WriteLock)
+                    {
+                        using (var trans = _db.BeginTransaction())
+                        {
+                            using (var selectCommand = _db.CreateCommand(
+                                "SELECT l.*, v.BatchId FROM Logs l " +
+                                    "LEFT JOIN Voucher v ON l.VoucherId=v.Id " +
+                                "WHERE Summarised=0 " +
+                                "LIMIT 1000",
+                                trans))
+                            using (var updateLogsCommand = _db.CreateCommand(
+                                "UPDATE Logs SET Summarised=1 WHERE Id=@Id"))
+                            using (var updateVoucherCommand = Utility.CreateVoucherEventCountUpdateCommand(_db, trans))
+                            using (var updateBatchCommand = Utility.CreateBatchEventCountUpdateCommand(_db, trans))
+                            {
+                                updateLogsCommand.Parameters.AddWithValue("@Id", null);
+
+                                using (var reader = selectCommand.ExecuteReader())
+                                {
+                                    var rowCount = 0;
+                                    while (reader.Read())
+                                    {
+                                        rowCount++;
+                                        doRefresh = true;
+
+                                        int printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta;
+                                        if ((reader["VoucherId"] != null) &&
+                                            Utility.CalculateEventCountDeltas(
+                                            (VendorEvent.VendorEventType)int.Parse((string)reader["EventType"]),
+                                            (bool)reader["Retry"],
+                                            out printCountDelta,
+                                            out reprintCountDelta,
+                                            out exportCountDelta,
+                                            out reExportCountDelta))
+                                        {
+                                            Utility.ExecuteEventCountUpdateQuery(updateVoucherCommand, (int)reader["VoucherId"],
+                                                printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+
+                                            if (reader["BatchId"] != null)
+                                            {
+                                                Utility.ExecuteEventCountUpdateQuery(updateBatchCommand, (int)reader["BatchId"],
+                                                    printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+                                            }
+                                        }
+
+                                        var logId = (long)reader["Id"];
+
+                                        updateLogsCommand.Parameters["@Id"].Value = (int)logId;
+                                        updateLogsCommand.ExecuteNonQuery();
+                                    }
+
+                                    if (rowCount == 0)
+                                    {
+                                        break;
+                                    }
+                                }
+                            }
+
+                            trans.Commit();
+                        }
+                    }
+
+                    lock (_lock)
+                    {
+                        isCancelled = _cancelled;
+                    }
+                }
+
+                if (! isCancelled && doRefresh)
+                {
+                    doRefresh = false;
+                    _refreshAction();
+                }
+
+                // We sleep and try again on the offchance that we got triggered too early.
+                lock (_lock)
+                {
+                    if (!_cancelled)
+                    {
+                        Monitor.Wait(_lock, _retryInterval);
+                    }
+                    isCancelled = _cancelled;
+                }
+            }
+        }
+    }
+}

BulkPrinting/BulkPrinting/ExportForm.cs

                                         var ExportEvent = new EventLog();
                                         ExportEvent.EventType = VendorEvent.VendorEventType.ExportVoucher;
                                         ExportEvent.VoucherId = int.Parse(read["Id"].ToString());
+                                        ExportEvent.BatchId = ExportBatch.Id;
                                         ExportEvent.Retry = (read["Exports"].ToString() != "0");
                                         LogEvents.Add(ExportEvent);
                                     }

BulkPrinting/BulkPrinting/LogDownloader.cs

                         using (var trans = _db.BeginTransaction())
                         {
                             using (var insertCommand = _db.CreateCommand(
-                                "INSERT INTO Logs (Id,  UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
-                                          "VALUES (@id, @userid, @voucherid, @eventdate, @eventtype, @retry)",
+                                "INSERT INTO Logs (Id,  UserId,  VoucherId,  EventDate,  EventType,  Retry,  Summarised) " +
+                                          "VALUES (@id, @userid, @voucherid, @eventdate, @eventtype, @retry, 0)",
                                 trans))
                             using (var updateCommand = _db.CreateCommand(
                                 "UPDATE Parameters SET Value=@Value WHERE Key='SyncBackwardsFromLogId'", trans))

BulkPrinting/BulkPrinting/LogUploader.cs

                     List<RemoteVendorEvent> eventList = new List<RemoteVendorEvent>();
                     int counter = 0;
                     using (var Command = _db.CreateCommand(
-                        "Select Id,UserId,VoucherId,EventDate,EventType From Logs WHERE Id > @id",
+                        "Select Id,UserId,VoucherId,EventDate,EventType,Retry From Logs WHERE Id > @id",
                         new SQLiteParameter("@id", lastSyncedLogId)))
                     {
                         using (SQLiteDataReader read = Command.ExecuteReader())
                                 nextEvent.EventDate = read.GetDateTime(3);
                                 nextEvent.EventType = (VendorEvent.VendorEventType)Enum.Parse(typeof(VendorEvent.VendorEventType), read.GetValue(4).ToString());
                                 nextEvent.VendorId = Globals.SessionData.Credentials.Payload.Vendor.id;
+                                nextEvent.Retry = read.GetBoolean(5);
                                 eventList.Add(nextEvent);
 
                                 if (counter == _uploadPageSize)

BulkPrinting/BulkPrinting/Migrations.cs

 using System;
+using System.Data.SQLite;
 
 namespace BulkPrinting
 {
     class Migrations
     {
+        private delegate void PostMigrateDelegate(DBHelper db, SQLiteTransaction trans);
+
         public static void CheckMigrations(DBHelper db)
         {
             var result = db.ExecuteScalar("SELECT Value FROM Parameters WHERE Key = 'Migration'");
                 throw new Exception(String.Format("Invalid migration value: {0}", result));
             }
 
-            if (startingMigration > 3)
+            if (startingMigration > 4)
             {
                 throw new Exception("Database is for a newer version of this application. Please upgrade and try again.");
             }
             {
                 Migration3(db);
             }
+            if (startingMigration < 4)
+            {
+                Migration4(db);
+            }
             //Add further migration executions here - Migration = '1', '2', '3' etc
 
             return;
         }
 
-        private static bool ApplyMigrationQueries(DBHelper db, params string[] queries)
+        private static bool ApplyMigrationQueries(DBHelper db, PostMigrateDelegate postMigrate, params string[] queries)
         {
             lock (db.WriteLock)
             {
                             command.ExecuteNonQuery();
                         }
                     }
+                    postMigrate?.Invoke(db, trans);
                     trans.Commit();
                 }
             }
         public static bool InitialVersion(DBHelper db)
         {
             return ApplyMigrationQueries(
-                db,
+                db, null,
                 "CREATE TABLE Batch (" +
                     "Id INT," +
                     "OrderDate DATETIME," +
         public static bool Migration1(DBHelper db)
         {
             return ApplyMigrationQueries(
-                db,
+                db, null,
                 "ALTER TABLE Orders ADD COLUMN InternalReference VARCHAR(32)",
                 "ALTER TABLE Batch ADD COLUMN InternalReference VARCHAR(32)",
 
         public static bool Migration2(DBHelper db)
         {
             return ApplyMigrationQueries(
-                db,
+                db, null,
                 "ALTER TABLE Batch ADD COLUMN Downloaded BOOLEAN",
                 "CREATE UNIQUE INDEX Batch_Id ON Batch(Id)",
                 "CREATE INDEX Batch_OrderDate ON Batch(OrderDate)",
         public static bool Migration3(DBHelper db)
         {
             return ApplyMigrationQueries(
-                db,
+                db, null,
 
-                // Forgot to update the migration value initially, hence the 'NOT EXISTS'
-                "CREATE INDEX IF NOT EXISTS Logs_VoucherId_EventType_Id ON Logs(VoucherId, EventType, Id)",
+                "CREATE INDEX Logs_VoucherId_EventType_Id ON Logs(VoucherId, EventType, Id)",
 
                 // IMPORTANT
                 "UPDATE Parameters SET Value='3' WHERE Key='Migration'"
            );
         }
+
+        public static bool Migration4(DBHelper db)
+        {
+            return ApplyMigrationQueries(
+                db,
+                (db2, trans) =>
+                {
+                    using (var selectCommand = db2.CreateCommand(
+                        "SELECT l.*, v.BatchId FROM Logs l " +
+                            "INNER JOIN Voucher v ON l.VoucherId=v.Id",
+                        trans))
+                    using (var updateVoucherCommand = Utility.CreateVoucherEventCountUpdateCommand(db2, trans))
+                    using (var updateBatchCommand = Utility.CreateBatchEventCountUpdateCommand(db2, trans))
+                    {
+                        using (var reader = selectCommand.ExecuteReader())
+                        {
+                            while (reader.Read())
+                            {
+                                int printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta;
+                                if (Utility.CalculateEventCountDeltas(
+                                    (VendorEvent.VendorEventType)int.Parse((string)reader["EventType"]),
+                                    (bool)reader["Retry"],
+                                    out printCountDelta,
+                                    out reprintCountDelta,
+                                    out exportCountDelta,
+                                    out reExportCountDelta))
+                                {
+                                    Utility.ExecuteEventCountUpdateQuery(updateVoucherCommand, (int)reader["VoucherId"],
+                                        printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+
+                                    Utility.ExecuteEventCountUpdateQuery(updateBatchCommand, (int)reader["BatchId"],
+                                        printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+                                }
+                            }
+                        }
+                    }
+                },
+
+                "ALTER TABLE Logs ADD COLUMN Summarised BOOLEAN DEFAULT 0",
+                "CREATE INDEX Logs_Summarised_Id ON Logs(Summarised, Id)",
+                "UPDATE Logs SET Summarised=1",
+
+                "ALTER TABLE Batch ADD COLUMN PrintCount INT DEFAULT 0",
+                "ALTER TABLE Batch ADD COLUMN ReprintCount INT DEFAULT 0",
+                "ALTER TABLE Batch ADD COLUMN ExportCount INT DEFAULT 0",
+                "ALTER TABLE Batch ADD COLUMN ReExportCount INT DEFAULT 0",
+
+                "ALTER TABLE Voucher ADD COLUMN PrintCount INT DEFAULT 0",
+                "ALTER TABLE Voucher ADD COLUMN ReprintCount INT DEFAULT 0",
+                "ALTER TABLE Voucher ADD COLUMN ExportCount INT DEFAULT 0",
+                "ALTER TABLE Voucher ADD COLUMN ReExportCount INT DEFAULT 0",
+
+                // IMPORTANT
+                "UPDATE Parameters SET Value='4' WHERE Key='Migration'"
+           );
+        }
     }
 }

BulkPrinting/BulkPrinting/Models.cs

     public class EventLog {
         public VendorEvent.VendorEventType EventType { get; set; }
         public int? VoucherId { get; set; }
+        public int? BatchId { get; set; }
         public bool Retry { get; set; }
     }
 

BulkPrinting/BulkPrinting/Program.cs

 
             AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
 
+#if SIMULATE_HDD_SERIAL
+            Globals.HDDSerialNumber = "9VMTDFGX";
+#else
             Globals.HDDSerialNumber = Utility.GetHDDSerial();
+#endif
 
             Application.EnableVisualStyles();
             Application.SetCompatibleTextRenderingDefault(false);

BulkPrinting/BulkPrinting/Utility.cs

                 if (ex.Response != null)
                 {
                     var response = ex.Response;
-                    var stream = response.GetResponseStream();
-                    var reader = new StreamReader(stream);
-                    var message = reader.ReadToEnd();
-                    MaxException MaxError = JsonConvert.DeserializeObject<MaxException>(message);
-                    if (MaxError.Code != null)
+                    HttpStatusCode? status = (response as HttpWebResponse)?.StatusCode;
+                    if (status.HasValue && (status.Value == HttpStatusCode.InternalServerError))
                     {
-                        MessageBox.Show("Error " + MaxError.Code.ToString() + ": " + MaxError.Error, "Login Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                        var stream = response.GetResponseStream();
+                        var reader = new StreamReader(stream);
+                        var message = reader.ReadToEnd();
+                        MaxException MaxError = JsonConvert.DeserializeObject<MaxException>(message);
+                        if (MaxError.Code != null)
+                        {
+                            MessageBox.Show("Error " + MaxError.Code.ToString() + ": " + MaxError.Error, "Login Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                        }
+                        else
+                        {
+                            MessageBox.Show("Login Failed. Please try again.", "Login Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                        }
                     }
                     else
                     {
                     {
                         Result = default(R);
                     }
-                    else
+                    else if (status.HasValue && (status == HttpStatusCode.InternalServerError))
                     {
                         var stream = response.GetResponseStream();
                         var reader = new StreamReader(stream);
                         {
                             MessageBox.Show("Error " + MaxError.Code.ToString() + ": " + MaxError.Error, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                         }
+                        else
+                        {
+                            MessageBox.Show(MaxError.Error, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                        }
+                    }
+                    else
+                    {
+                        MessageBox.Show("The server encountered an unexpected error.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                     }
                 }
                 return false;
                                 var ExportEvent = new EventLog();
                                 ExportEvent.EventType = VendorEvent.VendorEventType.PrintVoucher;
                                 ExportEvent.VoucherId = PrintedVoucher.VoucherId;
+                                ExportEvent.BatchId = BatchId;
                                 ExportEvent.Retry = IsReprint;
                                 LogEvents.Add(ExportEvent);
                             }
 
         public static void TriggerLogDownload()
         {
+#if ! SIMULATE_HDD_SERIAL
             if (Globals.LogDownloader == null)
             {
                 Globals.LogDownloader = new LogDownloader(Globals.DB);
                 Globals.LogDownloader.Start();
             }
+#endif
         }
 
         public static void TriggerLogUpload()
         {
+#if ! SIMULATE_HDD_SERIAL
             if (Globals.LogUploader == null)
             {
                 Globals.LogUploader = new LogUploader(Globals.DB);
             {
                 Globals.LogUploader.TriggerUpload();
             }
+#endif
+        }
+
+        public static void CreateEventCountUpdateQueryParameters(SQLiteCommand command)
+        {
+            command.Parameters.AddWithValue("@Id", null);
+            command.Parameters.AddWithValue("@PrintCountDelta", null);
+            command.Parameters.AddWithValue("@ReprintCountDelta", null);
+            command.Parameters.AddWithValue("@ExportCountDelta", null);
+            command.Parameters.AddWithValue("@ReExportCountDelta", null);
+        }
+
+        public static void ExecuteEventCountUpdateQuery(SQLiteCommand command, int id,
+            int printCountDelta, int reprintCountDelta, int exportCountDelta, int reExportCountDelta)
+        {
+            command.Parameters["@Id"].Value = id;
+            command.Parameters["@PrintCountDelta"].Value = printCountDelta;
+            command.Parameters["@ReprintCountDelta"].Value = reprintCountDelta;
+            command.Parameters["@ExportCountDelta"].Value = exportCountDelta;
+            command.Parameters["@ReExportCountDelta"].Value = reExportCountDelta;
+            command.ExecuteNonQuery();
+        }
+
+        public static SQLiteCommand CreateVoucherEventCountUpdateCommand(DBHelper db, SQLiteTransaction trans)
+        {
+            var command = db.CreateCommand(
+                "UPDATE Voucher SET " +
+                    "PrintCount=PrintCount+@PrintCountDelta," +
+                    "ReprintCount=ReprintCount+@ReprintCountDelta," +
+                    "ExportCount=ExportCount+@ExportCountDelta," +
+                    "ReExportCount=ReExportCount+@ReExportCountDelta " +
+                "WHERE Id=@Id",
+                trans);
+            CreateEventCountUpdateQueryParameters(command);
+            return command;
+        }
+
+        public static bool CalculateEventCountDeltas(VendorEvent.VendorEventType eventType, bool retry,
+            out int printCountDelta, out int reprintCountDelta, out int exportCountDelta, out int reExportCountDelta)
+        {
+            printCountDelta = 0;
+            reprintCountDelta = 0;
+            exportCountDelta = 0;
+            reExportCountDelta = 0;
+
+            if (eventType == VendorEvent.VendorEventType.PrintVoucher)
+            {
+                if (retry)
+                {
+                    reprintCountDelta++;
+                }
+                else
+                {
+                    printCountDelta++;
+                }
+                return true;
+            }
+            else if (eventType == VendorEvent.VendorEventType.ExportVoucher)
+            {
+                if (retry)
+                {
+                    reExportCountDelta++;
+                }
+                else
+                {
+                    exportCountDelta++;
+                }
+                return true;
+            }
+            return false;
+        }
+
+        public static SQLiteCommand CreateBatchEventCountUpdateCommand(DBHelper db, SQLiteTransaction trans)
+        {
+            var command = db.CreateCommand(
+                "UPDATE Batch SET " +
+                    "PrintCount=PrintCount+@PrintCountDelta," +
+                    "ReprintCount=ReprintCount+@ReprintCountDelta," +
+                    "ExportCount=ExportCount+@ExportCountDelta," +
+                    "ReExportCount=ReExportCount+@ReExportCountDelta " +
+                "WHERE Id=@Id",
+                trans);
+            CreateEventCountUpdateQueryParameters(command);
+            return command;
         }
 
         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)";
+            string Sql = "INSERT INTO Logs (UserId,  VoucherId,  EventDate,  EventType,  Retry,  Summarised) " +
+                                   "VALUES (@userid, @voucherid, @eventdate, @eventtype, @retry, 1)";
 
             lock (db.WriteLock)
             {
                 using (var trans = db.BeginTransaction())
                 {
-                    using (var Command = db.CreateCommand(Sql, trans))
+                    using (var insertLogsCommand = db.CreateCommand(Sql, trans))
+                    using (var updateVoucherCommand = CreateVoucherEventCountUpdateCommand(db, trans))
+                    using (var updateBatchCommand = CreateBatchEventCountUpdateCommand(db, trans))
                     {
                         foreach (var EventLog in EventLogs)
                         {
-                            Command.Parameters.Clear();
-                            Command.Parameters.AddWithValue("@userid", Globals.SessionData.Credentials.Payload.User.Id);
-                            Command.Parameters.AddWithValue("@voucherid", EventLog.VoucherId);
-                            Command.Parameters.AddWithValue("@eventdate", DateTime.UtcNow);
-                            Command.Parameters.AddWithValue("@eventtype", EventLog.EventType);
-                            Command.Parameters.AddWithValue("@retry", EventLog.Retry);
-                            Command.ExecuteNonQuery();
+                            insertLogsCommand.Parameters.Clear();
+                            insertLogsCommand.Parameters.AddWithValue("@userid", Globals.SessionData.Credentials.Payload.User.Id);
+                            insertLogsCommand.Parameters.AddWithValue("@voucherid", EventLog.VoucherId);
+                            insertLogsCommand.Parameters.AddWithValue("@eventdate", DateTime.UtcNow);
+                            insertLogsCommand.Parameters.AddWithValue("@eventtype", EventLog.EventType);
+                            insertLogsCommand.Parameters.AddWithValue("@retry", EventLog.Retry);
+                            insertLogsCommand.ExecuteNonQuery();
+
+                            if (EventLog.VoucherId.HasValue)
+                            {
+                                if (! EventLog.BatchId.HasValue)
+                                {
+                                    throw new Exception("Event log entry is missing a batch ID");
+                                }
+
+                                int printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta;
+                                if (CalculateEventCountDeltas(
+                                    EventLog.EventType,
+                                    EventLog.Retry,
+                                    out printCountDelta,
+                                    out reprintCountDelta,
+                                    out exportCountDelta,
+                                    out reExportCountDelta))
+                                {
+                                    ExecuteEventCountUpdateQuery(updateVoucherCommand, EventLog.VoucherId.Value,
+                                        printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+
+                                    ExecuteEventCountUpdateQuery(updateBatchCommand, EventLog.BatchId.Value,
+                                        printCountDelta, reprintCountDelta, exportCountDelta, reExportCountDelta);
+                                }
+                            }
                         }
                     }
                     trans.Commit();
             }
         }
 
-        public static void LogEvent(DBHelper db, VendorEvent.VendorEventType EventType, int? VoucherId = null, bool Retry = false)
+        public static void LogEvent(DBHelper db, VendorEvent.VendorEventType EventType)
         {
+            // Not for voucher-related events. If you add support for individual voucher events, please update print counts,
+            // etc., as in LogBulkEvents.
             db.ExecuteNonQuery(
-                "INSERT INTO Logs (UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
-                          "VALUES (@userid, @voucherid, @eventdate, @eventtype, @retry)",
+                "INSERT INTO Logs (UserId,  VoucherId,  EventDate,  EventType,  Retry,  Summarised) " +
+                          "VALUES (@userid, @voucherid, @eventdate, @eventtype, @retry, 1)",
                 new SQLiteParameter("@userid", Globals.SessionData.Credentials.Payload.User.Id),
-                new SQLiteParameter("@voucherid", VoucherId),
+                new SQLiteParameter("@voucherid", null),
                 new SQLiteParameter("@eventdate", DateTime.UtcNow),
                 new SQLiteParameter("@eventtype", EventType),
-                new SQLiteParameter("@retry", Retry));
+                new SQLiteParameter("@retry", false));
             if (Globals.SessionMode == SessionModes.Online)
             {
                 TriggerLogUpload();