Add VendorEvents

Change DateTime to DateTimeOffset where necessary

BulkPrintingAPI/Controllers/BatchesController.cs

         }
 
         [HttpGet]
-        public async Task<Page<Batch>> GetBatches([FromQuery] int page = 1,
+        public async Task<Page<Batch>> GetBatchesAsync([FromQuery] int page = 1,
             [FromQuery] int pageSize = 100)
         {
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
             return await Page<Batch>.GetPageAsync(
                 BatchesForVendor(credentials.Vendor.Id).OrderByDescending(b => b.OrderDate),
                 page, pageSize);
         }
 
         [HttpGet("{id}")]
-        public async Task<IActionResult> GetBatch([FromRoute] int id)
+        public async Task<IActionResult> GetBatchAsync([FromRoute] int id)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }
 
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
             var batch = await BatchesForVendor(credentials.Vendor.Id)
                 .Include(b => b.Account)
                 .SingleOrDefaultAsync(m => m.Id == id);
         }
 
         [HttpPost]
-        public async Task<IActionResult> PlaceOrder([FromBody] OrderRequest order)
+        public async Task<IActionResult> PlaceOrderAsync([FromBody] OrderRequest order)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }
 
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
             var catalogue = await Utils.GetProductCatalogueAsync(_clientFactory, _logger, _cache,
-                credentials);
+                credentials, false);
 
             Product product;
             if (!catalogue.ProductMap.TryGetValue(order.ProductId.Value, out product))
             {
-                return BadRequest("Invalid product ID");
+                return BadRequest(new { error = "Invalid product ID" });
             }
 
             var orderResponse = await MAX.Utils.PlaceOrderAsync(_clientFactory, _logger,

BulkPrintingAPI/Controllers/LoginController.cs

             MAX.LoginCredentials credentials;
             try
             {
-                credentials = await Utils.SyncUserAndVendorWithDb(_context, _dataEncryptionOptions,
+                credentials = await Utils.SyncUserAndVendorWithDbAsync(_context, _dataEncryptionOptions,
                     user, loginRequest.Password, loginRequest.VendorId.Value, loginRequest.SerialNumber);
             }
             catch (Exception e)
                 return Unauthorized();
             }
 
-            var now = DateTime.UtcNow;
-            var encodedJwt = new JwtSecurityTokenHandler().CreateEncodedJwt(
-                issuer: _tokenAuthenticationOptions.Issuer,
-                audience: _tokenAuthenticationOptions.Audience,
-                subject: new ClaimsIdentity(new Claim[] {
-                       new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
-                       new Claim("xpwd", loginRequest.Password),
-                       new Claim("xvid", loginRequest.VendorId.ToString()),
-                       new Claim(JwtRegisteredClaimNames.Jti, await _tokenAuthenticationOptions.NonceGenerator())
-                }),
-                notBefore: now,
-                expires: now.Add(_tokenAuthenticationOptions.Lifetime),
-                issuedAt: now,
-                signingCredentials: _tokenAuthenticationOptions.SigningCredentials,
-                encryptingCredentials: _tokenAuthenticationOptions.EncryptingCredentials
-            );
+            var now = DateTimeOffset.UtcNow;
+
+            _context.VendorEvents.Add(new MAX.Models.VendorEvent()
+            {
+                EventDate = now,
+                EventType = MAX.Models.VendorEvent.VendorEventType.Login,
+                UserId = credentials.User.Id,
+                VendorId = credentials.Vendor.Id
+            });
+            await _context.SaveChangesAsync();
+
+            var encodedJwt = await GetJwtAsync(now.DateTime, credentials);
 
             using (var derivedBytes = DataEncryptionOptions.DeriveKey(credentials.Password +
                 _dataEncryptionOptions.PasswordNoise, _dataEncryptionOptions.SaltLength,
                     JsonConvert.SerializeObject(
                         new
                         {
-                            date = DateTime.Now,
+                            date = now,
                             nonce = await _tokenAuthenticationOptions.NonceGenerator(),
                             user = credentials.User,
                             vendor = credentials.Vendor,
 
                 return Ok(new
                 {
+                    date = now,
                     access_token = encodedJwt,
                     credentials = new
                     {
                 });
             }
         }
+
+        [HttpGet("extend")]
+        public async Task<IActionResult> ExtendTokenAsync()
+        {
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+
+            MAX.Models.User user;
+            try
+            {
+                user = await MAX.Utils.AuthenticateUserAsync(_clientFactory, _logger,
+                    credentials.User.Id, credentials.User.Username, credentials.Vendor.Id,
+                    credentials.Vendor.SerialNumber, credentials.Password);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(
+                    "AuthenticateUserAsync failed for {0}: {1}",
+                    MAX.LoginCredentials.Format(credentials.User.Id, credentials.User.Username, credentials.Vendor.Id,
+                        credentials.Vendor.SerialNumber), e.Message);
+                return Unauthorized();
+            }
+
+            MAX.LoginCredentials possiblyUpdatedCredentials;
+            try
+            {
+                possiblyUpdatedCredentials = await Utils.SyncUserAndVendorWithDbAsync(_context, _dataEncryptionOptions,
+                    user, credentials.Password, credentials.Vendor.Id, credentials.Vendor.SerialNumber);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(
+                    "SyncUserAndVendorWithDb failed for {0}: {1}",
+                    MAX.LoginCredentials.Format(credentials.User.Id, credentials.User.Username, credentials.Vendor.Id,
+                        credentials.Vendor.SerialNumber), e.Message);
+                return Unauthorized();
+            }
+
+            var now = DateTimeOffset.UtcNow;
+
+            _context.VendorEvents.Add(new MAX.Models.VendorEvent()
+            {
+                EventDate = now,
+                EventType = MAX.Models.VendorEvent.VendorEventType.ExtendLogin,
+                UserId = possiblyUpdatedCredentials.User.Id,
+                VendorId = possiblyUpdatedCredentials.Vendor.Id
+            });
+            await _context.SaveChangesAsync();
+
+            return Ok(new
+            {
+                date = now,
+                access_token = await GetJwtAsync(now.DateTime, possiblyUpdatedCredentials),
+                user = possiblyUpdatedCredentials.User,
+                expires_in = (int)_tokenAuthenticationOptions.Lifetime.TotalSeconds
+            });
+        }
+
+        private async Task<string> GetJwtAsync(DateTime date, MAX.LoginCredentials credentials)
+        {
+            return new JwtSecurityTokenHandler().CreateEncodedJwt(
+                issuer: _tokenAuthenticationOptions.Issuer,
+                audience: _tokenAuthenticationOptions.Audience,
+                subject: new ClaimsIdentity(new Claim[] {
+                       new Claim(JwtRegisteredClaimNames.Sub, credentials.User.Id.ToString()),
+                       new Claim("xpwd", credentials.Password),
+                       new Claim("xvid", credentials.Vendor.Id.ToString()),
+                       new Claim(JwtRegisteredClaimNames.Jti, await _tokenAuthenticationOptions.NonceGenerator())
+                }),
+                notBefore: date,
+                expires: date.Add(_tokenAuthenticationOptions.Lifetime),
+                issuedAt: date,
+                signingCredentials: _tokenAuthenticationOptions.SigningCredentials,
+                encryptingCredentials: _tokenAuthenticationOptions.EncryptingCredentials
+            );
+        }
     }
 }

BulkPrintingAPI/Controllers/ProductsController.cs

         }
 
         [HttpGet]
-        public async Task<List<Network>> Get()
+        public async Task<List<Network>> GetAsync([FromQuery] bool refresh = false)
         {
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
             var catalogue = await Utils.GetProductCatalogueAsync(_clientFactory, _logger, _cache,
-                credentials);
+                credentials, refresh);
             return catalogue.Networks;
         }
     }

BulkPrintingAPI/Controllers/Utils.cs

             }
         }
 
-        public static async Task<MAX.LoginCredentials> SyncUserAndVendorWithDb(MAXContext context,
+        public static async Task<MAX.LoginCredentials> SyncUserAndVendorWithDbAsync(MAXContext context,
             DataEncryptionOptions dataEncryptionOptions, User user, string password, int vendorId,
             string serialNumber)
         {
             };
         }
 
-        public static async Task<MAX.LoginCredentials> GetLoginCredentialsFromRequest(
+        public static async Task<MAX.LoginCredentials> GetLoginCredentialsFromRequestAsync(
             HttpContext httpContext, MAXContext dbContext)
         {
             var authInfo = await httpContext.Authentication.GetAuthenticateInfoAsync("Bearer");
 
         public static async Task<ProductCatalogue> GetProductCatalogueAsync(
             MAX.ClientFactory clientFactory, ILogger logger, IMemoryCache cache,
-            MAX.LoginCredentials credentials)
+            MAX.LoginCredentials credentials, bool forceRefresh)
         {
-            return await cache.GetOrCreateAsync(
-                CacheKeys.GetAccountProductsKey(credentials.User.AccountId),
-                entry =>
+            var key = CacheKeys.GetAccountProductsKey(credentials.User.AccountId);
+            if (forceRefresh)
+            {
+                cache.Remove(key);
+            }
+            return await cache.GetOrCreateAsync(key, entry =>
                 {
                     // TODO: set expiry time, etc.
                     return MAX.Utils.GetProductCatalogueAsync(clientFactory, logger, credentials);

BulkPrintingAPI/Controllers/VendorEventsController.cs

+using BulkPrintingAPI.Pagination;
+using MAX.Models;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BulkPrintingAPI.Controllers
+{
+    [Produces("application/json")]
+    [Route("api/[controller]")]
+    public class VendorEventsController : Controller
+    {
+        private readonly MAXContext _context;
+
+        public class RemoteVendorEvent
+        {
+            [Required]
+            public int? Id { get; set; }
+
+            [Required]
+            public int? VendorId { get; set; }
+
+            [Required]
+            public int? UserId { get; set; }
+
+            public int? VoucherId { get; set; }
+
+            [Required]
+            public DateTimeOffset? EventDate { get; set; }
+
+            [Required]
+            public VendorEvent.VendorEventType? EventType { get; set; }
+        }
+
+        public VendorEventsController(MAXContext context)
+        {
+            _context = context;
+        }
+
+        [HttpGet]
+        public async Task<Page<VendorEvent>> GetVendorEventsAsync([FromQuery] int page = 1,
+            [FromQuery] int pageSize = 100)
+        {
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+            return await Page<VendorEvent>.GetPageAsync(
+                VendorEventsForVendor(credentials.Vendor.Id).OrderByDescending(e => e.EventDate),
+                page, pageSize);
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> PostRemoteVendorEventsAsync([FromBody] List<RemoteVendorEvent> remoteVendorEvents)
+        {
+            if (! ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+            var vendorId = credentials.Vendor.Id;
+            var lastVendorEventRemoteId = credentials.Vendor.LastVendorEventRemoteId;
+            var maxRemoteId = lastVendorEventRemoteId;
+            foreach (var remoteEvent in remoteVendorEvents)
+            {
+                if (vendorId != remoteEvent.VendorId)
+                {
+                    return BadRequest(new { error = "Vendor ID mismatch" });
+                }
+                if (lastVendorEventRemoteId.HasValue && (lastVendorEventRemoteId.Value >= remoteEvent.Id.Value))
+                {
+                    return BadRequest(new { error = "A supplied ID value is less than or equal to lastVendorRemoteId" });
+                }
+                if (! maxRemoteId.HasValue || (remoteEvent.Id.Value > maxRemoteId.Value))
+                {
+                    maxRemoteId = remoteEvent.Id.Value;
+                }
+                _context.VendorEvents.Add(new VendorEvent()
+                {
+                    RemoteId = remoteEvent.Id.Value,
+                    UserId = remoteEvent.UserId.Value,
+                    VendorId = remoteEvent.VendorId.Value,
+                    VoucherId = remoteEvent.VoucherId,
+                    EventType = remoteEvent.EventType.Value,
+                    EventDate = remoteEvent.EventDate.Value.ToUniversalTime()
+                });
+            }
+
+            // FIXME: race condition for simultaneous requests, although we should never have any from the same vendor
+            credentials.Vendor.LastVendorEventRemoteId = maxRemoteId;
+            await _context.SaveChangesAsync();
+
+            return Ok(new
+            {
+                lastVendorEventRemoteId = credentials.Vendor.LastVendorEventRemoteId
+            });
+        }
+
+        [HttpGet("meta")]
+        public async Task<IActionResult> GetVendorEventMetadata()
+        {
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+            return Ok(new
+            {
+                date = DateTimeOffset.UtcNow,
+                vendorId = credentials.Vendor.Id,
+                lastVendorEventRemoteId = credentials.Vendor.LastVendorEventRemoteId
+            });
+        }
+
+        private IQueryable<VendorEvent> VendorEventsForVendor(int vendorId)
+        {
+            return _context.VendorEvents.Where(e => e.VendorId == vendorId);
+        }
+    }
+}

BulkPrintingAPI/Controllers/VouchersController.cs

 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 
         }
 
         [HttpGet]
-        public async Task<IActionResult> GetVouchers([FromRoute] int batchId,
+        public async Task<IActionResult> GetVouchersAsync([FromRoute] int batchId,
             [FromQuery] int page = 1, [FromQuery] int pageSize = 100)
         {
             if (!ModelState.IsValid)
                 return BadRequest(ModelState);
             }
 
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
-            return Ok(await Page<Voucher>.GetPageAsync(
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
+            var result = await Page<Voucher>.GetPageAsync(
                 VouchersForBatchAndVendor(batchId, credentials.Vendor.Id)
                     .OrderBy(v => new { v.BatchId, v.SequenceNumber }),
-                page, pageSize));
+                page, pageSize);
+
+            var now = DateTimeOffset.UtcNow;
+            foreach (var voucher in result.Items)
+            {
+                _context.VendorEvents.Add(new VendorEvent()
+                {
+                    EventDate = now,
+                    EventType = VendorEvent.VendorEventType.DownloadVoucher,
+                    UserId = credentials.User.Id,
+                    VendorId = credentials.Vendor.Id,
+                    VoucherId = voucher.Id
+                });
+            }
+            await _context.SaveChangesAsync();
+
+            return Ok(result);
         }
 
         [HttpGet("{sequenceNumber}")]
-        public async Task<IActionResult> GetVoucher([FromRoute] int batchId, [FromRoute] int sequenceNumber)
+        public async Task<IActionResult> GetVoucherAsync([FromRoute] int batchId, [FromRoute] int sequenceNumber)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }
 
-            var credentials = await Utils.GetLoginCredentialsFromRequest(HttpContext, _context);
+            var credentials = await Utils.GetLoginCredentialsFromRequestAsync(HttpContext, _context);
             var voucher = await VouchersForBatchAndVendor(batchId, credentials.Vendor.Id)
                 .SingleOrDefaultAsync(v => (v.BatchId == batchId) && (v.SequenceNumber == sequenceNumber));
 
                 return NotFound();
             }
 
+            _context.VendorEvents.Add(new VendorEvent()
+            {
+                EventDate = DateTimeOffset.UtcNow,
+                EventType = VendorEvent.VendorEventType.DownloadVoucher,
+                UserId = credentials.User.Id,
+                VendorId = credentials.Vendor.Id,
+                VoucherId = voucher.Id
+            });
+            await _context.SaveChangesAsync();
+
             return Ok(voucher);
         }
 

BulkPrintingAPI/Migrations/20170705205151_InitialCreate.Designer.cs

 namespace BulkPrintingAPI.Migrations
 {
     [DbContext(typeof(MAXContext))]
-    [Migration("20170705205151_InitialCreate")]
+    [Migration("20170711104915_InitialCreate")]
     partial class InitialCreate
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasMaxLength(20);
 
-                    b.Property<DateTime>("OrderDate");
+                    b.Property<DateTimeOffset>("OrderDate");
+
+                    b.Property<Guid?>("OrderGuid");
 
                     b.Property<string>("OrderReference")
                         .IsRequired()
 
                     b.HasIndex("AccountId");
 
+                    b.HasIndex("OrderGuid")
+                        .IsUnique();
+
                     b.HasIndex("ReadyForDownload", "OrderDate");
 
                     b.ToTable("Batches");
                         .IsRequired()
                         .HasMaxLength(50);
 
-                    b.Property<DateTime>("LastLogin");
+                    b.Property<DateTimeOffset>("LastLogin");
 
                     b.Property<int>("Level");
 
                         .IsRequired()
                         .HasMaxLength(32);
 
+                    b.Property<int?>("LastVendorEventRemoteId");
+
                     b.Property<string>("SerialNumber")
                         .IsRequired()
                         .HasMaxLength(50);
                     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<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");

BulkPrintingAPI/Migrations/20170705205151_InitialCreate.cs

 using System;
 using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Metadata;
 
 namespace BulkPrintingAPI.Migrations
 {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.CreateTable(
+                name: "VendorEvents",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    EventDate = table.Column<DateTimeOffset>(nullable: false),
+                    EventType = table.Column<int>(nullable: false),
+                    RemoteId = table.Column<int>(nullable: true),
+                    UserId = table.Column<int>(nullable: false),
+                    VendorId = table.Column<int>(nullable: false),
+                    VoucherId = table.Column<int>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_VendorEvents", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
                 name: "Warehouses",
                 columns: table => new
                 {
                     FaceValue = table.Column<decimal>(nullable: false),
                     NetworkId = table.Column<int>(nullable: false),
                     NetworkName = table.Column<string>(maxLength: 20, nullable: false),
-                    OrderDate = table.Column<DateTime>(nullable: false),
+                    OrderDate = table.Column<DateTimeOffset>(nullable: false),
+                    OrderGuid = table.Column<Guid>(nullable: true),
                     OrderReference = table.Column<string>(maxLength: 20, nullable: false),
                     OrderedById = table.Column<int>(nullable: false),
                     ProductDescription = table.Column<string>(maxLength: 50, nullable: false),
                     CanReprintOnline = table.Column<bool>(nullable: false),
                     Enabled = table.Column<bool>(nullable: false),
                     FirstName = table.Column<string>(maxLength: 50, nullable: false),
-                    LastLogin = table.Column<DateTime>(nullable: false),
+                    LastLogin = table.Column<DateTimeOffset>(nullable: false),
                     Level = table.Column<int>(nullable: false),
                     OfflinePrintValue = table.Column<decimal>(nullable: false),
                     OfflineReprintValue = table.Column<decimal>(nullable: false),
                     AccountId = table.Column<int>(nullable: false),
                     EncryptedDatabasePassword = table.Column<byte[]>(maxLength: 32, nullable: false),
                     EncryptedVoucherKey = table.Column<byte[]>(maxLength: 32, nullable: false),
+                    LastVendorEventRemoteId = table.Column<int>(nullable: true),
                     SerialNumber = table.Column<string>(maxLength: 50, nullable: false)
                 },
                 constraints: table =>
                 column: "AccountId");
 
             migrationBuilder.CreateIndex(
+                name: "IX_Batches_OrderGuid",
+                table: "Batches",
+                column: "OrderGuid",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
                 name: "IX_Batches_ReadyForDownload_OrderDate",
                 table: "Batches",
                 columns: new[] { "ReadyForDownload", "OrderDate" });
                 column: "AccountId");
 
             migrationBuilder.CreateIndex(
+                name: "IX_VendorEvents_VendorId_RemoteId",
+                table: "VendorEvents",
+                columns: new[] { "VendorId", "RemoteId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
                 name: "IX_Vouchers_BatchId_SequenceNumber",
                 table: "Vouchers",
                 columns: new[] { "BatchId", "SequenceNumber" },
                 name: "Vendors");
 
             migrationBuilder.DropTable(
+                name: "VendorEvents");
+
+            migrationBuilder.DropTable(
                 name: "Vouchers");
 
             migrationBuilder.DropTable(

BulkPrintingAPI/Migrations/MAXContextModelSnapshot.cs

                         .IsRequired()
                         .HasMaxLength(20);
 
-                    b.Property<DateTime>("OrderDate");
+                    b.Property<DateTimeOffset>("OrderDate");
+
+                    b.Property<Guid?>("OrderGuid");
 
                     b.Property<string>("OrderReference")
                         .IsRequired()
 
                     b.HasIndex("AccountId");
 
+                    b.HasIndex("OrderGuid")
+                        .IsUnique();
+
                     b.HasIndex("ReadyForDownload", "OrderDate");
 
                     b.ToTable("Batches");
                         .IsRequired()
                         .HasMaxLength(50);
 
-                    b.Property<DateTime>("LastLogin");
+                    b.Property<DateTimeOffset>("LastLogin");
 
                     b.Property<int>("Level");
 
                         .IsRequired()
                         .HasMaxLength(32);
 
+                    b.Property<int?>("LastVendorEventRemoteId");
+
                     b.Property<string>("SerialNumber")
                         .IsRequired()
                         .HasMaxLength(50);
                     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<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");

BulkPrintingAPI/Properties/PublishProfiles/FolderProfile.pubxml

+<?xml version="1.0" encoding="utf-8"?>
+<!--
+This file is used by the publish/package process of your Web project. You can customize the behavior of this process
+by editing this MSBuild file. In order to learn more about this please visit https://go.microsoft.com/fwlink/?LinkID=208121. 
+-->
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <WebPublishMethod>FileSystem</WebPublishMethod>
+    <PublishProvider>FileSystem</PublishProvider>
+    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
+    <LastUsedPlatform>Any CPU</LastUsedPlatform>
+    <SiteUrlToLaunchAfterPublish />
+    <LaunchSiteAfterPublish>True</LaunchSiteAfterPublish>
+    <ExcludeApp_Data>False</ExcludeApp_Data>
+    <PublishFramework />
+    <ProjectGuid>92eeb85e-10ff-4902-9f73-ba4d58344824</ProjectGuid>
+    <publishUrl>bin\Release\PublishOutput</publishUrl>
+    <DeleteExistingFiles>False</DeleteExistingFiles>
+  </PropertyGroup>
+</Project>

BulkPrintingAPI/appsettings.json

   "TokenAuthentication": {
     "Audience": "bulk",
     "Issuer": "bulk",
-    "SecretKey": "SET IN secrets.json",
-    "Salt": "SET IN secrets.json",
+    "Key": "SET IN secrets.json",
     "TokenLifetime": 86400
   }
 }

MAXClient/Client.cs

                         DiscountPercentage = product.DiscountPercentage,
                         NetworkId = product.Network.Id,
                         NetworkName = product.Network.Name,
-                        OrderDate = DateTime.Now,
+                        OrderDate = DateTimeOffset.UtcNow,
                         OrderedById = _userId,
                         ReadyForDownload = false
                     },

MAXData/Models/Account.cs

     {
         public enum AccountStatus
         {
-            Unknown,
-            Enabled,
-            Suspended,
-            Closed
+            Unknown = 0,
+            Enabled = 1,
+            Suspended = 2,
+            Closed = 3
         }
 
         [DatabaseGenerated(DatabaseGeneratedOption.None)]

MAXData/Models/Batch.cs

         public enum Vouchertype
         {
             Voucher = 1,
-            SMS,
-            Data
+            SMS = 2,
+            Data = 3
         }
 
         [DatabaseGenerated(DatabaseGeneratedOption.None)]
         //[IgnoreDataMember]
         //public User OrderedBy { get; set; }
 
-        public DateTime OrderDate { get; set; }
+        public DateTimeOffset OrderDate { get; set; }
+
+        public Guid? OrderGuid { get; set; }
 
         [Required, MaxLength(20)]
         public string OrderReference { get; set; }

MAXData/Models/MAXContext.cs

 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata;
 
 namespace MAX.Models
 {
             modelBuilder.Entity<Batch>()
                 .HasIndex(b => new { b.ReadyForDownload, b.OrderDate });
 
+            modelBuilder.Entity<Batch>()
+                .HasIndex(b => new { b.OrderGuid })
+                .IsUnique();
+
+            modelBuilder.Entity<VendorEvent>()
+                .HasIndex(e => new { e.VendorId, e.RemoteId })
+                .IsUnique();
+
             modelBuilder.Entity<Voucher>()
                 .HasIndex(v => new { v.BatchId, v.SequenceNumber })
                 .IsUnique();
 
         public DbSet<User> Users { get; set; }
 
+        public DbSet<VendorEvent> VendorEvents { get; set; }
+
         public DbSet<Vendor> Vendors { get; set; }
 
         public DbSet<Voucher> Vouchers { get; set; }

MAXData/Models/User.cs

 
         public int System { get; set; }
 
-        public DateTime LastLogin { get; set; }
+        public DateTimeOffset LastLogin { get; set; }
 
         public bool CanPrintOnline { get; set; }
 

MAXData/Models/Vendor.cs

         [IgnoreDataMember]
         [Required, MaxLength(32)]
         public byte[] EncryptedVoucherKey { get; set; }
+
+        public int? LastVendorEventRemoteId { get; set; }
     }
 }

MAXData/Models/VendorEvent.cs

+using System;
+
+namespace MAX.Models
+{
+    public class VendorEvent
+    {
+        public enum VendorEventType
+        {
+            Unknown = 0,
+            Login = 1,
+            OfflineLogin = 2,
+            ExtendLogin = 3,
+            Logout = 4,
+            DownloadVoucher = 5,
+            PrintVoucher = 6,
+            ViewVoucherPIN = 7
+        }
+
+        public int Id { get; set; }
+
+        public int VendorId { get; set; }
+
+        public int UserId { get; set; }
+
+        public int? VoucherId { get; set; }
+
+        public int? RemoteId { get; set; }
+
+        public DateTimeOffset EventDate { get; set; }
+
+        public VendorEventType EventType { get; set; }
+    }
+}