server/AyaNova/Controllers/WorkOrderController.cs

@@ -500,6 +500,744 @@ namespace AyaNova.Api.Controllers
 
         #endregion WorkOrderItemPart
 
+
+
+
+        //*******************************new
+        /*
+      part requests
+
+              */
+
+        #region WorkOrderItemPartRequest
+
+        /// <summary>
+        /// Create WorkOrderItemPartRequest
+        /// </summary>       
+        /// <param name="newObject">WorkOrderItemPartRequest level only no descendents</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>WorkOrderItemPartRequest object (no descendents)</returns>
+        [HttpPost("items/partrequests")]
+        public async Task<IActionResult> PostWorkOrderItemPartRequest([FromBody] WorkOrderItemPartRequest 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.WorkOrderItemPartRequest))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            WorkOrderItemPartRequest o = await biz.CreatePartRequestAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemPartRequest), new { WorkOrderItemPartRequestId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get WorkOrderItemPartRequest object
+        /// </summary>
+        /// <param name="WorkOrderItemPartRequestId"></param>
+        /// <returns>A single WorkOrderItemPartRequest</returns>
+        [HttpGet("items/partrequests/{WorkOrderItemPartRequestId}")]
+        public async Task<IActionResult> GetWorkOrderItemPartRequest([FromRoute] long WorkOrderItemPartRequestId)
+        {
+            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.WorkOrderItemPartRequest))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.GetPartRequestAsync(WorkOrderItemPartRequestId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemPartRequest)));
+        }
+
+        /// <summary>
+        /// Put (update) WorkOrderItemPartRequest        
+        /// (Descendent objects must be updated via their individual routes seperately)
+        /// </summary>       
+        /// <param name="updatedObject">WorkOrderItemPartRequest - top level only, no descendents</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/partrequests")]
+        public async Task<IActionResult> PutWorkOrderItemPartRequest([FromBody] WorkOrderItemPartRequest 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.WorkOrderItemPartRequest))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.PartRequestPutAsync(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 WorkOrderItemPartRequest
+        /// </summary>
+        /// <param name="WorkOrderItemPartRequestId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/partrequests/{WorkOrderItemPartRequestId}")]
+        public async Task<IActionResult> DeleteWorkOrderItemPartRequest([FromRoute] long WorkOrderItemPartRequestId)
+        {
+            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.WorkOrderItemPartRequest))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.PartRequestDeleteAsync(WorkOrderItemPartRequestId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion WorkOrderItemPartRequest
+
+
+
+
+
+
+        //*******************************new
+        /*
+      scheduled users
+
+              */
+
+        #region WorkOrderItemScheduledUser
+
+        /// <summary>
+        /// Create WorkOrderItemScheduledUser
+        /// </summary>       
+        /// <param name="newObject">WorkOrderItemScheduledUser level only no descendents</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>WorkOrderItemScheduledUser object (no descendents)</returns>
+        [HttpPost("items/scheduledusers")]
+        public async Task<IActionResult> PostWorkOrderItemScheduledUser([FromBody] WorkOrderItemScheduledUser 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.WorkOrderItemScheduledUser))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            WorkOrderItemScheduledUser o = await biz.CreateScheduledUserAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemScheduledUser), new { WorkOrderItemScheduledUserId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get WorkOrderItemScheduledUser object
+        /// </summary>
+        /// <param name="WorkOrderItemScheduledUserId"></param>
+        /// <returns>A single WorkOrderItemScheduledUser</returns>
+        [HttpGet("items/scheduledusers/{WorkOrderItemScheduledUserId}")]
+        public async Task<IActionResult> GetWorkOrderItemScheduledUser([FromRoute] long WorkOrderItemScheduledUserId)
+        {
+            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.WorkOrderItemScheduledUser))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.GetScheduledUserAsync(WorkOrderItemScheduledUserId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemScheduledUser)));
+        }
+
+        /// <summary>
+        /// Put (update) WorkOrderItemScheduledUser        
+        /// (Descendent objects must be updated via their individual routes seperately)
+        /// </summary>       
+        /// <param name="updatedObject">WorkOrderItemScheduledUser - top level only, no descendents</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/scheduledusers")]
+        public async Task<IActionResult> PutWorkOrderItemScheduledUser([FromBody] WorkOrderItemScheduledUser 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.WorkOrderItemScheduledUser))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.ScheduledUserPutAsync(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 WorkOrderItemScheduledUser
+        /// </summary>
+        /// <param name="WorkOrderItemScheduledUserId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/scheduledusers/{WorkOrderItemScheduledUserId}")]
+        public async Task<IActionResult> DeleteWorkOrderItemScheduledUser([FromRoute] long WorkOrderItemScheduledUserId)
+        {
+            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.WorkOrderItemScheduledUser))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.ScheduledUserDeleteAsync(WorkOrderItemScheduledUserId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion WorkOrderItemScheduledUser
+
+
+
+        //*******************************new
+        /*
+     Expenses
+
+              */
+
+        #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.CreateExpenseAsync(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.GetExpenseAsync(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
+
+
+
+        //*******************************new
+        /*
+      Travel
+
+              */
+
+        #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.CreateTravelAsync(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.GetTravelAsync(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
+
+
+
+
+
+        //*******************************new
+        /*
+      Tasks
+
+              */
+
+        #region WorkOrderItemtask
+
+        /// <summary>
+        /// Create WorkOrderItemTask
+        /// </summary>       
+        /// <param name="newObject">WorkOrderItemTask level only no descendents</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>WorkOrderItemTask object (no descendents)</returns>
+        [HttpPost("items/tasks")]
+        public async Task<IActionResult> PostWorkOrderItemTask([FromBody] WorkOrderItemTask 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.WorkOrderItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            WorkOrderItemTask o = await biz.CreateTaskAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemTask), new { WorkOrderItemTaskId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get WorkOrderItemTask object
+        /// </summary>
+        /// <param name="WorkOrderItemTaskId"></param>
+        /// <returns>A single WorkOrderItemTask</returns>
+        [HttpGet("items/tasks/{WorkOrderItemTaskId}")]
+        public async Task<IActionResult> GetWorkOrderItemTask([FromRoute] long WorkOrderItemTaskId)
+        {
+            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.WorkOrderItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.GetTaskAsync(WorkOrderItemTaskId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemTask)));
+        }
+
+        /// <summary>
+        /// Put (update) WorkOrderItemTask        
+        /// (Descendent objects must be updated via their individual routes seperately)
+        /// </summary>       
+        /// <param name="updatedObject">WorkOrderItemTask - top level only, no descendents</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/tasks")]
+        public async Task<IActionResult> PutWorkOrderItemTask([FromBody] WorkOrderItemTask 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.WorkOrderItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.TaskPutAsync(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 WorkOrderItemTask
+        /// </summary>
+        /// <param name="WorkOrderItemTaskId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/tasks/{WorkOrderItemTaskId}")]
+        public async Task<IActionResult> DeleteWorkOrderItemTask([FromRoute] long WorkOrderItemTaskId)
+        {
+            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.WorkOrderItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.TaskDeleteAsync(WorkOrderItemTaskId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion WorkOrderItemTask
+
+
+
+
+
+        //*******************************new
+        /*
+      Loan
+
+              */
+
+        #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.CreateLoanAsync(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.GetLoanAsync(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
+
+
+        //*******************************new
+        /*
+     Units
+
+              */
+
+        #region WorkOrderItemUnit
+
+        /// <summary>
+        /// Create WorkOrderItemUnit
+        /// </summary>       
+        /// <param name="newObject">WorkOrderItemUnit level only no descendents</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>WorkOrderItemUnit object (no descendents)</returns>
+        [HttpPost("items/units")]
+        public async Task<IActionResult> PostWorkOrderItemUnit([FromBody] WorkOrderItemUnit 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.WorkOrderItemUnit))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            WorkOrderItemUnit o = await biz.CreateUnitAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(WorkOrderController.GetWorkOrderItemUnit), new { WorkOrderItemUnitId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get WorkOrderItemUnit object
+        /// </summary>
+        /// <param name="WorkOrderItemUnitId"></param>
+        /// <returns>A single WorkOrderItemUnit</returns>
+        [HttpGet("items/units/{WorkOrderItemUnitId}")]
+        public async Task<IActionResult> GetWorkOrderItemUnit([FromRoute] long WorkOrderItemUnitId)
+        {
+            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.WorkOrderItemUnit))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.GetUnitAsync(WorkOrderItemUnitId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o, !Authorized.HasModifyRole(HttpContext.Items, AyaType.WorkOrderItemUnit)));
+        }
+
+        /// <summary>
+        /// Put (update) WorkOrderItemUnit        
+        /// (Descendent objects must be updated via their individual routes seperately)
+        /// </summary>       
+        /// <param name="updatedObject">WorkOrderItemUnit - top level only, no descendents</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/units")]
+        public async Task<IActionResult> PutWorkOrderItemUnit([FromBody] WorkOrderItemUnit 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.WorkOrderItemUnit))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.UnitPutAsync(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 WorkOrderItemUnit
+        /// </summary>
+        /// <param name="WorkOrderItemUnitId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/units/{WorkOrderItemUnitId}")]
+        public async Task<IActionResult> DeleteWorkOrderItemUnit([FromRoute] long WorkOrderItemUnitId)
+        {
+            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.WorkOrderItemUnit))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.UnitDeleteAsync(WorkOrderItemUnitId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion WorkOrderItemUnit
+
+
+
+
         //------------