admin/raven
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reorg tag stuff

Browse Source
This commit is contained in:
John Cardinal
2020-05-16 19:55:43 +00:00
parent 69be6961ec
commit ba07b03893
23 changed files with 562 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
devdocs/todo.txt
View File

@@ -31,6 +31,9 @@ todo: API root controller
todo: api / server landing page is shitty on a mobile todo: api / server landing page is shitty on a mobile
and really just shitty, add a logo or some shit and really just shitty, add a logo or some shit
todo: Should server show uptime somewhere? todo: Should server show uptime somewhere?
todo: jobs should have a kill by time so they can't just sit running forever
also is there a way to kill a stuck job via ui possible?
todo: Log configuration into server log at startup? https://rockfish.ayanova.com/default.htm#!/rfcaseEdit/3523 todo: Log configuration into server log at startup? https://rockfish.ayanova.com/default.htm#!/rfcaseEdit/3523
log all config settings into server log on boot log all config settings into server log on boot
todo:aycontext clean up old block of weird definitions todo:aycontext clean up old block of weird definitions

20
server/AyaNova/Controllers/TagController.cs
View File

@@ -53,7 +53,7 @@ namespace AyaNova.Api.Controllers
{ {
if (serverState.IsClosed) if (serverState.IsClosed)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
return Ok(ApiOkResponse.Response(await TagUtil.TagListFilteredAsync(ct, query), true)); return Ok(ApiOkResponse.Response(await TagBiz.TagListFilteredAsync(ct, query), true));
} }
/// <summary> /// <summary>
@@ -66,7 +66,7 @@ namespace AyaNova.Api.Controllers
{ {
if (serverState.IsClosed) if (serverState.IsClosed)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
return Ok(ApiOkResponse.Response(await TagUtil.CloudListFilteredAsync(ct, query), true)); return Ok(ApiOkResponse.Response(await TagBiz.CloudListFilteredAsync(ct, query), true));
} }
@@ -94,7 +94,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (idList.Count == 0) if (idList.Count == 0)
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids"));
tag = TagUtil.NormalizeTag(tag); tag = TagBiz.NormalizeTag(tag);
if (string.IsNullOrWhiteSpace(tag)) if (string.IsNullOrWhiteSpace(tag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag"));
@@ -135,7 +135,7 @@ namespace AyaNova.Api.Controllers
if (!Authorized.HasModifyRole(HttpContext.Items, ayaType)) if (!Authorized.HasModifyRole(HttpContext.Items, ayaType))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
tag = TagUtil.NormalizeTag(tag); tag = TagBiz.NormalizeTag(tag);
if (string.IsNullOrWhiteSpace(tag)) if (string.IsNullOrWhiteSpace(tag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag"));
@@ -177,7 +177,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (idList.Count == 0) if (idList.Count == 0)
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids"));
tag = TagUtil.NormalizeTag(tag); tag = TagBiz.NormalizeTag(tag);
if (string.IsNullOrWhiteSpace(tag)) if (string.IsNullOrWhiteSpace(tag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag"));
@@ -219,7 +219,7 @@ namespace AyaNova.Api.Controllers
if (!Authorized.HasModifyRole(HttpContext.Items, ayaType)) if (!Authorized.HasModifyRole(HttpContext.Items, ayaType))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
tag = TagUtil.NormalizeTag(tag); tag = TagBiz.NormalizeTag(tag);
if (string.IsNullOrWhiteSpace(tag)) if (string.IsNullOrWhiteSpace(tag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "tag"));
@@ -263,10 +263,10 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (idList.Count == 0) if (idList.Count == 0)
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "List of ids"));
fromTag = TagUtil.NormalizeTag(fromTag); fromTag = TagBiz.NormalizeTag(fromTag);
if (string.IsNullOrWhiteSpace(fromTag)) if (string.IsNullOrWhiteSpace(fromTag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "fromTag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "fromTag"));
toTag = TagUtil.NormalizeTag(toTag); toTag = TagBiz.NormalizeTag(toTag);
if (string.IsNullOrWhiteSpace(toTag)) if (string.IsNullOrWhiteSpace(toTag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "toTag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "toTag"));
var JobName = $"BulkReplace tag \"{fromTag}\" with tag \"{toTag}\" on {ayaType} ({idList.Count} specified)"; var JobName = $"BulkReplace tag \"{fromTag}\" with tag \"{toTag}\" on {ayaType} ({idList.Count} specified)";
@@ -308,11 +308,11 @@ namespace AyaNova.Api.Controllers
if (!Authorized.HasModifyRole(HttpContext.Items, ayaType)) if (!Authorized.HasModifyRole(HttpContext.Items, ayaType))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
fromTag = TagUtil.NormalizeTag(fromTag); fromTag = TagBiz.NormalizeTag(fromTag);
if (string.IsNullOrWhiteSpace(fromTag)) if (string.IsNullOrWhiteSpace(fromTag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "fromTag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "fromTag"));
toTag = TagUtil.NormalizeTag(toTag); toTag = TagBiz.NormalizeTag(toTag);
if (string.IsNullOrWhiteSpace(toTag)) if (string.IsNullOrWhiteSpace(toTag))
return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "toTag")); return BadRequest(new ApiErrorResponse(ApiErrorCode.VALIDATION_REQUIRED, "toTag"));

2
server/AyaNova/DataList/DataListSqlFilterCriteriaBuilder.cs
View File

@@ -553,7 +553,7 @@ code from picklist in case I decide to do it later
//sounds like it might fuck up when using other languages so... //sounds like it might fuck up when using other languages so...
StringBuilder sbTags = new StringBuilder(); StringBuilder sbTags = new StringBuilder();
sbTags.Append("@> array["); sbTags.Append("@> array[");
List<string> normalizedTags = TagUtil.NormalizeTags(sTags); List<string> normalizedTags = TagBiz.NormalizeTags(sTags);
foreach (string s in normalizedTags) foreach (string s in normalizedTags)
{ {

12
server/AyaNova/biz/ContractBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Contract.AddAsync(newObject); await ct.Contract.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Contract SnapshotOfOriginalDBObj = new Contract(); Contract SnapshotOfOriginalDBObj = new Contract();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/CustomerBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Customer.AddAsync(newObject); await ct.Customer.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Customer SnapshotOfOriginalDBObj = new Customer(); Customer SnapshotOfOriginalDBObj = new Customer();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/HeadOfficeBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.HeadOffice.AddAsync(newObject); await ct.HeadOffice.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
HeadOffice SnapshotOfOriginalDBObj = new HeadOffice(); HeadOffice SnapshotOfOriginalDBObj = new HeadOffice();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/LoanUnitBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.LoanUnit.AddAsync(newObject); await ct.LoanUnit.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
LoanUnit SnapshotOfOriginalDBObj = new LoanUnit(); LoanUnit SnapshotOfOriginalDBObj = new LoanUnit();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

10
server/AyaNova/biz/PMBiz.cs
View File

@@ -93,7 +93,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, o.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, o.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(o, true); await SearchIndexAsync(o, true);
// await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, o.Tags, null); // await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, o.Tags, null);
return o; return o;
//} //}
@@ -134,7 +134,7 @@ namespace AyaNova.Biz
// //Handle child and associated items: // //Handle child and associated items:
// await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); // await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
// await SearchIndexAsync(outObj, true); // await SearchIndexAsync(outObj, true);
// await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); // await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
// return outObj; // return outObj;
} }
@@ -160,7 +160,7 @@ namespace AyaNova.Biz
dbObj.Serial = putObj.Serial; dbObj.Serial = putObj.Serial;
} }
dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags); dbObj.Tags = TagBiz.NormalizeTags(dbObj.Tags);
dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields); dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
//Set "original" value of concurrency token to input token //Set "original" value of concurrency token to input token
@@ -175,7 +175,7 @@ namespace AyaNova.Biz
//Log event and save context //Log event and save context
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObj, false); await SearchIndexAsync(dbObj, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
return true; return true;
} }
@@ -221,7 +221,7 @@ namespace AyaNova.Biz
// //Log event // //Log event
// await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Serial.ToString(), ct); // await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Serial.ToString(), ct);
// await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType); // await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
// await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags); // await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
// return true; // return true;
} }

12
server/AyaNova/biz/PMTemplateBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.PMTemplate.AddAsync(newObject); await ct.PMTemplate.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
PMTemplate SnapshotOfOriginalDBObj = new PMTemplate(); PMTemplate SnapshotOfOriginalDBObj = new PMTemplate();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/PartBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Part.AddAsync(newObject); await ct.Part.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Part SnapshotOfOriginalDBObj = new Part(); Part SnapshotOfOriginalDBObj = new Part();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/ProjectBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Project.AddAsync(newObject); await ct.Project.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Project SnapshotOfOriginalDBObj = new Project(); Project SnapshotOfOriginalDBObj = new Project();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/PurchaseOrderBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.PurchaseOrder.AddAsync(newObject); await ct.PurchaseOrder.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
PurchaseOrder SnapshotOfOriginalDBObj = new PurchaseOrder(); PurchaseOrder SnapshotOfOriginalDBObj = new PurchaseOrder();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

10
server/AyaNova/biz/QuoteBiz.cs
View File

@@ -92,7 +92,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, o.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, o.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(o, true); await SearchIndexAsync(o, true);
// await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, o.Tags, null); // await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, o.Tags, null);
return o; return o;
//} //}
@@ -134,7 +134,7 @@ namespace AyaNova.Biz
// //Handle child and associated items: // //Handle child and associated items:
// await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); // await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
// await SearchIndexAsync(outObj, true); // await SearchIndexAsync(outObj, true);
// await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); // await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
// return outObj; // return outObj;
} }
@@ -160,7 +160,7 @@ namespace AyaNova.Biz
dbObj.Serial = putObj.Serial; dbObj.Serial = putObj.Serial;
} }
dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags); dbObj.Tags = TagBiz.NormalizeTags(dbObj.Tags);
dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields); dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
//Set "original" value of concurrency token to input token //Set "original" value of concurrency token to input token
@@ -175,7 +175,7 @@ namespace AyaNova.Biz
//Log event and save context //Log event and save context
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObj, false); await SearchIndexAsync(dbObj, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
return true; return true;
} }
@@ -222,7 +222,7 @@ namespace AyaNova.Biz
// //Log event // //Log event
// await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Serial.ToString(), ct); // await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Serial.ToString(), ct);
// await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType); // await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
// await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags); // await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
// return true; // return true;
} }

12
server/AyaNova/biz/QuoteTemplateBiz.cs
View File

@@ -70,7 +70,7 @@ namespace AyaNova.Biz
//do stuff with QuoteTemplate //do stuff with QuoteTemplate
QuoteTemplate outObj = inObj; QuoteTemplate outObj = inObj;
outObj.Tags = TagUtil.NormalizeTags(outObj.Tags); outObj.Tags = TagBiz.NormalizeTags(outObj.Tags);
outObj.CustomFields = JsonUtil.CompactJson(outObj.CustomFields); outObj.CustomFields = JsonUtil.CompactJson(outObj.CustomFields);
//Save to db //Save to db
await ct.QuoteTemplate.AddAsync(outObj); await ct.QuoteTemplate.AddAsync(outObj);
@@ -78,7 +78,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(outObj, true); await SearchIndexAsync(outObj, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
return outObj; return outObj;
} }
@@ -119,7 +119,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(outObj, true); await SearchIndexAsync(outObj, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
return outObj; return outObj;
} }
@@ -139,7 +139,7 @@ namespace AyaNova.Biz
//Replace the db object with the PUT object //Replace the db object with the PUT object
CopyObject.Copy(inObj, dbObj, "Id"); CopyObject.Copy(inObj, dbObj, "Id");
dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags); dbObj.Tags = TagBiz.NormalizeTags(dbObj.Tags);
dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields); dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
//Set "original" value of concurrency token to input token //Set "original" value of concurrency token to input token
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event and save context //Log event and save context
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObj, false); await SearchIndexAsync(dbObj, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
return true; return true;
} }
@@ -197,7 +197,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
return true; return true;
} }

214
server/AyaNova/biz/TagBiz.cs
View File

@@ -1,13 +1,16 @@
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using EnumsNET;
using AyaNova.Util; using AyaNova.Util;
using AyaNova.Api.ControllerHelpers; using AyaNova.Api.ControllerHelpers;
using AyaNova.Models; using AyaNova.Models;
using System.Collections.Generic;
using System;
using System.Linq;
namespace AyaNova.Biz namespace AyaNova.Biz
{ {
//This class exists to process bulk tag job operations only
internal class TagBiz : BizObject, IJobObject internal class TagBiz : BizObject, IJobObject
{ {
internal TagBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles) internal TagBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
@@ -28,6 +31,213 @@ namespace AyaNova.Biz
} }
#region Utilities
/////////////////////////////////////
//UTILITIES
//
//clean up tags from client submission
//remove dupes, substitute dashes for spaces, lowercase and shorten if exceed 255 chars
//and sorts before returning to ensure consistent ordering
public static List<string> NormalizeTags(List<string> inTags)
{
if (inTags == null || inTags.Count == 0) return inTags;
List<string> outTags = new List<string>();
foreach (var tag in inTags)
outTags.Add(NormalizeTag(tag));
outTags.Sort();
return outTags.Distinct().ToList();
}
public static string NormalizeTag(string inObj)
{
if (string.IsNullOrWhiteSpace(inObj)) return null;
//Must be lowercase per rules
//This may be naive when we get international cust omers but for now supporting utf-8 and it appears it's safe to do this with unicode
inObj = inObj.ToLowerInvariant();
//No spaces in tags, replace with dashes
inObj = inObj.Replace(" ", "-");
//Remove multiple dash sequences
inObj = System.Text.RegularExpressions.Regex.Replace(inObj, "-+", "-");
//Ensure doesn't start or end with a dash
inObj = inObj.Trim('-');
//No longer than 255 characters
inObj = StringUtil.MaxLength(inObj, 255);
return inObj;
}
public static async Task ProcessDeleteTagsInRepositoryAsync(AyContext ct, List<string> deleteTags)
{
if (deleteTags.Count == 0) return;
foreach (string s in deleteTags)
{
bool bDone = false;
//Keep on trying until there is success
//this allows for concurrency issues
//I considered a circuit breaker / timeout here, but theoretically it should not be an issue
//at some point it should not be a concurrency issue anymore
//And this is not critical functionality requiring a transaction and locking
do
{
//START: Get tag word and concurrency token and count
var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s);
//if not present, then nothing to do
if (ExistingTag != null)
{
//No longer needed?
if (ExistingTag.RefCount == 1)
{
ct.Remove(ExistingTag);
}
else
{
//Decrement the refcount
ExistingTag.RefCount -= 1;
}
try
{
await ct.SaveChangesAsync();
bDone = true;
}
catch (Exception ex) when (ex is DbUpdateConcurrencyException)//allow for possible other types
{
//allow others to flow past
// string sss = ex.ToString();
}
}
} while (bDone == false);
}
}
public static async Task ProcessUpdateTagsInRepositoryAsync(AyContext ct, List<string> newTags, List<string> originalTags = null)
{
//just in case no new tags are present which could mean a user removed all tags from a record so this
//needs to proceed with the code below even if newTags is null as long as originalTags isn't also null
if (newTags == null) newTags = new List<string>();
if (originalTags == null) originalTags = new List<string>();
if (newTags.Count == 0 && originalTags.Count == 0) return;
List<string> deleteTags = new List<string>();
List<string> addTags = new List<string>();
if (originalTags != null)
{
//Update
//This logic to only come up with CHANGES, if the item is in both lists then it will disappear and not need to be dealt with as it's refcount is unchanged in this operation
//testing will validate it
deleteTags = originalTags.Except(newTags).ToList();
addTags = newTags.Except(originalTags).ToList();
}
else
{
//Add
addTags = newTags;
}
//ADD / INCREMENT TAGS
foreach (string s in addTags)
{
bool bDone = false;
//Keep on trying until there is success
//this allows for concurrency issues
//I considered a circuit breaker / timeout here, but theoretically it should not be an issue
//at some point it should not be a concurrency issue anymore
do
{
//START: Get tag word and concurrency token and count
var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s);
//if not present, then add it with a count of 0
if (ExistingTag == null)
{
await ct.Tag.AddAsync(new Tag() { Name = s, RefCount = 1 });
}
else
{
//Update the refcount
ExistingTag.RefCount += 1;
}
try
{
await ct.SaveChangesAsync();
bDone = true;
}
catch (Exception ex) when (ex is DbUpdateConcurrencyException)//this allows for other types
{
//allow others to flow past
//string sss = ex.ToString();
}
} while (bDone == false);
}
//DELETE TAGS
await ProcessDeleteTagsInRepositoryAsync(ct, deleteTags);
}
//Pick list for driving pick list route
//going with contains for now as I think it's more useful in the long run and still captures startswith intent by user
public static async Task<List<string>> TagListFilteredAsync(AyContext ct, string q)
{
//This path is intended for internal use and accepts that there may not be a filter specified
//however the client will always require a filter to display a tag list for choosing from
if (string.IsNullOrWhiteSpace(q))
{
return await ct.Tag.OrderBy(x => x.Name)
.Select(x => x.Name)
.AsNoTracking()
.ToListAsync();
}
else
{
q = NormalizeTag(q);
return await ct.Tag
.Where(x => x.Name.Contains(q))
.OrderBy(x => x.Name)
.Select(x => x.Name)
.Take(25)
.AsNoTracking()
.ToListAsync();
}
}
//Cloud list
public static async Task<List<TagCloudItem>> CloudListFilteredAsync(AyContext ct, string q)
{
//This path is intended for internal use and accepts that there may not be a filter specified
//however the client will always require a filter to display a tag list for choosing from
if (string.IsNullOrWhiteSpace(q))
{
return await ct.Tag.OrderByDescending(x => x.RefCount).Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount }).AsNoTracking().ToListAsync();
}
else
{
q = NormalizeTag(q);
//TODO: Use the EF CORE TAKE method to restrict the results to a maximum limit
//however need to ensure it doesn't balk when the limit is higher than the number of results (probably not but test that)
return await ct.Tag
.Where(x => x.Name.Contains(q))
.OrderByDescending(x => x.RefCount)
.Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount })
.AsNoTracking()
.ToListAsync();
}
}
public class TagCloudItem
{
public long RefCount { get; set; }
public string Name { get; set; }
}
#endregion utilities
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//JOB / OPERATIONS //JOB / OPERATIONS

411
server/AyaNova/biz/TagUtil.cs
View File

@@ -10,257 +10,208 @@ namespace AyaNova.Biz
{ {
public static class TagUtil public static class TagUtil
{ {
//clean up tags from client submission // //clean up tags from client submission
//remove dupes, substitute dashes for spaces, lowercase and shorten if exceed 255 chars // //remove dupes, substitute dashes for spaces, lowercase and shorten if exceed 255 chars
//and sorts before returning to ensure consistent ordering // //and sorts before returning to ensure consistent ordering
public static List<string> NormalizeTags(List<string> inTags) // public static List<string> NormalizeTags(List<string> inTags)
{ // {
if (inTags == null || inTags.Count == 0) return inTags; // if (inTags == null || inTags.Count == 0) return inTags;
List<string> outTags = new List<string>(); // List<string> outTags = new List<string>();
foreach (var tag in inTags) // foreach (var tag in inTags)
outTags.Add(NormalizeTag(tag)); // outTags.Add(NormalizeTag(tag));
outTags.Sort(); // outTags.Sort();
return outTags.Distinct().ToList(); // return outTags.Distinct().ToList();
} // }
public static string NormalizeTag(string inObj) // public static string NormalizeTag(string inObj)
{ // {
if(string.IsNullOrWhiteSpace(inObj)) return null; // if(string.IsNullOrWhiteSpace(inObj)) return null;
//Must be lowercase per rules // //Must be lowercase per rules
//This may be naive when we get international cust omers but for now supporting utf-8 and it appears it's safe to do this with unicode // //This may be naive when we get international cust omers but for now supporting utf-8 and it appears it's safe to do this with unicode
inObj = inObj.ToLowerInvariant(); // inObj = inObj.ToLowerInvariant();
//No spaces in tags, replace with dashes // //No spaces in tags, replace with dashes
inObj = inObj.Replace(" ", "-"); // inObj = inObj.Replace(" ", "-");
//Remove multiple dash sequences // //Remove multiple dash sequences
inObj = System.Text.RegularExpressions.Regex.Replace(inObj, "-+", "-"); // inObj = System.Text.RegularExpressions.Regex.Replace(inObj, "-+", "-");
//Ensure doesn't start or end with a dash // //Ensure doesn't start or end with a dash
inObj = inObj.Trim('-'); // inObj = inObj.Trim('-');
//No longer than 255 characters // //No longer than 255 characters
inObj = StringUtil.MaxLength(inObj, 255); // inObj = StringUtil.MaxLength(inObj, 255);
return inObj; // return inObj;
} // }
public static async Task ProcessDeleteTagsInRepositoryAsync(AyContext ct, List<string> deleteTags) // public static async Task ProcessDeleteTagsInRepositoryAsync(AyContext ct, List<string> deleteTags)
{ // {
if (deleteTags.Count == 0) return; // if (deleteTags.Count == 0) return;
foreach (string s in deleteTags) // foreach (string s in deleteTags)
{ // {
bool bDone = false; // bool bDone = false;
//Keep on trying until there is success // //Keep on trying until there is success
//this allows for concurrency issues // //this allows for concurrency issues
//I considered a circuit breaker / timeout here, but theoretically it should not be an issue // //I considered a circuit breaker / timeout here, but theoretically it should not be an issue
//at some point it should not be a concurrency issue anymore // //at some point it should not be a concurrency issue anymore
//And this is not critical functionality requiring a transaction and locking // //And this is not critical functionality requiring a transaction and locking
do // do
{ // {
//START: Get tag word and concurrency token and count // //START: Get tag word and concurrency token and count
var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s); // var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s);
//if not present, then nothing to do // //if not present, then nothing to do
if (ExistingTag != null) // if (ExistingTag != null)
{ // {
//No longer needed? // //No longer needed?
if (ExistingTag.RefCount == 1) // if (ExistingTag.RefCount == 1)
{ // {
ct.Remove(ExistingTag); // ct.Remove(ExistingTag);
} // }
else // else
{ // {
//Decrement the refcount // //Decrement the refcount
ExistingTag.RefCount -= 1; // ExistingTag.RefCount -= 1;
} // }
try // try
{ // {
await ct.SaveChangesAsync(); // await ct.SaveChangesAsync();
bDone = true; // bDone = true;
} // }
catch (Exception ex) when (ex is DbUpdateConcurrencyException)//allow for possible other types // catch (Exception ex) when (ex is DbUpdateConcurrencyException)//allow for possible other types
{ // {
//allow others to flow past // //allow others to flow past
// string sss = ex.ToString(); // // string sss = ex.ToString();
} // }
} // }
} while (bDone == false); // } while (bDone == false);
} // }
} // }
public static async Task ProcessUpdateTagsInRepositoryAsync(AyContext ct, List<string> newTags, List<string> originalTags = null) // public static async Task ProcessUpdateTagsInRepositoryAsync(AyContext ct, List<string> newTags, List<string> originalTags = null)
{ // {
//just in case no new tags are present which could mean a user removed all tags from a record so this // //just in case no new tags are present which could mean a user removed all tags from a record so this
//needs to proceed with the code below even if newTags is null as long as originalTags isn't also null // //needs to proceed with the code below even if newTags is null as long as originalTags isn't also null
if (newTags == null) newTags = new List<string>(); // if (newTags == null) newTags = new List<string>();
if (originalTags == null) originalTags = new List<string>(); // if (originalTags == null) originalTags = new List<string>();
if (newTags.Count == 0 && originalTags.Count == 0) return; // if (newTags.Count == 0 && originalTags.Count == 0) return;
List<string> deleteTags = new List<string>(); // List<string> deleteTags = new List<string>();
List<string> addTags = new List<string>(); // List<string> addTags = new List<string>();
if (originalTags != null) // if (originalTags != null)
{ // {
//Update // //Update
//This logic to only come up with CHANGES, if the item is in both lists then it will disappear and not need to be dealt with as it's refcount is unchanged in this operation // //This logic to only come up with CHANGES, if the item is in both lists then it will disappear and not need to be dealt with as it's refcount is unchanged in this operation
//testing will validate it // //testing will validate it
deleteTags = originalTags.Except(newTags).ToList(); // deleteTags = originalTags.Except(newTags).ToList();
addTags = newTags.Except(originalTags).ToList(); // addTags = newTags.Except(originalTags).ToList();
} // }
else // else
{ // {
//Add // //Add
addTags = newTags; // addTags = newTags;
} // }
//ADD / INCREMENT TAGS // //ADD / INCREMENT TAGS
foreach (string s in addTags) // foreach (string s in addTags)
{ // {
bool bDone = false; // bool bDone = false;
//Keep on trying until there is success // //Keep on trying until there is success
//this allows for concurrency issues // //this allows for concurrency issues
//I considered a circuit breaker / timeout here, but theoretically it should not be an issue // //I considered a circuit breaker / timeout here, but theoretically it should not be an issue
//at some point it should not be a concurrency issue anymore // //at some point it should not be a concurrency issue anymore
do // do
{ // {
//START: Get tag word and concurrency token and count // //START: Get tag word and concurrency token and count
var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s); // var ExistingTag = await ct.Tag.FirstOrDefaultAsync(x => x.Name == s);
//if not present, then add it with a count of 0 // //if not present, then add it with a count of 0
if (ExistingTag == null) // if (ExistingTag == null)
{ // {
await ct.Tag.AddAsync(new Tag() { Name = s, RefCount = 1 }); // await ct.Tag.AddAsync(new Tag() { Name = s, RefCount = 1 });
} // }
else // else
{ // {
//Update the refcount // //Update the refcount
ExistingTag.RefCount += 1; // ExistingTag.RefCount += 1;
} // }
try // try
{ // {
await ct.SaveChangesAsync(); // await ct.SaveChangesAsync();
bDone = true; // bDone = true;
} // }
catch (Exception ex) when (ex is DbUpdateConcurrencyException)//this allows for other types // catch (Exception ex) when (ex is DbUpdateConcurrencyException)//this allows for other types
{ // {
//allow others to flow past // //allow others to flow past
//string sss = ex.ToString(); // //string sss = ex.ToString();
} // }
} while (bDone == false); // } while (bDone == false);
} // }
//DELETE TAGS // //DELETE TAGS
await ProcessDeleteTagsInRepositoryAsync(ct, deleteTags); // await ProcessDeleteTagsInRepositoryAsync(ct, deleteTags);
} // }
//Pick list for driving pick list route // //Pick list for driving pick list route
//going with contains for now as I think it's more useful in the long run and still captures startswith intent by user // //going with contains for now as I think it's more useful in the long run and still captures startswith intent by user
public static async Task<List<string>> TagListFilteredAsync(AyContext ct, string q) // public static async Task<List<string>> TagListFilteredAsync(AyContext ct, string q)
{ // {
//This path is intended for internal use and accepts that there may not be a filter specified // //This path is intended for internal use and accepts that there may not be a filter specified
//however the client will always require a filter to display a tag list for choosing from // //however the client will always require a filter to display a tag list for choosing from
if (string.IsNullOrWhiteSpace(q)) // if (string.IsNullOrWhiteSpace(q))
{ // {
return await ct.Tag.OrderBy(x => x.Name) // return await ct.Tag.OrderBy(x => x.Name)
.Select(x => x.Name) // .Select(x => x.Name)
.AsNoTracking() // .AsNoTracking()
.ToListAsync(); // .ToListAsync();
} // }
else // else
{ // {
q = NormalizeTag(q); // q = NormalizeTag(q);
return await ct.Tag // return await ct.Tag
.Where(x => x.Name.Contains(q)) // .Where(x => x.Name.Contains(q))
.OrderBy(x => x.Name) // .OrderBy(x => x.Name)
.Select(x => x.Name) // .Select(x => x.Name)
.Take(25) // .Take(25)
.AsNoTracking() // .AsNoTracking()
.ToListAsync(); // .ToListAsync();
} // }
} // }
//Cloud list // //Cloud list
public static async Task<List<TagCloudItem>> CloudListFilteredAsync(AyContext ct, string q) // public static async Task<List<TagCloudItem>> CloudListFilteredAsync(AyContext ct, string q)
{ // {
//This path is intended for internal use and accepts that there may not be a filter specified // //This path is intended for internal use and accepts that there may not be a filter specified
//however the client will always require a filter to display a tag list for choosing from // //however the client will always require a filter to display a tag list for choosing from
if (string.IsNullOrWhiteSpace(q)) // if (string.IsNullOrWhiteSpace(q))
{ // {
return await ct.Tag.OrderByDescending(x => x.RefCount).Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount }).AsNoTracking().ToListAsync(); // return await ct.Tag.OrderByDescending(x => x.RefCount).Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount }).AsNoTracking().ToListAsync();
} // }
else // else
{ // {
q = NormalizeTag(q); // q = NormalizeTag(q);
//TODO: Use the EF CORE TAKE method to restrict the results to a maximum limit // //TODO: Use the EF CORE TAKE method to restrict the results to a maximum limit
//however need to ensure it doesn't balk when the limit is higher than the number of results (probably not but test that) // //however need to ensure it doesn't balk when the limit is higher than the number of results (probably not but test that)
return await ct.Tag // return await ct.Tag
.Where(x => x.Name.Contains(q)) // .Where(x => x.Name.Contains(q))
.OrderByDescending(x => x.RefCount) // .OrderByDescending(x => x.RefCount)
.Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount }) // .Select(x => new TagCloudItem() { Name = x.Name, RefCount = x.RefCount })
.AsNoTracking() // .AsNoTracking()
.ToListAsync(); // .ToListAsync();
} // }
} // }
public class TagCloudItem // public class TagCloudItem
{ // {
public long RefCount { get; set; } // public long RefCount { get; set; }
public string Name { get; set; } // public string Name { get; set; }
} // }
/////////////////////////////////
//BULK OPS JOBS
//
public static async Task<long> BulkAdd(AyaType ayaType, string tag, List<long> idList, AyContext ct)
{
//SUBMIT AS JOB
//todo iterate the object in question, open and update and save each one through it's biz object interface so rules etc are all maintained
//not sure if should update locked or read only objects, probably not I guess as it should only do whatever was done in interface
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
public static async Task<long> BulkAddAny(AyaType ayaType, string tag, AyContext ct)
{
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
public static async Task<long> BulkRemove(AyaType ayaType, string tag, List<long> idList, AyContext ct)
{
//todo iterate the object in question, open and update and save each one through it's biz object interface so rules etc are all maintained
//not sure if should update locked or read only objects, probably not I guess as it should only do whatever was done in interface
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
public static async Task<long> BulkRemoveAny(AyaType ayaType, string tag, AyContext ct)
{
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
public static async Task<long> BulkReplace(AyaType ayaType, string fromTag, string toTag, List<long> idList, AyContext ct)
{
//todo iterate the object in question, open and update and save each one through it's biz object interface so rules etc are all maintained
//not sure if should update locked or read only objects, probably not I guess as it should only do whatever was done in interface
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
public static async Task<long> BulkReplaceAny(AyaType ayaType, string fromTag, string toTag, AyContext ct)
{
await Task.CompletedTask;
throw new System.NotImplementedException("NOT IMPLEMENTED YET");
}
}//eoc }//eoc

12
server/AyaNova/biz/UnitBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Unit.AddAsync(newObject); await ct.Unit.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Unit SnapshotOfOriginalDBObj = new Unit(); Unit SnapshotOfOriginalDBObj = new Unit();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/UnitModelBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.UnitModel.AddAsync(newObject); await ct.UnitModel.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
UnitModel SnapshotOfOriginalDBObj = new UnitModel(); UnitModel SnapshotOfOriginalDBObj = new UnitModel();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

10
server/AyaNova/biz/UserBiz.cs
View File

@@ -67,7 +67,7 @@ namespace AyaNova.Biz
inObj.Password = Hasher.hash(inObj.Salt, inObj.Password); inObj.Password = Hasher.hash(inObj.Salt, inObj.Password);
inObj.Tags = TagUtil.NormalizeTags(inObj.Tags); inObj.Tags = TagBiz.NormalizeTags(inObj.Tags);
inObj.CustomFields = JsonUtil.CompactJson(inObj.CustomFields); inObj.CustomFields = JsonUtil.CompactJson(inObj.CustomFields);
//Seeder sets user options in advance so no need to create them here in that case //Seeder sets user options in advance so no need to create them here in that case
@@ -99,7 +99,7 @@ namespace AyaNova.Biz
await SearchIndexAsync(inObj, true); await SearchIndexAsync(inObj, true);
//TAGS //TAGS
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, inObj.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, inObj.Tags, null);
dtUser retUser = new dtUser(); dtUser retUser = new dtUser();
CopyObject.Copy(inObj, retUser); CopyObject.Copy(inObj, retUser);
@@ -146,7 +146,7 @@ namespace AyaNova.Biz
//Update the db object with the PUT object values //Update the db object with the PUT object values
CopyObject.Copy(inObj, dbObj, "Id, Salt, CurrentAuthToken, DlKey, DlKeyExpire"); CopyObject.Copy(inObj, dbObj, "Id, Salt, CurrentAuthToken, DlKey, DlKeyExpire");
dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags); dbObj.Tags = TagBiz.NormalizeTags(dbObj.Tags);
dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields); dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
//NOTE: It's valid to call this without intending to change login or password (null values) //NOTE: It's valid to call this without intending to change login or password (null values)
@@ -189,7 +189,7 @@ namespace AyaNova.Biz
await SearchIndexAsync(dbObj, false); await SearchIndexAsync(dbObj, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
return true; return true;
} }
@@ -252,7 +252,7 @@ namespace AyaNova.Biz
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
return true; return true;
} }

12
server/AyaNova/biz/VendorBiz.cs
View File

@@ -42,13 +42,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Vendor.AddAsync(newObject); await ct.Vendor.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -81,7 +81,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -110,7 +110,7 @@ namespace AyaNova.Biz
Vendor SnapshotOfOriginalDBObj = new Vendor(); Vendor SnapshotOfOriginalDBObj = new Vendor();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id"); CopyObject.Copy(putObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -129,7 +129,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

12
server/AyaNova/biz/WidgetBiz.cs
View File

@@ -43,13 +43,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.Widget.AddAsync(newObject); await ct.Widget.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -82,7 +82,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await SearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -111,7 +111,7 @@ namespace AyaNova.Biz
Widget SnapshotOfOriginalDBObj = new Widget(); Widget SnapshotOfOriginalDBObj = new Widget();
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(putObject, dbObject, "Id");//can update serial CopyObject.Copy(putObject, dbObject, "Id");//can update serial
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = putObject.Concurrency;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
@@ -130,7 +130,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObject, false); await SearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -155,7 +155,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
} }

112
server/AyaNova/biz/WorkOrderBiz.cs
View File

@@ -61,13 +61,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrder.AddAsync(newObject); await ct.WorkOrder.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await WorkOrderSearchIndexAsync(newObject, true); await WorkOrderSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -91,7 +91,7 @@ namespace AyaNova.Biz
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await WorkOrderSearchIndexAsync(newObject, true); await WorkOrderSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -157,7 +157,7 @@ namespace AyaNova.Biz
dbObject.Serial = dtPutObject.Serial; dbObject.Serial = dtPutObject.Serial;
} }
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -179,7 +179,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await WorkOrderSearchIndexAsync(dbObject, false); await WorkOrderSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -210,7 +210,7 @@ namespace AyaNova.Biz
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
#if (DEBUG) #if (DEBUG)
@@ -403,13 +403,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItem.AddAsync(newObject); await ct.WorkOrderItem.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItem, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItem, AyaEvent.Created), ct);
await ItemSearchIndexAsync(newObject, true); await ItemSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -463,7 +463,7 @@ namespace AyaNova.Biz
//Replace the db object with the PUT object //Replace the db object with the PUT object
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -485,7 +485,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItem, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItem, AyaEvent.Modified), ct);
await ItemSearchIndexAsync(dbObject, false); await ItemSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -550,7 +550,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItem, dbObject.Id, "wo:" + dbObject.WorkOrderId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItem, dbObject.Id, "wo:" + dbObject.WorkOrderId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItem); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItem);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//all good do the commit if it's ours //all good do the commit if it's ours
if (parentTransaction == null) if (parentTransaction == null)
@@ -668,13 +668,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemExpense.AddAsync(newObject); await ct.WorkOrderItemExpense.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemExpense, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemExpense, AyaEvent.Created), ct);
await ExpenseSearchIndexAsync(newObject, true); await ExpenseSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -714,7 +714,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -734,7 +734,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemExpense, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemExpense, AyaEvent.Modified), ct);
await ExpenseSearchIndexAsync(dbObject, false); await ExpenseSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -753,7 +753,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemExpense, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemExpense, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemExpense); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemExpense);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -857,13 +857,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemLabor.AddAsync(newObject); await ct.WorkOrderItemLabor.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemLabor, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemLabor, AyaEvent.Created), ct);
await LaborSearchIndexAsync(newObject, true); await LaborSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -903,7 +903,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -923,7 +923,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemLabor, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemLabor, AyaEvent.Modified), ct);
await LaborSearchIndexAsync(dbObject, false); await LaborSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -942,7 +942,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemLabor, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemLabor, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemLabor); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemLabor);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1045,13 +1045,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemLoan.AddAsync(newObject); await ct.WorkOrderItemLoan.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemLoan, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemLoan, AyaEvent.Created), ct);
await LoanSearchIndexAsync(newObject, true); await LoanSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -1091,7 +1091,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -1111,7 +1111,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemLoan, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemLoan, AyaEvent.Modified), ct);
await LoanSearchIndexAsync(dbObject, false); await LoanSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -1130,7 +1130,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemLoan, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemLoan, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemLoan); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemLoan);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1234,13 +1234,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemPart.AddAsync(newObject); await ct.WorkOrderItemPart.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemPart, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemPart, AyaEvent.Created), ct);
await PartSearchIndexAsync(newObject, true); await PartSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -1280,7 +1280,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -1300,7 +1300,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemPart, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemPart, AyaEvent.Modified), ct);
await PartSearchIndexAsync(dbObject, false); await PartSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -1319,7 +1319,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemPart, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemPart, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemPart); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemPart);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1420,13 +1420,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemPartRequest.AddAsync(newObject); await ct.WorkOrderItemPartRequest.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemPartRequest, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemPartRequest, AyaEvent.Created), ct);
await PartRequestSearchIndexAsync(newObject, true); await PartRequestSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -1466,7 +1466,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -1486,7 +1486,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemPartRequest, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemPartRequest, AyaEvent.Modified), ct);
await PartRequestSearchIndexAsync(dbObject, false); await PartRequestSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -1505,7 +1505,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemPartRequest, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemPartRequest, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemPartRequest); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemPartRequest);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1609,13 +1609,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemScheduledUser.AddAsync(newObject); await ct.WorkOrderItemScheduledUser.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemScheduledUser, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemScheduledUser, AyaEvent.Created), ct);
await ScheduledUserSearchIndexAsync(newObject, true); await ScheduledUserSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -1655,7 +1655,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -1675,7 +1675,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemScheduledUser, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemScheduledUser, AyaEvent.Modified), ct);
await ScheduledUserSearchIndexAsync(dbObject, false); await ScheduledUserSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -1694,7 +1694,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemScheduledUser, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemScheduledUser, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemScheduledUser); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemScheduledUser);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1798,13 +1798,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemTask.AddAsync(newObject); await ct.WorkOrderItemTask.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemTask, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemTask, AyaEvent.Created), ct);
await TaskSearchIndexAsync(newObject, true); await TaskSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -1844,7 +1844,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -1864,7 +1864,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemTask, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemTask, AyaEvent.Modified), ct);
await TaskSearchIndexAsync(dbObject, false); await TaskSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -1883,7 +1883,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemTask, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemTask, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemTask); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemTask);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -1987,13 +1987,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemTravel.AddAsync(newObject); await ct.WorkOrderItemTravel.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemTravel, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemTravel, AyaEvent.Created), ct);
await TravelSearchIndexAsync(newObject, true); await TravelSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -2033,7 +2033,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -2053,7 +2053,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemTravel, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemTravel, AyaEvent.Modified), ct);
await TravelSearchIndexAsync(dbObject, false); await TravelSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -2072,7 +2072,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemTravel, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemTravel, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemTravel); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemTravel);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }
@@ -2176,13 +2176,13 @@ namespace AyaNova.Biz
return null; return null;
else else
{ {
newObject.Tags = TagUtil.NormalizeTags(newObject.Tags); newObject.Tags = TagBiz.NormalizeTags(newObject.Tags);
newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields); newObject.CustomFields = JsonUtil.CompactJson(newObject.CustomFields);
await ct.WorkOrderItemUnit.AddAsync(newObject); await ct.WorkOrderItemUnit.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemUnit, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, AyaType.WorkOrderItemUnit, AyaEvent.Created), ct);
await UnitSearchIndexAsync(newObject, true); await UnitSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
} }
@@ -2222,7 +2222,7 @@ namespace AyaNova.Biz
CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj); CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
CopyObject.Copy(dtPutObject, dbObject, "Id"); CopyObject.Copy(dtPutObject, dbObject, "Id");
dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags); dbObject.Tags = TagBiz.NormalizeTags(dbObject.Tags);
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency; ct.Entry(dbObject).OriginalValues["Concurrency"] = dtPutObject.Concurrency;
@@ -2242,7 +2242,7 @@ namespace AyaNova.Biz
} }
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemUnit, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, AyaType.WorkOrderItemUnit, AyaEvent.Modified), ct);
await UnitSearchIndexAsync(dbObject, false); await UnitSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -2261,7 +2261,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemUnit, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, AyaType.WorkOrderItemUnit, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemUnit); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, AyaType.WorkOrderItemUnit);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return true; return true;
} }

12
server/AyaNova/biz/WorkorderTemplateBiz.cs
View File

@@ -70,7 +70,7 @@ namespace AyaNova.Biz
//do stuff with WorkOrderTemplate //do stuff with WorkOrderTemplate
WorkOrderTemplate outObj = inObj; WorkOrderTemplate outObj = inObj;
outObj.Tags = TagUtil.NormalizeTags(outObj.Tags); outObj.Tags = TagBiz.NormalizeTags(outObj.Tags);
outObj.CustomFields = JsonUtil.CompactJson(outObj.CustomFields); outObj.CustomFields = JsonUtil.CompactJson(outObj.CustomFields);
//Save to db //Save to db
await ct.WorkOrderTemplate.AddAsync(outObj); await ct.WorkOrderTemplate.AddAsync(outObj);
@@ -78,7 +78,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(outObj, true); await SearchIndexAsync(outObj, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
return outObj; return outObj;
} }
@@ -119,7 +119,7 @@ namespace AyaNova.Biz
//Handle child and associated items: //Handle child and associated items:
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, outObj.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(outObj, true); await SearchIndexAsync(outObj, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, outObj.Tags, null);
return outObj; return outObj;
} }
@@ -139,7 +139,7 @@ namespace AyaNova.Biz
//Replace the db object with the PUT object //Replace the db object with the PUT object
CopyObject.Copy(inObj, dbObj, "Id"); CopyObject.Copy(inObj, dbObj, "Id");
dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags); dbObj.Tags = TagBiz.NormalizeTags(dbObj.Tags);
dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields); dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
//Set "original" value of concurrency token to input token //Set "original" value of concurrency token to input token
@@ -154,7 +154,7 @@ namespace AyaNova.Biz
//Log event and save context //Log event and save context
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(dbObj, false); await SearchIndexAsync(dbObj, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
return true; return true;
} }
@@ -198,7 +198,7 @@ namespace AyaNova.Biz
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType); await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
return true; return true;
} }