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

Removed superfluous try catch throw pattern

Browse Source
This commit is contained in:
John Cardinal
2021-08-05 23:14:12 +00:00
parent 7c033a6e84
commit 49bd0d2d87
35 changed files with 2184 additions and 2684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -224,35 +224,26 @@ MULTIPLE discount / markup ITEMS
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Contract dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
Contract dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.Contract.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.Contract.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }
@@ -353,7 +344,7 @@ MULTIPLE discount / markup ITEMS
//SERVICE RATES //SERVICE RATES
if (proposedObj.ContractServiceRateOverrideItems.Count > 0) if (proposedObj.ContractServiceRateOverrideItems.Count > 0)
{ {
// List<string> allTags = new List<string>(); // List<string> allTags = new List<string>();
//check for overlapping dupes //check for overlapping dupes
//[NO DON"T CHECK FOR DUPES, OR AT LEAST NOT LIKE THIS, REMOVING FOR NOW] //[NO DON"T CHECK FOR DUPES, OR AT LEAST NOT LIKE THIS, REMOVING FOR NOW]
//Not sure what the dupe intent was but it should be entirely duped, not just one tag in common as with this //Not sure what the dupe intent was but it should be entirely duped, not just one tag in common as with this
@@ -389,7 +380,7 @@ MULTIPLE discount / markup ITEMS
//TRAVEL RATES //TRAVEL RATES
if (proposedObj.ContractTravelRateOverrideItems.Count > 0) if (proposedObj.ContractTravelRateOverrideItems.Count > 0)
{ {
for (int i = 0; i < proposedObj.ContractTravelRateOverrideItems.Count; i++) for (int i = 0; i < proposedObj.ContractTravelRateOverrideItems.Count; i++)
{ {
var item = proposedObj.ContractTravelRateOverrideItems[i]; var item = proposedObj.ContractTravelRateOverrideItems[i];
if (item.Tags.Count < 1) if (item.Tags.Count < 1)
@@ -673,7 +664,7 @@ MULTIPLE discount / markup ITEMS
}//end of process notifications }//end of process notifications

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

@@ -152,67 +152,59 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try
Customer dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
Customer dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
//DELETE DIRECT CHILD OBJECTS
//(note: the convention is to allow deletion of children created *in* the same UI area so this will delete contacts, customer notes, but not workorders of this customer for example)
{
var ContactIds = await ct.User.AsNoTracking().Where(z => z.CustomerId == id).Select(z => z.Id).ToListAsync();
if (ContactIds.Count() > 0)
{
UserBiz b = new UserBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in ContactIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"CustomerContact [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
}
{
var CustomerNoteIds = await ct.CustomerNote.AsNoTracking().Where(z => z.CustomerId == id).Select(z => z.Id).ToListAsync();
if (CustomerNoteIds.Count() > 0)
{
CustomerNoteBiz b = new CustomerNoteBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in CustomerNoteIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"CustomerNote [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
}
ct.Customer.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
//DELETE DIRECT CHILD OBJECTS
//(note: the convention is to allow deletion of children created *in* the same UI area so this will delete contacts, customer notes, but not workorders of this customer for example)
{ {
//NOTE: no need to rollback the transaction, it will auto-rollback if not committed and it is disposed when it goes out of scope either way var ContactIds = await ct.User.AsNoTracking().Where(z => z.CustomerId == id).Select(z => z.Id).ToListAsync();
if (ContactIds.Count() > 0)
{
throw; UserBiz b = new UserBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in ContactIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"CustomerContact [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
} }
{
var CustomerNoteIds = await ct.CustomerNote.AsNoTracking().Where(z => z.CustomerId == id).Select(z => z.Id).ToListAsync();
if (CustomerNoteIds.Count() > 0)
{
CustomerNoteBiz b = new CustomerNoteBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in CustomerNoteIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"CustomerNote [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
}
ct.Customer.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }
@@ -377,7 +369,7 @@ namespace AyaNova.Biz
var orderedList = from id in batch join z in batchResults on id equals z.Id select z; var orderedList = from id in batch join z in batchResults on id equals z.Id select z;
foreach (Customer w in orderedList) foreach (Customer w in orderedList)
{ {
await PopulateVizFields(w); await PopulateVizFields(w);

46
server/AyaNova/biz/CustomerNoteBiz.cs
View File

@@ -119,35 +119,29 @@ namespace AyaNova.Biz
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = null; Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = null;
if (parentTransaction == null) if (parentTransaction == null)
transaction = await ct.Database.BeginTransactionAsync(); transaction = await ct.Database.BeginTransactionAsync();
try
CustomerNote dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
CustomerNote dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); if (HasErrors)
return false; return false;
} if (HasErrors)
if (HasErrors) return false;
return false; ct.CustomerNote.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.CustomerNote.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, "CustomerNote", ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, "CustomerNote", ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
//all good do the commit if it's ours //all good do the commit if it's ours
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
}
catch
{
throw;
}
return true; return true;

47
server/AyaNova/biz/CustomerServiceRequestBiz.cs
View File

@@ -147,35 +147,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try CustomerServiceRequest dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
CustomerServiceRequest dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.CustomerServiceRequest.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.CustomerServiceRequest.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

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

@@ -151,52 +151,43 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
//DELETE DIRECT CHILD OBJECTS
{
var ContactIds = await ct.User.AsNoTracking().Where(z => z.HeadOfficeId == id).Select(z => z.Id).ToListAsync();
if (ContactIds.Count() > 0)
{
UserBiz b = new UserBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in ContactIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"HeadOfficeContact [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
}
ct.HeadOffice.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
//DELETE DIRECT CHILD OBJECTS
{ {
//NOTE: no need to rollback the transaction, it will auto-rollback if not committed and it is disposed when it goes out of scope either way var ContactIds = await ct.User.AsNoTracking().Where(z => z.HeadOfficeId == id).Select(z => z.Id).ToListAsync();
if (ContactIds.Count() > 0)
{
throw; UserBiz b = new UserBiz(ct, UserId, UserTranslationId, CurrentUserRoles);
foreach (long ItemId in ContactIds)
if (!await b.DeleteAsync(ItemId, transaction))
{
AddError(ApiErrorCode.CHILD_OBJECT_ERROR, null, $"HeadOfficeContact [{ItemId}]: {b.GetErrorsAsString()}");
return false;
}
}
} }
ct.HeadOffice.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }
@@ -503,7 +494,7 @@ namespace AyaNova.Biz
//## CREATED / MODIFIED EVENTS //## CREATED / MODIFIED EVENTS
if (ayaEvent == AyaEvent.Created || ayaEvent == AyaEvent.Modified) if (ayaEvent == AyaEvent.Created || ayaEvent == AyaEvent.Modified)
{ {
//# CONTRACT EXPIRY //# CONTRACT EXPIRY
{ {

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

@@ -152,35 +152,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try LoanUnit dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
LoanUnit dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.LoanUnit.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.LoanUnit.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }
@@ -303,7 +296,7 @@ namespace AyaNova.Biz
private async Task PopulateVizFields(LoanUnit o) private async Task PopulateVizFields(LoanUnit o)
{ {
if (o.UnitId != null) if (o.UnitId != null)
o.UnitViz = await ct.Unit.AsNoTracking().Where(x => x.Id == o.UnitId).Select(x => x.Serial).FirstOrDefaultAsync(); o.UnitViz = await ct.Unit.AsNoTracking().Where(x => x.Id == o.UnitId).Select(x => x.Serial).FirstOrDefaultAsync();
} }

51
server/AyaNova/biz/MemoBiz.cs
View File

@@ -44,8 +44,8 @@ namespace AyaNova.Biz
internal async Task<Memo> CreateAsync(Memo newObject) internal async Task<Memo> CreateAsync(Memo newObject)
{ {
newObject.Viewed=false;//default, it's new and not viewed yet but could have been set from a prior forward / reply as it's source newObject.Viewed = false;//default, it's new and not viewed yet but could have been set from a prior forward / reply as it's source
newObject.Replied=false;//'' newObject.Replied = false;//''
await ValidateAsync(newObject);//a bit different, can't update a memo so only need to worry about new objects await ValidateAsync(newObject);//a bit different, can't update a memo so only need to worry about new objects
if (HasErrors) if (HasErrors)
return null; return null;
@@ -138,35 +138,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.Memo.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Memo.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

56
server/AyaNova/biz/NotifySubscriptionBiz.cs
View File

@@ -136,37 +136,30 @@ namespace AyaNova.Biz
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
//ValidateCanDelete(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.NotifySubscription.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.EventType.ToString(), ct);
// await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//TODO: DELETE RELATED RECORDS HERE
//all good do the commit
await transaction.CommitAsync();
}
catch
{
throw;
} }
//ValidateCanDelete(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.NotifySubscription.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.EventType.ToString(), ct);
// await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
//TODO: DELETE RELATED RECORDS HERE
//all good do the commit
await transaction.CommitAsync();
return true; return true;
} }
} }
@@ -231,8 +224,9 @@ namespace AyaNova.Biz
} }
} }
if(proposedObj.DeliveryMethod==NotifyDeliveryMethod.App && !string.IsNullOrEmpty(proposedObj.DeliveryAddress)){ if (proposedObj.DeliveryMethod == NotifyDeliveryMethod.App && !string.IsNullOrEmpty(proposedObj.DeliveryAddress))
AddError(ApiErrorCode.VALIDATION_INVALID_VALUE, "DeliveryAddress","In app delivery should not specify a delivery address"); {
AddError(ApiErrorCode.VALIDATION_INVALID_VALUE, "DeliveryAddress", "In app delivery should not specify a delivery address");
} }

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

@@ -334,43 +334,34 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try PM dbObject = await ct.PM.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// PMGetAsync(id, false);
if (dbObject == null)
{ {
PM dbObject = await ct.PM.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// PMGetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await PMValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
await PMValidateCanDelete(dbObject);
if (HasErrors) //collect the child id's to delete
var ItemIds = await ct.PMItem.AsNoTracking().Where(z => z.PMId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ItemIds)
if (!await ItemDeleteAsync(ItemId, transaction))
return false; return false;
//collect the child id's to delete ct.PM.Remove(dbObject);
var ItemIds = await ct.PMItem.AsNoTracking().Where(z => z.PMId == id).Select(z => z.Id).ToListAsync(); await ct.SaveChangesAsync();
//Delete children await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
foreach (long ItemId in ItemIds) await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (!await ItemDeleteAsync(ItemId, transaction)) await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
return false; await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await PMHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
ct.PM.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await PMHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
//NOTE: no need to rollback the transaction, it will auto-rollback if not committed and it is disposed when it goes out of scope either way
throw;
}
return true; return true;
} }
} }
@@ -1196,78 +1187,72 @@ namespace AyaNova.Biz
internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
var dbObject = await ct.PMItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
if (dbObject == null)
{ {
var dbObject = await ct.PMItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ItemValidateCanDelete(dbObject);
if (HasErrors)
return false;
//collect the child id's to delete
var ExpenseIds = await ct.PMItemExpense.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var LaborIds = await ct.PMItemLabor.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.PMItemLoan.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.PMItemPart.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.PMItemScheduledUser.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var TaskIds = await ct.PMItemTask.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var TravelIds = await ct.PMItemTravel.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var UnitIds = await ct.PMItemUnit.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var OutsideServiceIds = await ct.PMItemOutsideService.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ExpenseIds)
if (!await ExpenseDeleteAsync(ItemId, transaction))
return false; return false;
} foreach (long ItemId in LaborIds)
ItemValidateCanDelete(dbObject); if (!await LaborDeleteAsync(ItemId, transaction))
if (HasErrors) return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false; return false;
//collect the child id's to delete ct.PMItem.Remove(dbObject);
var ExpenseIds = await ct.PMItemExpense.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); await ct.SaveChangesAsync();
var LaborIds = await ct.PMItemLabor.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.PMItemLoan.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.PMItemPart.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.PMItemScheduledUser.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); //Log event
var TaskIds = await ct.PMItemTask.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.PMId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
var TravelIds = await ct.PMItemTravel.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
var UnitIds = await ct.PMItemUnit.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
var OutsideServiceIds = await ct.PMItemOutsideService.Where(z => z.PMItemId == id).Select(z => z.Id).ToListAsync(); await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
//Delete children //all good do the commit if it's ours
foreach (long ItemId in ExpenseIds) if (parentTransaction == null)
if (!await ExpenseDeleteAsync(ItemId, transaction)) await transaction.CommitAsync();
return false; await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
foreach (long ItemId in LaborIds)
if (!await LaborDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false;
ct.PMItem.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.PMId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
//all good do the commit if it's ours
if (parentTransaction == null)
await transaction.CommitAsync();
await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -1520,28 +1505,22 @@ namespace AyaNova.Biz
internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await ExpenseGetAsync(id, false);
ExpenseValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.PMItemExpense.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await ExpenseGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? ExpenseValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.PMItemExpense.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
if (parentTransaction == null)
await transaction.CommitAsync();
await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -1870,28 +1849,22 @@ namespace AyaNova.Biz
internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await LaborGetAsync(id, false);
LaborValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.PMItemLabor.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await LaborGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? LaborValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.PMItemLabor.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
if (parentTransaction == null)
await transaction.CommitAsync();
await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2251,29 +2224,22 @@ namespace AyaNova.Biz
internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await LoanGetAsync(id, false);
{ LoanValidateCanDelete(dbObject);
var dbObject = await LoanGetAsync(id, false); if (HasErrors)
LoanValidateCanDelete(dbObject); return false;
if (HasErrors) ct.PMItemLoan.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.PMItemLoan.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2648,28 +2614,22 @@ namespace AyaNova.Biz
internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await OutsideServiceGetAsync(id, false);
OutsideServiceValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.PMItemOutsideService.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await OutsideServiceGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? OutsideServiceValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.PMItemOutsideService.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
if (parentTransaction == null)
await transaction.CommitAsync();
await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2981,32 +2941,24 @@ namespace AyaNova.Biz
internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await PartGetAsync(id, false);
PartValidateCanDelete(dbObject);
if (HasErrors)
return false;
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
ct.PMItemPart.Remove(dbObject);
await ct.SaveChangesAsync();
if (HasErrors)
{ {
var dbObject = await PartGetAsync(id, false); await transaction.RollbackAsync();
PartValidateCanDelete(dbObject); return false;
if (HasErrors)
return false;
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
ct.PMItemPart.Remove(dbObject);
await ct.SaveChangesAsync();
if (HasErrors)
{
await transaction.RollbackAsync();
return false;
}
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
@@ -3399,27 +3351,19 @@ namespace AyaNova.Biz
internal async Task<bool> ScheduledUserDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ScheduledUserDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await ScheduledUserGetAsync(id, false);
{ ScheduledUserValidateCanDelete(dbObject);
var dbObject = await ScheduledUserGetAsync(id, false); if (HasErrors)
ScheduledUserValidateCanDelete(dbObject); return false;
if (HasErrors) ct.PMItemScheduledUser.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.PMItemScheduledUser.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await ScheduledUserHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await ScheduledUserHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3638,28 +3582,20 @@ namespace AyaNova.Biz
internal async Task<bool> TaskDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> TaskDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await TaskGetAsync(id, false);
{ TaskValidateCanDelete(dbObject);
var dbObject = await TaskGetAsync(id, false); if (HasErrors)
TaskValidateCanDelete(dbObject); return false;
if (HasErrors) ct.PMItemTask.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.PMItemTask.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await TaskHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await TaskHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3914,29 +3850,23 @@ namespace AyaNova.Biz
internal async Task<bool> TravelDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> TravelDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await TravelGetAsync(id, false);
TravelValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.PMItemTravel.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await TravelGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct); TravelValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.PMItemTravel.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await TravelHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await TravelHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -4283,27 +4213,20 @@ namespace AyaNova.Biz
internal async Task<bool> UnitDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> UnitDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await UnitGetAsync(id, false);
{ UnitValidateCanDelete(dbObject);
var dbObject = await UnitGetAsync(id, false); if (HasErrors)
UnitValidateCanDelete(dbObject); return false;
if (HasErrors) ct.PMItemUnit.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.PMItemUnit.Remove(dbObject);
await ct.SaveChangesAsync(); //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await UnitHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "pmitem:" + dbObject.PMItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await UnitHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -5270,7 +5193,7 @@ namespace AyaNova.Biz
} }
catch catch
{ {
throw; thrxxow;
} }
finally finally
{ {

47
server/AyaNova/biz/PartAssemblyBiz.cs
View File

@@ -175,35 +175,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try PartAssembly dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
PartAssembly dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.PartAssembly.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.PartAssembly.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

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

@@ -152,35 +152,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Part dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
Part dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.Part.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Part.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

99
server/AyaNova/biz/PartInventoryBiz.cs
View File

@@ -42,59 +42,6 @@ namespace AyaNova.Biz
internal async Task<PartInventory> CreateAsync(dtPartInventory newDtObject) internal async Task<PartInventory> CreateAsync(dtPartInventory newDtObject)
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{
try
{
//get the last record if exists (will not if opening balance)
var LastEntry = await ct.PartInventory.OrderByDescending(m => m.EntryDate).FirstOrDefaultAsync(m => m.PartId == newDtObject.PartId && m.PartWarehouseId == newDtObject.PartWarehouseId);
PartInventory newObject = new PartInventory();
newObject.Description = newDtObject.Description;
newObject.EntryDate = DateTime.UtcNow;
newObject.PartId = newDtObject.PartId;
newObject.PartWarehouseId = newDtObject.PartWarehouseId;
newObject.SourceId = null;
newObject.SourceType = null;
newObject.Quantity = newDtObject.Quantity;
if (LastEntry != null)
{
newObject.LastEntryDate = LastEntry.EntryDate;
newObject.LastBalance = LastEntry.Balance;
newObject.Balance = LastEntry.Balance + newObject.Quantity;
}
else
{
newObject.Balance = newObject.Quantity;
}
await ValidateAsync(newObject);
if (HasErrors)
return null;
else
{
await ct.PartInventory.AddAsync(newObject);
await ct.SaveChangesAsync();
await transaction.CommitAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true);
return newObject;
}
}
catch
{
throw;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE (internal version)
//
internal async Task<PartInventory> CreateAsync(dtInternalPartInventory newDtObject)
{
try
{ {
//get the last record if exists (will not if opening balance) //get the last record if exists (will not if opening balance)
var LastEntry = await ct.PartInventory.OrderByDescending(m => m.EntryDate).FirstOrDefaultAsync(m => m.PartId == newDtObject.PartId && m.PartWarehouseId == newDtObject.PartWarehouseId); var LastEntry = await ct.PartInventory.OrderByDescending(m => m.EntryDate).FirstOrDefaultAsync(m => m.PartId == newDtObject.PartId && m.PartWarehouseId == newDtObject.PartWarehouseId);
@@ -103,8 +50,8 @@ namespace AyaNova.Biz
newObject.EntryDate = DateTime.UtcNow; newObject.EntryDate = DateTime.UtcNow;
newObject.PartId = newDtObject.PartId; newObject.PartId = newDtObject.PartId;
newObject.PartWarehouseId = newDtObject.PartWarehouseId; newObject.PartWarehouseId = newDtObject.PartWarehouseId;
newObject.SourceId = newDtObject.SourceId; newObject.SourceId = null;
newObject.SourceType = newDtObject.SourceType; newObject.SourceType = null;
newObject.Quantity = newDtObject.Quantity; newObject.Quantity = newDtObject.Quantity;
if (LastEntry != null) if (LastEntry != null)
@@ -125,17 +72,53 @@ namespace AyaNova.Biz
{ {
await ct.PartInventory.AddAsync(newObject); await ct.PartInventory.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await transaction.CommitAsync();
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);
return newObject; return newObject;
} }
} }
catch }
////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE (internal version)
//
internal async Task<PartInventory> CreateAsync(dtInternalPartInventory newDtObject)
{
//get the last record if exists (will not if opening balance)
var LastEntry = await ct.PartInventory.OrderByDescending(m => m.EntryDate).FirstOrDefaultAsync(m => m.PartId == newDtObject.PartId && m.PartWarehouseId == newDtObject.PartWarehouseId);
PartInventory newObject = new PartInventory();
newObject.Description = newDtObject.Description;
newObject.EntryDate = DateTime.UtcNow;
newObject.PartId = newDtObject.PartId;
newObject.PartWarehouseId = newDtObject.PartWarehouseId;
newObject.SourceId = newDtObject.SourceId;
newObject.SourceType = newDtObject.SourceType;
newObject.Quantity = newDtObject.Quantity;
if (LastEntry != null)
{ {
newObject.LastEntryDate = LastEntry.EntryDate;
throw; newObject.LastBalance = LastEntry.Balance;
newObject.Balance = LastEntry.Balance + newObject.Quantity;
}
else
{
newObject.Balance = newObject.Quantity;
} }
await ValidateAsync(newObject);
if (HasErrors)
return null;
else
{
await ct.PartInventory.AddAsync(newObject);
await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true);
return newObject;
}
} }

42
server/AyaNova/biz/PartWarehouseBiz.cs
View File

@@ -152,33 +152,25 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.PartWarehouse.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.PartWarehouse.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

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

@@ -152,33 +152,26 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.Project.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Project.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

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

@@ -121,7 +121,7 @@ namespace AyaNova.Biz
{ {
var ret = await ct.PurchaseOrder.Include(z => z.Items).AsNoTracking().SingleOrDefaultAsync(z => z.Id == id); var ret = await ct.PurchaseOrder.Include(z => z.Items).AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
if (populateDisplayFields) if (populateDisplayFields)
await SetDisplayFields(ret,false); await SetDisplayFields(ret, false);
if (logTheGetEvent && ret != null) if (logTheGetEvent && ret != null)
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Retrieved), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Retrieved), ct);
@@ -323,37 +323,30 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
ct.PurchaseOrder.Remove(dbObject);
await BizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
if (HasErrors)
{
await transaction.RollbackAsync();
return false;
}
await ct.SaveChangesAsync();
await transaction.CommitAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
ct.PurchaseOrder.Remove(dbObject);
await BizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
if (HasErrors)
{ {
await transaction.RollbackAsync();
throw; return false;
} }
await ct.SaveChangesAsync();
await transaction.CommitAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }

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

@@ -342,47 +342,38 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Quote dbObject = await ct.Quote.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// QuoteGetAsync(id, false);
if (dbObject == null)
{ {
Quote dbObject = await ct.Quote.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// QuoteGetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await QuoteValidateCanDelete(dbObject);
if (HasErrors)
return false;
//States collection
if (!await StateDeleteAsync(id, transaction))
return false;
//collect the child id's to delete
var ItemIds = await ct.QuoteItem.AsNoTracking().Where(z => z.QuoteId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ItemIds)
if (!await ItemDeleteAsync(ItemId, transaction))
return false;
ct.Quote.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await QuoteHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch await QuoteValidateCanDelete(dbObject);
{ if (HasErrors)
//NOTE: no need to rollback the transaction, it will auto-rollback if not committed and it is disposed when it goes out of scope either way return false;
throw; //States collection
if (!await StateDeleteAsync(id, transaction))
return false;
//collect the child id's to delete
var ItemIds = await ct.QuoteItem.AsNoTracking().Where(z => z.QuoteId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ItemIds)
if (!await ItemDeleteAsync(ItemId, transaction))
return false;
ct.Quote.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await QuoteHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
return true; return true;
} }
} }
@@ -1027,24 +1018,15 @@ namespace AyaNova.Biz
// (note: this would only ever be called when a quote is deleted, there is no direct delete) // (note: this would only ever be called when a quote is deleted, there is no direct delete)
internal async Task<bool> StateDeleteAsync(long workOrderId, IDbContextTransaction parentTransaction) internal async Task<bool> StateDeleteAsync(long workOrderId, IDbContextTransaction parentTransaction)
{ {
try var stateList = await ct.QuoteState.AsNoTracking().Where(z => z.QuoteId == workOrderId).ToListAsync();
foreach (var wostate in stateList)
{ {
var stateList = await ct.QuoteState.AsNoTracking().Where(z => z.QuoteId == workOrderId).ToListAsync(); ct.QuoteState.Remove(wostate);
await ct.SaveChangesAsync();
foreach (var wostate in stateList) //no need to call this because it's only going to run this method if the quote is deleted and
{ //via process standard notifciation events for quote deletion will remove any state delayed notifications anyway so
ct.QuoteState.Remove(wostate); //nothing to call or do here related to notification
await ct.SaveChangesAsync(); // await StateHandlePotentialNotificationEvent(AyaEvent.Deleted, wostate);
//no need to call this because it's only going to run this method if the quote is deleted and
//via process standard notifciation events for quote deletion will remove any state delayed notifications anyway so
//nothing to call or do here related to notification
// await StateHandlePotentialNotificationEvent(AyaEvent.Deleted, wostate);
}
}
catch
{
throw;
} }
return true; return true;
} }
@@ -1409,78 +1391,71 @@ namespace AyaNova.Biz
internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await ct.QuoteItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
if (dbObject == null)
{ {
var dbObject = await ct.QuoteItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ItemValidateCanDelete(dbObject);
if (HasErrors)
return false;
//collect the child id's to delete
var ExpenseIds = await ct.QuoteItemExpense.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var LaborIds = await ct.QuoteItemLabor.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.QuoteItemLoan.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.QuoteItemPart.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.QuoteItemScheduledUser.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var TaskIds = await ct.QuoteItemTask.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var TravelIds = await ct.QuoteItemTravel.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var UnitIds = await ct.QuoteItemUnit.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var OutsideServiceIds = await ct.QuoteItemOutsideService.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ExpenseIds)
if (!await ExpenseDeleteAsync(ItemId, transaction))
return false; return false;
} foreach (long ItemId in LaborIds)
ItemValidateCanDelete(dbObject); if (!await LaborDeleteAsync(ItemId, transaction))
if (HasErrors) return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false; return false;
//collect the child id's to delete ct.QuoteItem.Remove(dbObject);
var ExpenseIds = await ct.QuoteItemExpense.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); await ct.SaveChangesAsync();
var LaborIds = await ct.QuoteItemLabor.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.QuoteItemLoan.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.QuoteItemPart.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.QuoteItemScheduledUser.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); //Log event
var TaskIds = await ct.QuoteItemTask.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.QuoteId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
var TravelIds = await ct.QuoteItemTravel.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
var UnitIds = await ct.QuoteItemUnit.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
var OutsideServiceIds = await ct.QuoteItemOutsideService.Where(z => z.QuoteItemId == id).Select(z => z.Id).ToListAsync(); await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
//Delete children //all good do the commit if it's ours
foreach (long ItemId in ExpenseIds) if (parentTransaction == null)
if (!await ExpenseDeleteAsync(ItemId, transaction)) await transaction.CommitAsync();
return false; await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
foreach (long ItemId in LaborIds)
if (!await LaborDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false;
ct.QuoteItem.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.QuoteId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
//all good do the commit if it's ours
if (parentTransaction == null)
await transaction.CommitAsync();
await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -1742,29 +1717,23 @@ namespace AyaNova.Biz
internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await ExpenseGetAsync(id, false);
ExpenseValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.QuoteItemExpense.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await ExpenseGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? ExpenseValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.QuoteItemExpense.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2112,29 +2081,23 @@ namespace AyaNova.Biz
internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try
{
var dbObject = await LaborGetAsync(id, false);
LaborValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.QuoteItemLabor.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event var dbObject = await LaborGetAsync(id, false);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? LaborValidateCanDelete(dbObject);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); if (HasErrors)
return false;
ct.QuoteItemLabor.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2508,29 +2471,22 @@ namespace AyaNova.Biz
internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await LoanGetAsync(id, false);
{ LoanValidateCanDelete(dbObject);
var dbObject = await LoanGetAsync(id, false); if (HasErrors)
LoanValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemLoan.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemLoan.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2914,28 +2870,20 @@ namespace AyaNova.Biz
internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await OutsideServiceGetAsync(id, false);
{ OutsideServiceValidateCanDelete(dbObject);
var dbObject = await OutsideServiceGetAsync(id, false); if (HasErrors)
OutsideServiceValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemOutsideService.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemOutsideService.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3254,33 +3202,24 @@ namespace AyaNova.Biz
internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
var dbObject = await PartGetAsync(id, false);
try PartValidateCanDelete(dbObject);
if (HasErrors)
return false;
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
ct.QuoteItemPart.Remove(dbObject);
await ct.SaveChangesAsync();
if (HasErrors)
{ {
var dbObject = await PartGetAsync(id, false); await transaction.RollbackAsync();
PartValidateCanDelete(dbObject); return false;
if (HasErrors)
return false;
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
ct.QuoteItemPart.Remove(dbObject);
await ct.SaveChangesAsync();
if (HasErrors)
{
await transaction.RollbackAsync();
return false;
}
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null)
await transaction.CommitAsync();
await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
@@ -3690,27 +3629,19 @@ namespace AyaNova.Biz
internal async Task<bool> ScheduledUserDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ScheduledUserDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await ScheduledUserGetAsync(id, false);
{ ScheduledUserValidateCanDelete(dbObject);
var dbObject = await ScheduledUserGetAsync(id, false); if (HasErrors)
ScheduledUserValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemScheduledUser.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemScheduledUser.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await ScheduledUserHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await ScheduledUserHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3943,27 +3874,19 @@ namespace AyaNova.Biz
internal async Task<bool> TaskDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> TaskDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await TaskGetAsync(id, false);
{ TaskValidateCanDelete(dbObject);
var dbObject = await TaskGetAsync(id, false); if (HasErrors)
TaskValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemTask.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemTask.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await TaskHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await TaskHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -4227,28 +4150,20 @@ namespace AyaNova.Biz
internal async Task<bool> TravelDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> TravelDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await TravelGetAsync(id, false);
{ TravelValidateCanDelete(dbObject);
var dbObject = await TravelGetAsync(id, false); if (HasErrors)
TravelValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemTravel.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemTravel.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await TravelHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await TravelHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -4614,27 +4529,19 @@ namespace AyaNova.Biz
internal async Task<bool> UnitDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> UnitDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await UnitGetAsync(id, false);
{ UnitValidateCanDelete(dbObject);
var dbObject = await UnitGetAsync(id, false); if (HasErrors)
UnitValidateCanDelete(dbObject); return false;
if (HasErrors) ct.QuoteItemUnit.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.QuoteItemUnit.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "quoteitem:" + dbObject.QuoteItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await UnitHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await UnitHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }

40
server/AyaNova/biz/QuoteStatusBiz.cs
View File

@@ -50,7 +50,7 @@ namespace AyaNova.Biz
} }
} }
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//GET //GET
// //
@@ -107,31 +107,23 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.QuoteStatus.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.QuoteStatus.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
}
catch
{
throw;
}
return true; return true;
} }
} }

47
server/AyaNova/biz/ReminderBiz.cs
View File

@@ -152,35 +152,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Reminder dbObject = await ct.Reminder.SingleOrDefaultAsync(m => m.Id == id);
if (dbObject == null)
{ {
Reminder dbObject = await ct.Reminder.SingleOrDefaultAsync(m => m.Id == id); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.Reminder.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Reminder.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

40
server/AyaNova/biz/ReportBiz.cs
View File

@@ -208,29 +208,21 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.Report.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
}
catch
{
throw;
} }
await ValidateCanDelete(dbObject);
if (HasErrors)
return false;
ct.Report.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
return true; return true;
} }
} }
@@ -714,11 +706,7 @@ namespace AyaNova.Biz
log.LogInformation(PageLog.ToString()); log.LogInformation(PageLog.ToString());
} }
// var v=await page.GetContentAsync();//for debugging purposes
// var v=await page.GetContentAsync();
throw; throw;
} }
finally finally

46
server/AyaNova/biz/ReviewBiz.cs
View File

@@ -152,35 +152,27 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.Review.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Review.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

46
server/AyaNova/biz/ServiceRateBiz.cs
View File

@@ -152,35 +152,27 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.ServiceRate.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.ServiceRate.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

45
server/AyaNova/biz/TaskGroupBiz.cs
View File

@@ -159,35 +159,26 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try TaskGroup dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
TaskGroup dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
ValidateCanDelete(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.TaskGroup.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
}
catch
{
throw;
} }
ValidateCanDelete(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.TaskGroup.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
return true; return true;
} }
} }

46
server/AyaNova/biz/TaxCodeBiz.cs
View File

@@ -152,35 +152,27 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.TaxCode.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.TaxCode.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

48
server/AyaNova/biz/TravelRateBiz.cs
View File

@@ -152,35 +152,27 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.TravelRate.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.TravelRate.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }
@@ -253,7 +245,7 @@ namespace AyaNova.Biz
} }
} }
if (!isNew && (proposedObj.Cost != currentObj.Cost || proposedObj.Charge != currentObj.Charge)) if (!isNew && (proposedObj.Cost != currentObj.Cost || proposedObj.Charge != currentObj.Charge))
{ {

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

@@ -152,33 +152,25 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Unit dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
Unit dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.Unit.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.Unit.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }

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

@@ -138,7 +138,7 @@ namespace AyaNova.Biz
else else
AddError(ApiErrorCode.CONCURRENCY_CONFLICT); AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
return null; return null;
} }
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(putObject, false); await SearchIndexAsync(putObject, false);
await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags); await TagBiz.ProcessUpdateTagsInRepositoryAsync(ct, putObject.Tags, dbObject.Tags);
@@ -153,33 +153,25 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.UnitModel.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
if (HasErrors)
return false;
ct.UnitModel.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }

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

@@ -676,64 +676,54 @@ namespace AyaNova.Biz
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = null; Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = null;
if (parentTransaction == null) if (parentTransaction == null)
transaction = await ct.Database.BeginTransactionAsync(); transaction = await ct.Database.BeginTransactionAsync();
try User dbObject = await ct.User.SingleOrDefaultAsync(z => z.Id == id);
if (dbObject == null)
{ {
User dbObject = await ct.User.SingleOrDefaultAsync(z => z.Id == id); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
//Also used for Contacts (customer type user or ho type user)
//by users with no User right but with Customer rights so need to double check here
if (
(dbObject.IsOutsideUser && !Authorized.HasDeleteRole(CurrentUserRoles, AyaType.Customer)) ||
(!dbObject.IsOutsideUser && !Authorized.HasDeleteRole(CurrentUserRoles, AyaType.User))
)
{
AddError(ApiErrorCode.NOT_AUTHORIZED);
return false;
}
await ValidateCanDelete(dbObject);
if (HasErrors)
return false;
//Delete sibling objects
//USEROPTIONS
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from auseroptions where userid = {dbObject.Id}");
//NOTIFY SUBSCRIPTIONS
//Note: will cascade delete notifyevent, and notification automatically
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from anotifysubscription where userid = {dbObject.Id}");
//personal datalist options
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adatalistsavedfilter where public = {false} and userid = {dbObject.Id}");
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adatalistcolumnview where userid = {dbObject.Id}");
//Dashboard view
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adashboardview where userid = {dbObject.Id}");
//Remove the object
ct.User.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
//all good do the commit if it's ours
if (parentTransaction == null)
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch
//Also used for Contacts (customer type user or ho type user)
//by users with no User right but with Customer rights so need to double check here
if (
(dbObject.IsOutsideUser && !Authorized.HasDeleteRole(CurrentUserRoles, AyaType.Customer)) ||
(!dbObject.IsOutsideUser && !Authorized.HasDeleteRole(CurrentUserRoles, AyaType.User))
)
{ {
AddError(ApiErrorCode.NOT_AUTHORIZED);
//no need to rollback, the transaction will rollback automatically if it's disposed without committing return false;
throw;
} }
//Note: Transaction does not need to be disposed it will automatically when it goes out of scope due to Using statement
await ValidateCanDelete(dbObject);
if (HasErrors)
return false;
//Delete sibling objects
//USEROPTIONS
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from auseroptions where userid = {dbObject.Id}");
//NOTIFY SUBSCRIPTIONS
//Note: will cascade delete notifyevent, and notification automatically
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from anotifysubscription where userid = {dbObject.Id}");
//personal datalist options
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adatalistsavedfilter where public = {false} and userid = {dbObject.Id}");
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adatalistcolumnview where userid = {dbObject.Id}");
//Dashboard view
await ct.Database.ExecuteSqlInterpolatedAsync($"delete from adashboardview where userid = {dbObject.Id}");
//Remove the object
ct.User.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
//all good do the commit if it's ours
if (parentTransaction == null)
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }

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

@@ -152,31 +152,23 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try Vendor dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
Vendor dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
ct.Vendor.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
} }
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
ct.Vendor.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Name, ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }

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

@@ -195,36 +195,28 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ValidateCanDelete(dbObject);
return false; if (HasErrors)
} return false;
ValidateCanDelete(dbObject); if (HasErrors)
if (HasErrors) return false;
return false; ct.Widget.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.Widget.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags); await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
//all good do the commit //all good do the commit
await transaction.CommitAsync(); await transaction.CommitAsync();
await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await HandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
} }

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

@@ -361,47 +361,37 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try WorkOrder dbObject = await ct.WorkOrder.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// WorkOrderGetAsync(id, false);
if (dbObject == null)
{ {
WorkOrder dbObject = await ct.WorkOrder.AsNoTracking().Where(z => z.Id == id).FirstOrDefaultAsync();// WorkOrderGetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
WorkOrderValidateCanDelete(dbObject);
if (HasErrors)
return false;
//States collection
if (!await StateDeleteAsync(id, transaction))
return false;
//collect the child id's to delete
var ItemIds = await ct.WorkOrderItem.AsNoTracking().Where(z => z.WorkOrderId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ItemIds)
if (!await ItemDeleteAsync(ItemId, transaction))
return false;
ct.WorkOrder.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await WorkOrderHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
} }
catch WorkOrderValidateCanDelete(dbObject);
{ if (HasErrors)
//NOTE: no need to rollback the transaction, it will auto-rollback if not committed and it is disposed when it goes out of scope either way return false;
throw; //States collection
if (!await StateDeleteAsync(id, transaction))
return false;
} //collect the child id's to delete
var ItemIds = await ct.WorkOrderItem.AsNoTracking().Where(z => z.WorkOrderId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ItemIds)
if (!await ItemDeleteAsync(ItemId, transaction))
return false;
ct.WorkOrder.Remove(dbObject);
await ct.SaveChangesAsync();
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, dbObject.Serial.ToString(), ct);
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
await transaction.CommitAsync();
await WorkOrderHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
return true; return true;
} }
} }
@@ -1405,24 +1395,16 @@ namespace AyaNova.Biz
// (note: this would only ever be called when a workorder is deleted, there is no direct delete) // (note: this would only ever be called when a workorder is deleted, there is no direct delete)
internal async Task<bool> StateDeleteAsync(long workOrderId, IDbContextTransaction parentTransaction) internal async Task<bool> StateDeleteAsync(long workOrderId, IDbContextTransaction parentTransaction)
{ {
try var stateList = await ct.WorkOrderState.AsNoTracking().Where(z => z.WorkOrderId == workOrderId).ToListAsync();
{
var stateList = await ct.WorkOrderState.AsNoTracking().Where(z => z.WorkOrderId == workOrderId).ToListAsync();
foreach (var wostate in stateList) foreach (var wostate in stateList)
{
ct.WorkOrderState.Remove(wostate);
await ct.SaveChangesAsync();
//no need to call this because it's only going to run this method if the workorder is deleted and
//via process standard notifciation events for workorder deletion will remove any state delayed notifications anyway so
//nothing to call or do here related to notification
// await StateHandlePotentialNotificationEvent(AyaEvent.Deleted, wostate);
}
}
catch
{ {
ct.WorkOrderState.Remove(wostate);
throw; await ct.SaveChangesAsync();
//no need to call this because it's only going to run this method if the workorder is deleted and
//via process standard notifciation events for workorder deletion will remove any state delayed notifications anyway so
//nothing to call or do here related to notification
// await StateHandlePotentialNotificationEvent(AyaEvent.Deleted, wostate);
} }
return true; return true;
} }
@@ -1827,81 +1809,73 @@ namespace AyaNova.Biz
internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ItemDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await ct.WorkOrderItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id);
if (dbObject == null)
{ {
var dbObject = await ct.WorkOrderItem.AsNoTracking().SingleOrDefaultAsync(z => z.Id == id); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); ItemValidateCanDelete(dbObject);
if (HasErrors)
return false;
//collect the child id's to delete
var ExpenseIds = await ct.WorkOrderItemExpense.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var LaborIds = await ct.WorkOrderItemLabor.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.WorkOrderItemLoan.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.WorkOrderItemPart.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var PartRequestIds = await ct.WorkOrderItemPartRequest.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.WorkOrderItemScheduledUser.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var TaskIds = await ct.WorkOrderItemTask.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var TravelIds = await ct.WorkOrderItemTravel.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var UnitIds = await ct.WorkOrderItemUnit.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var OutsideServiceIds = await ct.WorkOrderItemOutsideService.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
//Delete children
foreach (long ItemId in ExpenseIds)
if (!await ExpenseDeleteAsync(ItemId, transaction))
return false; return false;
} foreach (long ItemId in LaborIds)
ItemValidateCanDelete(dbObject); if (!await LaborDeleteAsync(ItemId, transaction))
if (HasErrors) return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartRequestIds)
if (!await PartRequestDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false; return false;
//collect the child id's to delete ct.WorkOrderItem.Remove(dbObject);
var ExpenseIds = await ct.WorkOrderItemExpense.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync(); await ct.SaveChangesAsync();
var LaborIds = await ct.WorkOrderItemLabor.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var LoanIds = await ct.WorkOrderItemLoan.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var PartIds = await ct.WorkOrderItemPart.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var PartRequestIds = await ct.WorkOrderItemPartRequest.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var ScheduledUserIds = await ct.WorkOrderItemScheduledUser.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var TaskIds = await ct.WorkOrderItemTask.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var TravelIds = await ct.WorkOrderItemTravel.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var UnitIds = await ct.WorkOrderItemUnit.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
var OutsideServiceIds = await ct.WorkOrderItemOutsideService.Where(z => z.WorkOrderItemId == id).Select(z => z.Id).ToListAsync();
//Delete children //Log event
foreach (long ItemId in ExpenseIds) await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.WorkOrderId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
if (!await ExpenseDeleteAsync(ItemId, transaction)) await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
return false; await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
foreach (long ItemId in LaborIds) await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
if (!await LaborDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in LoanIds)
if (!await LoanDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartIds)
if (!await PartDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in PartRequestIds)
if (!await PartRequestDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in ScheduledUserIds)
if (!await ScheduledUserDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TaskIds)
if (!await TaskDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in TravelIds)
if (!await TravelDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in UnitIds)
if (!await UnitDeleteAsync(ItemId, transaction))
return false;
foreach (long ItemId in OutsideServiceIds)
if (!await OutsideServiceDeleteAsync(ItemId, transaction))
return false;
ct.WorkOrderItem.Remove(dbObject); //all good do the commit if it's ours
await ct.SaveChangesAsync(); if (parentTransaction == null)
await transaction.CommitAsync();
//Log event await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "wo:" + dbObject.WorkOrderId.ToString(), ct);//FIX wo?? Not sure what is best here; revisit
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await TagBiz.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
await FileUtil.DeleteAttachmentsForObjectAsync(dbObject.AyaType, dbObject.Id, ct);
//all good do the commit if it's ours
if (parentTransaction == null)
await transaction.CommitAsync();
await ItemHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2162,26 +2136,18 @@ namespace AyaNova.Biz
internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> ExpenseDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await ExpenseGetAsync(id, false);
{ ExpenseValidateCanDelete(dbObject);
var dbObject = await ExpenseGetAsync(id, false); if (HasErrors)
ExpenseValidateCanDelete(dbObject); return false;
if (HasErrors) ct.WorkOrderItemExpense.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.WorkOrderItemExpense.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
//Log event await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix?? if (parentTransaction == null)
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await transaction.CommitAsync();
if (parentTransaction == null) await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
await transaction.CommitAsync();
await ExpenseHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2518,27 +2484,19 @@ namespace AyaNova.Biz
internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LaborDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await LaborGetAsync(id, false);
{ LaborValidateCanDelete(dbObject);
var dbObject = await LaborGetAsync(id, false); if (HasErrors)
LaborValidateCanDelete(dbObject); return false;
if (HasErrors) ct.WorkOrderItemLabor.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.WorkOrderItemLabor.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await LaborHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -2899,26 +2857,19 @@ namespace AyaNova.Biz
internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> LoanDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await LoanGetAsync(id, false);
{ LoanValidateCanDelete(dbObject);
var dbObject = await LoanGetAsync(id, false); if (HasErrors)
LoanValidateCanDelete(dbObject); return false;
if (HasErrors) ct.WorkOrderItemLoan.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.WorkOrderItemLoan.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await LoanHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3295,26 +3246,19 @@ namespace AyaNova.Biz
internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> OutsideServiceDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await OutsideServiceGetAsync(id, false);
{ OutsideServiceValidateCanDelete(dbObject);
var dbObject = await OutsideServiceGetAsync(id, false); if (HasErrors)
OutsideServiceValidateCanDelete(dbObject); return false;
if (HasErrors) ct.WorkOrderItemOutsideService.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.WorkOrderItemOutsideService.Remove(dbObject);
await ct.SaveChangesAsync();
//Log event //Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix?? await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await OutsideServiceHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -3781,34 +3725,26 @@ namespace AyaNova.Biz
internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> PartDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
var dbObject = await PartGetAsync(id, false);
try PartValidateCanDelete(dbObject);
if (HasErrors)
return false;
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction);
ct.WorkOrderItemPart.Remove(dbObject);
await ct.SaveChangesAsync();
await PartInventoryAdjustmentAsync(AyaEvent.Deleted, null, dbObject, transaction);
if (HasErrors)
{ {
var dbObject = await PartGetAsync(id, false); await transaction.RollbackAsync();
PartValidateCanDelete(dbObject); return false;
if (HasErrors) }
return false; //Log event
await PartBizActionsAsync(AyaEvent.Deleted, null, dbObject, transaction); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
ct.WorkOrderItemPart.Remove(dbObject); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await ct.SaveChangesAsync();
await PartInventoryAdjustmentAsync(AyaEvent.Deleted, null, dbObject, transaction);
if (HasErrors)
{
await transaction.RollbackAsync();
return false;
}
//Log event
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
if (parentTransaction == null) if (parentTransaction == null)
await transaction.CommitAsync(); await transaction.CommitAsync();
await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject); await PartHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }
@@ -4352,25 +4288,18 @@ namespace AyaNova.Biz
internal async Task<bool> PartRequestDeleteAsync(long id, IDbContextTransaction parentTransaction = null) internal async Task<bool> PartRequestDeleteAsync(long id, IDbContextTransaction parentTransaction = null)
{ {
var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync(); var transaction = parentTransaction ?? await ct.Database.BeginTransactionAsync();
try var dbObject = await PartRequestGetAsync(id, false);
{ PartRequestValidateCanDelete(dbObject);
var dbObject = await PartRequestGetAsync(id, false); if (HasErrors)
PartRequestValidateCanDelete(dbObject); return false;
if (HasErrors) ct.WorkOrderItemPartRequest.Remove(dbObject);
return false; await ct.SaveChangesAsync();
ct.WorkOrderItemPartRequest.Remove(dbObject); //Log event
await ct.SaveChangesAsync(); await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix??
//Log event await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct);
await EventLogProcessor.DeleteObjectLogAsync(UserId, dbObject.AyaType, dbObject.Id, "woitem:" + dbObject.WorkOrderItemId.ToString(), ct);//Fix?? if (parentTransaction == null)
await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, dbObject.AyaType, ct); await transaction.CommitAsync();
if (parentTransaction == null) await PartRequestHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
await transaction.CommitAsync();
await PartRequestHandlePotentialNotificationEvent(AyaEvent.Deleted, dbObject);
}
catch
{
throw;
}
return true; return true;
} }

38
server/AyaNova/biz/WorkOrderItemPriorityBiz.cs
View File

@@ -137,31 +137,23 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.WorkOrderItemPriority.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.WorkOrderItemPriority.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
}
catch
{
throw;
}
return true; return true;
} }
} }

38
server/AyaNova/biz/WorkOrderItemStatusBiz.cs
View File

@@ -137,31 +137,23 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.WorkOrderItemStatus.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.WorkOrderItemStatus.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
}
catch
{
throw;
}
return true; return true;
} }
} }

38
server/AyaNova/biz/WorkOrderStatusBiz.cs
View File

@@ -137,31 +137,23 @@ namespace AyaNova.Biz
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try var dbObject = await GetAsync(id, false);
if (dbObject == null)
{ {
var dbObject = await GetAsync(id, false); AddError(ApiErrorCode.NOT_FOUND);
if (dbObject == null) return false;
{ }
AddError(ApiErrorCode.NOT_FOUND); await ValidateCanDeleteAsync(dbObject);
return false; if (HasErrors)
} return false;
await ValidateCanDeleteAsync(dbObject); ct.WorkOrderStatus.Remove(dbObject);
if (HasErrors) await ct.SaveChangesAsync();
return false;
ct.WorkOrderStatus.Remove(dbObject);
await ct.SaveChangesAsync();
//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, ct); await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType, ct);
await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct); await FileUtil.DeleteAttachmentsForObjectAsync(BizType, dbObject.Id, ct);
await transaction.CommitAsync(); await transaction.CommitAsync();
}
catch
{
throw;
}
return true; return true;
} }
} }

1888
server/AyaNova/util/Seeder.cs
View File

File diff suppressed because it is too large Load Diff

3
server/AyaNova/util/TaskUtil.cs
View File

@@ -34,8 +34,7 @@ namespace AyaNova.Util
await task.ConfigureAwait(false); await task.ConfigureAwait(false);
} }
catch (Exception ex) catch (Exception ex)
{ {
// TODO: consider whether derived types are also acceptable.
if (!acceptableExceptions.Contains(ex.GetType())) if (!acceptableExceptions.Contains(ex.GetType()))
throw; throw;
} }