Add InternalReference field to batches and send it through when placing orders.

BulkPrintingAPI/Controllers/BatchesController.cs

             [Required]
             public string CustomerReference { get; set; }
 
+            [Required]
+            public string InternalReference { get; set; }
+
             public Guid? OrderGuid { get; set; }
         };
 
             }
 
             var orderResponse = await MAX.Utils.PlaceOrderAsync(_clientFactory, _logger,
-                credentials, product, order.Quantity, order.CustomerReference, order.OrderGuid,
+                credentials, product, order.Quantity, order.CustomerReference, order.InternalReference, order.OrderGuid,
                 Utils.AesDecryptBytes(credentials.Vendor.EncryptedVoucherKey,
                     _dataEncryptionOptions.DefaultKey));
 

BulkPrintingAPI/Migrations/20180111104438_AddInternalReference.Designer.cs

+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using MAX.Models;
+
+namespace BulkPrintingAPI.Migrations
+{
+    [DbContext(typeof(MAXContext))]
+    [Migration("20180111104438_AddInternalReference")]
+    partial class AddInternalReference
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+            modelBuilder
+                .HasAnnotation("ProductVersion", "1.1.2")
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("MAX.Models.Account", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<decimal>("Balance");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<string>("Reference")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<int>("Status");
+
+                    b.Property<int>("WarehouseId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("MAX.Models.Batch", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<int>("AccountId");
+
+                    b.Property<decimal>("Cost");
+
+                    b.Property<int>("DeliveredQuantity");
+
+                    b.Property<decimal>("DiscountPercentage");
+
+                    b.Property<decimal>("FaceValue");
+
+                    b.Property<string>("InternalReference")
+                        .HasMaxLength(32);
+
+                    b.Property<int>("NetworkId");
+
+                    b.Property<string>("NetworkName")
+                        .IsRequired()
+                        .HasMaxLength(20);
+
+                    b.Property<DateTimeOffset>("OrderDate");
+
+                    b.Property<Guid?>("OrderGuid");
+
+                    b.Property<string>("OrderReference")
+                        .IsRequired()
+                        .HasMaxLength(20);
+
+                    b.Property<int>("OrderedById");
+
+                    b.Property<string>("ProductDescription")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<int>("ProductId");
+
+                    b.Property<bool>("ReadyForDownload");
+
+                    b.Property<int>("RequestedQuantity");
+
+                    b.Property<int>("VendorId");
+
+                    b.Property<int>("VoucherType");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("OrderGuid")
+                        .IsUnique();
+
+                    b.HasIndex("ReadyForDownload", "OrderDate");
+
+                    b.ToTable("Batches");
+                });
+
+            modelBuilder.Entity("MAX.Models.User", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<int>("AccountId");
+
+                    b.Property<bool>("BulkExport");
+
+                    b.Property<decimal>("BulkExportMaxValue");
+
+                    b.Property<bool>("BulkOrder");
+
+                    b.Property<decimal>("BulkOrderMaxValue");
+
+                    b.Property<bool>("BulkReExport");
+
+                    b.Property<bool>("BulkViewPins");
+
+                    b.Property<bool>("CanPrintOffline");
+
+                    b.Property<bool>("CanPrintOnline");
+
+                    b.Property<bool>("CanReprintOffline");
+
+                    b.Property<bool>("CanReprintOnline");
+
+                    b.Property<bool>("Enabled");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<DateTimeOffset>("LastLogin");
+
+                    b.Property<int>("Level");
+
+                    b.Property<decimal>("OfflinePrintValue");
+
+                    b.Property<decimal>("OfflineReprintValue");
+
+                    b.Property<decimal>("OnlinePrintValue");
+
+                    b.Property<decimal>("OnlineReprintValue");
+
+                    b.Property<string>("Surname")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<int>("System");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("MAX.Models.Vendor", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<int>("AccountId");
+
+                    b.Property<byte[]>("EncryptedDatabasePassword")
+                        .IsRequired()
+                        .HasMaxLength(32);
+
+                    b.Property<byte[]>("EncryptedVoucherKey")
+                        .IsRequired()
+                        .HasMaxLength(32);
+
+                    b.Property<int?>("LastVendorEventRemoteId");
+
+                    b.Property<string>("SerialNumber")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Vendors");
+                });
+
+            modelBuilder.Entity("MAX.Models.VendorEvent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset>("EventDate");
+
+                    b.Property<int>("EventType");
+
+                    b.Property<int?>("RemoteId");
+
+                    b.Property<bool>("Retry");
+
+                    b.Property<int>("UserId");
+
+                    b.Property<int>("VendorId");
+
+                    b.Property<int?>("VoucherId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VendorId", "RemoteId")
+                        .IsUnique();
+
+                    b.ToTable("VendorEvents");
+                });
+
+            modelBuilder.Entity("MAX.Models.Voucher", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<int>("BatchId");
+
+                    b.Property<string>("EncryptedPIN")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.Property<DateTime>("ExpiryDate")
+                        .HasColumnType("Date");
+
+                    b.Property<int>("SequenceNumber");
+
+                    b.Property<string>("Serial")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BatchId", "SequenceNumber")
+                        .IsUnique();
+
+                    b.ToTable("Vouchers");
+                });
+
+            modelBuilder.Entity("MAX.Models.Warehouse", b =>
+                {
+                    b.Property<int>("Id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50);
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Warehouses");
+                });
+
+            modelBuilder.Entity("MAX.Models.Account", b =>
+                {
+                    b.HasOne("MAX.Models.Warehouse", "Warehouse")
+                        .WithMany("Accounts")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MAX.Models.Batch", b =>
+                {
+                    b.HasOne("MAX.Models.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MAX.Models.User", b =>
+                {
+                    b.HasOne("MAX.Models.Account", "Account")
+                        .WithMany("Users")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MAX.Models.Vendor", b =>
+                {
+                    b.HasOne("MAX.Models.Account", "Account")
+                        .WithMany("Vendors")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("MAX.Models.Voucher", b =>
+                {
+                    b.HasOne("MAX.Models.Batch", "Batch")
+                        .WithMany("Vouchers")
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+        }
+    }
+}

BulkPrintingAPI/Migrations/20180111104438_AddInternalReference.cs

+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BulkPrintingAPI.Migrations
+{
+    public partial class AddInternalReference : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "InternalReference",
+                table: "Batches",
+                maxLength: 32,
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "InternalReference",
+                table: "Batches");
+        }
+    }
+}

BulkPrintingAPI/Migrations/MAXContextModelSnapshot.cs

 
                     b.Property<decimal>("FaceValue");
 
+                    b.Property<string>("InternalReference")
+                        .HasMaxLength(32);
+
                     b.Property<int>("NetworkId");
 
                     b.Property<string>("NetworkName")

MAXClient/Client.cs

         }
 
         public async Task<OrderResponse> PlaceOrderAsync(int accountId, Product product, int quantity,
-            string customerReference, Guid? orderGuid, byte[] key)
+            string customerReference, string internalReference, Guid? orderGuid, byte[] key)
         {
             if (key.Length != 24)
             {
                     .Append(BitConverter.ToString(key, 8, 8).Replace("-", ""))
                     .Append("|")
                     .Append(BitConverter.ToString(key, 16, 8).Replace("-", ""))
+                    .Append("|")
+                    .Append(internalReference)
                     .ToString()))).ConfigureAwait(false);
 
             var response = Decrypt(await ReadMessageAsync().ConfigureAwait(false));
                         RequestedQuantity = int.Parse(parts[3]),
                         DeliveredQuantity = int.Parse(parts[4]),
                         Cost = decimal.Parse(parts[5]),
+                        InternalReference = internalReference,
                         OrderGuid = orderGuid,
                         AccountId = accountId,
                         VendorId = _vendorId,

MAXClient/Utils.cs

 
         public static async Task<OrderResponse> PlaceOrderAsync(
             ClientFactory clientFactory, ILogger logger, LoginCredentials credentials,
-            Product product, int quantity, string customerReference, Guid? orderGuid, byte[] key)
+            Product product, int quantity, string customerReference, string internalReference,
+            Guid? orderGuid, byte[] key)
         {
             using (var client = clientFactory.GetClient(logger, credentials))
             {
                         credentials.ToString()));
                 }
                 return await client.PlaceOrderAsync(credentials.User.AccountId,
-                    product, quantity, customerReference, orderGuid, key).ConfigureAwait(false);
+                    product, quantity, customerReference, internalReference, orderGuid, key).ConfigureAwait(false);
             }
         }
     }

MAXData/Models/Batch.cs

         [Required, MaxLength(20)]
         public string OrderReference { get; set; }
 
+        [MaxLength(32)]
+        public string InternalReference { get; set; }
+
         public int NetworkId { get; set; }
 
         [Required, MaxLength(20)]