From de361171a25033cb0fc63a73207c494e8624d0d6 Mon Sep 17 00:00:00 2001
From: John Cardinal <support@ayanova.com>
Date: Wed, 28 Jul 2021 14:56:14 +0000
Subject: [PATCH]

---
 server/AyaNova/Controllers/PMController.cs | 1323 ++++++++++++++++++--
 1 file changed, 1192 insertions(+), 131 deletions(-)

diff --git a/server/AyaNova/Controllers/PMController.cs b/server/AyaNova/Controllers/PMController.cs
index 8ffd8cc0..9eda41a9 100644
--- a/server/AyaNova/Controllers/PMController.cs
+++ b/server/AyaNova/Controllers/PMController.cs
@@ -3,12 +3,12 @@ using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using AyaNova.Models;
 using AyaNova.Api.ControllerHelpers;
 using AyaNova.Biz;
-
+using Microsoft.EntityFrameworkCore;
+using System.Linq;
 
 namespace AyaNova.Api.Controllers
 {
@@ -38,186 +38,1247 @@ namespace AyaNova.Api.Controllers
             serverState = apiServerState;
         }
 
+   
+            /*
+                ██████╗ ███╗   ███╗
+                ██╔══██╗████╗ ████║
+                ██████╔╝██╔████╔██║
+                ██╔═══╝ ██║╚██╔╝██║
+                ██║     ██║ ╚═╝ ██║
+                ╚═╝     ╚═╝     ╚═╝
+            */
+
+        #region PM top level routes
+        /// <summary>
+        /// Create PM
+        /// </summary>
+        /// <param name="newObject">PM - top level only, no descendants</param>
+        /// <param name="apiVersion">From route path</param>
+        /// <returns>PM</returns>
+        [HttpPost]
+        public async Task<IActionResult> PostPM([FromBody] PM newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+
+            if (newObject.Items.Count > 0)
+                return BadRequest(new ApiErrorResponse(ApiErrorCode.INVALID_OPERATION, "generalerror", "Work order POST route accepts header only; POST Work order descendants separately"));
+
+            PM o = await biz.PMCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        // /// <summary>
+        // /// Duplicate PM
+        // /// (Wiki and Attachments are not duplicated)
+        // /// </summary>
+        // /// <param name="id">Source object id</param>
+        // /// <param name="apiVersion">From route path</param>
+        // /// <returns>PM</returns>
+        // [HttpPost("duplicate/{id}")]
+        // public async Task<IActionResult> DuplicatePM([FromRoute] long id, ApiVersion apiVersion)
+        // {
+        //     if (!serverState.IsOpen)
+        //         return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+        //     PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+        //     if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
+        //         return StatusCode(403, new ApiNotAuthorizedResponse());
+        //     if (!ModelState.IsValid)
+        //         return BadRequest(new ApiErrorResponse(ModelState));
+        //     PM o = await biz.PMDuplicateAsync(id);
+        //     if (o == null)
+        //         return BadRequest(new ApiErrorResponse(biz.Errors));
+        //     else
+        //         return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        // }
+
 
         /// <summary>
-        /// Get full PM object
+        /// Get PM
         /// </summary>
         /// <param name="id"></param>
-        /// <returns>A single PM</returns>
+        /// <returns>PM</returns>
         [HttpGet("{id}")]
         public async Task<IActionResult> GetPM([FromRoute] long id)
         {
             if (!serverState.IsOpen)
                 return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
-            //Instantiate the business object handler
             PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
-
-            //NOTE: This is the first check and often the only check but in some cases with some objects this will also need to check biz object rules 
             if (!Authorized.HasReadFullRole(HttpContext.Items, biz.BizType))
                 return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.PMGetAsync(id, true);
+            if (o == null) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
 
+
+        /// <summary>
+        /// Update PM        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PM - top level only, no Items or other descendants</param>
+        /// <returns>Updated work order header</returns>
+        [HttpPut]
+        public async Task<IActionResult> PutPM([FromBody] PM updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
             if (!ModelState.IsValid)
                 return BadRequest(new ApiErrorResponse(ModelState));
 
-            var o = await biz.GetAsync(id);
+            if (updatedObject.Items.Count > 0)
+            {
+                return BadRequest(new ApiErrorResponse(ApiErrorCode.INVALID_OPERATION, "generalerror", "Work order PUT route accepts header only; PUT Work order descendants separately"));
+            }
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.PMPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PM
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeletePM([FromRoute] long id)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PM) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.PMDeleteAsync(id))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+
+
+        /// <summary>
+        /// Get PM id from work order serial number
+        /// </summary>
+        /// <param name="number"></param>
+        /// <returns>PM</returns>
+        [HttpGet("id-from-number/{number}")]
+        public async Task<IActionResult> GetPMIdFromNumber([FromRoute] long number)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PM))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await ct.PM.AsNoTracking()
+               .Where(z => z.Serial == number)
+               .Select(z => z.Id)
+               .SingleOrDefaultAsync();
+            if (o == 0) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+
+        #endregion PMTopLevel routes
+
+
+
+       
+
+
+
+
+        /*
+            ██╗████████╗███████╗███╗   ███╗███████╗
+            ██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
+            ██║   ██║   █████╗  ██╔████╔██║███████╗
+            ██║   ██║   ██╔══╝  ██║╚██╔╝██║╚════██║
+            ██║   ██║   ███████╗██║ ╚═╝ ██║███████║
+            ╚═╝   ╚═╝   ╚══════╝╚═╝     ╚═╝╚══════╝
+        */
+
+        #region PMItem
+        /// <summary>
+        /// Create PMItem
+        /// </summary>       
+        /// <param name="newObject">PMItem - no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItem object</returns>
+        [HttpPost("items")]
+        public async Task<IActionResult> PostPMItem([FromBody] PMItem newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItem o = await biz.ItemCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItem), new { PMItemId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItem object
+        /// </summary>
+        /// <param name="PMItemId"></param>
+        /// <returns>A single PMItem</returns>
+        [HttpGet("items/{PMItemId}")]
+        public async Task<IActionResult> GetPMItem([FromRoute] long PMItemId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.ItemGetAsync(PMItemId);
             if (o == null)
                 return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-
-            // NOTE: HERE would be the second check of biz rules before returning the object
-            // in cases where there is also a business rule to affect retrieval on top of basic rights
-
             return Ok(ApiOkResponse.Response(o));
         }
 
 
 
         /// <summary>
-        /// Update PM
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="inObj"></param>
-        /// <returns></returns>
-        [HttpPut("{id}")]
-        public async Task<IActionResult> PutPM([FromRoute] long id, [FromBody] PM inObj)
+        /// Update PMItem        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItem - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/")]
+        public async Task<IActionResult> PutPMItem([FromBody] PMItem updatedObject)
         {
             if (!serverState.IsOpen)
                 return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
             if (!ModelState.IsValid)
                 return BadRequest(new ApiErrorResponse(ModelState));
-
-            //Instantiate the business object handler       
             PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
-
-            var o = await biz.GetAsync(id, false);
-            if (o == null)
-                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-
-            if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType))
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
                 return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
+            var o = await biz.ItemPutAsync(updatedObject); 
+            if (o == null)
             {
-                if (!await biz.PutAsync(o, inObj))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
                 else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
             }
             return Ok(ApiOkResponse.Response(new { Concurrency = o.Concurrency }));
         }
 
 
-
-
-
-
         /// <summary>
-        /// Create PM
+        /// Delete PMItem
         /// </summary>
-        /// <param name="pmTemplateId"></param>
-        /// <param name="customerId"></param>
-        /// <param name="serial">force a workorder number, leave null to autogenerate the next one in sequence (mostly used for import)</param>
-        /// <param name="apiVersion">From route path</param>
-        /// <returns>A created workorder ready to fill out</returns>
-        [HttpPost("Create")]
-        public async Task<IActionResult> PostPM([FromQuery] long? pmTemplateId, long? customerId, uint? serial, ApiVersion apiVersion)
+        /// <param name="PMItemId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/{PMItemId}")]
+        public async Task<IActionResult> DeletePMItem([FromRoute] long PMItemId)
         {
             if (!serverState.IsOpen)
                 return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
-            //Instantiate the business object handler
-            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
-
-            //If a user has change roles
-            if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
             if (!ModelState.IsValid)
                 return BadRequest(new ApiErrorResponse(ModelState));
-
-            //Create and validate
-            PM o = await biz.CreateAsync(pmTemplateId,customerId, serial);
-            if (o == null)
-                return BadRequest(new ApiErrorResponse(biz.Errors));
-            else
-                return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
-
-
-        }
-
-        // /// <summary>
-        // /// Duplicate PM
-        // /// </summary>
-        // /// <param name="id">Create a duplicate of this items id</param>
-        // /// <param name="apiVersion">From route path</param>
-        // /// <returns></returns>
-        // [HttpPost("duplicate/{id}")]
-        // public async Task<IActionResult> DuplicatePM([FromRoute] long id, ApiVersion apiVersion)
-        // {
-        //     if (!serverState.IsOpen)
-        //         return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
-        //     //Instantiate the business object handler
-        //     PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
-
-        //     //If a user has change roles
-        //     if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
-        //         return StatusCode(403, new ApiNotAuthorizedResponse());
-
-        //     if (!ModelState.IsValid)
-        //         return BadRequest(new ApiErrorResponse(ModelState));
-
-        //     var oSrc = await biz.GetAsync(id, false);
-        //     if (oSrc == null)
-        //         return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-
-        //     //Create and validate
-        //     PM o = await biz.DuplicateAsync(oSrc);
-        //     if (o == null)
-        //         return BadRequest(new ApiErrorResponse(biz.Errors));
-        //     else
-        //         return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
-
-        // }
-
-
-
-        /// <summary>
-        /// Delete PM
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns>Ok</returns>
-        [HttpDelete("{id}")]
-        public async Task<IActionResult> DeletePM([FromRoute] long id)
-        {
-            if (!serverState.IsOpen)
-                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
-            if (!ModelState.IsValid)
-                return BadRequest(new ApiErrorResponse(ModelState));
-
-            //Instantiate the business object handler
             PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
-
-            var o = await biz.GetAsync(id, false);
-            if (o == null)
-                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-
-            if (!Authorized.HasDeleteRole(HttpContext.Items, biz.BizType))
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
                 return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            if (!await biz.DeleteAsync(o))
+            if (!await biz.ItemDeleteAsync(PMItemId))
                 return BadRequest(new ApiErrorResponse(biz.Errors));
-
             return NoContent();
         }
 
+        #endregion pmitem
+
+
+        /*
+            ███████╗██╗  ██╗██████╗ ███████╗███╗   ██╗███████╗███████╗███████╗
+            ██╔════╝╚██╗██╔╝██╔══██╗██╔════╝████╗  ██║██╔════╝██╔════╝██╔════╝
+            █████╗   ╚███╔╝ ██████╔╝█████╗  ██╔██╗ ██║███████╗█████╗  ███████╗
+            ██╔══╝   ██╔██╗ ██╔═══╝ ██╔══╝  ██║╚██╗██║╚════██║██╔══╝  ╚════██║
+            ███████╗██╔╝ ██╗██║     ███████╗██║ ╚████║███████║███████╗███████║
+            ╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═══╝╚══════╝╚══════╝╚══════╝
+        */
+
+        #region PMItemExpense
+
+        /// <summary>
+        /// Create PMItemExpense
+        /// </summary>       
+        /// <param name="newObject">PMItemExpense level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemExpense object (no descendants)</returns>
+        [HttpPost("items/expenses")]
+        public async Task<IActionResult> PostPMItemExpense([FromBody] PMItemExpense newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemExpense o = await biz.ExpenseCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemExpense), new { PMItemExpenseId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemExpense object
+        /// </summary>
+        /// <param name="PMItemExpenseId"></param>
+        /// <returns>A single PMItemExpense</returns>
+        [HttpGet("items/expenses/{PMItemExpenseId}")]
+        public async Task<IActionResult> GetPMItemExpense([FromRoute] long PMItemExpenseId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.ExpenseGetAsync(PMItemExpenseId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemExpense        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemExpense - top level only, no descendants</param>
+        /// <returns>Updated Expense item</returns>
+        [HttpPut("items/expenses")]
+        public async Task<IActionResult> PutPMItemExpense([FromBody] PMItemExpense updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.ExpensePutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemExpense
+        /// </summary>
+        /// <param name="PMItemExpenseId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/expenses/{PMItemExpenseId}")]
+        public async Task<IActionResult> DeletePMItemExpense([FromRoute] long PMItemExpenseId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.ExpenseDeleteAsync(PMItemExpenseId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemExpense
+
+
+        /*
+            ██╗      █████╗ ██████╗  ██████╗ ██████╗ 
+            ██║     ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
+            ██║     ███████║██████╔╝██║   ██║██████╔╝
+            ██║     ██╔══██║██╔══██╗██║   ██║██╔══██╗
+            ███████╗██║  ██║██████╔╝╚██████╔╝██║  ██║
+            ╚══════╝╚═╝  ╚═╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝
+
+        */
+
+        #region PMItemLabor
+
+        /// <summary>
+        /// Create PMItemLabor
+        /// </summary>       
+        /// <param name="newObject">PMItemLabor level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemLabor object (no descendants)</returns>
+        [HttpPost("items/labors")]
+        public async Task<IActionResult> PostPMItemLabor([FromBody] PMItemLabor newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemLabor))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemLabor o = await biz.LaborCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemLabor), new { PMItemLaborId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemLabor object
+        /// </summary>
+        /// <param name="PMItemLaborId"></param>
+        /// <returns>A single PMItemLabor</returns>
+        [HttpGet("items/labors/{PMItemLaborId}")]
+        public async Task<IActionResult> GetPMItemLabor([FromRoute] long PMItemLaborId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemLabor))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.LaborGetAsync(PMItemLaborId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+
+        /// <summary>
+        /// Update PMItemLabor        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemLabor - top level only, no descendants</param>
+        /// <returns>Updated object</returns>
+        [HttpPut("items/labors")]
+        public async Task<IActionResult> PutPMItemLabor([FromBody] PMItemLabor updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemLabor))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.LaborPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+
+        /// <summary>
+        /// Delete PMItemLabor
+        /// </summary>
+        /// <param name="PMItemLaborId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/labors/{PMItemLaborId}")]
+        public async Task<IActionResult> DeletePMItemLabor([FromRoute] long PMItemLaborId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemLabor))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.LaborDeleteAsync(PMItemLaborId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+
+        #endregion PMItemLabor
+
+
+        /*
+            ██╗      ██████╗  █████╗ ███╗   ██╗
+            ██║     ██╔═══██╗██╔══██╗████╗  ██║
+            ██║     ██║   ██║███████║██╔██╗ ██║
+            ██║     ██║   ██║██╔══██║██║╚██╗██║
+            ███████╗╚██████╔╝██║  ██║██║ ╚████║
+            ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝
+        */
+
+        #region PMItemLoan
+
+        /// <summary>
+        /// Create PMItemLoan
+        /// </summary>       
+        /// <param name="newObject">PMItemLoan level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemLoan object (no descendants)</returns>
+        [HttpPost("items/loans")]
+        public async Task<IActionResult> PostPMItemLoan([FromBody] PMItemLoan newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemLoan o = await biz.LoanCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemLoan), new { PMItemLoanId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemLoan object
+        /// </summary>
+        /// <param name="PMItemLoanId"></param>
+        /// <returns>A single PMItemLoan</returns>
+        [HttpGet("items/loans/{PMItemLoanId}")]
+        public async Task<IActionResult> GetPMItemLoan([FromRoute] long PMItemLoanId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.LoanGetAsync(PMItemLoanId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemLoan        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemLoan - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/loans")]
+        public async Task<IActionResult> PutPMItemLoan([FromBody] PMItemLoan updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.LoanPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemLoan
+        /// </summary>
+        /// <param name="PMItemLoanId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/loans/{PMItemLoanId}")]
+        public async Task<IActionResult> DeletePMItemLoan([FromRoute] long PMItemLoanId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.LoanDeleteAsync(PMItemLoanId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemLoan
+
+
+        /*           
+
+             ██████╗ ██╗   ██╗████████╗███████╗██╗██████╗ ███████╗    ███████╗███████╗██████╗ ██╗   ██╗██╗ ██████╗███████╗
+            ██╔═══██╗██║   ██║╚══██╔══╝██╔════╝██║██╔══██╗██╔════╝    ██╔════╝██╔════╝██╔══██╗██║   ██║██║██╔════╝██╔════╝
+            ██║   ██║██║   ██║   ██║   ███████╗██║██║  ██║█████╗      ███████╗█████╗  ██████╔╝██║   ██║██║██║     █████╗  
+            ██║   ██║██║   ██║   ██║   ╚════██║██║██║  ██║██╔══╝      ╚════██║██╔══╝  ██╔══██╗╚██╗ ██╔╝██║██║     ██╔══╝  
+            ╚██████╔╝╚██████╔╝   ██║   ███████║██║██████╔╝███████╗    ███████║███████╗██║  ██║ ╚████╔╝ ██║╚██████╗███████╗
+             ╚═════╝  ╚═════╝    ╚═╝   ╚══════╝╚═╝╚═════╝ ╚══════╝    ╚══════╝╚══════╝╚═╝  ╚═╝  ╚═══╝  ╚═╝ ╚═════╝╚══════╝
+          
+        */
+
+
+        #region PMItemOutsideService
+
+        /// <summary>
+        /// Create PMItemOutsideService
+        /// </summary>       
+        /// <param name="newObject">PMItemOutsideService level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemOutsideService object (no descendants)</returns>
+        [HttpPost("items/outside-services")]
+        public async Task<IActionResult> PostPMItemOutsideService([FromBody] PMItemOutsideService newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemOutsideService o = await biz.OutsideServiceCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemOutsideService), new { PMItemOutsideServiceId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemOutsideService object
+        /// </summary>
+        /// <param name="PMItemOutsideServiceId"></param>
+        /// <returns>A single PMItemOutsideService</returns>
+        [HttpGet("items/outside-services/{PMItemOutsideServiceId}")]
+        public async Task<IActionResult> GetPMItemOutsideService([FromRoute] long PMItemOutsideServiceId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.OutsideServiceGetAsync(PMItemOutsideServiceId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemOutsideService        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemOutsideService - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/outside-services")]
+        public async Task<IActionResult> PutPMItemOutsideService([FromBody] PMItemOutsideService updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.OutsideServicePutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemOutsideService
+        /// </summary>
+        /// <param name="PMItemOutsideServiceId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/outside-services/{PMItemOutsideServiceId}")]
+        public async Task<IActionResult> DeletePMItemOutsideService([FromRoute] long PMItemOutsideServiceId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.OutsideServiceDeleteAsync(PMItemOutsideServiceId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemOutsideService
+
+
+
+        /*
+            ██████╗  █████╗ ██████╗ ████████╗███████╗
+            ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝
+            ██████╔╝███████║██████╔╝   ██║   ███████╗
+            ██╔═══╝ ██╔══██║██╔══██╗   ██║   ╚════██║
+            ██║     ██║  ██║██║  ██║   ██║   ███████║
+            ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚══════╝
+        */
+
+        #region PMItemPart
+
+        /// <summary>
+        /// Create PMItemPart
+        /// </summary>       
+        /// <param name="newObject">PMItemPart level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemPart object (no descendants)</returns>
+        [HttpPost("items/parts")]
+        public async Task<IActionResult> PostPMItemPart([FromBody] PMItemPart newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemPart o = await biz.CreatePartAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemPart), new { PMItemPartId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemPart object
+        /// </summary>
+        /// <param name="PMItemPartId"></param>
+        /// <returns>A single PMItemPart</returns>
+        [HttpGet("items/parts/{PMItemPartId}")]
+        public async Task<IActionResult> GetPMItemPart([FromRoute] long PMItemPartId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.PartGetAsync(PMItemPartId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemPart        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemPart - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/parts")]
+        public async Task<IActionResult> PutPMItemPart([FromBody] PMItemPart updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.PartPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemPart
+        /// </summary>
+        /// <param name="PMItemPartId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/parts/{PMItemPartId}")]
+        public async Task<IActionResult> DeletePMItemPart([FromRoute] long PMItemPartId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.PartDeleteAsync(PMItemPartId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemPart
+
+
+
+        /*
+            ███████╗ ██████╗██╗  ██╗███████╗██████╗ ██╗   ██╗██╗     ███████╗██████╗       ██╗   ██╗███████╗███████╗██████╗ ███████╗
+            ██╔════╝██╔════╝██║  ██║██╔════╝██╔══██╗██║   ██║██║     ██╔════╝██╔══██╗      ██║   ██║██╔════╝██╔════╝██╔══██╗██╔════╝
+            ███████╗██║     ███████║█████╗  ██║  ██║██║   ██║██║     █████╗  ██║  ██║█████╗██║   ██║███████╗█████╗  ██████╔╝███████╗
+            ╚════██║██║     ██╔══██║██╔══╝  ██║  ██║██║   ██║██║     ██╔══╝  ██║  ██║╚════╝██║   ██║╚════██║██╔══╝  ██╔══██╗╚════██║
+            ███████║╚██████╗██║  ██║███████╗██████╔╝╚██████╔╝███████╗███████╗██████╔╝      ╚██████╔╝███████║███████╗██║  ██║███████║
+            ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═════╝  ╚═════╝ ╚══════╝╚══════╝╚═════╝        ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═╝╚══════╝
+        */
+
+        #region PMItemScheduledUser
+
+        /// <summary>
+        /// Create PMItemScheduledUser
+        /// </summary>       
+        /// <param name="newObject">PMItemScheduledUser level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemScheduledUser object (no descendants)</returns>
+        [HttpPost("items/scheduled-users")]
+        public async Task<IActionResult> PostPMItemScheduledUser([FromBody] PMItemScheduledUser newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemScheduledUser o = await biz.ScheduledUserCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemScheduledUser), new { PMItemScheduledUserId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemScheduledUser object
+        /// </summary>
+        /// <param name="PMItemScheduledUserId"></param>
+        /// <returns>A single PMItemScheduledUser</returns>
+        [HttpGet("items/scheduled-users/{PMItemScheduledUserId}")]
+        public async Task<IActionResult> GetPMItemScheduledUser([FromRoute] long PMItemScheduledUserId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemScheduledUser))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.ScheduledUserGetAsync(PMItemScheduledUserId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemScheduledUser        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemScheduledUser - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/scheduled-users")]
+        public async Task<IActionResult> PutPMItemScheduledUser([FromBody] PMItemScheduledUser updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.ScheduledUserPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemScheduledUser
+        /// </summary>
+        /// <param name="PMItemScheduledUserId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/scheduled-users/{PMItemScheduledUserId}")]
+        public async Task<IActionResult> DeletePMItemScheduledUser([FromRoute] long PMItemScheduledUserId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.ScheduledUserDeleteAsync(PMItemScheduledUserId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemScheduledUser
+
+
+        /*
+            ████████╗ █████╗ ███████╗██╗  ██╗
+            ╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
+               ██║   ███████║███████╗█████╔╝ 
+               ██║   ██╔══██║╚════██║██╔═██╗ 
+               ██║   ██║  ██║███████║██║  ██╗
+               ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
+        */
+
+        #region PMItemtask
+
+        /// <summary>
+        /// Create PMItemTask
+        /// </summary>       
+        /// <param name="newObject">PMItemTask level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemTask object (no descendants)</returns>
+        [HttpPost("items/tasks")]
+        public async Task<IActionResult> PostPMItemTask([FromBody] PMItemTask newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemTask) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemTask o = await biz.TaskCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemTask), new { PMItemTaskId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemTask object
+        /// </summary>
+        /// <param name="PMItemTaskId"></param>
+        /// <returns>A single PMItemTask</returns>
+        [HttpGet("items/tasks/{PMItemTaskId}")]
+        public async Task<IActionResult> GetPMItemTask([FromRoute] long PMItemTaskId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.TaskGetAsync(PMItemTaskId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemTask        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemTask - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/tasks")]
+        public async Task<IActionResult> PutPMItemTask([FromBody] PMItemTask updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemTask))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.TaskPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemTask
+        /// </summary>
+        /// <param name="PMItemTaskId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/tasks/{PMItemTaskId}")]
+        public async Task<IActionResult> DeletePMItemTask([FromRoute] long PMItemTaskId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemTask) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.TaskDeleteAsync(PMItemTaskId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemTask
+
+
+        /*
+            ████████╗██████╗  █████╗ ██╗   ██╗███████╗██╗     
+            ╚══██╔══╝██╔══██╗██╔══██╗██║   ██║██╔════╝██║     
+               ██║   ██████╔╝███████║██║   ██║█████╗  ██║     
+               ██║   ██╔══██╗██╔══██║╚██╗ ██╔╝██╔══╝  ██║     
+               ██║   ██║  ██║██║  ██║ ╚████╔╝ ███████╗███████╗
+               ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝
+        */
+
+        #region PMItemTravel
+
+        /// <summary>
+        /// Create PMItemTravel
+        /// </summary>       
+        /// <param name="newObject">PMItemTravel level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemTravel object (no descendants)</returns>
+        [HttpPost("items/travels")]
+        public async Task<IActionResult> PostPMItemTravel([FromBody] PMItemTravel newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemTravel))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemTravel o = await biz.TravelCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemTravel), new { PMItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemTravel object
+        /// </summary>
+        /// <param name="PMItemTravelId"></param>
+        /// <returns>A single PMItemTravel</returns>
+        [HttpGet("items/travels/{PMItemTravelId}")]
+        public async Task<IActionResult> GetPMItemTravel([FromRoute] long PMItemTravelId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemTravel))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.TravelGetAsync(PMItemTravelId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemTravel        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemTravel - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/travels")]
+        public async Task<IActionResult> PutPMItemTravel([FromBody] PMItemTravel updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemTravel))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.TravelPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemTravel
+        /// </summary>
+        /// <param name="PMItemTravelId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/travels/{PMItemTravelId}")]
+        public async Task<IActionResult> DeletePMItemTravel([FromRoute] long PMItemTravelId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemTravel))
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.TravelDeleteAsync(PMItemTravelId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemTravel
+
+
+        /*
+            ██╗   ██╗███╗   ██╗██╗████████╗
+            ██║   ██║████╗  ██║██║╚══██╔══╝
+            ██║   ██║██╔██╗ ██║██║   ██║   
+            ██║   ██║██║╚██╗██║██║   ██║   
+            ╚██████╔╝██║ ╚████║██║   ██║   
+            ╚═════╝ ╚═╝  ╚═══╝╚═╝   ╚═╝  
+        */
+
+        #region PMItemUnit
+
+        /// <summary>
+        /// Create PMItemUnit
+        /// </summary>       
+        /// <param name="newObject">PMItemUnit level only no descendants</param>
+        /// <param name="apiVersion"></param>
+        /// <returns>PMItemUnit object (no descendants)</returns>
+        [HttpPost("items/units")]
+        public async Task<IActionResult> PostPMItemUnit([FromBody] PMItemUnit newObject, ApiVersion apiVersion)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMItemUnit o = await biz.UnitCreateAsync(newObject);
+            if (o == null)
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            else
+                return CreatedAtAction(nameof(PMController.GetPMItemUnit), new { PMItemUnitId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
+        }
+
+
+        /// <summary>
+        /// Get PMItemUnit object
+        /// </summary>
+        /// <param name="PMItemUnitId"></param>
+        /// <returns>A single PMItemUnit</returns>
+        [HttpGet("items/units/{PMItemUnitId}")]
+        public async Task<IActionResult> GetPMItemUnit([FromRoute] long PMItemUnitId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsSubContractorRestricted)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            var o = await biz.UnitGetAsync(PMItemUnitId);
+            if (o == null)
+                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Update PMItemUnit        
+        ///
+        /// </summary>       
+        /// <param name="updatedObject">PMItemUnit - top level only, no descendants</param>
+        /// <returns>New concurrency token</returns>
+        [HttpPut("items/units")]
+        public async Task<IActionResult> PutPMItemUnit([FromBody] PMItemUnit updatedObject)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            var o = await biz.UnitPutAsync(updatedObject); 
+            if (o == null)
+            {
+                if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
+                    return StatusCode(409, new ApiErrorResponse(biz.Errors));
+                else
+                    return BadRequest(new ApiErrorResponse(biz.Errors));
+            }
+            return Ok(ApiOkResponse.Response(o));
+        }
+
+        /// <summary>
+        /// Delete PMItemUnit
+        /// </summary>
+        /// <param name="PMItemUnitId"></param>
+        /// <returns>NoContent</returns>
+        [HttpDelete("items/units/{PMItemUnitId}")]
+        public async Task<IActionResult> DeletePMItemUnit([FromRoute] long PMItemUnitId)
+        {
+            if (!serverState.IsOpen)
+                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
+            if (!ModelState.IsValid)
+                return BadRequest(new ApiErrorResponse(ModelState));
+            PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
+            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
+                return StatusCode(403, new ApiNotAuthorizedResponse());
+            if (!await biz.UnitDeleteAsync(PMItemUnitId))
+                return BadRequest(new ApiErrorResponse(biz.Errors));
+            return NoContent();
+        }
+
+        #endregion PMItemUnit