using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.Logging;
using AyaNova.Models;
using AyaNova.Api.ControllerHelpers;
using AyaNova.Biz;
using Microsoft.EntityFrameworkCore;
using System.Linq;

namespace AyaNova.Api.Controllers
{

    [ApiController]
    [ApiVersion("8.0")]
    [Route("api/v{version:apiVersion}/quote")]
    [Produces("application/json")]
    [Authorize]
    public class QuoteController : ControllerBase
    {
        private readonly AyContext ct;
        private readonly ILogger<QuoteController> log;
        private readonly ApiServerState serverState;


        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="dbcontext"></param>
        /// <param name="logger"></param>
        /// <param name="apiServerState"></param>  
        public QuoteController(AyContext dbcontext, ILogger<QuoteController> logger, ApiServerState apiServerState)
        {
            ct = dbcontext;
            log = logger;
            serverState = apiServerState;
        }

   
        /*
             ██████╗ ██╗   ██╗ ██████╗ ████████╗███████╗
             ██╔═══██╗██║   ██║██╔═══██╗╚══██╔══╝██╔════╝
             ██║   ██║██║   ██║██║   ██║   ██║   █████╗  
             ██║▄▄ ██║██║   ██║██║   ██║   ██║   ██╔══╝  
             ╚██████╔╝╚██████╔╝╚██████╔╝   ██║   ███████╗
             ╚══▀▀═╝  ╚═════╝  ╚═════╝    ╚═╝   ╚══════╝
        */

        #region Quote top level routes
        /// <summary>
        /// Create Quote
        /// </summary>
        /// <param name="newObject">Quote - top level only, no descendants</param>
        /// <param name="apiVersion">From route path</param>
        /// <returns>Quote</returns>
        [HttpPost]
        public async Task<IActionResult> PostQuote([FromBody] Quote newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.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"));

            Quote o = await biz.QuoteCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuote), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        // /// <summary>
        // /// Duplicate Quote
        // /// (Wiki and Attachments are not duplicated)
        // /// </summary>
        // /// <param name="id">Source object id</param>
        // /// <param name="apiVersion">From route path</param>
        // /// <returns>Quote</returns>
        // [HttpPost("duplicate/{id}")]
        // public async Task<IActionResult> DuplicateQuote([FromRoute] long id, ApiVersion apiVersion)
        // {
        //     if (!serverState.IsOpen)
        //         return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
        //     QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
        //     if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
        //         return StatusCode(403, new ApiNotAuthorizedResponse());
        //     if (!ModelState.IsValid)
        //         return BadRequest(new ApiErrorResponse(ModelState));
        //     Quote o = await biz.QuoteDuplicateAsync(id);
        //     if (o == null)
        //         return BadRequest(new ApiErrorResponse(biz.Errors));
        //     else
        //         return CreatedAtAction(nameof(QuoteController.GetQuote), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        // }


        /// <summary>
        /// Get Quote
        /// </summary>
        /// <param name="id"></param>
        /// <returns>Quote</returns>
        [HttpGet("{id}")]
        public async Task<IActionResult> GetQuote([FromRoute] long id)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, biz.BizType))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.QuoteGetAsync(id, true);
            if (o == null) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }


        /// <summary>
        /// Update Quote        
        ///
        /// </summary>       
        /// <param name="updatedObject">Quote - top level only, no Items or other descendants</param>
        /// <returns>Updated work order header</returns>
        [HttpPut]
        public async Task<IActionResult> PutQuote([FromBody] Quote updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));

            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"));
            }
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            var o = await biz.QuotePutAsync(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 Quote
        /// </summary>
        /// <param name="id"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteQuote([FromRoute] long id)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.Quote) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.QuoteDeleteAsync(id))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }



        /// <summary>
        /// Get Quote id from work order serial number
        /// </summary>
        /// <param name="number"></param>
        /// <returns>Quote</returns>
        [HttpGet("id-from-number/{number}")]
        public async Task<IActionResult> GetQuoteIdFromNumber([FromRoute] long number)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));

            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.Quote))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await ct.Quote.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 QuoteTopLevel routes



        /*

            ███████╗████████╗ █████╗ ████████╗███████╗███████╗
            ██╔════╝╚══██╔══╝██╔══██╗╚══██╔══╝██╔════╝██╔════╝
            ███████╗   ██║   ███████║   ██║   █████╗  ███████╗
            ╚════██║   ██║   ██╔══██║   ██║   ██╔══╝  ╚════██║
            ███████║   ██║   ██║  ██║   ██║   ███████╗███████║
            ╚══════╝   ╚═╝   ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝

            */


        #region QuoteState
        /// <summary>
        /// Create QuoteState
        /// </summary>       
        /// <param name="newObject">QuoteState</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteState object</returns>
        [HttpPost("states")]
        public async Task<IActionResult> PostQuoteState([FromBody] QuoteState newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteStatus) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteState o = await biz.StateCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteState), new { QuoteStateId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteState object
        /// </summary>
        /// <param name="QuoteStateId"></param>
        /// <returns>A single QuoteState</returns>
        [HttpGet("states/{QuoteStateId}")]
        public async Task<IActionResult> GetQuoteState([FromRoute] long QuoteStateId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteStatus))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.StateGetAsync(QuoteStateId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }




        #endregion quotestate




        /*
            ██╗████████╗███████╗███╗   ███╗███████╗
            ██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
            ██║   ██║   █████╗  ██╔████╔██║███████╗
            ██║   ██║   ██╔══╝  ██║╚██╔╝██║╚════██║
            ██║   ██║   ███████╗██║ ╚═╝ ██║███████║
            ╚═╝   ╚═╝   ╚══════╝╚═╝     ╚═╝╚══════╝
        */

        #region QuoteItem
        /// <summary>
        /// Create QuoteItem
        /// </summary>       
        /// <param name="newObject">QuoteItem - no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItem object</returns>
        [HttpPost("items")]
        public async Task<IActionResult> PostQuoteItem([FromBody] QuoteItem newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItem) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItem o = await biz.ItemCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItem), new { QuoteItemId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItem object
        /// </summary>
        /// <param name="QuoteItemId"></param>
        /// <returns>A single QuoteItem</returns>
        [HttpGet("items/{QuoteItemId}")]
        public async Task<IActionResult> GetQuoteItem([FromRoute] long QuoteItemId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItem) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.ItemGetAsync(QuoteItemId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }



        /// <summary>
        /// Update QuoteItem        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItem - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/")]
        public async Task<IActionResult> PutQuoteItem([FromBody] QuoteItem updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItem) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            var o = await biz.ItemPutAsync(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(new { Concurrency = o.Concurrency }));
        }


        /// <summary>
        /// Delete QuoteItem
        /// </summary>
        /// <param name="QuoteItemId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/{QuoteItemId}")]
        public async Task<IActionResult> DeleteQuoteItem([FromRoute] long QuoteItemId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItem) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.ItemDeleteAsync(QuoteItemId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion quoteitem


        /*
            ███████╗██╗  ██╗██████╗ ███████╗███╗   ██╗███████╗███████╗███████╗
            ██╔════╝╚██╗██╔╝██╔══██╗██╔════╝████╗  ██║██╔════╝██╔════╝██╔════╝
            █████╗   ╚███╔╝ ██████╔╝█████╗  ██╔██╗ ██║███████╗█████╗  ███████╗
            ██╔══╝   ██╔██╗ ██╔═══╝ ██╔══╝  ██║╚██╗██║╚════██║██╔══╝  ╚════██║
            ███████╗██╔╝ ██╗██║     ███████╗██║ ╚████║███████║███████╗███████║
            ╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝╚═╝  ╚═══╝╚══════╝╚══════╝╚══════╝
        */

        #region QuoteItemExpense

        /// <summary>
        /// Create QuoteItemExpense
        /// </summary>       
        /// <param name="newObject">QuoteItemExpense level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemExpense object (no descendants)</returns>
        [HttpPost("items/expenses")]
        public async Task<IActionResult> PostQuoteItemExpense([FromBody] QuoteItemExpense newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemExpense o = await biz.ExpenseCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemExpense), new { QuoteItemExpenseId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemExpense object
        /// </summary>
        /// <param name="QuoteItemExpenseId"></param>
        /// <returns>A single QuoteItemExpense</returns>
        [HttpGet("items/expenses/{QuoteItemExpenseId}")]
        public async Task<IActionResult> GetQuoteItemExpense([FromRoute] long QuoteItemExpenseId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.ExpenseGetAsync(QuoteItemExpenseId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemExpense        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemExpense - top level only, no descendants</param>
        /// <returns>Updated Expense item</returns>
        [HttpPut("items/expenses")]
        public async Task<IActionResult> PutQuoteItemExpense([FromBody] QuoteItemExpense updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemExpense) || 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 QuoteItemExpense
        /// </summary>
        /// <param name="QuoteItemExpenseId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/expenses/{QuoteItemExpenseId}")]
        public async Task<IActionResult> DeleteQuoteItemExpense([FromRoute] long QuoteItemExpenseId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.ExpenseDeleteAsync(QuoteItemExpenseId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemExpense


        /*
            ██╗      █████╗ ██████╗  ██████╗ ██████╗ 
            ██║     ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
            ██║     ███████║██████╔╝██║   ██║██████╔╝
            ██║     ██╔══██║██╔══██╗██║   ██║██╔══██╗
            ███████╗██║  ██║██████╔╝╚██████╔╝██║  ██║
            ╚══════╝╚═╝  ╚═╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝

        */

        #region QuoteItemLabor

        /// <summary>
        /// Create QuoteItemLabor
        /// </summary>       
        /// <param name="newObject">QuoteItemLabor level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemLabor object (no descendants)</returns>
        [HttpPost("items/labors")]
        public async Task<IActionResult> PostQuoteItemLabor([FromBody] QuoteItemLabor newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemLabor))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemLabor o = await biz.LaborCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemLabor), new { QuoteItemLaborId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemLabor object
        /// </summary>
        /// <param name="QuoteItemLaborId"></param>
        /// <returns>A single QuoteItemLabor</returns>
        [HttpGet("items/labors/{QuoteItemLaborId}")]
        public async Task<IActionResult> GetQuoteItemLabor([FromRoute] long QuoteItemLaborId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemLabor))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.LaborGetAsync(QuoteItemLaborId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }


        /// <summary>
        /// Update QuoteItemLabor        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemLabor - top level only, no descendants</param>
        /// <returns>Updated object</returns>
        [HttpPut("items/labors")]
        public async Task<IActionResult> PutQuoteItemLabor([FromBody] QuoteItemLabor updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemLabor))
                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 QuoteItemLabor
        /// </summary>
        /// <param name="QuoteItemLaborId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/labors/{QuoteItemLaborId}")]
        public async Task<IActionResult> DeleteQuoteItemLabor([FromRoute] long QuoteItemLaborId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemLabor))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.LaborDeleteAsync(QuoteItemLaborId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }


        #endregion QuoteItemLabor


        /*
            ██╗      ██████╗  █████╗ ███╗   ██╗
            ██║     ██╔═══██╗██╔══██╗████╗  ██║
            ██║     ██║   ██║███████║██╔██╗ ██║
            ██║     ██║   ██║██╔══██║██║╚██╗██║
            ███████╗╚██████╔╝██║  ██║██║ ╚████║
            ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝
        */

        #region QuoteItemLoan

        /// <summary>
        /// Create QuoteItemLoan
        /// </summary>       
        /// <param name="newObject">QuoteItemLoan level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemLoan object (no descendants)</returns>
        [HttpPost("items/loans")]
        public async Task<IActionResult> PostQuoteItemLoan([FromBody] QuoteItemLoan newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemLoan) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemLoan o = await biz.LoanCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemLoan), new { QuoteItemLoanId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemLoan object
        /// </summary>
        /// <param name="QuoteItemLoanId"></param>
        /// <returns>A single QuoteItemLoan</returns>
        [HttpGet("items/loans/{QuoteItemLoanId}")]
        public async Task<IActionResult> GetQuoteItemLoan([FromRoute] long QuoteItemLoanId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemLoan) || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.LoanGetAsync(QuoteItemLoanId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemLoan        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemLoan - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/loans")]
        public async Task<IActionResult> PutQuoteItemLoan([FromBody] QuoteItemLoan updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemLoan) || 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 QuoteItemLoan
        /// </summary>
        /// <param name="QuoteItemLoanId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/loans/{QuoteItemLoanId}")]
        public async Task<IActionResult> DeleteQuoteItemLoan([FromRoute] long QuoteItemLoanId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemLoan) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.LoanDeleteAsync(QuoteItemLoanId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemLoan


        /*           

             ██████╗ ██╗   ██╗████████╗███████╗██╗██████╗ ███████╗    ███████╗███████╗██████╗ ██╗   ██╗██╗ ██████╗███████╗
            ██╔═══██╗██║   ██║╚══██╔══╝██╔════╝██║██╔══██╗██╔════╝    ██╔════╝██╔════╝██╔══██╗██║   ██║██║██╔════╝██╔════╝
            ██║   ██║██║   ██║   ██║   ███████╗██║██║  ██║█████╗      ███████╗█████╗  ██████╔╝██║   ██║██║██║     █████╗  
            ██║   ██║██║   ██║   ██║   ╚════██║██║██║  ██║██╔══╝      ╚════██║██╔══╝  ██╔══██╗╚██╗ ██╔╝██║██║     ██╔══╝  
            ╚██████╔╝╚██████╔╝   ██║   ███████║██║██████╔╝███████╗    ███████║███████╗██║  ██║ ╚████╔╝ ██║╚██████╗███████╗
             ╚═════╝  ╚═════╝    ╚═╝   ╚══════╝╚═╝╚═════╝ ╚══════╝    ╚══════╝╚══════╝╚═╝  ╚═╝  ╚═══╝  ╚═╝ ╚═════╝╚══════╝
          
        */


        #region QuoteItemOutsideService

        /// <summary>
        /// Create QuoteItemOutsideService
        /// </summary>       
        /// <param name="newObject">QuoteItemOutsideService level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemOutsideService object (no descendants)</returns>
        [HttpPost("items/outside-services")]
        public async Task<IActionResult> PostQuoteItemOutsideService([FromBody] QuoteItemOutsideService newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemOutsideService) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemOutsideService o = await biz.OutsideServiceCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemOutsideService), new { QuoteItemOutsideServiceId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemOutsideService object
        /// </summary>
        /// <param name="QuoteItemOutsideServiceId"></param>
        /// <returns>A single QuoteItemOutsideService</returns>
        [HttpGet("items/outside-services/{QuoteItemOutsideServiceId}")]
        public async Task<IActionResult> GetQuoteItemOutsideService([FromRoute] long QuoteItemOutsideServiceId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemOutsideService) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.OutsideServiceGetAsync(QuoteItemOutsideServiceId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemOutsideService        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemOutsideService - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/outside-services")]
        public async Task<IActionResult> PutQuoteItemOutsideService([FromBody] QuoteItemOutsideService updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemOutsideService) || 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 QuoteItemOutsideService
        /// </summary>
        /// <param name="QuoteItemOutsideServiceId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/outside-services/{QuoteItemOutsideServiceId}")]
        public async Task<IActionResult> DeleteQuoteItemOutsideService([FromRoute] long QuoteItemOutsideServiceId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemOutsideService) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.OutsideServiceDeleteAsync(QuoteItemOutsideServiceId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemOutsideService



        /*
            ██████╗  █████╗ ██████╗ ████████╗███████╗
            ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝
            ██████╔╝███████║██████╔╝   ██║   ███████╗
            ██╔═══╝ ██╔══██║██╔══██╗   ██║   ╚════██║
            ██║     ██║  ██║██║  ██║   ██║   ███████║
            ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚══════╝
        */

        #region QuoteItemPart

        /// <summary>
        /// Create QuoteItemPart
        /// </summary>       
        /// <param name="newObject">QuoteItemPart level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemPart object (no descendants)</returns>
        [HttpPost("items/parts")]
        public async Task<IActionResult> PostQuoteItemPart([FromBody] QuoteItemPart newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemPart) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemPart o = await biz.CreatePartAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemPart), new { QuoteItemPartId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemPart object
        /// </summary>
        /// <param name="QuoteItemPartId"></param>
        /// <returns>A single QuoteItemPart</returns>
        [HttpGet("items/parts/{QuoteItemPartId}")]
        public async Task<IActionResult> GetQuoteItemPart([FromRoute] long QuoteItemPartId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemPart) || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.PartGetAsync(QuoteItemPartId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemPart        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemPart - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/parts")]
        public async Task<IActionResult> PutQuoteItemPart([FromBody] QuoteItemPart updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemPart) || 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 QuoteItemPart
        /// </summary>
        /// <param name="QuoteItemPartId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/parts/{QuoteItemPartId}")]
        public async Task<IActionResult> DeleteQuoteItemPart([FromRoute] long QuoteItemPartId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemPart) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.PartDeleteAsync(QuoteItemPartId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemPart



        /*
            ███████╗ ██████╗██╗  ██╗███████╗██████╗ ██╗   ██╗██╗     ███████╗██████╗       ██╗   ██╗███████╗███████╗██████╗ ███████╗
            ██╔════╝██╔════╝██║  ██║██╔════╝██╔══██╗██║   ██║██║     ██╔════╝██╔══██╗      ██║   ██║██╔════╝██╔════╝██╔══██╗██╔════╝
            ███████╗██║     ███████║█████╗  ██║  ██║██║   ██║██║     █████╗  ██║  ██║█████╗██║   ██║███████╗█████╗  ██████╔╝███████╗
            ╚════██║██║     ██╔══██║██╔══╝  ██║  ██║██║   ██║██║     ██╔══╝  ██║  ██║╚════╝██║   ██║╚════██║██╔══╝  ██╔══██╗╚════██║
            ███████║╚██████╗██║  ██║███████╗██████╔╝╚██████╔╝███████╗███████╗██████╔╝      ╚██████╔╝███████║███████╗██║  ██║███████║
            ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═════╝  ╚═════╝ ╚══════╝╚══════╝╚═════╝        ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═╝╚══════╝
        */

        #region QuoteItemScheduledUser

        /// <summary>
        /// Create QuoteItemScheduledUser
        /// </summary>       
        /// <param name="newObject">QuoteItemScheduledUser level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemScheduledUser object (no descendants)</returns>
        [HttpPost("items/scheduled-users")]
        public async Task<IActionResult> PostQuoteItemScheduledUser([FromBody] QuoteItemScheduledUser newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemScheduledUser) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemScheduledUser o = await biz.ScheduledUserCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemScheduledUser), new { QuoteItemScheduledUserId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemScheduledUser object
        /// </summary>
        /// <param name="QuoteItemScheduledUserId"></param>
        /// <returns>A single QuoteItemScheduledUser</returns>
        [HttpGet("items/scheduled-users/{QuoteItemScheduledUserId}")]
        public async Task<IActionResult> GetQuoteItemScheduledUser([FromRoute] long QuoteItemScheduledUserId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemScheduledUser))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.ScheduledUserGetAsync(QuoteItemScheduledUserId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemScheduledUser        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemScheduledUser - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/scheduled-users")]
        public async Task<IActionResult> PutQuoteItemScheduledUser([FromBody] QuoteItemScheduledUser updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemScheduledUser) || 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 QuoteItemScheduledUser
        /// </summary>
        /// <param name="QuoteItemScheduledUserId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/scheduled-users/{QuoteItemScheduledUserId}")]
        public async Task<IActionResult> DeleteQuoteItemScheduledUser([FromRoute] long QuoteItemScheduledUserId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemScheduledUser) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.ScheduledUserDeleteAsync(QuoteItemScheduledUserId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemScheduledUser


        /*
            ████████╗ █████╗ ███████╗██╗  ██╗
            ╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
               ██║   ███████║███████╗█████╔╝ 
               ██║   ██╔══██║╚════██║██╔═██╗ 
               ██║   ██║  ██║███████║██║  ██╗
               ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
        */

        #region QuoteItemtask

        /// <summary>
        /// Create QuoteItemTask
        /// </summary>       
        /// <param name="newObject">QuoteItemTask level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemTask object (no descendants)</returns>
        [HttpPost("items/tasks")]
        public async Task<IActionResult> PostQuoteItemTask([FromBody] QuoteItemTask newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemTask) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemTask o = await biz.TaskCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemTask), new { QuoteItemTaskId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemTask object
        /// </summary>
        /// <param name="QuoteItemTaskId"></param>
        /// <returns>A single QuoteItemTask</returns>
        [HttpGet("items/tasks/{QuoteItemTaskId}")]
        public async Task<IActionResult> GetQuoteItemTask([FromRoute] long QuoteItemTaskId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemTask))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.TaskGetAsync(QuoteItemTaskId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemTask        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemTask - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/tasks")]
        public async Task<IActionResult> PutQuoteItemTask([FromBody] QuoteItemTask updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemTask))
                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 QuoteItemTask
        /// </summary>
        /// <param name="QuoteItemTaskId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/tasks/{QuoteItemTaskId}")]
        public async Task<IActionResult> DeleteQuoteItemTask([FromRoute] long QuoteItemTaskId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemTask) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.TaskDeleteAsync(QuoteItemTaskId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemTask


        /*
            ████████╗██████╗  █████╗ ██╗   ██╗███████╗██╗     
            ╚══██╔══╝██╔══██╗██╔══██╗██║   ██║██╔════╝██║     
               ██║   ██████╔╝███████║██║   ██║█████╗  ██║     
               ██║   ██╔══██╗██╔══██║╚██╗ ██╔╝██╔══╝  ██║     
               ██║   ██║  ██║██║  ██║ ╚████╔╝ ███████╗███████╗
               ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝
        */

        #region QuoteItemTravel

        /// <summary>
        /// Create QuoteItemTravel
        /// </summary>       
        /// <param name="newObject">QuoteItemTravel level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemTravel object (no descendants)</returns>
        [HttpPost("items/travels")]
        public async Task<IActionResult> PostQuoteItemTravel([FromBody] QuoteItemTravel newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemTravel))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemTravel o = await biz.TravelCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemTravel), new { QuoteItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemTravel object
        /// </summary>
        /// <param name="QuoteItemTravelId"></param>
        /// <returns>A single QuoteItemTravel</returns>
        [HttpGet("items/travels/{QuoteItemTravelId}")]
        public async Task<IActionResult> GetQuoteItemTravel([FromRoute] long QuoteItemTravelId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemTravel))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.TravelGetAsync(QuoteItemTravelId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemTravel        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemTravel - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/travels")]
        public async Task<IActionResult> PutQuoteItemTravel([FromBody] QuoteItemTravel updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemTravel))
                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 QuoteItemTravel
        /// </summary>
        /// <param name="QuoteItemTravelId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/travels/{QuoteItemTravelId}")]
        public async Task<IActionResult> DeleteQuoteItemTravel([FromRoute] long QuoteItemTravelId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemTravel))
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.TravelDeleteAsync(QuoteItemTravelId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemTravel


        /*
            ██╗   ██╗███╗   ██╗██╗████████╗
            ██║   ██║████╗  ██║██║╚══██╔══╝
            ██║   ██║██╔██╗ ██║██║   ██║   
            ██║   ██║██║╚██╗██║██║   ██║   
            ╚██████╔╝██║ ╚████║██║   ██║   
            ╚═════╝ ╚═╝  ╚═══╝╚═╝   ╚═╝  
        */

        #region QuoteItemUnit

        /// <summary>
        /// Create QuoteItemUnit
        /// </summary>       
        /// <param name="newObject">QuoteItemUnit level only no descendants</param>
        /// <param name="apiVersion"></param>
        /// <returns>QuoteItemUnit object (no descendants)</returns>
        [HttpPost("items/units")]
        public async Task<IActionResult> PostQuoteItemUnit([FromBody] QuoteItemUnit newObject, ApiVersion apiVersion)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.QuoteItemUnit) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteItemUnit o = await biz.UnitCreateAsync(newObject);
            if (o == null)
                return BadRequest(new ApiErrorResponse(biz.Errors));
            else
                return CreatedAtAction(nameof(QuoteController.GetQuoteItemUnit), new { QuoteItemUnitId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
        }


        /// <summary>
        /// Get QuoteItemUnit object
        /// </summary>
        /// <param name="QuoteItemUnitId"></param>
        /// <returns>A single QuoteItemUnit</returns>
        [HttpGet("items/units/{QuoteItemUnitId}")]
        public async Task<IActionResult> GetQuoteItemUnit([FromRoute] long QuoteItemUnitId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.QuoteItemUnit) || biz.UserIsSubContractorRestricted)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            var o = await biz.UnitGetAsync(QuoteItemUnitId);
            if (o == null)
                return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
            return Ok(ApiOkResponse.Response(o));
        }

        /// <summary>
        /// Update QuoteItemUnit        
        ///
        /// </summary>       
        /// <param name="updatedObject">QuoteItemUnit - top level only, no descendants</param>
        /// <returns>New concurrency token</returns>
        [HttpPut("items/units")]
        public async Task<IActionResult> PutQuoteItemUnit([FromBody] QuoteItemUnit updatedObject)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.QuoteItemUnit) || 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 QuoteItemUnit
        /// </summary>
        /// <param name="QuoteItemUnitId"></param>
        /// <returns>NoContent</returns>
        [HttpDelete("items/units/{QuoteItemUnitId}")]
        public async Task<IActionResult> DeleteQuoteItemUnit([FromRoute] long QuoteItemUnitId)
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            if (!ModelState.IsValid)
                return BadRequest(new ApiErrorResponse(ModelState));
            QuoteBiz biz = QuoteBiz.GetBiz(ct, HttpContext);
            if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.QuoteItemUnit) || biz.UserIsRestrictedType)
                return StatusCode(403, new ApiNotAuthorizedResponse());
            if (!await biz.UnitDeleteAsync(QuoteItemUnitId))
                return BadRequest(new ApiErrorResponse(biz.Errors));
            return NoContent();
        }

        #endregion QuoteItemUnit




        //------------


    }//eoc
}//eons