1351 lines
71 KiB
C#
1351 lines
71 KiB
C#
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]
|
|
[Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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) || 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, biz.BizType))
|
|
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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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, Asp.Versioning.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 |