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
/// <summary>
@@ -70,7 +67,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrder o = await biz.CreateAsync(newObject);
WorkOrder o = await biz.WorkOrderCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
@@ -95,7 +92,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrder o = await biz.DuplicateAsync(id);
WorkOrder o = await biz.WorkOrderDuplicateAsync(id);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
@@ -118,7 +115,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
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));
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);
if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType))
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 (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
@@ -166,24 +163,22 @@ namespace AyaNova.Api.Controllers
WorkOrderBiz biz = WorkOrderBiz.GetBiz(ct, HttpContext);
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrder))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.DeleteAsync(id))
if (!await biz.WorkOrderDeleteAsync(id))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderTopLevel routes
/*
██╗████████╗███████╗███╗ ███╗███████╗
██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
██║ ██║ █████╗ ██╔████╔██║███████╗
██║ ██║ ██╔══╝ ██║╚██╔╝██║╚════██║
██║ ██║ ███████╗██║ ╚═╝ ██║███████║
╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝
*/
/*
██╗████████╗███████╗███╗ ███╗███████╗
██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
██║ ██║ █████╗ ██╔████╔██║███████╗
██║ ██║ ██╔══╝ ██║╚██╔╝██║╚════██║
██║ ██║ ███████╗██║ ╚═╝ ██║███████║
╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝
*/
#region WorkOrderItem
/// <summary>
@@ -202,7 +197,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItem o = await biz.CreateItemAsync(newObject);
WorkOrderItem o = await biz.ItemCreateAsync(newObject);
if (o == null)
return BadRequest(new ApiErrorResponse(biz.Errors));
else
@@ -225,7 +220,7 @@ namespace AyaNova.Api.Controllers
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.GetItemAsync(WorkOrderItemId);
var o = await biz.ItemGetAsync(WorkOrderItemId);
if (o == null)
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItem)));
@@ -283,16 +278,122 @@ namespace AyaNova.Api.Controllers
#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
@@ -393,6 +494,113 @@ namespace AyaNova.Api.Controllers
#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
/*
███████╗ ██████╗██╗ ██╗███████╗██████╗ ██╗ ██╗██╗ ███████╗██████╗ ██╗ ██╗███████╗███████╗██████╗ ███████╗
██╔════╝██╔════╝██║ ██║██╔════╝██╔══██╗██║ ██║██║ ██╔════╝██╔══██╗ ██║ ██║██╔════╝██╔════╝██╔══██╗██╔════╝
@@ -710,219 +919,6 @@ namespace AyaNova.Api.Controllers
#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>
/// Create WorkOrderItemLoan
/// Create WorkOrderItemTravel
/// </summary>
/// <param name="newObject">WorkOrderItemLoan level only no descendents</param>
/// <param name="newObject">WorkOrderItemTravel 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)
/// <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.WorkOrderItemLoan))
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
WorkOrderItemLoan o = await biz.LoanCreateAsync(newObject);
WorkOrderItemTravel o = await biz.TravelCreateAsync(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));
return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemTravel), new { WorkOrderItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
}
/// <summary>
/// Get WorkOrderItemLoan object
/// Get WorkOrderItemTravel object
/// </summary>
/// <param name="WorkOrderItemLoanId"></param>
/// <returns>A single WorkOrderItemLoan</returns>
[HttpGet("items/loans/{WorkOrderItemLoanId}")]
public async Task<IActionResult> GetWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId)
/// <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.WorkOrderItemLoan))
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!ModelState.IsValid)
return BadRequest(new ApiErrorResponse(ModelState));
var o = await biz.LoanGetAsync(WorkOrderItemLoanId);
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.WorkOrderItemLoan)));
return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel)));
}
/// <summary>
/// Put (update) WorkOrderItemLoan
/// Put (update) WorkOrderItemTravel
/// (Descendent objects must be updated via their individual routes seperately)
/// </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>
[HttpPut("items/loans")]
public async Task<IActionResult> PutWorkOrderItemLoan([FromBody] WorkOrderItemLoan updatedObject)
[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.WorkOrderItemLoan))
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
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 (biz.Errors.Exists(m => m.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
@@ -1113,26 +1109,26 @@ namespace AyaNova.Api.Controllers
}
/// <summary>
/// Delete WorkOrderItemLoan
/// Delete WorkOrderItemTravel
/// </summary>
/// <param name="WorkOrderItemLoanId"></param>
/// <param name="WorkOrderItemTravelId"></param>
/// <returns>NoContent</returns>
[HttpDelete("items/loans/{WorkOrderItemLoanId}")]
public async Task<IActionResult> DeleteWorkOrderItemLoan([FromRoute] long WorkOrderItemLoanId)
[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.WorkOrderItemLoan))
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.WorkOrderItemTravel))
return StatusCode(403, new ApiNotAuthorizedResponse());
if (!await biz.LoanDeleteAsync(WorkOrderItemLoanId))
if (!await biz.TravelDeleteAsync(WorkOrderItemTravelId))
return BadRequest(new ApiErrorResponse(biz.Errors));
return NoContent();
}
#endregion WorkOrderItemLoan
#endregion WorkOrderItemTravel
/*

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

@@ -53,11 +53,11 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE
//
internal async Task<WorkOrder> CreateAsync(dtWorkOrder dtNewObject)
internal async Task<WorkOrder> WorkOrderCreateAsync(dtWorkOrder dtNewObject)
{
WorkOrder newObject = new WorkOrder();
CopyObject.Copy(dtNewObject, newObject);
await ValidateAsync(newObject, null);
await WorkOrderValidateAsync(newObject, null);
if (HasErrors)
return null;
else
@@ -68,7 +68,7 @@ namespace AyaNova.Biz
await ct.WorkOrder.AddAsync(newObject);
await ct.SaveChangesAsync();
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);
return newObject;
}
@@ -78,9 +78,9 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
//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)
{
AddError(ApiErrorCode.NOT_FOUND, "id");
@@ -94,7 +94,7 @@ namespace AyaNova.Biz
await ct.WorkOrder.AddAsync(newObject);
await ct.SaveChangesAsync();
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);
return newObject;
}
@@ -104,7 +104,7 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
// 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
//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
//
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);
@@ -155,7 +155,7 @@ namespace AyaNova.Biz
dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
ct.Entry(dbObject).OriginalValues["ConcurrencyToken"] = dtPutObject.ConcurrencyToken;
await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
await WorkOrderValidateAsync(dbObject, SnapshotOfOriginalDBObj);
if (HasErrors)
return null;
@@ -172,7 +172,7 @@ namespace AyaNova.Biz
return null;
}
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);
return dbObject;
}
@@ -180,14 +180,14 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
//DELETE
//
internal async Task<bool> DeleteAsync(long id)
internal async Task<bool> WorkOrderDeleteAsync(long id)
{
using (var transaction = await ct.Database.BeginTransactionAsync())
{
try
{
WorkOrder dbObject = await ct.WorkOrder.SingleOrDefaultAsync(m => m.Id == id);
ValidateCanDelete(dbObject);
WorkOrderValidateCanDelete(dbObject);
if (HasErrors)
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
var SearchParams = new Search.SearchIndexProcessObjectParameters(UserTranslationId, obj.Id, BizType);
@@ -256,7 +256,7 @@ namespace AyaNova.Biz
//
//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
@@ -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
}
@@ -325,7 +325,7 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
//CREATE
//
internal async Task<WorkOrderItem> CreateItemAsync(dtWorkOrderItem dtNewObject)
internal async Task<WorkOrderItem> ItemCreateAsync(dtWorkOrderItem dtNewObject)
{
WorkOrderItem newObject = new WorkOrderItem();
CopyObject.Copy(dtNewObject, newObject);
@@ -349,7 +349,7 @@ namespace AyaNova.Biz
////////////////////////////////////////////////////////////////////////////////////////////////
// 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
//if so, then need to implement AddError and in route handle Null return with Error check just like PUT route does now