using System; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using System.Linq; using AyaNova.Util; using AyaNova.Api.ControllerHelpers; using Microsoft.Extensions.Logging; using AyaNova.Models; using Newtonsoft.Json.Linq; using System.Collections.Generic; using Newtonsoft.Json; namespace AyaNova.Biz { internal class PartBiz : BizObject, IJobObject, ISearchAbleObject, IReportAbleObject, IExportAbleObject, IImportAbleObject, INotifiableObject { internal PartBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles) { ct = dbcontext; UserId = currentUserId; UserTranslationId = userTranslationId; CurrentUserRoles = UserRoles; BizType = AyaType.Part; } internal static PartBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null) { if (httpContext != null) return new PartBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items)); else return new PartBiz(ct, 1, ServerBootConfig.AYANOVA_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdmin); } //////////////////////////////////////////////////////////////////////////////////////////////// //EXISTS internal async Task ExistsAsync(long id) { return await ct.Part.AnyAsync(z => z.Id == id); } //////////////////////////////////////////////////////////////////////////////////////////////// //CREATE // internal async Task CreateAsync(Part newObject) { await ValidateAsync(newObject, null); if (HasErrors) return null; else { newObject.Tags = TagBiz.NormalizeTags(newObject.Tags); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); await ct.Part.AddAsync(newObject); await ct.SaveChangesAsync(); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await SearchIndexAsync(newObject, true); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await HandlePotentialNotificationEvent(AyaEvent.Created, newObject); return newObject; } } // //////////////////////////////////////////////////////////////////////////////////////////////// // //DUPLICATE // // // internal async Task DuplicateAsync(long id) // { // Part dbObject = await GetAsync(id, false); // if (dbObject == null) // { // AddError(ApiErrorCode.NOT_FOUND, "id"); // return null; // } // Part newObject = new Part(); // CopyObject.Copy(dbObject, newObject, "Wiki"); // string newUniqueName = string.Empty; // bool NotUnique = true; // long l = 1; // do // { // newUniqueName = Util.StringUtil.UniqueNameBuilder(dbObject.Name, l++, 255); // NotUnique = await ct.Part.AnyAsync(m => m.Name == newUniqueName); // } while (NotUnique); // newObject.Name = newUniqueName; // newObject.Id = 0; // newObject.Concurrency = 0; // await ct.Part.AddAsync(newObject); // await ct.SaveChangesAsync(); // await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); // await SearchIndexAsync(newObject, true); // await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); // await HandlePotentialNotificationEvent(AyaEvent.Created, newObject); // return newObject; // } //////////////////////////////////////////////////////////////////////////////////////////////// //GET // internal async Task GetAsync(long id, bool logTheGetEvent = true) { var ret = await ct.Part.AsNoTracking().SingleOrDefaultAsync(m => m.Id == id); if (logTheGetEvent && ret != null) await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Retrieved), ct); return ret; } //////////////////////////////////////////////////////////////////////////////////////////////// //UPDATE // internal async Task PutAsync(Part 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, dbObject.Id, BizType, AyaEvent.Modified), ct); await SearchIndexAsync(putObject, false); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags); await HandlePotentialNotificationEvent(AyaEvent.Modified, putObject, dbObject); return putObject; } //////////////////////////////////////////////////////////////////////////////////////////////// //DELETE // internal async Task DeleteAsync(long id) { using (var transaction = await ct.Database.BeginTransactionAsync()) { Part 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.AType == AyaType.Part && 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.Part.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(AyaEvent.Deleted, dbObject); return true; } } //////////////////////////////////////////////////////////////////////////////////////////////// //UPDATESERIALS // internal async Task> PutSerialsAsync(long id, List serials) { //Fixup serials int nAdded = 0; int nRemoved = 0; var ExistingSerials = await ct.PartSerial.Where(z => z.PartId == id).OrderBy(z => z.Serial).ToListAsync(); //Remove any that should not be there anymore foreach (PartSerial ps in ExistingSerials) { if (!serials.Contains(ps.Serial)) { ct.PartSerial.Remove(ps); nRemoved++; } } //Add any new ones foreach (string s in serials) { if (!ExistingSerials.Any(z => z.Serial == s)) { ct.PartSerial.Add(new PartSerial() { Serial = s, PartId = id }); nAdded++; } } try { await ct.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!await ExistsAsync(id)) AddError(ApiErrorCode.NOT_FOUND); else AddError(ApiErrorCode.CONCURRENCY_CONFLICT); return null; } await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Modified, $"LT:PartSerialNumbersAvailable change (+{nAdded}, -{nRemoved})"), ct); return await ct.PartSerial.Where(z => z.PartId == id).OrderBy(z => z.Serial).Select(z => z.Serial).ToListAsync(); } //////////////////////////////////////////////////////////////////////////////////////////////// //APPEND SERIALS - called by PO add and WorkOrderItemPart delete ops to add serials to a part // internal static async Task AppendSerialsAsync(long partId, string serialText, AyContext ct, long UserId) { if (string.IsNullOrWhiteSpace(serialText)) return; var serials = System.Text.RegularExpressions.Regex.Split(serialText, "[\\s,]+", System.Text.RegularExpressions.RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(2000)).Select(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().OrderBy(x => x).ToArray(); int nAdded = 0; var ExistingSerials = await ct.PartSerial.Where(z => z.PartId == partId).OrderBy(z => z.Serial).ToListAsync(); //Add any new ones foreach (string s in serials) { if (!ExistingSerials.Any(z => z.Serial == s)) { ct.PartSerial.Add(new PartSerial() { Serial = s, PartId = partId }); nAdded++; } } await ct.SaveChangesAsync(); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, partId, AyaType.Part, AyaEvent.Modified, $"LT:PartSerialNumbersAvailable change (+{nAdded})"), ct); } //////////////////////////////////////////////////////////////////////////////////////////////// //REMOVE SERIALS - called by PO delete ops and WorkOrderItemPart create ops to remove serials from a part // internal static async Task RemoveSerialsAsync(long partId, string serialText, AyContext ct, long UserId) { if (string.IsNullOrWhiteSpace(serialText)) return; var serials = System.Text.RegularExpressions.Regex.Split(serialText, "[\\s,]+", System.Text.RegularExpressions.RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(2000)).Select(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().OrderBy(x => x).ToArray(); int nRemoved = 0; var ExistingSerials = await ct.PartSerial.Where(z => z.PartId == partId).OrderBy(z => z.Serial).ToListAsync(); foreach (PartSerial ps in ExistingSerials) { if (serials.Contains(ps.Serial)) { ct.PartSerial.Remove(ps); nRemoved++; } } await ct.SaveChangesAsync(); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, partId, AyaType.Part, AyaEvent.Modified, $"LT:PartSerialNumbersAvailable change (-{nRemoved})"), ct); } //////////////////////////////////////////////////////////////////////////////////////////////// //UPDATE STOCK LEVELS // internal async Task> PutStockLevelsAsync(long id, List putPartStockLevels) { //Fixup serials int nAdded = 0; int nRemoved = 0; var ExistingStockLevels = await ct.PartStockLevel.Where(z => z.PartId == id).ToListAsync(); //Remove any that should not be there anymore and update any that should foreach (PartStockLevel existingPS in ExistingStockLevels) { var putPS = putPartStockLevels.Where(z => z.PartWarehouseId == existingPS.PartWarehouseId).FirstOrDefault(); if (putPS == null) { //no longer in the existing collection so ditch it ct.PartStockLevel.Remove(existingPS); nRemoved++; } else { //still here, so update if necessary existingPS.MinimumQuantity = putPS.MinimumQuantity; } } //Add any new ones foreach (PartStockLevel putPS in putPartStockLevels) { if (!ExistingStockLevels.Any(z => z.PartWarehouseId == putPS.PartWarehouseId)) { ct.PartStockLevel.Add(new PartStockLevel() { PartWarehouseId = putPS.PartWarehouseId, PartId = id, MinimumQuantity = putPS.MinimumQuantity }); nAdded++; } } try { await ct.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!await ExistsAsync(id)) AddError(ApiErrorCode.NOT_FOUND); else AddError(ApiErrorCode.CONCURRENCY_CONFLICT); return null; } await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Modified, $"LT:PartStockingLevels change (+{nAdded}, -{nRemoved})"), ct); var ret = await ct.PartStockLevel.AsNoTracking().Where(z => z.PartId == id).OrderBy(z => z.PartWarehouseId).ToListAsync(); foreach (PartStockLevel ps in ret) { ps.PartWarehouseDisplay = await ct.PartWarehouse.AsNoTracking().Where(z => z.Id == ps.PartWarehouseId).Select(z => z.Name).FirstOrDefaultAsync(); } return ret; } //////////////////////////////////////////////////////////////////////////////////////////////// //UPDATE PART COST // internal async Task PutPartCostAsync(long id, decimal newCost) { var dbObject = await ct.Part.FirstOrDefaultAsync(x => x.Id == id); if (dbObject == null) { AddError(ApiErrorCode.NOT_FOUND, "id"); return false; } dbObject.Cost = newCost; try { await ct.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!await ExistsAsync(id)) AddError(ApiErrorCode.NOT_FOUND); else AddError(ApiErrorCode.CONCURRENCY_CONFLICT); return false; } await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); return true; } //////////////////////////////////////////////////////////////////////////////////////////////// //SEARCH // private async Task SearchIndexAsync(Part 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 GetSearchResultSummary(long id, AyaType specificType) { var obj = await GetAsync(id, false); var SearchParams = new Search.SearchIndexProcessObjectParameters(); DigestSearchText(obj, SearchParams); return SearchParams; } public void DigestSearchText(Part obj, Search.SearchIndexProcessObjectParameters searchParams) { if (obj != null) searchParams.AddText(obj.Notes) .AddText(obj.Name) .AddText(obj.Description) .AddText(obj.ManufacturerNumber) .AddText(obj.WholeSalerNumber) .AddText(obj.AlternativeWholeSalerNumber) .AddText(obj.UnitOfMeasure) .AddText(obj.UPC) .AddText(obj.Wiki) .AddText(obj.Tags) .AddCustomFields(obj.CustomFields); } //////////////////////////////////////////////////////////////////////////////////////////////// //VALIDATION // private async Task ValidateAsync(Part proposedObj, Part currentObj) { bool isNew = currentObj == null; //name required if (string.IsNullOrWhiteSpace(proposedObj.Name)) AddError(ApiErrorCode.VALIDATION_REQUIRED, "PartName"); //If name is otherwise OK, check that Name is unique if (!PropertyHasErrors("Name")) { //Use Any command is efficient way to check existance, it doesn't return the record, just a true or false if (await ct.Part.AnyAsync(m => m.Name == proposedObj.Name && m.Id != proposedObj.Id)) { AddError(ApiErrorCode.VALIDATION_NOT_UNIQUE, "PartName"); } } //MIGRATE_OUTSTANDING awaiting inventory / biz rule to ensure serialized part can't be unserialized if there is any inventory /* BrokenRules.Assert("TrackSerialNumberRequired", "Part.Error.MustTrackSerial", "TrackSerialNumber", !this.IsNew && value==false && PartHasSerialNumbers.GetItem(this.mID)); //case 1011 BrokenRules.Assert("TrackSerialHasInventory", "Part.Error.TrackSerialHasInventory", "TrackSerialNumber", !this.IsNew && value == true && PartInventoryValuesFetcher.GetItem(mID).QuantityOnHand>0); */ //Any form customizations to validate? var FormCustomization = await ct.FormCustom.AsNoTracking().SingleOrDefaultAsync(x => x.FormKey == AyaType.Part.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(Part inObj) { //Referential integrity //FOREIGN KEY CHECKS if (await ct.PartSerial.AnyAsync(m => m.PartId == inObj.Id)) AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PartSerial")); if (await ct.PartAssemblyItem.AnyAsync(z => z.PartId == inObj.Id) == true) AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PartAssembly")); if (await ct.PartInventory.AnyAsync(z => z.PartId == inObj.Id) == true) AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PartInventoryList"));//translates to "Part inventory" if (await ct.PartStockLevel.AnyAsync(m => m.PartId == inObj.Id)) AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PartStockingLevels")); if (await ct.PurchaseOrderItem.AnyAsync(m => m.PartId == inObj.Id)) AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PurchaseOrder")); } //////////////////////////////////////////////////////////////////////////////////////////////// //REPORTING // public async Task 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.Part.AsNoTracking().Where(z => batch.Contains(z.Id)).ToArrayAsync(); //order the results back into original var orderedList = from id in batch join z in batchResults on id equals z.Id select z; batchResults = null; foreach (Part 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(Part o) { if (o.WholeSalerId != null) { if (!vc.Has("vendorname", o.WholeSalerId)) vc.Add(await ct.Vendor.AsNoTracking().Where(x => x.Id == o.WholeSalerId).Select(x => x.Name).FirstOrDefaultAsync(), "vendorname", o.WholeSalerId); o.WholeSalerViz = vc.Get("vendorname", o.WholeSalerId); } if (o.ManufacturerId != null) { if (!vc.Has("vendorname", o.ManufacturerId)) vc.Add(await ct.Vendor.AsNoTracking().Where(x => x.Id == o.ManufacturerId).Select(x => x.Name).FirstOrDefaultAsync(), "vendorname", o.ManufacturerId); o.ManufacturerViz = vc.Get("vendorname", o.ManufacturerId); } if (o.AlternativeWholeSalerId != null) { if (!vc.Has("vendorname", o.AlternativeWholeSalerId)) vc.Add(await ct.Vendor.AsNoTracking().Where(x => x.Id == o.AlternativeWholeSalerId).Select(x => x.Name).FirstOrDefaultAsync(), "vendorname", o.AlternativeWholeSalerId); o.AlternativeWholeSalerViz = vc.Get("vendorname", o.AlternativeWholeSalerId); } //if there turns out to be a situation where there are just too many serials slowing down the reporting always //can look at tying this to the report data list column selection to check if serials are selected to display or not o.PartSerialsViz = string.Join(", ", (await ct.PartSerial.Where(z => z.PartId == o.Id).OrderBy(z => z.Serial).Select(z => z.Serial).ToListAsync())); } //////////////////////////////////////////////////////////////////////////////////////////////// // IMPORT EXPORT // public async Task GetExportData(DataListSelectedRequest dataListSelectedRequest, Guid jobId) { //for now just re-use the report data code //this may turn out to be the pattern for most biz object types but keeping it seperate allows for custom usage from time to time return await GetReportData(dataListSelectedRequest, jobId); } public async Task> ImportData(JArray ja) { List ImportResult = new List(); string ImportTag = $"imported-{FileUtil.GetSafeDateFileName()}"; var jsset = JsonSerializer.CreateDefault(new JsonSerializerSettings { ContractResolver = new AyaNova.Util.JsonUtil.ShouldSerializeContractResolver(new string[] { "Concurrency", "Id", "CustomFields" }) }); foreach (JObject j in ja) { var w = j.ToObject(jsset); if (j["CustomFields"] != null) w.CustomFields = j["CustomFields"].ToString(); w.Tags.Add(ImportTag);//so user can find them all and revert later if necessary var res = await CreateAsync(w); if (res == null) { ImportResult.Add($"* {w.Name} - {this.GetErrorsAsString()}"); this.ClearErrors(); } else { ImportResult.Add($"{w.Name} - ok"); } } return ImportResult; } //////////////////////////////////////////////////////////////////////////////////////////////// //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($"ProjectBiz.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 idList = new List(); long FailedObjectCount = 0; JObject jobData = JObject.Parse(job.JobInfo); if (jobData.ContainsKey("idList")) idList = ((JArray)jobData["idList"]).ToObject>(); else idList = await ct.Part.AsNoTracking().Select(z => z.Id).ToListAsync(); bool SaveIt = false; foreach (long id in idList) { try { SaveIt = false; ClearErrors(); Part 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++; } } } catch (Exception ex) { await JobsBiz.LogJobAsync(job.GId, $"LT:Errors id({id})"); await JobsBiz.LogJobAsync(job.GId, ExceptionUtil.ExtractAllExceptionMessages(ex)); } } 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(AyaEvent ayaEvent, ICoreBizObjectModel proposedObj, ICoreBizObjectModel currentObj = null) { ILogger log = AyaNova.Util.ApplicationLogging.CreateLogger(); if (ServerBootConfig.SEEDING || ServerBootConfig.MIGRATING) return; log.LogDebug($"HandlePotentialNotificationEvent processing: [AyaType:{this.BizType}, AyaEvent:{ayaEvent}]"); bool isNew = currentObj == null; //STANDARD EVENTS FOR ALL OBJECTS await NotifyEventHelper.ProcessStandardObjectEvents(ayaEvent, proposedObj, ct); //SPECIFIC EVENTS FOR THIS OBJECT }//end of process notifications ///////////////////////////////////////////////////////////////////// }//eoc }//eons