server/biz/GZCaseBiz.cs

@@ -414,8 +414,7 @@ namespace Sockeye.Biz
             log.LogDebug($"HandlePotentialNotificationEvent processing:  [SockType:{this.BizType}, AyaEvent:{ayaEvent}]");
 
             bool isNew = currentObj == null;
-
-            proposedObj.Name = "LICENSE ID" + proposedObj.Id.ToString();
+          
             //STANDARD EVENTS FOR ALL OBJECTS
             await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
 

server/biz/ProductBiz.cs

@@ -0,0 +1,449 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using System.Linq;
+using Sockeye.Util;
+using Sockeye.Api.ControllerHelpers;
+using Sockeye.Models;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Sockeye.Biz
+{
+    internal class ProductBiz : BizObject, IJobObject, ISearchAbleObject, IReportAbleObject, IExportAbleObject, INotifiableObject
+    {
+        internal ProductBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
+        {
+            ct = dbcontext;
+            UserId = currentUserId;
+            UserTranslationId = userTranslationId;
+            CurrentUserRoles = UserRoles;
+            BizType = SockType.Product;
+        }
+
+        internal static ProductBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null)
+        {
+            if (httpContext != null)
+                return new ProductBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items));
+            else
+                return new ProductBiz(ct, 1, ServerBootConfig.SOCKEYE_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdmin);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //EXISTS 
+        internal async Task<bool> ExistsAsync(long id)
+        {
+            return await ct.Product.AnyAsync(z => z.Id == id);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //CREATE   
+        //
+        internal async Task<Product> CreateAsync(Product newObject)
+        {
+            await ValidateAsync(newObject, null);
+            if (HasErrors)
+                return null;
+            else
+            {
+                newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
+                newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
+                await ct.Product.AddAsync(newObject);
+                await ct.SaveChangesAsync();
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, SockEvent.Created), ct);
+                await SearchIndexAsync(newObject, true);
+                await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
+                await HandlePotentialNotificationEvent(SockEvent.Created, newObject);
+                return newObject;
+            }
+        }
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //GET 
+        //      
+        internal async Task<Product> GetAsync(long id, bool logTheGetEvent = true)
+        {
+            var ret = await ct.Product.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
+            if (logTheGetEvent && ret != null)
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, SockEvent.Retrieved), ct);
+            return ret;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //UPDATE
+        //
+        internal async Task<Product> PutAsync(Product putObject)
+        {
+            var dbObject = await GetAsync(putObject.Id, false);
+            if (dbObject == null)
+            {
+                AddError(ApiErrorCode.NOT_FOUND, "id");
+                return null;
+            }
+            if (dbObject.Concurrency != putObject.Concurrency)
+            {
+                AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+
+            putObject.Tags = TagBiz.NormalizeTags(putObject.Tags);
+            putObject.CustomFields = JsonUtil.CompactJson(putObject.CustomFields);
+            await ValidateAsync(putObject, dbObject);
+            if (HasErrors) return null;
+            ct.Replace(dbObject, putObject);
+            try
+            {
+                await ct.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!await ExistsAsync(putObject.Id))
+                    AddError(ApiErrorCode.NOT_FOUND);
+                else
+                    AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, putObject.Id, BizType, SockEvent.Modified), ct);
+            await SearchIndexAsync(putObject, false);
+            await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags);
+            await HandlePotentialNotificationEvent(SockEvent.Modified, putObject, dbObject);
+            return putObject;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //DELETE
+        //
+        internal async Task<bool> DeleteAsync(long id)
+        {
+            using (var transaction = await ct.Database.BeginTransactionAsync())
+            {
+
+                Product dbObject = await GetAsync(id, false);
+                if (dbObject == null)
+                {
+                    AddError(ApiErrorCode.NOT_FOUND);
+                    return false;
+                }
+                await ValidateCanDeleteAsync(dbObject);
+                if (HasErrors)
+                    return false;
+
+
+
+
+                {
+                    var IDList = await ct.Review.AsNoTracking().Where(x => x.SockType == SockType.Product && x.ObjectId == id).Select(x => x.Id).ToListAsync();
+                    if (IDList.Count() > 0)
+                    {
+                        ReviewBiz b = new ReviewBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
+                        foreach (long ItemId in IDList)
+                            if (!await b.DeleteAsync(ItemId, transaction))
+                            {
+                                AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"Review [{ItemId}]: {b.GetErrorsAsString()}");
+                                return false;
+                            }
+                    }
+                }
+
+                ct.Product.Remove(dbObject);
+                await ct.SaveChangesAsync();
+
+                //Log event 
+                await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
+                await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
+                await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
+                await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
+                await transaction.CommitAsync();
+                await HandlePotentialNotificationEvent(SockEvent.Deleted, dbObject);
+
+                return true;
+            }
+        }
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //SEARCH
+        //
+        private async Task SearchIndexAsync(Product obj, bool isNew)
+        {
+            var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
+            DigestSearchText(obj, SearchParams);
+            if (isNew)
+                await Search.ProcessNewObjectKeywordsAsync(SearchParams);
+            else
+                await Search.ProcessUpdatedObjectKeywordsAsync(SearchParams);
+        }
+
+        public async Task<Search.SearchIndexProcessObjectParameters> GetSearchResultSummary(long id, SockType specificType)
+        {
+            var obj = await GetAsync(id, false);
+            var SearchParams = new Search.SearchIndexProcessObjectParameters();
+            DigestSearchText(obj, SearchParams);
+            return SearchParams;
+        }
+
+        public void DigestSearchText(Product obj, Search.SearchIndexProcessObjectParameters searchParams)
+        {
+            if (obj != null)
+                searchParams.AddText(obj.VendorCode)
+                            .AddText(obj.Name)
+                            .AddText(obj.Wiki)
+                            .AddText(obj.Tags)
+                            .AddText(obj.OurCode)
+                            .AddCustomFields(obj.CustomFields);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //VALIDATION
+        //
+
+        private async Task ValidateAsync(Product proposedObj, Product currentObj)
+        {
+            bool isNew = currentObj == null;
+
+
+
+            //Any form customizations to validate?
+            var FormCustomization = await ct.FormCustom.AsNoTracking().SingleOrDefaultAsync(z => z.FormKey == SockType.Product.ToString());
+            if (FormCustomization != null)
+            {
+                //Yeppers, do the validation, there are two, the custom fields and the regular fields that might be set to required
+
+                //validate users choices for required non custom fields
+                RequiredFieldsValidator.Validate(this, FormCustomization, proposedObj);
+
+                //validate custom fields
+                CustomFieldsValidator.Validate(this, FormCustomization, proposedObj.CustomFields);
+            }
+
+        }
+
+
+        private async Task ValidateCanDeleteAsync(Product inObj)
+        {
+
+            await Task.CompletedTask;
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //REPORTING
+        //
+        public async Task<JArray> GetReportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            var idList = dataListSelectedRequest.SelectedRowIds;
+            JArray ReportData = new JArray();
+            while (idList.Any())
+            {
+                var batch = idList.Take(IReportAbleObject.REPORT_DATA_BATCH_SIZE);
+                idList = idList.Skip(IReportAbleObject.REPORT_DATA_BATCH_SIZE).ToArray();
+
+                //query for this batch, comes back in db natural order unfortunately
+                var batchResults = await ct.Product.AsNoTracking().Where(z => batch.Contains(z.Id)).ToArrayAsync();
+
+                //order the results back into original
+                //What is happening here:
+                //for performance the query is batching a bunch at once by fetching a block of items from the sql server
+                //however it's returning in db order which is often not the order the id list is in
+                //so it needs to be sorted back into the same order as the ide list
+                //This would not be necessary if just fetching each one at a time individually (like in workorder get report data)
+
+                var orderedList = from id in batch join z in batchResults on id equals z.Id select z;
+                batchResults = null;
+
+                foreach (Product w in orderedList)
+                {
+                    if (!ReportRenderManager.KeepGoing(jobId)) return null;
+
+                    var jo = JObject.FromObject(w);
+                    if (!JsonUtil.JTokenIsNullOrEmpty(jo["CustomFields"]))
+                        jo["CustomFields"] = JObject.Parse((string)jo["CustomFields"]);
+                    ReportData.Add(jo);
+                }
+                orderedList = null;
+            }
+            vc.Clear();
+            return ReportData;
+        }
+        private VizCache vc = new VizCache();
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////       
+        // IMPORT EXPORT
+        //
+
+        public async Task<JArray> GetExportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            return await GetReportData(dataListSelectedRequest, jobId);
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //JOB / OPERATIONS
+        //
+        public async Task HandleJobAsync(OpsJob job)
+        {
+            //Hand off the particular job to the corresponding processing code
+            //NOTE: If this code throws an exception the caller (JobsBiz::ProcessJobsAsync) will automatically set the job to failed and log the exeption so 
+            //basically any error condition during job processing should throw up an exception if it can't be handled
+            switch (job.JobType)
+            {
+                case JobType.BatchCoreObjectOperation:
+                    await ProcessBatchJobAsync(job);
+                    break;
+                default:
+                    throw new System.ArgumentOutOfRangeException($"ProductBiz.HandleJob-> Invalid job type{job.JobType.ToString()}");
+            }
+        }
+
+
+
+        private async Task ProcessBatchJobAsync(OpsJob job)
+        {
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Running);
+            await JobsBiz.LogJobAsync(job.GId, $"LT:StartJob {job.SubType}");
+            List<long> idList = new List<long>();
+            long FailedObjectCount = 0;
+            JObject jobData = JObject.Parse(job.JobInfo);
+            if (jobData.ContainsKey("idList"))
+                idList = ((JArray)jobData["idList"]).ToObject<List<long>>();
+            else
+                idList = await ct.Product.AsNoTracking().Select(z => z.Id).ToListAsync();
+            bool SaveIt = false;
+
+            //---------------------------------
+            //case 4192
+            TimeSpan ProgressAndCancelCheckSpan = new TimeSpan(0, 0, ServerBootConfig.JOB_PROGRESS_UPDATE_AND_CANCEL_CHECK_SECONDS);
+            DateTime LastProgressCheck = DateTime.UtcNow.Subtract(new TimeSpan(1, 1, 1, 1, 1));
+            var TotalRecords = idList.LongCount();
+            long CurrentRecord = -1;
+            //---------------------------------
+
+            foreach (long id in idList)
+            {
+                try
+                {
+                    //--------------------------------
+                    //case 4192
+                    //Update progress / cancel requested?                    
+                    CurrentRecord++;
+                    if (DateUtil.IsAfterDuration(LastProgressCheck, ProgressAndCancelCheckSpan))
+                    {
+                        await JobsBiz.UpdateJobProgressAsync(job.GId, $"{CurrentRecord}/{TotalRecords}");
+                        if (await JobsBiz.GetJobStatusAsync(job.GId) == JobStatus.CancelRequested)
+                            break;
+                        LastProgressCheck = DateTime.UtcNow;
+                    }
+                    //---------------------------------
+
+                    SaveIt = false;
+                    ClearErrors();
+                    Product o = null;
+                    //save a fetch if it's a delete
+                    if (job.SubType != JobSubType.Delete)
+                        o = await GetAsync(id, false);
+                    switch (job.SubType)
+                    {
+                        case JobSubType.TagAddAny:
+                        case JobSubType.TagAdd:
+                        case JobSubType.TagRemoveAny:
+                        case JobSubType.TagRemove:
+                        case JobSubType.TagReplaceAny:
+                        case JobSubType.TagReplace:
+                            SaveIt = TagBiz.ProcessBatchTagOperation(o.Tags, (string)jobData["tag"], jobData.ContainsKey("toTag") ? (string)jobData["toTag"] : null, job.SubType);
+                            break;
+                        case JobSubType.Delete:
+                            if (!await DeleteAsync(id))
+                            {
+                                await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                                FailedObjectCount++;
+                            }
+                            break;
+                        default:
+                            throw new System.ArgumentOutOfRangeException($"ProcessBatchJobAsync -> Invalid job Subtype{job.SubType}");
+                    }
+                    if (SaveIt)
+                    {
+                        o = await PutAsync(o);
+                        if (o == null)
+                        {
+                            await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                            FailedObjectCount++;
+                        }
+                    }
+
+                    //delay so we're not tying up all the resources in a tight loop
+                    await Task.Delay(Sockeye.Util.ServerBootConfig.JOB_OBJECT_HANDLE_BATCH_JOB_LOOP_DELAY);
+                }
+                catch (Exception ex)
+                {
+                    await JobsBiz.LogJobAsync(job.GId, $"LT:Errors id({id})");
+                    await JobsBiz.LogJobAsync(job.GId, ExceptionUtil.ExtractAllExceptionMessages(ex));
+                }
+            }
+
+            //---------------------------------
+            //case 4192
+            await JobsBiz.UpdateJobProgressAsync(job.GId, $"{++CurrentRecord}/{TotalRecords}");
+            //---------------------------------
+
+            await JobsBiz.LogJobAsync(job.GId, $"LT:BatchJob {job.SubType} {idList.Count}{(FailedObjectCount > 0 ? " - LT:Failed " + FailedObjectCount : "")}");
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Completed);
+        }
+
+
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        // NOTIFICATION PROCESSING
+        //
+        public async Task HandlePotentialNotificationEvent(SockEvent ayaEvent, ICoreBizObjectModel proposedObj, ICoreBizObjectModel currentObj = null)
+        {
+            ILogger log = Sockeye.Util.ApplicationLogging.CreateLogger<ProductBiz>();
+
+            log.LogDebug($"HandlePotentialNotificationEvent processing:  [SockType:{this.BizType}, AyaEvent:{ayaEvent}]");
+
+            bool isNew = currentObj == null;
+          
+            //STANDARD EVENTS FOR ALL OBJECTS
+            await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
+
+            //SPECIFIC EVENTS FOR THIS OBJECT
+            Product o = (Product)proposedObj;
+
+            //## DELETED EVENTS
+            //any event added below needs to be removed, so
+            //just blanket remove any event for this object of eventtype that would be added below here
+            //do it regardless any time there's an update and then
+            //let this code below handle the refreshing addition that could have changes           
+            //await NotifyEventHelper.ClearPriorEventsForObject(ct, SockType.Product, o.Id, NotifyEventType.ContractExpiring);
+
+
+            //## CREATED / MODIFIED EVENTS
+            if (ayaEvent == SockEvent.Created || ayaEvent == SockEvent.Modified)
+            {
+
+
+
+            }
+
+        }//end of process notifications
+
+
+        /////////////////////////////////////////////////////////////////////
+
+    }//eoc
+
+
+}//eons
+

server/biz/PurchaseBiz.cs

@@ -438,7 +438,7 @@ namespace Sockeye.Biz
 
             bool isNew = currentObj == null;
 
-            proposedObj.Name = "LICENSE ID" + proposedObj.Id.ToString();
+            proposedObj.Name = "PURCHASE ID" + proposedObj.Id.ToString();
             //STANDARD EVENTS FOR ALL OBJECTS
             await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
 

server/biz/SubscriptionServerBiz.cs

@@ -0,0 +1,455 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using System.Linq;
+using Sockeye.Util;
+using Sockeye.Api.ControllerHelpers;
+using Sockeye.Models;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Sockeye.Biz
+{
+    internal class SubscriptionServerBiz : BizObject, IJobObject, ISearchAbleObject, IReportAbleObject, IExportAbleObject, INotifiableObject
+    {
+        internal SubscriptionServerBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
+        {
+            ct = dbcontext;
+            UserId = currentUserId;
+            UserTranslationId = userTranslationId;
+            CurrentUserRoles = UserRoles;
+            BizType = SockType.SubscriptionServer;
+        }
+
+        internal static SubscriptionServerBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null)
+        {
+            if (httpContext != null)
+                return new SubscriptionServerBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items));
+            else
+                return new SubscriptionServerBiz(ct, 1, ServerBootConfig.SOCKEYE_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdmin);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //EXISTS 
+        internal async Task<bool> ExistsAsync(long id)
+        {
+            return await ct.SubscriptionServer.AnyAsync(z => z.Id == id);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //CREATE   
+        //
+        internal async Task<SubscriptionServer> CreateAsync(SubscriptionServer newObject)
+        {
+            await ValidateAsync(newObject, null);
+            if (HasErrors)
+                return null;
+            else
+            {
+                newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
+                newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
+                await ct.SubscriptionServer.AddAsync(newObject);
+                await ct.SaveChangesAsync();
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, SockEvent.Created), ct);
+                await SearchIndexAsync(newObject, true);
+                await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
+                await HandlePotentialNotificationEvent(SockEvent.Created, newObject);
+                return newObject;
+            }
+        }
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //GET 
+        //      
+        internal async Task<SubscriptionServer> GetAsync(long id, bool logTheGetEvent = true)
+        {
+            var ret = await ct.SubscriptionServer.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
+            if (logTheGetEvent && ret != null)
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, SockEvent.Retrieved), ct);
+            return ret;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //UPDATE
+        //
+        internal async Task<SubscriptionServer> PutAsync(SubscriptionServer putObject)
+        {
+            var dbObject = await GetAsync(putObject.Id, false);
+            if (dbObject == null)
+            {
+                AddError(ApiErrorCode.NOT_FOUND, "id");
+                return null;
+            }
+            if (dbObject.Concurrency != putObject.Concurrency)
+            {
+                AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+
+            putObject.Tags = TagBiz.NormalizeTags(putObject.Tags);
+            putObject.CustomFields = JsonUtil.CompactJson(putObject.CustomFields);
+            await ValidateAsync(putObject, dbObject);
+            if (HasErrors) return null;
+            ct.Replace(dbObject, putObject);
+            try
+            {
+                await ct.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!await ExistsAsync(putObject.Id))
+                    AddError(ApiErrorCode.NOT_FOUND);
+                else
+                    AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, putObject.Id, BizType, SockEvent.Modified), ct);
+            await SearchIndexAsync(putObject, false);
+            await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags);
+            await HandlePotentialNotificationEvent(SockEvent.Modified, putObject, dbObject);
+            return putObject;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //DELETE
+        //
+        internal async Task<bool> DeleteAsync(long id)
+        {
+            using (var transaction = await ct.Database.BeginTransactionAsync())
+            {
+
+                SubscriptionServer dbObject = await GetAsync(id, false);
+                if (dbObject == null)
+                {
+                    AddError(ApiErrorCode.NOT_FOUND);
+                    return false;
+                }
+                await ValidateCanDeleteAsync(dbObject);
+                if (HasErrors)
+                    return false;
+
+
+
+
+                {
+                    var IDList = await ct.Review.AsNoTracking().Where(x => x.SockType == SockType.SubscriptionServer && x.ObjectId == id).Select(x => x.Id).ToListAsync();
+                    if (IDList.Count() > 0)
+                    {
+                        ReviewBiz b = new ReviewBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
+                        foreach (long ItemId in IDList)
+                            if (!await b.DeleteAsync(ItemId, transaction))
+                            {
+                                AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"Review [{ItemId}]: {b.GetErrorsAsString()}");
+                                return false;
+                            }
+                    }
+                }
+
+                ct.SubscriptionServer.Remove(dbObject);
+                await ct.SaveChangesAsync();
+
+                //Log event 
+                await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
+                await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
+                await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
+                await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
+                await transaction.CommitAsync();
+                await HandlePotentialNotificationEvent(SockEvent.Deleted, dbObject);
+
+                return true;
+            }
+        }
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //SEARCH
+        //
+        private async Task SearchIndexAsync(SubscriptionServer obj, bool isNew)
+        {
+            var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
+            DigestSearchText(obj, SearchParams);
+            if (isNew)
+                await Search.ProcessNewObjectKeywordsAsync(SearchParams);
+            else
+                await Search.ProcessUpdatedObjectKeywordsAsync(SearchParams);
+        }
+
+        public async Task<Search.SearchIndexProcessObjectParameters> GetSearchResultSummary(long id, SockType specificType)
+        {
+            var obj = await GetAsync(id, false);
+            var SearchParams = new Search.SearchIndexProcessObjectParameters();
+            DigestSearchText(obj, SearchParams);
+            return SearchParams;
+        }
+
+        public void DigestSearchText(SubscriptionServer obj, Search.SearchIndexProcessObjectParameters searchParams)
+        {
+            if (obj != null)
+                searchParams.AddText(obj.DataCenter)
+                            .AddText(obj.Name)
+                            .AddText(obj.Notes)
+                            .AddText(obj.TimeZone)
+                            .AddText(obj.TrialContact)
+                            .AddText(obj.TrialEmail)
+                            .AddText(obj.TrialCompany)
+                            .AddText(obj.OperatingSystem)
+                            .AddText(obj.CustomerSubDomain)
+                            .AddText(obj.Wiki)
+                            .AddText(obj.Tags)                            
+                            .AddCustomFields(obj.CustomFields);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //VALIDATION
+        //
+
+        private async Task ValidateAsync(SubscriptionServer proposedObj, SubscriptionServer currentObj)
+        {
+            bool isNew = currentObj == null;
+
+
+
+            //Any form customizations to validate?
+            var FormCustomization = await ct.FormCustom.AsNoTracking().SingleOrDefaultAsync(z => z.FormKey == SockType.SubscriptionServer.ToString());
+            if (FormCustomization != null)
+            {
+                //Yeppers, do the validation, there are two, the custom fields and the regular fields that might be set to required
+
+                //validate users choices for required non custom fields
+                RequiredFieldsValidator.Validate(this, FormCustomization, proposedObj);
+
+                //validate custom fields
+                CustomFieldsValidator.Validate(this, FormCustomization, proposedObj.CustomFields);
+            }
+
+        }
+
+
+        private async Task ValidateCanDeleteAsync(SubscriptionServer inObj)
+        {
+
+            await Task.CompletedTask;
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //REPORTING
+        //
+        public async Task<JArray> GetReportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            var idList = dataListSelectedRequest.SelectedRowIds;
+            JArray ReportData = new JArray();
+            while (idList.Any())
+            {
+                var batch = idList.Take(IReportAbleObject.REPORT_DATA_BATCH_SIZE);
+                idList = idList.Skip(IReportAbleObject.REPORT_DATA_BATCH_SIZE).ToArray();
+
+                //query for this batch, comes back in db natural order unfortunately
+                var batchResults = await ct.SubscriptionServer.AsNoTracking().Where(z => batch.Contains(z.Id)).ToArrayAsync();
+
+                //order the results back into original
+                //What is happening here:
+                //for performance the query is batching a bunch at once by fetching a block of items from the sql server
+                //however it's returning in db order which is often not the order the id list is in
+                //so it needs to be sorted back into the same order as the ide list
+                //This would not be necessary if just fetching each one at a time individually (like in workorder get report data)
+
+                var orderedList = from id in batch join z in batchResults on id equals z.Id select z;
+                batchResults = null;
+
+                foreach (SubscriptionServer w in orderedList)
+                {
+                    if (!ReportRenderManager.KeepGoing(jobId)) return null;
+
+                    var jo = JObject.FromObject(w);
+                    if (!JsonUtil.JTokenIsNullOrEmpty(jo["CustomFields"]))
+                        jo["CustomFields"] = JObject.Parse((string)jo["CustomFields"]);
+                    ReportData.Add(jo);
+                }
+                orderedList = null;
+            }
+            vc.Clear();
+            return ReportData;
+        }
+        private VizCache vc = new VizCache();
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////       
+        // IMPORT EXPORT
+        //
+
+        public async Task<JArray> GetExportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            return await GetReportData(dataListSelectedRequest, jobId);
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //JOB / OPERATIONS
+        //
+        public async Task HandleJobAsync(OpsJob job)
+        {
+            //Hand off the particular job to the corresponding processing code
+            //NOTE: If this code throws an exception the caller (JobsBiz::ProcessJobsAsync) will automatically set the job to failed and log the exeption so 
+            //basically any error condition during job processing should throw up an exception if it can't be handled
+            switch (job.JobType)
+            {
+                case JobType.BatchCoreObjectOperation:
+                    await ProcessBatchJobAsync(job);
+                    break;
+                default:
+                    throw new System.ArgumentOutOfRangeException($"SubscriptionServerBiz.HandleJob-> Invalid job type{job.JobType.ToString()}");
+            }
+        }
+
+
+
+        private async Task ProcessBatchJobAsync(OpsJob job)
+        {
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Running);
+            await JobsBiz.LogJobAsync(job.GId, $"LT:StartJob {job.SubType}");
+            List<long> idList = new List<long>();
+            long FailedObjectCount = 0;
+            JObject jobData = JObject.Parse(job.JobInfo);
+            if (jobData.ContainsKey("idList"))
+                idList = ((JArray)jobData["idList"]).ToObject<List<long>>();
+            else
+                idList = await ct.SubscriptionServer.AsNoTracking().Select(z => z.Id).ToListAsync();
+            bool SaveIt = false;
+
+            //---------------------------------
+            //case 4192
+            TimeSpan ProgressAndCancelCheckSpan = new TimeSpan(0, 0, ServerBootConfig.JOB_PROGRESS_UPDATE_AND_CANCEL_CHECK_SECONDS);
+            DateTime LastProgressCheck = DateTime.UtcNow.Subtract(new TimeSpan(1, 1, 1, 1, 1));
+            var TotalRecords = idList.LongCount();
+            long CurrentRecord = -1;
+            //---------------------------------
+
+            foreach (long id in idList)
+            {
+                try
+                {
+                    //--------------------------------
+                    //case 4192
+                    //Update progress / cancel requested?                    
+                    CurrentRecord++;
+                    if (DateUtil.IsAfterDuration(LastProgressCheck, ProgressAndCancelCheckSpan))
+                    {
+                        await JobsBiz.UpdateJobProgressAsync(job.GId, $"{CurrentRecord}/{TotalRecords}");
+                        if (await JobsBiz.GetJobStatusAsync(job.GId) == JobStatus.CancelRequested)
+                            break;
+                        LastProgressCheck = DateTime.UtcNow;
+                    }
+                    //---------------------------------
+
+                    SaveIt = false;
+                    ClearErrors();
+                    SubscriptionServer o = null;
+                    //save a fetch if it's a delete
+                    if (job.SubType != JobSubType.Delete)
+                        o = await GetAsync(id, false);
+                    switch (job.SubType)
+                    {
+                        case JobSubType.TagAddAny:
+                        case JobSubType.TagAdd:
+                        case JobSubType.TagRemoveAny:
+                        case JobSubType.TagRemove:
+                        case JobSubType.TagReplaceAny:
+                        case JobSubType.TagReplace:
+                            SaveIt = TagBiz.ProcessBatchTagOperation(o.Tags, (string)jobData["tag"], jobData.ContainsKey("toTag") ? (string)jobData["toTag"] : null, job.SubType);
+                            break;
+                        case JobSubType.Delete:
+                            if (!await DeleteAsync(id))
+                            {
+                                await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                                FailedObjectCount++;
+                            }
+                            break;
+                        default:
+                            throw new System.ArgumentOutOfRangeException($"ProcessBatchJobAsync -> Invalid job Subtype{job.SubType}");
+                    }
+                    if (SaveIt)
+                    {
+                        o = await PutAsync(o);
+                        if (o == null)
+                        {
+                            await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                            FailedObjectCount++;
+                        }
+                    }
+
+                    //delay so we're not tying up all the resources in a tight loop
+                    await Task.Delay(Sockeye.Util.ServerBootConfig.JOB_OBJECT_HANDLE_BATCH_JOB_LOOP_DELAY);
+                }
+                catch (Exception ex)
+                {
+                    await JobsBiz.LogJobAsync(job.GId, $"LT:Errors id({id})");
+                    await JobsBiz.LogJobAsync(job.GId, ExceptionUtil.ExtractAllExceptionMessages(ex));
+                }
+            }
+
+            //---------------------------------
+            //case 4192
+            await JobsBiz.UpdateJobProgressAsync(job.GId, $"{++CurrentRecord}/{TotalRecords}");
+            //---------------------------------
+
+            await JobsBiz.LogJobAsync(job.GId, $"LT:BatchJob {job.SubType} {idList.Count}{(FailedObjectCount > 0 ? " - LT:Failed " + FailedObjectCount : "")}");
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Completed);
+        }
+
+
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        // NOTIFICATION PROCESSING
+        //
+        public async Task HandlePotentialNotificationEvent(SockEvent ayaEvent, ICoreBizObjectModel proposedObj, ICoreBizObjectModel currentObj = null)
+        {
+            ILogger log = Sockeye.Util.ApplicationLogging.CreateLogger<SubscriptionServerBiz>();
+
+            log.LogDebug($"HandlePotentialNotificationEvent processing:  [SockType:{this.BizType}, AyaEvent:{ayaEvent}]");
+
+            bool isNew = currentObj == null;
+          
+            //STANDARD EVENTS FOR ALL OBJECTS
+            await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
+
+            //SPECIFIC EVENTS FOR THIS OBJECT
+            SubscriptionServer o = (SubscriptionServer)proposedObj;
+
+            //## DELETED EVENTS
+            //any event added below needs to be removed, so
+            //just blanket remove any event for this object of eventtype that would be added below here
+            //do it regardless any time there's an update and then
+            //let this code below handle the refreshing addition that could have changes           
+            //await NotifyEventHelper.ClearPriorEventsForObject(ct, SockType.SubscriptionServer, o.Id, NotifyEventType.ContractExpiring);
+
+
+            //## CREATED / MODIFIED EVENTS
+            if (ayaEvent == SockEvent.Created || ayaEvent == SockEvent.Modified)
+            {
+
+
+
+            }
+
+        }//end of process notifications
+
+
+        /////////////////////////////////////////////////////////////////////
+
+    }//eoc
+
+
+}//eons
+

server/biz/TrialLicenseRequestBiz.cs

@@ -0,0 +1,463 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using System.Linq;
+using Sockeye.Util;
+using Sockeye.Api.ControllerHelpers;
+using Sockeye.Models;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Sockeye.Biz
+{
+    internal class TrialLicenseRequestBiz : BizObject, IJobObject, ISearchAbleObject, IReportAbleObject, IExportAbleObject, INotifiableObject
+    {
+        internal TrialLicenseRequestBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
+        {
+            ct = dbcontext;
+            UserId = currentUserId;
+            UserTranslationId = userTranslationId;
+            CurrentUserRoles = UserRoles;
+            BizType = SockType.TrialLicenseRequest;
+        }
+
+        internal static TrialLicenseRequestBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null)
+        {
+            if (httpContext != null)
+                return new TrialLicenseRequestBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items));
+            else
+                return new TrialLicenseRequestBiz(ct, 1, ServerBootConfig.SOCKEYE_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdmin);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //EXISTS 
+        internal async Task<bool> ExistsAsync(long id)
+        {
+            return await ct.TrialLicenseRequest.AnyAsync(z => z.Id == id);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //CREATE   
+        //
+        internal async Task<TrialLicenseRequest> CreateAsync(TrialLicenseRequest newObject)
+        {
+            await ValidateAsync(newObject, null);
+            if (HasErrors)
+                return null;
+            else
+            {
+                newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
+                newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
+                await ct.TrialLicenseRequest.AddAsync(newObject);
+                await ct.SaveChangesAsync();
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, SockEvent.Created), ct);
+                await SearchIndexAsync(newObject, true);
+                await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
+                await HandlePotentialNotificationEvent(SockEvent.Created, newObject);
+                return newObject;
+            }
+        }
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //GET 
+        //      
+        internal async Task<TrialLicenseRequest> GetAsync(long id, bool logTheGetEvent = true)
+        {
+            var ret = await ct.TrialLicenseRequest.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
+            if (logTheGetEvent && ret != null)
+                await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, SockEvent.Retrieved), ct);
+            return ret;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //UPDATE
+        //
+        internal async Task<TrialLicenseRequest> PutAsync(TrialLicenseRequest putObject)
+        {
+            var dbObject = await GetAsync(putObject.Id, false);
+            if (dbObject == null)
+            {
+                AddError(ApiErrorCode.NOT_FOUND, "id");
+                return null;
+            }
+            if (dbObject.Concurrency != putObject.Concurrency)
+            {
+                AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+
+            putObject.Tags = TagBiz.NormalizeTags(putObject.Tags);
+            putObject.CustomFields = JsonUtil.CompactJson(putObject.CustomFields);
+            await ValidateAsync(putObject, dbObject);
+            if (HasErrors) return null;
+            ct.Replace(dbObject, putObject);
+            try
+            {
+                await ct.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!await ExistsAsync(putObject.Id))
+                    AddError(ApiErrorCode.NOT_FOUND);
+                else
+                    AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
+                return null;
+            }
+            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, putObject.Id, BizType, SockEvent.Modified), ct);
+            await SearchIndexAsync(putObject, false);
+            await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags);
+            await HandlePotentialNotificationEvent(SockEvent.Modified, putObject, dbObject);
+            return putObject;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //DELETE
+        //
+        internal async Task<bool> DeleteAsync(long id)
+        {
+            using (var transaction = await ct.Database.BeginTransactionAsync())
+            {
+
+                TrialLicenseRequest dbObject = await GetAsync(id, false);
+                if (dbObject == null)
+                {
+                    AddError(ApiErrorCode.NOT_FOUND);
+                    return false;
+                }
+                await ValidateCanDeleteAsync(dbObject);
+                if (HasErrors)
+                    return false;
+
+
+
+
+                {
+                    var IDList = await ct.Review.AsNoTracking().Where(x => x.SockType == SockType.TrialLicenseRequest && x.ObjectId == id).Select(x => x.Id).ToListAsync();
+                    if (IDList.Count() > 0)
+                    {
+                        ReviewBiz b = new ReviewBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
+                        foreach (long ItemId in IDList)
+                            if (!await b.DeleteAsync(ItemId, transaction))
+                            {
+                                AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"Review [{ItemId}]: {b.GetErrorsAsString()}");
+                                return false;
+                            }
+                    }
+                }
+
+                ct.TrialLicenseRequest.Remove(dbObject);
+                await ct.SaveChangesAsync();
+
+                //Log event 
+                await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
+                await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
+                await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
+                await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
+                await transaction.CommitAsync();
+                await HandlePotentialNotificationEvent(SockEvent.Deleted, dbObject);
+
+                return true;
+            }
+        }
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //SEARCH
+        //
+        private async Task SearchIndexAsync(TrialLicenseRequest obj, bool isNew)
+        {
+            var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
+            DigestSearchText(obj, SearchParams);
+            if (isNew)
+                await Search.ProcessNewObjectKeywordsAsync(SearchParams);
+            else
+                await Search.ProcessUpdatedObjectKeywordsAsync(SearchParams);
+        }
+
+        public async Task<Search.SearchIndexProcessObjectParameters> GetSearchResultSummary(long id, SockType specificType)
+        {
+            var obj = await GetAsync(id, false);
+            var SearchParams = new Search.SearchIndexProcessObjectParameters();
+            DigestSearchText(obj, SearchParams);
+            return SearchParams;
+        }
+
+        public void DigestSearchText(TrialLicenseRequest obj, Search.SearchIndexProcessObjectParameters searchParams)
+        {
+            if (obj != null)
+                searchParams.AddText(obj.DbId)
+                            .AddText(obj.CompanyName)
+                            .AddText(obj.ContactName)
+                            .AddText(obj.Email)
+                            .AddText(obj.EmailConfirmCode)
+                            .AddText(obj.RejectReason)
+                            .AddText(obj.Key)                           
+                            .AddText(obj.Wiki)
+                            .AddText(obj.Tags)
+                            .AddCustomFields(obj.CustomFields);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //VALIDATION
+        //
+
+        private async Task ValidateAsync(TrialLicenseRequest proposedObj, TrialLicenseRequest currentObj)
+        {
+            bool isNew = currentObj == null;
+
+
+
+            //Any form customizations to validate?
+            var FormCustomization = await ct.FormCustom.AsNoTracking().SingleOrDefaultAsync(z => z.FormKey == SockType.TrialLicenseRequest.ToString());
+            if (FormCustomization != null)
+            {
+                //Yeppers, do the validation, there are two, the custom fields and the regular fields that might be set to required
+
+                //validate users choices for required non custom fields
+                RequiredFieldsValidator.Validate(this, FormCustomization, proposedObj);
+
+                //validate custom fields
+                CustomFieldsValidator.Validate(this, FormCustomization, proposedObj.CustomFields);
+            }
+
+        }
+
+
+        private async Task ValidateCanDeleteAsync(TrialLicenseRequest inObj)
+        {
+
+            await Task.CompletedTask;
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //REPORTING
+        //
+        public async Task<JArray> GetReportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            var idList = dataListSelectedRequest.SelectedRowIds;
+            JArray ReportData = new JArray();
+            while (idList.Any())
+            {
+                var batch = idList.Take(IReportAbleObject.REPORT_DATA_BATCH_SIZE);
+                idList = idList.Skip(IReportAbleObject.REPORT_DATA_BATCH_SIZE).ToArray();
+
+                //query for this batch, comes back in db natural order unfortunately
+                var batchResults = await ct.TrialLicenseRequest.AsNoTracking().Where(z => batch.Contains(z.Id)).ToArrayAsync();
+
+                //order the results back into original
+                //What is happening here:
+                //for performance the query is batching a bunch at once by fetching a block of items from the sql server
+                //however it's returning in db order which is often not the order the id list is in
+                //so it needs to be sorted back into the same order as the ide list
+                //This would not be necessary if just fetching each one at a time individually (like in workorder get report data)
+
+                var orderedList = from id in batch join z in batchResults on id equals z.Id select z;
+                batchResults = null;
+
+                foreach (TrialLicenseRequest w in orderedList)
+                {
+                    if (!ReportRenderManager.KeepGoing(jobId)) return null;
+                    await PopulateVizFields(w);
+                    var jo = JObject.FromObject(w);
+                    if (!JsonUtil.JTokenIsNullOrEmpty(jo["CustomFields"]))
+                        jo["CustomFields"] = JObject.Parse((string)jo["CustomFields"]);
+                    ReportData.Add(jo);
+                }
+                orderedList = null;
+            }
+            vc.Clear();
+            return ReportData;
+        }
+        private VizCache vc = new VizCache();
+
+
+        //populate viz fields from provided object
+        private async Task PopulateVizFields(TrialLicenseRequest o)
+        {
+            if (!vc.Has("customer", o.CustomerId))
+            {
+                vc.Add(await ct.Customer.AsNoTracking().Where(x => x.Id == o.CustomerId).Select(x => x.Name).FirstOrDefaultAsync(), "customer", o.CustomerId);
+            }
+            o.CustomerViz = vc.Get("customer", o.CustomerId);
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////       
+        // IMPORT EXPORT
+        //
+
+        public async Task<JArray> GetExportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId)
+        {
+            return await GetReportData(dataListSelectedRequest, jobId);
+        }
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //JOB / OPERATIONS
+        //
+        public async Task HandleJobAsync(OpsJob job)
+        {
+            //Hand off the particular job to the corresponding processing code
+            //NOTE: If this code throws an exception the caller (JobsBiz::ProcessJobsAsync) will automatically set the job to failed and log the exeption so 
+            //basically any error condition during job processing should throw up an exception if it can't be handled
+            switch (job.JobType)
+            {
+                case JobType.BatchCoreObjectOperation:
+                    await ProcessBatchJobAsync(job);
+                    break;
+                default:
+                    throw new System.ArgumentOutOfRangeException($"TrialLicenseRequestBiz.HandleJob-> Invalid job type{job.JobType.ToString()}");
+            }
+        }
+
+
+
+        private async Task ProcessBatchJobAsync(OpsJob job)
+        {
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Running);
+            await JobsBiz.LogJobAsync(job.GId, $"LT:StartJob {job.SubType}");
+            List<long> idList = new List<long>();
+            long FailedObjectCount = 0;
+            JObject jobData = JObject.Parse(job.JobInfo);
+            if (jobData.ContainsKey("idList"))
+                idList = ((JArray)jobData["idList"]).ToObject<List<long>>();
+            else
+                idList = await ct.TrialLicenseRequest.AsNoTracking().Select(z => z.Id).ToListAsync();
+            bool SaveIt = false;
+
+            //---------------------------------
+            //case 4192
+            TimeSpan ProgressAndCancelCheckSpan = new TimeSpan(0, 0, ServerBootConfig.JOB_PROGRESS_UPDATE_AND_CANCEL_CHECK_SECONDS);
+            DateTime LastProgressCheck = DateTime.UtcNow.Subtract(new TimeSpan(1, 1, 1, 1, 1));
+            var TotalRecords = idList.LongCount();
+            long CurrentRecord = -1;
+            //---------------------------------
+
+            foreach (long id in idList)
+            {
+                try
+                {
+                    //--------------------------------
+                    //case 4192
+                    //Update progress / cancel requested?                    
+                    CurrentRecord++;
+                    if (DateUtil.IsAfterDuration(LastProgressCheck, ProgressAndCancelCheckSpan))
+                    {
+                        await JobsBiz.UpdateJobProgressAsync(job.GId, $"{CurrentRecord}/{TotalRecords}");
+                        if (await JobsBiz.GetJobStatusAsync(job.GId) == JobStatus.CancelRequested)
+                            break;
+                        LastProgressCheck = DateTime.UtcNow;
+                    }
+                    //---------------------------------
+
+                    SaveIt = false;
+                    ClearErrors();
+                    TrialLicenseRequest o = null;
+                    //save a fetch if it's a delete
+                    if (job.SubType != JobSubType.Delete)
+                        o = await GetAsync(id, false);
+                    switch (job.SubType)
+                    {
+                        case JobSubType.TagAddAny:
+                        case JobSubType.TagAdd:
+                        case JobSubType.TagRemoveAny:
+                        case JobSubType.TagRemove:
+                        case JobSubType.TagReplaceAny:
+                        case JobSubType.TagReplace:
+                            SaveIt = TagBiz.ProcessBatchTagOperation(o.Tags, (string)jobData["tag"], jobData.ContainsKey("toTag") ? (string)jobData["toTag"] : null, job.SubType);
+                            break;
+                        case JobSubType.Delete:
+                            if (!await DeleteAsync(id))
+                            {
+                                await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                                FailedObjectCount++;
+                            }
+                            break;
+                        default:
+                            throw new System.ArgumentOutOfRangeException($"ProcessBatchJobAsync -> Invalid job Subtype{job.SubType}");
+                    }
+                    if (SaveIt)
+                    {
+                        o = await PutAsync(o);
+                        if (o == null)
+                        {
+                            await JobsBiz.LogJobAsync(job.GId, $"LT:Errors {GetErrorsAsString()} id {id}");
+                            FailedObjectCount++;
+                        }
+                    }
+
+                    //delay so we're not tying up all the resources in a tight loop
+                    await Task.Delay(Sockeye.Util.ServerBootConfig.JOB_OBJECT_HANDLE_BATCH_JOB_LOOP_DELAY);
+                }
+                catch (Exception ex)
+                {
+                    await JobsBiz.LogJobAsync(job.GId, $"LT:Errors id({id})");
+                    await JobsBiz.LogJobAsync(job.GId, ExceptionUtil.ExtractAllExceptionMessages(ex));
+                }
+            }
+
+            //---------------------------------
+            //case 4192
+            await JobsBiz.UpdateJobProgressAsync(job.GId, $"{++CurrentRecord}/{TotalRecords}");
+            //---------------------------------
+
+            await JobsBiz.LogJobAsync(job.GId, $"LT:BatchJob {job.SubType} {idList.Count}{(FailedObjectCount > 0 ? " - LT:Failed " + FailedObjectCount : "")}");
+            await JobsBiz.UpdateJobStatusAsync(job.GId, JobStatus.Completed);
+        }
+
+
+
+
+
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        // NOTIFICATION PROCESSING
+        //
+        public async Task HandlePotentialNotificationEvent(SockEvent ayaEvent, ICoreBizObjectModel proposedObj, ICoreBizObjectModel currentObj = null)
+        {
+            ILogger log = Sockeye.Util.ApplicationLogging.CreateLogger<TrialLicenseRequestBiz>();
+
+            log.LogDebug($"HandlePotentialNotificationEvent processing:  [SockType:{this.BizType}, AyaEvent:{ayaEvent}]");
+
+            bool isNew = currentObj == null;
+
+            proposedObj.Name = "TRIAL LICENSE REQUEST ID" + proposedObj.Id.ToString();
+            //STANDARD EVENTS FOR ALL OBJECTS
+            await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct);
+
+            //SPECIFIC EVENTS FOR THIS OBJECT
+            TrialLicenseRequest o = (TrialLicenseRequest)proposedObj;
+
+            //## DELETED EVENTS
+            //any event added below needs to be removed, so
+            //just blanket remove any event for this object of eventtype that would be added below here
+            //do it regardless any time there's an update and then
+            //let this code below handle the refreshing addition that could have changes           
+            //await NotifyEventHelper.ClearPriorEventsForObject(ct, SockType.TrialLicenseRequest, o.Id, NotifyEventType.ContractExpiring);
+
+
+            //## CREATED / MODIFIED EVENTS
+            if (ayaEvent == SockEvent.Created || ayaEvent == SockEvent.Modified)
+            {
+
+
+
+            }
+
+        }//end of process notifications
+
+
+        /////////////////////////////////////////////////////////////////////
+
+    }//eoc
+
+
+}//eons
+

server/models/SubscriptionServer.cs

@@ -15,6 +15,7 @@ namespace Sockeye.Models
         [Required]
         public string Name { get; set; }
         public bool Active { get; set; }
+        public string Notes { get; set; }
         public DateTime Created { get; set; }
         [Required]
         public string DataCenter { get; set; }

server/util/AySchema.cs

@@ -887,7 +887,7 @@ $BODY$ LANGUAGE PLPGSQL STABLE");
 
 
                 await ExecQueryAsync("CREATE TABLE asubscriptionserver (id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, active BOOL NOT NULL DEFAULT true, created TIMESTAMPTZ NOT NULL, "
-                                  + "name TEXT NOT NULL, datacenter TEXT NOT NULL, timezone TEXT NOT NULL, lastupdated TIMESTAMPTZ, subscriptionexpire TIMESTAMPTZ NOT NULL, "
+                                  + "name TEXT NOT NULL, notes TEXT, datacenter TEXT NOT NULL, timezone TEXT NOT NULL, lastupdated TIMESTAMPTZ, subscriptionexpire TIMESTAMPTZ NOT NULL, "
                                   + "trialexpire TIMESTAMPTZ, trialcontact TEXT, trialemail TEXT, trialcompany TEXT, operatingsystem TEXT, customersubdomain TEXT, "
                                   + "wiki TEXT, customfields TEXT, tags VARCHAR(255) ARRAY, licenseid BIGINT REFERENCES alicense(id), customerid BIGINT REFERENCES acustomer(id) )");