Add re-export functionality.

BulkPrintingAPI/Controllers/BatchesController.cs

 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;
 
             return Ok(orderResponse);
         }
+
+        [HttpPost("{id}/a8a7b01e-9da9-4353-ad5c-f47d83d83065")]
+        public async Task<IActionResult> ReExportBatchAsync([FromRoute] int id)
+        {
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+
+            var batch = await BatchesForVendor(credentials.Vendor.Id)
+                .SingleOrDefaultAsync(m => m.Id == id);
+            if (batch == null)
+            {
+                return NotFound();
+            }
+            else
+            {
+                await _context.Database.ExecuteSqlCommandAsync("DELETE FROM [Vouchers] WHERE [BatchId]={0}",
+                    System.Threading.CancellationToken.None, id);
+
+                batch.ReadyForDownload = false;
+                await _context.SaveChangesAsync();
+
+                await MAX.Utils.ReExportBatchAsync(_clientFactory, _logger, credentials, id,
+                    Utils.AesDecryptBytes(credentials.Vendor.EncryptedVoucherKey, _dataEncryptionOptions.DefaultKey));
+            }
+            return Ok();
+        }
     }
 }

MAXClient/Client.cs

             }
         }
 
+
+        private string ExpectResponse(string response, string prefix)
+        {
+            if (response.StartsWith("ER"))
+            {
+                var parts = response.Split('|');
+                int errorCode;
+                if ((parts.Length < 2) || !int.TryParse(parts[1], out errorCode))
+                {
+                    errorCode = -1;
+                }
+                var message = parts.Length >= 3 ? parts[2] : String.Format("Malformed server error: {0}", response);
+                _logger.LogError("MAX Error for {0}: {1} (code {2})",
+                    LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber), message, errorCode);
+                throw new MAXException(errorCode, message);
+            }
+            else if (!response.StartsWith(prefix))
+            {
+                _logger.LogError("Invalid MAX response for {0}: {1}",
+                    LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber),
+                    response);
+                throw new Exception(String.Format("Invalid server response: {0}", response));
+            }
+            return response;
+        }
+
         public async Task<Account> GetAccountAsync()
         {
             await WriteMessageAsync(new MessageBuilder().Append("Acc")).ConfigureAwait(false);
             return catalogue;
         }
 
-        private void ThrowParseError(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;
 
         public int ReceiveTimeout { get; set; }
 
-        public int SendTimeout { get; set; }
-
-        private string ExpectResponse(string response, string prefix)
+        public async Task ReExportBatchAsync(int batchId, byte[] key)
         {
-            if (response.StartsWith("ER"))
-            {
-                var parts = response.Split('|');
-                int errorCode;
-                if ((parts.Length < 2) || ! int.TryParse(parts[1], out errorCode))
-                {
-                    errorCode = -1;
-                }
-                var message = parts.Length >= 3 ? parts[2] : String.Format("Malformed server error: {0}", response);
-                _logger.LogError("MAX Error for {0}: {1} (code {2})",
-                    LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber), message, errorCode);
-                throw new MAXException(errorCode, message);
-            }
-            else if (! response.StartsWith(prefix))
+            if (key.Length != 24)
             {
-                _logger.LogError("Invalid MAX response for {0}: {1}",
-                    LoginCredentials.Format(_userId, _username, _vendorId, _serialNumber),
-                    response);
-                throw new Exception(String.Format("Invalid server response: {0}", response));
+                throw new ArgumentException("24 byte key expected", nameof(key));
             }
-            return response;
+
+            await WriteMessageAsync(new MessageBuilder()
+                .Append("ReExport ")
+                .Append(Encrypt(new StringBuilder()
+                    .Append(batchId)
+                    .Append("|2|") // EncType: 0:None, 1:DES, 2:Triple DES
+                    .Append(BitConverter.ToString(key, 0, 8).Replace("-", ""))
+                    .Append("|")
+                    .Append(BitConverter.ToString(key, 8, 8).Replace("-", ""))
+                    .Append("|")
+                    .Append(BitConverter.ToString(key, 16, 8).Replace("-", ""))
+                    .ToString()))).ConfigureAwait(false);
+
+            ExpectResponse(Decrypt(await ReadMessageAsync().ConfigureAwait(false)), "OK");
+        }
+
+        public int SendTimeout { get; set; }
+
+        private void ThrowParseError(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 async Task WriteMessageAsync(MessageBuilder message)

MAXClient/Utils.cs

                     product, quantity, customerReference, internalReference, orderGuid, key).ConfigureAwait(false);
             }
         }
+
+        public static async Task ReExportBatchAsync(
+            ClientFactory clientFactory, ILogger logger, LoginCredentials credentials,
+            int batchId, byte[] key)
+        {
+            using (var client = clientFactory.GetClient(logger, credentials))
+            {
+                await client.ConnectAsync().ConfigureAwait(false);
+                await client.ReExportBatchAsync(batchId, key).ConfigureAwait(false);
+            }
+        }
     }
 }