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

Browse Source
This commit is contained in:
John Cardinal
2021-05-03 23:41:37 +00:00
parent 64f0f7c315
commit 12662a4b07
12 changed files with 553 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
server/AyaNova/biz/AyaType.cs
View File

@@ -139,7 +139,9 @@ namespace AyaNova.Biz
PartInventoryRequest = 70,//for list only not, synthetic object
WorkOrderStatus = 71,
TaskGroup = 72,
WorkOrderItemOutsideService = 73
WorkOrderItemOutsideService = 73,
WorkOrderItemPriority=74,
WorkOrderItemStatus=75

22
server/AyaNova/biz/BizRoles.cs
View File

@@ -461,6 +461,28 @@ namespace AyaNova.Biz
Select = AuthorizationRoles.All//sub restricted by client and biz rules as status has it's own role settings so just keep it open for everyone to potentially access
});
////////////////////////////////////////////////////////////
//WorkOrderItemStatus
//
roles.Add(AyaType.WorkOrderItemStatus, new BizRoleSet()
{
Change = AuthorizationRoles.BizAdminFull | AuthorizationRoles.DispatchFull | AuthorizationRoles.TechFull | AuthorizationRoles.SubContractorFull | AuthorizationRoles.AccountingFull,
ReadFullRecord = AuthorizationRoles.BizAdminLimited | AuthorizationRoles.DispatchLimited | AuthorizationRoles.SalesFull |
AuthorizationRoles.SalesLimited | AuthorizationRoles.SubContractorLimited | AuthorizationRoles.TechLimited | AuthorizationRoles.CustomerLimited | AuthorizationRoles.CustomerFull,
Select = AuthorizationRoles.All
});
////////////////////////////////////////////////////////////
//WorkOrderItemPriority
//
roles.Add(AyaType.WorkOrderItemPriority, new BizRoleSet()
{
Change = AuthorizationRoles.BizAdminFull | AuthorizationRoles.DispatchFull | AuthorizationRoles.TechFull | AuthorizationRoles.SubContractorFull | AuthorizationRoles.AccountingFull,
ReadFullRecord = AuthorizationRoles.BizAdminLimited | AuthorizationRoles.DispatchLimited | AuthorizationRoles.SalesFull |
AuthorizationRoles.SalesLimited | AuthorizationRoles.SubContractorLimited | AuthorizationRoles.TechLimited | AuthorizationRoles.CustomerLimited | AuthorizationRoles.CustomerFull,
Select = AuthorizationRoles.All
});
////////////////////////////////////////////////////////////
//WorkOrder
//

8
server/AyaNova/biz/FormFieldReference.cs
View File

@@ -842,8 +842,6 @@ namespace AyaNova.Biz
l.Add(new FormField { TKey = "WorkOrderInternalReferenceNumber", FieldKey = "WorkOrderInternalReferenceNumber" });
l.Add(new FormField { TKey = "WorkOrderOnsite", FieldKey = "WorkOrderOnsite" });
l.Add(new FormField { TKey = "Tags", FieldKey = "Tags" });
l.Add(new FormField { TKey = "Wiki", FieldKey = "Wiki" });
l.Add(new FormField { TKey = "Attachments", FieldKey = "Attachments" });
@@ -877,6 +875,12 @@ namespace AyaNova.Biz
l.Add(new FormField { TKey = "Wiki", FieldKey = "WorkOrderItemWiki", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "Attachments", FieldKey = "WorkOrderItemAttachments", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemWorkOrderStatusID", FieldKey = "WorkOrderItemWorkOrderStatusID", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemPriorityID", FieldKey = "WorkOrderItemPriorityID", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemRequestDate", FieldKey = "WorkOrderItemRequestDate", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemWarrantyService", FieldKey = "WorkOrderItemWarrantyService", TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemCustom1", FieldKey = "WorkOrderItemCustom1", IsCustomField = true, TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemCustom2", FieldKey = "WorkOrderItemCustom2", IsCustomField = true, TKeySection = "WorkOrderItem" });
l.Add(new FormField { TKey = "WorkOrderItemCustom3", FieldKey = "WorkOrderItemCustom3", IsCustomField = true, TKeySection = "WorkOrderItem" });

250
server/AyaNova/biz/WorkOrderItemStatusBiz.cs Normal file
View File

@@ -0,0 +1,250 @@
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using AyaNova.Util;
using AyaNova.Api.ControllerHelpers;
using AyaNova.Models;
namespace AyaNova.Biz
{
internal class WorkOrderItemStatusBiz : BizObject, ISearchAbleObject
{
internal WorkOrderItemStatusBiz(AyContext dbcontext, long currentUserId, long userTranslationId, AuthorizationRoles UserRoles)
{
ct = dbcontext;
UserId = currentUserId;
UserTranslationId = userTranslationId;
CurrentUserRoles = UserRoles;
BizType = AyaType.WorkOrderItemStatus;
}
internal static WorkOrderItemStatusBiz GetBiz(AyContext ct, Microsoft.AspNetCore.Http.HttpContext httpContext = null)
{
if (httpContext != null)
return new WorkOrderItemStatusBiz(ct, UserIdFromContext.Id(httpContext.Items), UserTranslationIdFromContext.Id(httpContext.Items), UserRolesFromContext.Roles(httpContext.Items));
else
return new WorkOrderItemStatusBiz(ct, 1, ServerBootConfig.AYANOVA_DEFAULT_TRANSLATION_ID, AuthorizationRoles.BizAdminFull);
}
////////////////////////////////////////////////////////////////////////////////////////////////
//EXISTS
internal async Task<bool> ExistsAsync(long id)
{
return await ct.WorkOrderItemStatus.AnyAsync(z => z.Id == id);
}
////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE
//
internal async Task<WorkOrderItemStatus> CreateAsync(WorkOrderItemStatus newObject)
{
await ValidateAsync(newObject, null);
if (HasErrors)
return null;
else
{
await ct.WorkOrderItemStatus.AddAsync(newObject);
await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true);
return newObject;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
//DUPLICATE
//
internal async Task<WorkOrderItemStatus> DuplicateAsync(long id)
{
var dbObject = await GetAsync(id, false);
if (dbObject == null)
{
AddError(ApiErrorCode.NOT_FOUND, "id");
return null;
}
WorkOrderItemStatus newObject = new WorkOrderItemStatus();
CopyObject.Copy(dbObject, newObject);
string newUniqueName = string.Empty;
bool NotUnique = true;
long l = 1;
do
{
newUniqueName = Util.StringUtil.UniqueNameBuilder(dbObject.Name, l++, 255);
NotUnique = await ct.WorkOrderItemStatus.AnyAsync(m => m.Name == newUniqueName);
} while (NotUnique);
newObject.Name = newUniqueName;
newObject.Id = 0;
newObject.Concurrency = 0;
await ct.WorkOrderItemStatus.AddAsync(newObject);
await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true);
return newObject;
}
////////////////////////////////////////////////////////////////////////////////////////////////
//GET
//
internal async Task<WorkOrderItemStatus> GetAsync(long id, bool logTheGetEvent = true)
{
var ret = await ct.WorkOrderItemStatus.AsNoTracking().SingleOrDefaultAsync(m => m.Id == id);
if (logTheGetEvent && ret != null)
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, id, BizType, AyaEvent.Retrieved), ct);
return ret;
}
////////////////////////////////////////////////////////////////////////////////////////////////
//UPDATE
//
internal async Task<WorkOrderItemStatus> PutAsync(WorkOrderItemStatus putObject)
{
var dbObject = await GetAsync(putObject.Id, false);
if (dbObject == null)
{
AddError(ApiErrorCode.NOT_FOUND, "id");
return null;
}
if (dbObject.Concurrency != putObject.Concurrency)
{
AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
return null;
}
await ValidateAsync(putObject, dbObject);
if (HasErrors) return null;
ct.Replace(dbObject, putObject);
try
{
await ct.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!await ExistsAsync(putObject.Id))
AddError(ApiErrorCode.NOT_FOUND);
else
AddError(ApiErrorCode.CONCURRENCY_CONFLICT);
return null;
}
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObject.Id, BizType, AyaEvent.Modified), ct);
await SearchIndexAsync(putObject, false);
return putObject;
}
////////////////////////////////////////////////////////////////////////////////////////////////
//DELETE
//
internal async Task<bool> DeleteAsync(long id)
{
using (var transaction = await ct.Database.BeginTransactionAsync())
{
try
{
var dbObject = await GetAsync(id, false);
if (dbObject == null)
{
AddError(ApiErrorCode.NOT_FOUND);
return false;
}
await ValidateCanDeleteAsync(dbObject);
if (HasErrors)
return false;
ct.WorkOrderItemStatus.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
{
//Just re-throw for now, let exception handler deal, but in future may want to deal with this more here
throw;
}
return true;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
//SEARCH
//
private async Task SearchIndexAsync(WorkOrderItemStatus obj, bool isNew)
{
var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
DigestSearchText(obj, SearchParams);
if (isNew)
await Search.ProcessNewObjectKeywordsAsync(SearchParams);
else
await Search.ProcessUpdatedObjectKeywordsAsync(SearchParams);
}
public async Task<Search.SearchIndexProcessObjectParameters> GetSearchResultSummary(long id)
{
var obj = await GetAsync(id, false);
var SearchParams = new Search.SearchIndexProcessObjectParameters();
DigestSearchText(obj, SearchParams);
return SearchParams;
}
public void DigestSearchText(WorkOrderItemStatus obj, Search.SearchIndexProcessObjectParameters searchParams)
{
if (obj != null)
searchParams.AddText(obj.Notes)
.AddText(obj.Name);
}
////////////////////////////////////////////////////////////////////////////////////////////////
//VALIDATION
//
private async Task ValidateAsync(WorkOrderItemStatus proposedObj, WorkOrderItemStatus currentObj)
{
bool isNew = currentObj == null;
//Name required
if (string.IsNullOrWhiteSpace(proposedObj.Name))
AddError(ApiErrorCode.VALIDATION_REQUIRED, "Name");
//If name is otherwise OK, check that name is unique
if (!PropertyHasErrors("Name"))
{
//Use Any command is efficient way to check existance, it doesn't return the record, just a true or false
if (await ct.WorkOrderItemStatus.AnyAsync(m => m.Name == proposedObj.Name && m.Id != proposedObj.Id))
{
AddError(ApiErrorCode.VALIDATION_NOT_UNIQUE, "Name");
}
}
}
private async Task ValidateCanDeleteAsync(WorkOrderItemStatus inObj)
{
//MIGRATE_OUTSTANDING - check workorder records once wo is coded here
await Task.CompletedTask;
//Referential integrity
//FOREIGN KEY CHECKS
// if (await ct.PurchaseOrder.AnyAsync(m => m.WorkOrderItemStatusId == inObj.Id))
// AddError(ApiErrorCode.VALIDATION_REFERENTIAL_INTEGRITY, "generalerror", await Translate("PurchaseOrder"));
}
/////////////////////////////////////////////////////////////////////
}//eoc
}//eons