diff --git a/server/AyaNova/Controllers/ContractController.cs b/server/AyaNova/Controllers/ContractController.cs
index 8c8ab93f..c9da1d4f 100644
--- a/server/AyaNova/Controllers/ContractController.cs
+++ b/server/AyaNova/Controllers/ContractController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) Contract
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchContract([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Contract> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            ContractBiz biz = ContractBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post Contract
         /// </summary>
diff --git a/server/AyaNova/Controllers/CustomerController.cs b/server/AyaNova/Controllers/CustomerController.cs
index 0c8c88dd..6ad97b42 100644
--- a/server/AyaNova/Controllers/CustomerController.cs
+++ b/server/AyaNova/Controllers/CustomerController.cs
@@ -112,53 +112,7 @@ namespace AyaNova.Api.Controllers
             }
             return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
         }
-
-
-
-        /// <summary>
-        /// Patch (update) Customer
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchCustomer([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Customer> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            CustomerBiz biz = CustomerBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
+    
 
         /// <summary>
         /// Post Customer
diff --git a/server/AyaNova/Controllers/HeadOfficeController.cs b/server/AyaNova/Controllers/HeadOfficeController.cs
index 2349381b..f9f843dc 100644
--- a/server/AyaNova/Controllers/HeadOfficeController.cs
+++ b/server/AyaNova/Controllers/HeadOfficeController.cs
@@ -113,53 +113,6 @@ namespace AyaNova.Api.Controllers
             return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
         }
 
-
-
-        /// <summary>
-        /// Patch (update) HeadOffice
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchHeadOffice([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<HeadOffice> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            HeadOfficeBiz biz = HeadOfficeBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post HeadOffice
         /// </summary>
diff --git a/server/AyaNova/Controllers/LoanUnitController.cs b/server/AyaNova/Controllers/LoanUnitController.cs
index a32acccb..183d4f61 100644
--- a/server/AyaNova/Controllers/LoanUnitController.cs
+++ b/server/AyaNova/Controllers/LoanUnitController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) LoanUnit
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchLoanUnit([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<LoanUnit> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            LoanUnitBiz biz = LoanUnitBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post LoanUnit
         /// </summary>
diff --git a/server/AyaNova/Controllers/PMTemplateController.cs b/server/AyaNova/Controllers/PMTemplateController.cs
index 4bed0125..30ef0d5b 100644
--- a/server/AyaNova/Controllers/PMTemplateController.cs
+++ b/server/AyaNova/Controllers/PMTemplateController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) PMTemplate
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchPMTemplate([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<PMTemplate> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            PMTemplateBiz biz = PMTemplateBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post PMTemplate
         /// </summary>
diff --git a/server/AyaNova/Controllers/PartController.cs b/server/AyaNova/Controllers/PartController.cs
index 863f7ceb..cb265d3c 100644
--- a/server/AyaNova/Controllers/PartController.cs
+++ b/server/AyaNova/Controllers/PartController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) Part
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchPart([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Part> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            PartBiz biz = PartBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post Part
         /// </summary>
diff --git a/server/AyaNova/Controllers/ProjectController.cs b/server/AyaNova/Controllers/ProjectController.cs
index 9593ee04..b23da182 100644
--- a/server/AyaNova/Controllers/ProjectController.cs
+++ b/server/AyaNova/Controllers/ProjectController.cs
@@ -113,53 +113,7 @@ namespace AyaNova.Api.Controllers
             return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
         }
 
-
-
-        /// <summary>
-        /// Patch (update) Project
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchProject([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Project> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            ProjectBiz biz = ProjectBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
+      
         /// <summary>
         /// Post Project
         /// </summary>
diff --git a/server/AyaNova/Controllers/PurchaseOrderController.cs b/server/AyaNova/Controllers/PurchaseOrderController.cs
index bfa8a27c..a9f0421c 100644
--- a/server/AyaNova/Controllers/PurchaseOrderController.cs
+++ b/server/AyaNova/Controllers/PurchaseOrderController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) PurchaseOrder
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchPurchaseOrder([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<PurchaseOrder> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            PurchaseOrderBiz biz = PurchaseOrderBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post PurchaseOrder
         /// </summary>
diff --git a/server/AyaNova/Controllers/QuoteTemplateController.cs b/server/AyaNova/Controllers/QuoteTemplateController.cs
index 65064312..2f632fa0 100644
--- a/server/AyaNova/Controllers/QuoteTemplateController.cs
+++ b/server/AyaNova/Controllers/QuoteTemplateController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) QuoteTemplate
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchQuoteTemplate([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<QuoteTemplate> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            QuoteTemplateBiz biz = QuoteTemplateBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post QuoteTemplate
         /// </summary>
diff --git a/server/AyaNova/Controllers/UnitController.cs b/server/AyaNova/Controllers/UnitController.cs
index c1d9c796..ffd82b59 100644
--- a/server/AyaNova/Controllers/UnitController.cs
+++ b/server/AyaNova/Controllers/UnitController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) Unit
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchUnit([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Unit> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            UnitBiz biz = UnitBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post Unit
         /// </summary>
diff --git a/server/AyaNova/Controllers/UnitModelController.cs b/server/AyaNova/Controllers/UnitModelController.cs
index 9c0a6eb2..b3b4b7ea 100644
--- a/server/AyaNova/Controllers/UnitModelController.cs
+++ b/server/AyaNova/Controllers/UnitModelController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) UnitModel
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchUnitModel([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<UnitModel> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            UnitModelBiz biz = UnitModelBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post UnitModel
         /// </summary>
diff --git a/server/AyaNova/Controllers/UserController.cs b/server/AyaNova/Controllers/UserController.cs
index 83850165..dd8c6aa6 100644
--- a/server/AyaNova/Controllers/UserController.cs
+++ b/server/AyaNova/Controllers/UserController.cs
@@ -143,62 +143,6 @@ namespace AyaNova.Api.Controllers
 
 
 
-        /// <summary>
-        /// Patch (update) User
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchUser([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<User> objectPatch)
-        {
-             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
-            UserBiz biz = UserBiz.GetBiz(ct, HttpContext);
-            var o = await ct.User.SingleOrDefaultAsync(m => m.Id == id);
-
-            if (o == null)
-            {
-                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-            }
-
-            if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType))
-            {
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-            }
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                {
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-                }
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!UserExists(id))
-                {
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                }
-                else
-                {
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-                }
-            }
-
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post User
         /// </summary>
diff --git a/server/AyaNova/Controllers/UserOptionsController.cs b/server/AyaNova/Controllers/UserOptionsController.cs
index 471ba750..f9d1c2ff 100644
--- a/server/AyaNova/Controllers/UserOptionsController.cs
+++ b/server/AyaNova/Controllers/UserOptionsController.cs
@@ -143,67 +143,6 @@ namespace AyaNova.Api.Controllers
 
 
 
-        /// <summary>
-        /// Patch (update) UserOptions
-        /// </summary>
-        /// <param name="id">UserId</param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchUserOptions([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<UserOptions> objectPatch)
-        {
-            if (!serverState.IsClosed)
-                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
-
-            if (!ModelState.IsValid)
-            {
-                return BadRequest(new ApiErrorResponse(ModelState));
-            }
-
-            var UserId = UserIdFromContext.Id(HttpContext.Items);
-
-            //Instantiate the business object handler
-            UserOptionsBiz biz = new UserOptionsBiz(ct, UserId, UserRolesFromContext.Roles(HttpContext.Items));
-
-            var o = await ct.UserOptions.SingleOrDefaultAsync(m => m.UserId == id);
-
-            if (o == null)
-            {
-                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-            }
-
-            if (id != UserId && !Authorized.HasModifyRole(HttpContext.Items, AyaType.UserOptions))
-            {
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-            }
-
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                {
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-                }
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!UserOptionsExists(id))
-                {
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                }
-                else
-                {
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-                }
-            }
-
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
-
         private bool UserOptionsExists(long id)
         {
             //NOTE: checks by UserId, NOT by Id as in most other objects
diff --git a/server/AyaNova/Controllers/VendorController.cs b/server/AyaNova/Controllers/VendorController.cs
index f703be51..7ebf8b1f 100644
--- a/server/AyaNova/Controllers/VendorController.cs
+++ b/server/AyaNova/Controllers/VendorController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) Vendor
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchVendor([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Vendor> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            VendorBiz biz = VendorBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post Vendor
         /// </summary>
diff --git a/server/AyaNova/Controllers/WidgetController.cs b/server/AyaNova/Controllers/WidgetController.cs
index f0d7a2ee..e4318c9b 100644
--- a/server/AyaNova/Controllers/WidgetController.cs
+++ b/server/AyaNova/Controllers/WidgetController.cs
@@ -121,52 +121,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) widget
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchWidget([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<Widget> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            WidgetBiz biz = WidgetBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post widget
         /// </summary>
diff --git a/server/AyaNova/Controllers/WorkOrderTemplateController.cs b/server/AyaNova/Controllers/WorkOrderTemplateController.cs
index d7a67ef6..ff9c1ee9 100644
--- a/server/AyaNova/Controllers/WorkOrderTemplateController.cs
+++ b/server/AyaNova/Controllers/WorkOrderTemplateController.cs
@@ -114,52 +114,6 @@ namespace AyaNova.Api.Controllers
         }
 
 
-
-        /// <summary>
-        /// Patch (update) WorkOrderTemplate
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="concurrencyToken"></param>
-        /// <param name="objectPatch"></param>
-        /// <returns></returns>
-        [HttpPatch("{id}/{concurrencyToken}")]
-        public async Task<IActionResult> PatchWorkOrderTemplate([FromRoute] long id, [FromRoute] uint concurrencyToken, [FromBody]JsonPatchDocument<WorkOrderTemplate> objectPatch)
-        {
-            //https://dotnetcoretutorials.com/2017/11/29/json-patch-asp-net-core/
-
-            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
-            WorkOrderTemplateBiz biz = WorkOrderTemplateBiz.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))
-                return StatusCode(403, new ApiNotAuthorizedResponse());
-
-            try
-            {
-                //patch and validate
-                if (!await biz.PatchAsync(o, objectPatch, concurrencyToken))
-                    return BadRequest(new ApiErrorResponse(biz.Errors));
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!await biz.ExistsAsync(id))
-                    return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
-                else
-                    return StatusCode(409, new ApiErrorResponse(ApiErrorCode.CONCURRENCY_CONFLICT));
-            }
-            return Ok(ApiOkResponse.Response(new { ConcurrencyToken = o.ConcurrencyToken }, true));
-        }
-
-
         /// <summary>
         /// Post WorkOrderTemplate
         /// </summary>
diff --git a/server/AyaNova/biz/ContractBiz.cs b/server/AyaNova/biz/ContractBiz.cs
index 2efa1c91..c186c799 100644
--- a/server/AyaNova/biz/ContractBiz.cs
+++ b/server/AyaNova/biz/ContractBiz.cs
@@ -159,37 +159,6 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(Contract dbObj, JsonPatchDocument<Contract> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Contract>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Contract SnapshotOfOriginalDBObj = new Contract();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
         private async Task SearchIndexAsync(Contract obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/CustomerBiz.cs b/server/AyaNova/biz/CustomerBiz.cs
index 388e9f39..2961fab8 100644
--- a/server/AyaNova/biz/CustomerBiz.cs
+++ b/server/AyaNova/biz/CustomerBiz.cs
@@ -159,37 +159,7 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(Customer dbObj, JsonPatchDocument<Customer> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Customer>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Customer SnapshotOfOriginalDBObj = new Customer();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+      
         private async Task SearchIndexAsync(Customer obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/HeadOfficeBiz.cs b/server/AyaNova/biz/HeadOfficeBiz.cs
index 069bffce..003dbe35 100644
--- a/server/AyaNova/biz/HeadOfficeBiz.cs
+++ b/server/AyaNova/biz/HeadOfficeBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(HeadOffice dbObj, JsonPatchDocument<HeadOffice> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<HeadOffice>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            HeadOffice SnapshotOfOriginalDBObj = new HeadOffice();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+      
         private async Task SearchIndexAsync(HeadOffice obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/LoanUnitBiz.cs b/server/AyaNova/biz/LoanUnitBiz.cs
index 368c4ab0..da89107f 100644
--- a/server/AyaNova/biz/LoanUnitBiz.cs
+++ b/server/AyaNova/biz/LoanUnitBiz.cs
@@ -159,37 +159,6 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(LoanUnit dbObj, JsonPatchDocument<LoanUnit> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<LoanUnit>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            LoanUnit SnapshotOfOriginalDBObj = new LoanUnit();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
         private async Task SearchIndexAsync(LoanUnit obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/PMTemplateBiz.cs b/server/AyaNova/biz/PMTemplateBiz.cs
index 14e8f4e3..a72f979c 100644
--- a/server/AyaNova/biz/PMTemplateBiz.cs
+++ b/server/AyaNova/biz/PMTemplateBiz.cs
@@ -159,37 +159,6 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(PMTemplate dbObj, JsonPatchDocument<PMTemplate> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<PMTemplate>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            PMTemplate SnapshotOfOriginalDBObj = new PMTemplate();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
         private async Task SearchIndexAsync(PMTemplate obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/PartBiz.cs b/server/AyaNova/biz/PartBiz.cs
index 5c86a1da..f082f951 100644
--- a/server/AyaNova/biz/PartBiz.cs
+++ b/server/AyaNova/biz/PartBiz.cs
@@ -159,37 +159,7 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(Part dbObj, JsonPatchDocument<Part> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Part>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Part SnapshotOfOriginalDBObj = new Part();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+       
         private async Task SearchIndexAsync(Part obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/ProjectBiz.cs b/server/AyaNova/biz/ProjectBiz.cs
index 461a0673..47d9a14d 100644
--- a/server/AyaNova/biz/ProjectBiz.cs
+++ b/server/AyaNova/biz/ProjectBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(Project dbObj, JsonPatchDocument<Project> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Project>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Project SnapshotOfOriginalDBObj = new Project();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+      
         private async Task SearchIndexAsync(Project obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/PurchaseOrderBiz.cs b/server/AyaNova/biz/PurchaseOrderBiz.cs
index 4df7607c..112527e2 100644
--- a/server/AyaNova/biz/PurchaseOrderBiz.cs
+++ b/server/AyaNova/biz/PurchaseOrderBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(PurchaseOrder dbObj, JsonPatchDocument<PurchaseOrder> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<PurchaseOrder>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            PurchaseOrder SnapshotOfOriginalDBObj = new PurchaseOrder();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+      
         private async Task SearchIndexAsync(PurchaseOrder obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/QuoteTemplateBiz.cs b/server/AyaNova/biz/QuoteTemplateBiz.cs
index 538cb84a..c3b4cb43 100644
--- a/server/AyaNova/biz/QuoteTemplateBiz.cs
+++ b/server/AyaNova/biz/QuoteTemplateBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(QuoteTemplate dbObj, JsonPatchDocument<QuoteTemplate> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<QuoteTemplate>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            QuoteTemplate SnapshotOfOriginalDBObj = new QuoteTemplate();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+       
         private async Task SearchIndexAsync(QuoteTemplate obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/UnitBiz.cs b/server/AyaNova/biz/UnitBiz.cs
index 12a82db5..a3830b52 100644
--- a/server/AyaNova/biz/UnitBiz.cs
+++ b/server/AyaNova/biz/UnitBiz.cs
@@ -159,37 +159,7 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(Unit dbObj, JsonPatchDocument<Unit> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Unit>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Unit SnapshotOfOriginalDBObj = new Unit();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+      
         private async Task SearchIndexAsync(Unit obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/UnitModelBiz.cs b/server/AyaNova/biz/UnitModelBiz.cs
index 4ee46084..90a5e350 100644
--- a/server/AyaNova/biz/UnitModelBiz.cs
+++ b/server/AyaNova/biz/UnitModelBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(UnitModel dbObj, JsonPatchDocument<UnitModel> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<UnitModel>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            UnitModel SnapshotOfOriginalDBObj = new UnitModel();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+     
         private async Task SearchIndexAsync(UnitModel obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/UserBiz.cs b/server/AyaNova/biz/UserBiz.cs
index ba071657..b5f5a8d7 100644
--- a/server/AyaNova/biz/UserBiz.cs
+++ b/server/AyaNova/biz/UserBiz.cs
@@ -193,58 +193,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(User dbObj, JsonPatchDocument<User> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed
-            if (!ValidateJsonPatch<User>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            User SnapshotOfOriginalDBObj = new User();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            //Is the user patching the password?
-            if (!string.IsNullOrWhiteSpace(dbObj.Password) && dbObj.Password != SnapshotOfOriginalDBObj.Password)
-            {
-                //YES password is being updated:                
-                dbObj.Password = Hasher.hash(dbObj.Salt, dbObj.Password);
-            }
-
-            //Updating login?
-            if (!string.IsNullOrWhiteSpace(dbObj.Login) && dbObj.Login != SnapshotOfOriginalDBObj.Login)
-            {
-                //YES Login is being updated:                
-                dbObj.Login = SnapshotOfOriginalDBObj.Login;
-            }
-            else
-            {
-                //No, use the original value
-                dbObj.Login = SnapshotOfOriginalDBObj.Login;
-            }
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-            await ct.SaveChangesAsync();
-
-            //Log modification and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
-
+      
         //put
         internal async Task<bool> ChangePasswordAsync(long userId, string newPassword)
         {
diff --git a/server/AyaNova/biz/UserOptionsBiz.cs b/server/AyaNova/biz/UserOptionsBiz.cs
index 03cc0eb5..b3f0931c 100644
--- a/server/AyaNova/biz/UserOptionsBiz.cs
+++ b/server/AyaNova/biz/UserOptionsBiz.cs
@@ -62,29 +62,7 @@ namespace AyaNova.Biz
             await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, AyaType.User, AyaEvent.Modified), ct);
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(UserOptions dbObj, JsonPatchDocument<UserOptions> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed
-            if (!ValidateJsonPatch<UserOptions>.Validate(this, objectPatch, "UserId")) return false;
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            Validate(dbObj);
-            if (HasErrors)
-                return false;
-
-            await ct.SaveChangesAsync();
-            //Log
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, AyaType.User, AyaEvent.Modified), ct);
-            return true;
-        }
-
-
-
+     
 
         ////////////////////////////////////////////////////////////////////////////////////////////////
         //VALIDATION
diff --git a/server/AyaNova/biz/VendorBiz.cs b/server/AyaNova/biz/VendorBiz.cs
index 5b72a10d..e54fe0e7 100644
--- a/server/AyaNova/biz/VendorBiz.cs
+++ b/server/AyaNova/biz/VendorBiz.cs
@@ -158,38 +158,7 @@ namespace AyaNova.Biz
 
             return true;
         }
-
-        //patch
-        internal async Task<bool> PatchAsync(Vendor dbObj, JsonPatchDocument<Vendor> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<Vendor>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Vendor SnapshotOfOriginalDBObj = new Vendor();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+       
         private async Task SearchIndexAsync(Vendor obj, bool isNew)
         {
             //SEARCH INDEXING
diff --git a/server/AyaNova/biz/WidgetBiz.cs b/server/AyaNova/biz/WidgetBiz.cs
index e667fba5..a1217bcf 100644
--- a/server/AyaNova/biz/WidgetBiz.cs
+++ b/server/AyaNova/biz/WidgetBiz.cs
@@ -158,37 +158,6 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(Widget dbObj, JsonPatchDocument<Widget> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed
-            //Note: Id and Serial are all checked for and disallowed in the validate code by default
-            if (!ValidateJsonPatch<Widget>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            Widget SnapshotOfOriginalDBObj = new Widget();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
 
         private async Task SearchIndexAsync(Widget obj, bool isNew)
         {
diff --git a/server/AyaNova/biz/WorkorderTemplateBiz.cs b/server/AyaNova/biz/WorkorderTemplateBiz.cs
index b04164e3..ac420980 100644
--- a/server/AyaNova/biz/WorkorderTemplateBiz.cs
+++ b/server/AyaNova/biz/WorkorderTemplateBiz.cs
@@ -159,37 +159,7 @@ namespace AyaNova.Biz
             return true;
         }
 
-        //patch
-        internal async Task<bool> PatchAsync(WorkOrderTemplate dbObj, JsonPatchDocument<WorkOrderTemplate> objectPatch, uint concurrencyToken)
-        {
-            //Validate Patch is allowed            
-            if (!ValidateJsonPatch<WorkOrderTemplate>.Validate(this, objectPatch)) return false;
-
-            //make a snapshot of the original for validation but update the original to preserve workflow           
-            WorkOrderTemplate SnapshotOfOriginalDBObj = new WorkOrderTemplate();
-            CopyObject.Copy(dbObj, SnapshotOfOriginalDBObj);
-
-            //Do the patching
-            objectPatch.ApplyTo(dbObj);
-
-            dbObj.Tags = TagUtil.NormalizeTags(dbObj.Tags);
-            dbObj.CustomFields = JsonUtil.CompactJson(dbObj.CustomFields);
-
-            ct.Entry(dbObj).OriginalValues["ConcurrencyToken"] = concurrencyToken;
-            await ValidateAsync(dbObj, SnapshotOfOriginalDBObj);
-            if (HasErrors)
-                return false;
-
-            //Log event and save context
-            await EventLogProcessor.LogEventToDatabaseAsync(new Event(UserId, dbObj.Id, BizType, AyaEvent.Modified), ct);
-            await SearchIndexAsync(dbObj, false);
-
-            await TagUtil.ProcessUpdateTagsInRepositoryAsync(ct, dbObj.Tags, SnapshotOfOriginalDBObj.Tags);
-
-            return true;
-        }
-
-
+       
         private async Task SearchIndexAsync(WorkOrderTemplate obj, bool isNew)
         {
             //SEARCH INDEXING