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
2020-05-11 18:00:02 +00:00
parent e68e2d048a
commit 600885422a
2 changed files with 298 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

566
server/AyaNova/Controllers/WorkOrderController.cs
View File

@@ -41,17 +41,14 @@ namespace AyaNova.Api.Controllers
/* /*
██╗ ██╗ ██████╗ ██████╗ ██╗ ██╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗
██╗ ██╗ ██████╗ ██████╗ ██╗ ██╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗ ██║ ██║██╔═══██╗██╔══██╗██║ ██╔╝ ██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗
██║ ██║██╔═══██╗██╔══██╗██║ ██╔╝ ██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗ ██║ █╗ ██║██║ ██║██████╔╝█████╔╝█████╗██║ ██║██████╔╝██║ ██║█████╗ ██████╔╝
██║ █╗ ██║██║ ██║██████╔╝█████╔╝█████╗██║ ██║██████╔╝██║ ██║█████╗ ██████╔╝ ██║███╗██║██║ ██║██╔══██╗██╔═██╗╚════╝██║ ██║██╔══██╗██║ ██║██╔══╝ ██╔══██╗
██║███╗██║██║ ██║██╔══██╗██╔═██╗╚════╝██║ ██║██╔══██╗██║ ██║██╔══╝ ██╔══██╗ ╚███╔███╔╝╚██████╔╝██║ ██║██║ ██╗ ╚██████╔╝██║ ██║██████╔╝███████╗██║ ██║
╚███╔███╔╝╚██████╔╝██║ ██║██║ ██╗ ╚██████╔╝██║ ██║██████╔╝███████╗██║ ██║ ╚══╝╚══╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝
╚══╝╚══╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝ */
*/
#region WorkOrder top level routes #region WorkOrder top level routes
/// <summary> /// <summary>
@@ -70,7 +67,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrder o = await biz.CreateAsync(newObject); WorkOrder o = await biz.WorkOrderCreateAsync(newObject);
if (o == null) if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
else else
@@ -95,7 +92,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrder o = await biz.DuplicateAsync(id); WorkOrder o = await biz.WorkOrderDuplicateAsync(id);
if (o == null) if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
else else
@@ -118,7 +115,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.GetEntireWorkOrderAsync(id); var o = await biz.WorkOrderGetAsync(id);
if (o == null) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND)); if (o == null) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, biz.BizType))); return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, biz.BizType)));
} }
@@ -140,7 +137,7 @@ namespace AyaNova.Api.Controllers
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType)) if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.PutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token var o = await biz.WorkOrderPutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null) if (o == null)
{ {
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT)) if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
@@ -166,24 +163,22 @@ namespace AyaNova.Api.Controllers
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrder)) if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrder))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.DeleteAsync(id)) if (!await biz.WorkOrderDeleteAsync(id))
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent(); return NoContent();
} }
#endregion WorkOrderTopLevel routes #endregion WorkOrderTopLevel routes
/*
██╗████████╗███████╗███╗ ███╗███████╗ /*
██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝ ██╗████████╗███████╗███╗ ███╗███████╗
██║ ██║ █████╗ ██╔████╔██║███████╗ ██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
██║ ██║ ██╔══╝ ██║╚██╔╝██║╚════██║ ██║ ██║ █████╗ ██╔████╔██║███████╗
██║ ██║ ███████╗██║ ╚═╝ ██║███████║ ██║ ██║ ██╔══╝ ██║╚██╔╝██║╚════██║
╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝ ██║ ██║ ███████╗██║ ╚═╝ ██║███████║
╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝
*/
*/
#region WorkOrderItem #region WorkOrderItem
/// <summary> /// <summary>
@@ -202,7 +197,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItem o = await biz.CreateItemAsync(newObject); WorkOrderItem o = await biz.ItemCreateAsync(newObject);
if (o == null) if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
else else
@@ -225,7 +220,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.GetItemAsync(WorkOrderItemId); var o = await biz.ItemGetAsync(WorkOrderItemId);
if (o == null) if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND)); return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItem))); return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItem)));
@@ -283,16 +278,122 @@ namespace AyaNova.Api.Controllers
#endregion workorderitem #endregion workorderitem
/*
██╗ █████╗ ██████╗ ██████╗ ██████╗ /*
██║ ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗ ███████╗██╗ ██╗██████╗ ███████╗███╗ ██╗███████╗███████╗███████╗
██║ ███████║██████╔╝██║ ██║██████╔╝ ██╔════╝╚██╗██╔╝██╔══██╗██╔════╝████╗ ██║██╔════╝██╔════╝██╔════╝
██║ ██╔══██║██╔══██╗██║ ██║██╔══██╗ █████╗ ╚███╔╝ ██████╔╝█████╗ ██╔██╗ ██║███████╗█████╗ ███████╗
███████╗██║ ██║██████╔╝╚██████╔╝██║ ██║ ██╔══╝ ██╔██╗ ██╔═══╝ ██╔══╝ ██║╚██╗██║╚════██║██╔══╝ ╚════██║
╚══════╝╚═╝ ╚═╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ███████╗██╔╝ ██╗██║ ███████╗██║ ╚████║███████║███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═══╝╚══════╝╚══════╝╚══════╝
*/
*/ #region WorkOrderItemExpense
/// <summary>
/// Create WorkOrderItemExpense
/// </summary>
/// <param name="newObject">WorkOrderItemExpense level only no descendents</param>
/// <param name="apiVersion"></param>
/// <returns>WorkOrderItemExpense object (no descendents)</returns>
[HttpPost("items/expenses")]
public async Task<IActionResult> PostWorkOrderItemExpense([FromBody] WorkOrderItemExpense newObject, ApiVersion apiVersion)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemExpense o = await biz.ExpenseCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemExpense), new { WorkOrderItemExpenseId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
}
/// <summary>
/// Get WorkOrderItemExpense object
/// </summary>
/// <param name="WorkOrderItemExpenseId"></param>
/// <returns>A single WorkOrderItemExpense</returns>
[HttpGet("items/expenses/{WorkOrderItemExpenseId}")]
public async Task<IActionResult> GetWorkOrderItemExpense([FromRoute] long WorkOrderItemExpenseId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.ExpenseGetAsync(WorkOrderItemExpenseId);
if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemExpense)));
}
/// <summary>
/// Put (update) WorkOrderItemExpense
/// (Descendent objects must be updated via their individual routes seperately)
/// </summary>
/// <param name="updatedObject">WorkOrderItemExpense - top level only, no descendents</param>
/// <returns>New concurrency token</returns>
[HttpPut("items/expenses")]
public async Task<IActionResult> PutWorkOrderItemExpense([FromBody] WorkOrderItemExpense updatedObject)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.ExpensePutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null)
{
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
return StatusCode(409, new ApiErrorResponse(biz.Errors));
else
return BadRequest(new ApiErrorResponse(biz.Errors));
}
return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
}
/// <summary>
/// Delete WorkOrderItemExpense
/// </summary>
/// <param name="WorkOrderItemExpenseId"></param>
/// <returns>NoContent</returns>
[HttpDelete("items/expenses/{WorkOrderItemExpenseId}")]
public async Task<IActionResult> DeleteWorkOrderItemExpense([FromRoute] long WorkOrderItemExpenseId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.ExpenseDeleteAsync(WorkOrderItemExpenseId))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderItemExpense
/*
██╗ █████╗ ██████╗ ██████╗ ██████╗
██║ ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
██║ ███████║██████╔╝██║ ██║██████╔╝
██║ ██╔══██║██╔══██╗██║ ██║██╔══██╗
███████╗██║ ██║██████╔╝╚██████╔╝██║ ██║
╚══════╝╚═╝ ╚═╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝
*/
#region WorkOrderItemLabor #region WorkOrderItemLabor
@@ -393,6 +494,113 @@ namespace AyaNova.Api.Controllers
#endregion WorkOrderItemLabor #endregion WorkOrderItemLabor
/*
██╗ ██████╗ █████╗ ███╗ ██╗
██║ ██╔═══██╗██╔══██╗████╗ ██║
██║ ██║ ██║███████║██╔██╗ ██║
██║ ██║ ██║██╔══██║██║╚██╗██║
███████╗╚██████╔╝██║ ██║██║ ╚████║
╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝
*/
#region WorkOrderItemLoan
/// <summary>
/// Create WorkOrderItemLoan
/// </summary>
/// <param name="newObject">WorkOrderItemLoan level only no descendents</param>
/// <param name="apiVersion"></param>
/// <returns>WorkOrderItemLoan object (no descendents)</returns>
[HttpPost("items/loans")]
public async Task<IActionResult> PostWorkOrderItemLoan([FromBody] WorkOrderItemLoan newObject, ApiVersion apiVersion)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemLoan))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemLoan o = await biz.LoanCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemLoan), new { WorkOrderItemLoanId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
}
/// <summary>
/// Get WorkOrderItemLoan object
/// </summary>
/// <param name="WorkOrderItemLoanId"></param>
/// <returns>A single WorkOrderItemLoan</returns>
[HttpGet("items/loans/{WorkOrderItemLoanId}")]
public async Task<IActionResult> GetWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemLoan))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.LoanGetAsync(WorkOrderItemLoanId);
if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemLoan)));
}
/// <summary>
/// Put (update) WorkOrderItemLoan
/// (Descendent objects must be updated via their individual routes seperately)
/// </summary>
/// <param name="updatedObject">WorkOrderItemLoan - top level only, no descendents</param>
/// <returns>New concurrency token</returns>
[HttpPut("items/loans")]
public async Task<IActionResult> PutWorkOrderItemLoan([FromBody] WorkOrderItemLoan updatedObject)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemLoan))
return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.LoanPutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null)
{
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
return StatusCode(409, new ApiErrorResponse(biz.Errors));
else
return BadRequest(new ApiErrorResponse(biz.Errors));
}
return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
}
/// <summary>
/// Delete WorkOrderItemLoan
/// </summary>
/// <param name="WorkOrderItemLoanId"></param>
/// <returns>NoContent</returns>
[HttpDelete("items/loans/{WorkOrderItemLoanId}")]
public async Task<IActionResult> DeleteWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemLoan))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.LoanDeleteAsync(WorkOrderItemLoanId))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderItemLoan
/* /*
██████╗ █████╗ ██████╗ ████████╗███████╗ ██████╗ █████╗ ██████╗ ████████╗███████╗
██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝ ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝
@@ -604,6 +812,7 @@ namespace AyaNova.Api.Controllers
#endregion WorkOrderItemPartRequest #endregion WorkOrderItemPartRequest
/* /*
███████╗ ██████╗██╗ ██╗███████╗██████╗ ██╗ ██╗██╗ ███████╗██████╗ ██╗ ██╗███████╗███████╗██████╗ ███████╗ ███████╗ ██████╗██╗ ██╗███████╗██████╗ ██╗ ██╗██╗ ███████╗██████╗ ██╗ ██╗███████╗███████╗██████╗ ███████╗
██╔════╝██╔════╝██║ ██║██╔════╝██╔══██╗██║ ██║██║ ██╔════╝██╔══██╗ ██║ ██║██╔════╝██╔════╝██╔══██╗██╔════╝ ██╔════╝██╔════╝██║ ██║██╔════╝██╔══██╗██║ ██║██║ ██╔════╝██╔══██╗ ██║ ██║██╔════╝██╔════╝██╔══██╗██╔════╝
@@ -710,219 +919,6 @@ namespace AyaNova.Api.Controllers
#endregion WorkOrderItemScheduledUser #endregion WorkOrderItemScheduledUser
/*
███████╗██╗ ██╗██████╗ ███████╗███╗ ██╗███████╗███████╗███████╗
██╔════╝╚██╗██╔╝██╔══██╗██╔════╝████╗ ██║██╔════╝██╔════╝██╔════╝
█████╗ ╚███╔╝ ██████╔╝█████╗ ██╔██╗ ██║███████╗█████╗ ███████╗
██╔══╝ ██╔██╗ ██╔═══╝ ██╔══╝ ██║╚██╗██║╚════██║██╔══╝ ╚════██║
███████╗██╔╝ ██╗██║ ███████╗██║ ╚████║███████║███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═══╝╚══════╝╚══════╝╚══════╝
*/
#region WorkOrderItemExpense
/// <summary>
/// Create WorkOrderItemExpense
/// </summary>
/// <param name="newObject">WorkOrderItemExpense level only no descendents</param>
/// <param name="apiVersion"></param>
/// <returns>WorkOrderItemExpense object (no descendents)</returns>
[HttpPost("items/expenses")]
public async Task<IActionResult> PostWorkOrderItemExpense([FromBody] WorkOrderItemExpense newObject, ApiVersion apiVersion)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemExpense o = await biz.ExpenseCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemExpense), new { WorkOrderItemExpenseId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
}
/// <summary>
/// Get WorkOrderItemExpense object
/// </summary>
/// <param name="WorkOrderItemExpenseId"></param>
/// <returns>A single WorkOrderItemExpense</returns>
[HttpGet("items/expenses/{WorkOrderItemExpenseId}")]
public async Task<IActionResult> GetWorkOrderItemExpense([FromRoute] long WorkOrderItemExpenseId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.ExpenseGetAsync(WorkOrderItemExpenseId);
if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemExpense)));
}
/// <summary>
/// Put (update) WorkOrderItemExpense
/// (Descendent objects must be updated via their individual routes seperately)
/// </summary>
/// <param name="updatedObject">WorkOrderItemExpense - top level only, no descendents</param>
/// <returns>New concurrency token</returns>
[HttpPut("items/expenses")]
public async Task<IActionResult> PutWorkOrderItemExpense([FromBody] WorkOrderItemExpense updatedObject)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.ExpensePutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null)
{
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
return StatusCode(409, new ApiErrorResponse(biz.Errors));
else
return BadRequest(new ApiErrorResponse(biz.Errors));
}
return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
}
/// <summary>
/// Delete WorkOrderItemExpense
/// </summary>
/// <param name="WorkOrderItemExpenseId"></param>
/// <returns>NoContent</returns>
[HttpDelete("items/expenses/{WorkOrderItemExpenseId}")]
public async Task<IActionResult> DeleteWorkOrderItemExpense([FromRoute] long WorkOrderItemExpenseId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemExpense))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.ExpenseDeleteAsync(WorkOrderItemExpenseId))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderItemExpense
/*
████████╗██████╗ █████╗ ██╗ ██╗███████╗██╗
╚══██╔══╝██╔══██╗██╔══██╗██║ ██║██╔════╝██║
██║ ██████╔╝███████║██║ ██║█████╗ ██║
██║ ██╔══██╗██╔══██║╚██╗ ██╔╝██╔══╝ ██║
██║ ██║ ██║██║ ██║ ╚████╔╝ ███████╗███████╗
╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═══╝ ╚══════╝╚══════╝
*/
#region WorkOrderItemTravel
/// <summary>
/// Create WorkOrderItemTravel
/// </summary>
/// <param name="newObject">WorkOrderItemTravel level only no descendents</param>
/// <param name="apiVersion"></param>
/// <returns>WorkOrderItemTravel object (no descendents)</returns>
[HttpPost("items/travels")]
public async Task<IActionResult> PostWorkOrderItemTravel([FromBody] WorkOrderItemTravel newObject, ApiVersion apiVersion)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemTravel o = await biz.TravelCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemTravel), new { WorkOrderItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
}
/// <summary>
/// Get WorkOrderItemTravel object
/// </summary>
/// <param name="WorkOrderItemTravelId"></param>
/// <returns>A single WorkOrderItemTravel</returns>
[HttpGet("items/travels/{WorkOrderItemTravelId}")]
public async Task<IActionResult> GetWorkOrderItemTravel([FromRoute] long WorkOrderItemTravelId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.TravelGetAsync(WorkOrderItemTravelId);
if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel)));
}
/// <summary>
/// Put (update) WorkOrderItemTravel
/// (Descendent objects must be updated via their individual routes seperately)
/// </summary>
/// <param name="updatedObject">WorkOrderItemTravel - top level only, no descendents</param>
/// <returns>New concurrency token</returns>
[HttpPut("items/travels")]
public async Task<IActionResult> PutWorkOrderItemTravel([FromBody] WorkOrderItemTravel updatedObject)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.TravelPutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null)
{
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
return StatusCode(409, new ApiErrorResponse(biz.Errors));
else
return BadRequest(new ApiErrorResponse(biz.Errors));
}
return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
}
/// <summary>
/// Delete WorkOrderItemTravel
/// </summary>
/// <param name="WorkOrderItemTravelId"></param>
/// <returns>NoContent</returns>
[HttpDelete("items/travels/{WorkOrderItemTravelId}")]
public async Task<IActionResult> DeleteWorkOrderItemTravel([FromRoute] long WorkOrderItemTravelId)
{
if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.TravelDeleteAsync(WorkOrderItemTravelId))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderItemTravel
/* /*
████████╗ █████╗ ███████╗██╗ ██╗ ████████╗ █████╗ ███████╗██╗ ██╗
╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝ ╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
@@ -1030,78 +1026,78 @@ namespace AyaNova.Api.Controllers
/* /*
██╗ ██████╗ █████╗ ███╗ ██╗ ████████╗██████╗ █████╗ ██╗ ██╗███████╗██╗
██║ ██╔═══██╗██╔══██╗████╗ ██║ ╚══██╔══╝██╔══██╗██╔══██╗██║ ██║██╔════╝██║
██║ ██║ ██║███████║██╔██╗ ██║ ██║ ██████╔╝███████║██║ ██║█████╗ ██║
██║ ██║ ██║██╔══██║██║╚██╗██║ ██║ ██╔══██╗██╔══██║╚██╗ ██╔╝██╔══╝ ██║
███████╗╚██████╔╝██║ ██║██║ ╚████║ ██║ ██║ ██║██║ ██║ ╚████╔╝ ███████╗███████╗
╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═══╝ ╚══════╝╚══════╝
*/ */
#region WorkOrderItemLoan #region WorkOrderItemTravel
/// <summary> /// <summary>
/// Create WorkOrderItemLoan /// Create WorkOrderItemTravel
/// </summary> /// </summary>
/// <param name="newObject">WorkOrderItemLoan level only no descendents</param> /// <param name="newObject">WorkOrderItemTravel level only no descendents</param>
/// <param name="apiVersion"></param> /// <param name="apiVersion"></param>
/// <returns>WorkOrderItemLoan object (no descendents)</returns> /// <returns>WorkOrderItemTravel object (no descendents)</returns>
[HttpPost("items/loans")] [HttpPost("items/travels")]
public async Task<IActionResult> PostWorkOrderItemLoan([FromBody] WorkOrderItemLoan newObject, ApiVersion apiVersion) public async Task<IActionResult> PostWorkOrderItemTravel([FromBody] WorkOrderItemTravel newObject, ApiVersion apiVersion)
{ {
if (!serverState.IsOpen) if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemLoan)) if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemLoan o = await biz.LoanCreateAsync(newObject); WorkOrderItemTravel o = await biz.TravelCreateAsync(newObject);
if (o == null) if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
else else
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemLoan), new { WorkOrderItemLoanId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o)); return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemTravel), new { WorkOrderItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
} }
/// <summary> /// <summary>
/// Get WorkOrderItemLoan object /// Get WorkOrderItemTravel object
/// </summary> /// </summary>
/// <param name="WorkOrderItemLoanId"></param> /// <param name="WorkOrderItemTravelId"></param>
/// <returns>A single WorkOrderItemLoan</returns> /// <returns>A single WorkOrderItemTravel</returns>
[HttpGet("items/loans/{WorkOrderItemLoanId}")] [HttpGet("items/travels/{WorkOrderItemTravelId}")]
public async Task<IActionResult> GetWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId) public async Task<IActionResult> GetWorkOrderItemTravel([FromRoute] long WorkOrderItemTravelId)
{ {
if (!serverState.IsOpen) if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemLoan)) if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.LoanGetAsync(WorkOrderItemLoanId); var o = await biz.TravelGetAsync(WorkOrderItemTravelId);
if (o == null) if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND)); return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemLoan))); return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel)));
} }
/// <summary> /// <summary>
/// Put (update) WorkOrderItemLoan /// Put (update) WorkOrderItemTravel
/// (Descendent objects must be updated via their individual routes seperately) /// (Descendent objects must be updated via their individual routes seperately)
/// </summary> /// </summary>
/// <param name="updatedObject">WorkOrderItemLoan - top level only, no descendents</param> /// <param name="updatedObject">WorkOrderItemTravel - top level only, no descendents</param>
/// <returns>New concurrency token</returns> /// <returns>New concurrency token</returns>
[HttpPut("items/loans")] [HttpPut("items/travels")]
public async Task<IActionResult> PutWorkOrderItemLoan([FromBody] WorkOrderItemLoan updatedObject) public async Task<IActionResult> PutWorkOrderItemTravel([FromBody] WorkOrderItemTravel updatedObject)
{ {
if (!serverState.IsOpen) if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemLoan)) if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
var o = await biz.LoanPutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token var o = await biz.TravelPutAsync(updatedObject);//In future may need to return entire object, for now just concurrency token
if (o == null) if (o == null)
{ {
if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT)) if (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
@@ -1113,26 +1109,26 @@ namespace AyaNova.Api.Controllers
} }
/// <summary> /// <summary>
/// Delete WorkOrderItemLoan /// Delete WorkOrderItemTravel
/// </summary> /// </summary>
/// <param name="WorkOrderItemLoanId"></param> /// <param name="WorkOrderItemTravelId"></param>
/// <returns>NoContent</returns> /// <returns>NoContent</returns>
[HttpDelete("items/loans/{WorkOrderItemLoanId}")] [HttpDelete("items/travels/{WorkOrderItemTravelId}")]
public async Task<IActionResult> DeleteWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId) public async Task<IActionResult> DeleteWorkOrderItemTravel([FromRoute] long WorkOrderItemTravelId)
{ {
if (!serverState.IsOpen) if (!serverState.IsOpen)
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason)); return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
if (!ModelState.IsValid) if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState)); return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext); WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemLoan)) if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse()); return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.LoanDeleteAsync(WorkOrderItemLoanId)) if (!await biz.TravelDeleteAsync(WorkOrderItemTravelId))
return BadRequest(new ApiErrorResponse(biz.Errors)); return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent(); return NoContent();
} }
#endregion WorkOrderItemLoan #endregion WorkOrderItemTravel
/* /*

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

@@ -53,11 +53,11 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE //CREATE
// //
internal async Task<WorkOrder> CreateAsync(dtWorkOrder dtNewObject) internal async Task<WorkOrder> WorkOrderCreateAsync(dtWorkOrder dtNewObject)
{ {
WorkOrder newObject = new WorkOrder(); WorkOrder newObject = new WorkOrder();
CopyObject.Copy(dtNewObject, newObject); CopyObject.Copy(dtNewObject, newObject);
await ValidateAsync(newObject, null); await WorkOrderValidateAsync(newObject, null);
if (HasErrors) if (HasErrors)
return null; return null;
else else
@@ -68,7 +68,7 @@ namespace AyaNova.Biz
await ct.WorkOrder.AddAsync(newObject); await ct.WorkOrder.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await WorkOrderSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -78,9 +78,9 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//DUPLICATE //DUPLICATE
// //
internal async Task<WorkOrder> DuplicateAsync(long id) internal async Task<WorkOrder> WorkOrderDuplicateAsync(long id)
{ {
WorkOrder dbObject = await GetEntireWorkOrderAsync(id, false); WorkOrder dbObject = await WorkOrderGetAsync(id, false);
if (dbObject == null) if (dbObject == null)
{ {
AddError(ApiErrorCode.NOT_FOUND, "id"); AddError(ApiErrorCode.NOT_FOUND, "id");
@@ -94,7 +94,7 @@ namespace AyaNova.Biz
await ct.WorkOrder.AddAsync(newObject); await ct.WorkOrder.AddAsync(newObject);
await ct.SaveChangesAsync(); await ct.SaveChangesAsync();
await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct); await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, newObject.Id, BizType, AyaEvent.Created), ct);
await SearchIndexAsync(newObject, true); await WorkOrderSearchIndexAsync(newObject, true);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null); await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, newObject.Tags, null);
return newObject; return newObject;
} }
@@ -104,7 +104,7 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
// GET // GET
// //
internal async Task<WorkOrder> GetEntireWorkOrderAsync(long id, bool logTheGetEvent = true) internal async Task<WorkOrder> WorkOrderGetAsync(long id, bool logTheGetEvent = true)
{ {
//Note: there could be rules checking here in future, i.e. can only get own workorder or something //Note: there could be rules checking here in future, i.e. can only get own workorder or something
//if so, then need to implement AddError and in route handle Null return with Error check just like PUT route does now //if so, then need to implement AddError and in route handle Null return with Error check just like PUT route does now
@@ -128,7 +128,7 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//UPDATE //UPDATE
// //
internal async Task<WorkOrder> PutAsync(dtWorkOrder dtPutObject) internal async Task<WorkOrder> WorkOrderPutAsync(dtWorkOrder dtPutObject)
{ {
WorkOrder dbObject = await ct.WorkOrder.SingleOrDefaultAsync(m => m.Id == dtPutObject.Id); WorkOrder dbObject = await ct.WorkOrder.SingleOrDefaultAsync(m => m.Id == dtPutObject.Id);
@@ -155,7 +155,7 @@ namespace AyaNova.Biz
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields); dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["ConcurrencyToken"] = dtPutObject.ConcurrencyToken; ct.Entry(dbObject).OriginalValues["ConcurrencyToken"] = dtPutObject.ConcurrencyToken;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj); await WorkOrderValidateAsync(dbObject, SnapshotOfOriginalDBObj);
if (HasErrors) if (HasErrors)
return null; return null;
@@ -172,7 +172,7 @@ namespace AyaNova.Biz
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(dbObject, false); await WorkOrderSearchIndexAsync(dbObject, false);
await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags); await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObject.Tags, SnapshotOfOriginalDBObj.Tags);
return dbObject; return dbObject;
} }
@@ -180,14 +180,14 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//DELETE //DELETE
// //
internal async Task<bool> DeleteAsync(long id) internal async Task<bool> WorkOrderDeleteAsync(long id)
{ {
using (var transaction = await ct.Database.BeginTransactionAsync()) using (var transaction = await ct.Database.BeginTransactionAsync())
{ {
try try
{ {
WorkOrder dbObject = await ct.WorkOrder.SingleOrDefaultAsync(m => m.Id == id); WorkOrder dbObject = await ct.WorkOrder.SingleOrDefaultAsync(m => m.Id == id);
ValidateCanDelete(dbObject); WorkOrderValidateCanDelete(dbObject);
if (HasErrors) if (HasErrors)
return false; return false;
@@ -227,7 +227,7 @@ namespace AyaNova.Biz
} }
} }
private async Task SearchIndexAsync(WorkOrder obj, bool isNew) private async Task WorkOrderSearchIndexAsync(WorkOrder obj, bool isNew)
{ {
//SEARCH INDEXING //SEARCH INDEXING
var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType); var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
@@ -256,7 +256,7 @@ namespace AyaNova.Biz
// //
//Can save or update? //Can save or update?
private async Task ValidateAsync(WorkOrder proposedObj, WorkOrder currentObj) private async Task WorkOrderValidateAsync(WorkOrder proposedObj, WorkOrder currentObj)
{ {
//run validation and biz rules //run validation and biz rules
@@ -298,7 +298,7 @@ namespace AyaNova.Biz
private void ValidateCanDelete(WorkOrder dbObject) private void WorkOrderValidateCanDelete(WorkOrder dbObject)
{ {
//whatever needs to be check to delete this object //whatever needs to be check to delete this object
} }
@@ -325,7 +325,7 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE //CREATE
// //
internal async Task<WorkOrderItem> CreateItemAsync(dtWorkOrderItem dtNewObject) internal async Task<WorkOrderItem> ItemCreateAsync(dtWorkOrderItem dtNewObject)
{ {
WorkOrderItem newObject = new WorkOrderItem(); WorkOrderItem newObject = new WorkOrderItem();
CopyObject.Copy(dtNewObject, newObject); CopyObject.Copy(dtNewObject, newObject);
@@ -349,7 +349,7 @@ namespace AyaNova.Biz
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
// GET // GET
// //
internal async Task<WorkOrderItem> GetItemAsync(long id, bool logTheGetEvent = true) internal async Task<WorkOrderItem> ItemGetAsync(long id, bool logTheGetEvent = true)
{ {
//Note: there could be rules checking here in future, i.e. can only get own workorder or something //Note: there could be rules checking here in future, i.e. can only get own workorder or something
//if so, then need to implement AddError and in route handle Null return with Error check just like PUT route does now //if so, then need to implement AddError and in route handle Null return with Error check just like PUT route does now