Add ability to log all MAX responses.

Improve error logging on parse errors of MAX response parts.

BulkPrintingAPI/appsettings.Development.json

     "Port": 4006,
     "ConnectTimeout": 10000,
     "ReceiveTimeout": 10000,
-    "SendTimeout":  10000
+    "SendTimeout": 10000,
+    "LogResponses":  true
   }
 }

BulkPrintingAPI/appsettings.json

   "Logging": {
     "IncludeScopes": false,
     "LogLevel": {
-      "Default": "Warning"
+      "Default": "Debug"
     }
   },
   "TokenAuthentication": {

MAXClient/Client.cs

         private int _userId;
         private string _username;
         private string _password;
+        private bool _logResponses;
 
         private TcpClient _connection = null;
         private NetworkStream _connectionStream = null;
 
         private bool _disposed = false;
 
-        public Client(ILogger logger, string host, int port, int vendorId, string serialNumber, int userId, string username, string password)
+        public Client(ILogger logger, bool logResponses, string host, int port, int vendorId, string serialNumber, int userId, string username, string password)
         {
             _logger = logger;
             _host = host;
             _userId = userId;
             _username = username;
             _password = password;
+            _logResponses = logResponses;
 
             ConnectTimeout = 10000;
             ReceiveTimeout = 10000;
             SendTimeout = 10000;
         }
 
-        public Client(ILogger logger, string host, int port, LoginCredentials credentials)
-            : this(logger, host, port, credentials.Vendor.Id, credentials.Vendor.SerialNumber,
+        public Client(ILogger logger, bool logResponses, string host, int port, LoginCredentials credentials)
+            : this(logger, logResponses, host, port, credentials.Vendor.Id, credentials.Vendor.SerialNumber,
                   credentials.User.Id, credentials.User.Username, credentials.Password)
         {
         }
                 Username = _username,
                 FirstName = parts[4],
                 Surname = parts[3],
-                Enabled = bool.Parse(parts[6]),
-                Level = (User.UserLevel)int.Parse(parts[1]),
-                System = int.Parse(parts[2]),
-                LastLogin = DateTime.Parse(parts[5])
+                Enabled = ParseBool(parts[6], "User.Enabled(6)", response),
+                Level = (User.UserLevel)ParseInt(parts[1], "User.Level(1)", response),
+                System = ParseInt(parts[2], "User.System(2)", response),
+                LastLogin = ParseDateTime(parts[5], "User.LastLogin(5)", response)
             };
 
             if (user.Level == User.UserLevel.CustomUser)
             {
-                user.CanPrintOffline = bool.Parse(parts[7]);
-                user.OfflinePrintValue = decimal.Parse(parts[8]);
-                user.CanPrintOnline = bool.Parse(parts[9]);
-                user.OnlinePrintValue = decimal.Parse(parts[10]);
-                user.CanReprintOffline = bool.Parse(parts[11]);
-                user.OfflineReprintValue = decimal.Parse(parts[12]);
-                user.CanReprintOnline = bool.Parse(parts[13]);
-                user.OnlineReprintValue = decimal.Parse(parts[14]);
-                user.BulkExport = bool.Parse(parts[15]);
-                user.BulkExportMaxValue = decimal.Parse(parts[16]);
-                user.BulkOrder = bool.Parse(parts[17]);
-                user.BulkOrderMaxValue = decimal.Parse(parts[18]);
-                user.BulkViewPins = bool.Parse(parts[19]);
-                user.BulkReExport = bool.Parse(parts[20]);
+                user.CanPrintOffline = ParseBool(parts[7], "User.CanPrintOffline(7)", response);
+                user.OfflinePrintValue = ParseDecimal(parts[8], "User.OfflinePrintValue(8)", response);
+                user.CanPrintOnline = ParseBool(parts[9], "User.CanPrintOnline(9)", response);
+                user.OnlinePrintValue = ParseDecimal(parts[10], "User.OnlinePrintValue(10)", response);
+                user.CanReprintOffline = ParseBool(parts[11], "User.CanReprintOffline(11)", response);
+                user.OfflineReprintValue = ParseDecimal(parts[12], "User.OfflineReprintValue(12)", response);
+                user.CanReprintOnline = ParseBool(parts[13], "User.CanReprintOnline(13)", response);
+                user.OnlineReprintValue = ParseDecimal(parts[14], "User.OnlineReprintValue(14)", response);
+                user.BulkExport = ParseBool(parts[15], "User.BulkExport(15)", response);
+                user.BulkExportMaxValue = ParseDecimal(parts[16], "User.BulkExportMaxValue(16)", response);
+                user.BulkOrder = ParseBool(parts[17], "User.BulkOrder(17)", response);
+                user.BulkOrderMaxValue = ParseDecimal(parts[18], "User.BulkOrderMaxValue(18)", response);
+                user.BulkViewPins = ParseBool(parts[19], "User.BulkViewPins(19)", response);
+                user.BulkReExport = ParseBool(parts[20], "User.BulkReExport(20)", response);
             }
 
             return user;
 
         private string Decrypt(string cipherText)
         {
-            return Utils.TripleDESDecrypt(cipherText, _des);
+            var response = Utils.TripleDESDecrypt(cipherText, _des);
+            if (_logResponses)
+            {
+                _logger.LogDebug("Decrypted response for {0}: {1}", LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber), response);
+            }
+            return response;
         }
 
         private string Encrypt(string plainText)
             var parts = response.Split('|');
             return new Account()
             {
-                Id = int.Parse(parts[1]),
+                Id = ParseInt(parts[1], "Account.Id(1)", response),
                 Name = parts[2],
-                Balance = decimal.Parse(parts[3]),
-                Status = (Account.AccountStatus)int.Parse(parts[4]),
+                Balance = ParseDecimal(parts[3], "Account.Balance(3)", response),
+                Status = (Account.AccountStatus)ParseInt(parts[4], "Account.AccountStatus(4)", response),
                 Reference = parts[5],
                 Warehouse = new Warehouse()
                 {
-                    Id = int.Parse(parts[6]),
+                    Id = ParseInt(parts[6], "Account.Warehouse.Id(6)", response),
                     Name = parts[7]
                 }
             };
             var response = ExpectResponse(Decrypt(await ReadMessageAsync().ConfigureAwait(false)), "OK");
 
             var parts = response.Split('|');
-            var count = int.Parse(parts[1]);
+            var count = ParseInt(parts[1], "Products.Count(1)", response);
 
             var catalogue = new ProductCatalogue();
             
                 response = ExpectResponse(Decrypt(await ReadMessageAsync().ConfigureAwait(false)), "OK");
 
                 parts = response.Split('|');
-                int networkId = int.Parse(parts[4]);
+                int networkId = ParseInt(parts[4], "Product.NetworkId(4)", response);
                 Network network;
                 if (! catalogue.NetworkMap.TryGetValue(networkId, out network))
                 {
 
                 catalogue.AddProduct(
                     network: network,
-                    id: int.Parse(parts[1]),
-                    faceValue: decimal.Parse(parts[2]),
+                    id: ParseInt(parts[1], "Product.Id(1)", response),
+                    faceValue: ParseDecimal(parts[2], "Product.FaceValue(2)", response),
                     description: parts[3],
-                    voucherType: (Batch.Vouchertype)int.Parse(parts[6]),
-                    discountPercentage: decimal.Parse(parts[7])
+                    voucherType: (Batch.Vouchertype)ParseInt(parts[6], "Product.VoucherType(6)", response),
+                    discountPercentage: ParseDecimal(parts[7], "Product.DiscountPercentage(7)", response)
                 );
             }
 
             return catalogue;
         }
 
+        private bool LogParseError(string value, string valueName, string valueType, string fullResponse)
+        {
+            _logger.LogError(
+                "Failed to parse value: valueType={0} valueName={1} value={2} fullResponse={3} {4}",
+                valueType,
+                valueName,
+                value,
+                fullResponse,
+                LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber)
+            );
+            throw new Exception(String.Format("Invalid value for {0}", valueName));
+        }
+
+        private bool ParseBool(string value, string valueName, string fullResponse)
+        {
+            bool ret;
+            if (! bool.TryParse(value, out ret))
+            {
+                LogParseError(value, valueName, "bool", fullResponse);
+            }
+            return ret;
+        }
+
+        private DateTime ParseDateTime(string value, string valueName, string fullResponse)
+        {
+            DateTime ret;
+            if (!DateTime.TryParse(value, out ret))
+            {
+                LogParseError(value, valueName, "DateTime", fullResponse);
+            }
+            return ret;
+        }
+
+        private decimal ParseDecimal(string value, string valueName, string fullResponse)
+        {
+            decimal ret;
+            if (!decimal.TryParse(value, out ret))
+            {
+                LogParseError(value, valueName, "decimal", fullResponse);
+            }
+            return ret;
+        }
+
+        private int ParseInt(string value, string valueName, string fullResponse)
+        {
+            int ret;
+            if (!int.TryParse(value, out ret))
+            {
+                LogParseError(value, valueName, "int", fullResponse);
+            }
+            return ret;
+        }
+
         public async Task<OrderResponse> PlaceOrderAsync(int accountId, Product product, int quantity,
             string customerReference, string internalReference, Guid? orderGuid, byte[] key)
         {
             {
                 Batch = new Batch()
                 {
-                    Id = int.Parse(parts[1]),
+                    Id = ParseInt(parts[1], "Batch.Id(1)", response),
                     OrderReference = parts[2],
-                    RequestedQuantity = int.Parse(parts[3]),
-                    DeliveredQuantity = int.Parse(parts[4]),
-                    Cost = decimal.Parse(parts[5]),
+                    RequestedQuantity = ParseInt(parts[3], "Batch.RequestQuantity(3)", response),
+                    DeliveredQuantity = ParseInt(parts[4], "Batch.DeliveredQuantity(4)", response),
+                    Cost = ParseDecimal(parts[5], "Batch.Cost(5)", response),
                     InternalReference = internalReference,
                     OrderGuid = orderGuid,
                     AccountId = accountId,
                     OrderedById = _userId,
                     ReadyForDownload = false
                 },
-                RemainingBalance = decimal.Parse(parts[6])
+                RemainingBalance = ParseDecimal(parts[6], "Batch.RemainingBalance(6)", response)
             };
         }
 
             {
                 throw new Exception("Invalid message size");
             }
-            return Encoding.ASCII.GetString(await ReadBytesAsync(size).ConfigureAwait(false));
+            var response = Encoding.ASCII.GetString(await ReadBytesAsync(size).ConfigureAwait(false));
+            if (_logResponses)
+            {
+                _logger.LogDebug("Response for {0}: {1}", LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber), response);
+            }
+            return response;
         }
 
         public int ReceiveTimeout { get; set; }

MAXClient/ClientFactory.cs

         public Client GetClient(ILogger logger, int vendorId, string serialNumber, int userId,
             string username, string password)
         {
-            var client = new Client(logger, Host, Port, vendorId, serialNumber, userId,
+            var client = new Client(logger, LogResponses, Host, Port, vendorId, serialNumber, userId,
                 username, password);
             client.ConnectTimeout = ConnectTimeout;
             client.ReceiveTimeout = ReceiveTimeout;
 
         public Client GetClient(ILogger logger, LoginCredentials credentials)
         {
-            var client = new Client(logger, Host, Port, credentials);
+            var client = new Client(logger, LogResponses, Host, Port, credentials);
             client.ConnectTimeout = ConnectTimeout;
             client.ReceiveTimeout = ReceiveTimeout;
             client.SendTimeout = SendTimeout;
         public int ReceiveTimeout { get; set; }
 
         public int SendTimeout { get; set; }
+
+        public bool LogResponses { get; set; }
     }
 }