1290 lines
66 KiB
C#
1290 lines
66 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]
|
|
[ApiVersion("8.0")]
|
|
[Route("api/v{version:apiVersion}/pm")]
|
|
[Produces("application/json")]
|
|
[Authorize]
|
|
public class PMController : ControllerBase
|
|
{
|
|
private readonly AyContext ct;
|
|
private readonly ILogger<PMController> log;
|
|
private readonly ApiServerState serverState;
|
|
|
|
|
|
/// <summary>
|
|
/// ctor
|
|
/// </summary>
|
|
/// <param name="dbcontext"></param>
|
|
/// <param name="logger"></param>
|
|
/// <param name="apiServerState"></param>
|
|
public PMController(AyContext dbcontext, ILogger<PMController> logger, ApiServerState apiServerState)
|
|
{
|
|
ct = dbcontext;
|
|
log = logger;
|
|
serverState = apiServerState;
|
|
}
|
|
|
|
|
|
/*
|
|
██████╗ ███╗ ███╗
|
|
██╔══██╗████╗ ████║
|
|
██████╔╝██╔████╔██║
|
|
██╔═══╝ ██║╚██╔╝██║
|
|
██║ ██║ ╚═╝ ██║
|
|
╚═╝ ╚═╝ ╚═╝
|
|
*/
|
|
|
|
#region PM top level routes
|
|
/// <summary>
|
|
/// Create PM
|
|
/// </summary>
|
|
/// <param name="newObject">PM - top level only, no descendants</param>
|
|
/// <param name="apiVersion">From route path</param>
|
|
/// <returns>PM</returns>
|
|
[HttpPost]
|
|
public async Task<IActionResult> PostPM([FromBody] PM newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
|
|
if (newObject.Items.Count > 0)
|
|
return BadRequest(new ApiErrorResponse(ApiErrorCode.INVALID_OPERATION, "generalerror", "Work order POST route accepts header only; POST Work order descendants separately"));
|
|
|
|
PM o = await biz.PMCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
// /// <summary>
|
|
// /// Duplicate PM
|
|
// /// (Wiki and Attachments are not duplicated)
|
|
// /// </summary>
|
|
// /// <param name="id">Source object id</param>
|
|
// /// <param name="apiVersion">From route path</param>
|
|
// /// <returns>PM</returns>
|
|
// [HttpPost("duplicate/{id}")]
|
|
// public async Task<IActionResult> DuplicatePM([FromRoute] long id, ApiVersion apiVersion)
|
|
// {
|
|
// if (!serverState.IsOpen)
|
|
// return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
// PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
// if (!Authorized.HasCreateRole(HttpContext.Items, biz.BizType))
|
|
// return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
// if (!ModelState.IsValid)
|
|
// return BadRequest(new ApiErrorResponse(ModelState));
|
|
// PM o = await biz.PMDuplicateAsync(id);
|
|
// if (o == null)
|
|
// return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
// else
|
|
// return CreatedAtAction(nameof(PMController.GetPM), new { id = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
// }
|
|
|
|
|
|
/// <summary>
|
|
/// Get PM
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>PM</returns>
|
|
[HttpGet("{id}")]
|
|
public async Task<IActionResult> GetPM([FromRoute] long id)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.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.PMGetAsync(id, true);
|
|
if (o == null) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Update PM
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PM - top level only, no Items or other descendants</param>
|
|
/// <returns>Updated work order header</returns>
|
|
[HttpPut]
|
|
public async Task<IActionResult> PutPM([FromBody] PM updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
|
|
if (updatedObject.Items.Count > 0)
|
|
{
|
|
return BadRequest(new ApiErrorResponse(ApiErrorCode.INVALID_OPERATION, "generalerror", "Work order PUT route accepts header only; PUT Work order descendants separately"));
|
|
}
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, biz.BizType) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.PMPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PM
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("{id}")]
|
|
public async Task<IActionResult> DeletePM([FromRoute] long id)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PM) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.PMDeleteAsync(id))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Get PM id from work order serial number
|
|
/// </summary>
|
|
/// <param name="number"></param>
|
|
/// <returns>PM</returns>
|
|
[HttpGet("id-from-number/{number}")]
|
|
public async Task<IActionResult> GetPMIdFromNumber([FromRoute] long number)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PM))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await ct.PM.AsNoTracking()
|
|
.Where(z => z.Serial == number)
|
|
.Select(z => z.Id)
|
|
.SingleOrDefaultAsync();
|
|
if (o == 0) return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
|
|
#endregion PMTopLevel routes
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
██╗████████╗███████╗███╗ ███╗███████╗
|
|
██║╚══██╔══╝██╔════╝████╗ ████║██╔════╝
|
|
██║ ██║ █████╗ ██╔████╔██║███████╗
|
|
██║ ██║ ██╔══╝ ██║╚██╔╝██║╚════██║
|
|
██║ ██║ ███████╗██║ ╚═╝ ██║███████║
|
|
╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝
|
|
*/
|
|
|
|
#region PMItem
|
|
/// <summary>
|
|
/// Create PMItem
|
|
/// </summary>
|
|
/// <param name="newObject">PMItem - no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItem object</returns>
|
|
[HttpPost("items")]
|
|
public async Task<IActionResult> PostPMItem([FromBody] PMItem newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItem o = await biz.ItemCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItem), new { PMItemId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItem object
|
|
/// </summary>
|
|
/// <param name="PMItemId"></param>
|
|
/// <returns>A single PMItem</returns>
|
|
[HttpGet("items/{PMItemId}")]
|
|
public async Task<IActionResult> GetPMItem([FromRoute] long PMItemId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.ItemGetAsync(PMItemId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Update PMItem
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItem - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/")]
|
|
public async Task<IActionResult> PutPMItem([FromBody] PMItem updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItem) || 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 PMItem
|
|
/// </summary>
|
|
/// <param name="PMItemId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/{PMItemId}")]
|
|
public async Task<IActionResult> DeletePMItem([FromRoute] long PMItemId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItem) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.ItemDeleteAsync(PMItemId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion pmitem
|
|
|
|
|
|
/*
|
|
███████╗██╗ ██╗██████╗ ███████╗███╗ ██╗███████╗███████╗███████╗
|
|
██╔════╝╚██╗██╔╝██╔══██╗██╔════╝████╗ ██║██╔════╝██╔════╝██╔════╝
|
|
█████╗ ╚███╔╝ ██████╔╝█████╗ ██╔██╗ ██║███████╗█████╗ ███████╗
|
|
██╔══╝ ██╔██╗ ██╔═══╝ ██╔══╝ ██║╚██╗██║╚════██║██╔══╝ ╚════██║
|
|
███████╗██╔╝ ██╗██║ ███████╗██║ ╚████║███████║███████╗███████║
|
|
╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═══╝╚══════╝╚══════╝╚══════╝
|
|
*/
|
|
|
|
#region PMItemExpense
|
|
|
|
/// <summary>
|
|
/// Create PMItemExpense
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemExpense level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemExpense object (no descendants)</returns>
|
|
[HttpPost("items/expenses")]
|
|
public async Task<IActionResult> PostPMItemExpense([FromBody] PMItemExpense newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemExpense o = await biz.ExpenseCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemExpense), new { PMItemExpenseId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemExpense object
|
|
/// </summary>
|
|
/// <param name="PMItemExpenseId"></param>
|
|
/// <returns>A single PMItemExpense</returns>
|
|
[HttpGet("items/expenses/{PMItemExpenseId}")]
|
|
public async Task<IActionResult> GetPMItemExpense([FromRoute] long PMItemExpenseId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.ExpenseGetAsync(PMItemExpenseId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemExpense
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemExpense - top level only, no descendants</param>
|
|
/// <returns>Updated Expense item</returns>
|
|
[HttpPut("items/expenses")]
|
|
public async Task<IActionResult> PutPMItemExpense([FromBody] PMItemExpense updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.ExpensePutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemExpense
|
|
/// </summary>
|
|
/// <param name="PMItemExpenseId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/expenses/{PMItemExpenseId}")]
|
|
public async Task<IActionResult> DeletePMItemExpense([FromRoute] long PMItemExpenseId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemExpense) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.ExpenseDeleteAsync(PMItemExpenseId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemExpense
|
|
|
|
|
|
/*
|
|
██╗ █████╗ ██████╗ ██████╗ ██████╗
|
|
██║ ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗
|
|
██║ ███████║██████╔╝██║ ██║██████╔╝
|
|
██║ ██╔══██║██╔══██╗██║ ██║██╔══██╗
|
|
███████╗██║ ██║██████╔╝╚██████╔╝██║ ██║
|
|
╚══════╝╚═╝ ╚═╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝
|
|
|
|
*/
|
|
|
|
#region PMItemLabor
|
|
|
|
/// <summary>
|
|
/// Create PMItemLabor
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemLabor level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemLabor object (no descendants)</returns>
|
|
[HttpPost("items/labors")]
|
|
public async Task<IActionResult> PostPMItemLabor([FromBody] PMItemLabor newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemLabor))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemLabor o = await biz.LaborCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemLabor), new { PMItemLaborId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemLabor object
|
|
/// </summary>
|
|
/// <param name="PMItemLaborId"></param>
|
|
/// <returns>A single PMItemLabor</returns>
|
|
[HttpGet("items/labors/{PMItemLaborId}")]
|
|
public async Task<IActionResult> GetPMItemLabor([FromRoute] long PMItemLaborId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemLabor))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.LaborGetAsync(PMItemLaborId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Update PMItemLabor
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemLabor - top level only, no descendants</param>
|
|
/// <returns>Updated object</returns>
|
|
[HttpPut("items/labors")]
|
|
public async Task<IActionResult> PutPMItemLabor([FromBody] PMItemLabor updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemLabor))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.LaborPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete PMItemLabor
|
|
/// </summary>
|
|
/// <param name="PMItemLaborId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/labors/{PMItemLaborId}")]
|
|
public async Task<IActionResult> DeletePMItemLabor([FromRoute] long PMItemLaborId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemLabor))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.LaborDeleteAsync(PMItemLaborId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
|
|
#endregion PMItemLabor
|
|
|
|
|
|
/*
|
|
██╗ ██████╗ █████╗ ███╗ ██╗
|
|
██║ ██╔═══██╗██╔══██╗████╗ ██║
|
|
██║ ██║ ██║███████║██╔██╗ ██║
|
|
██║ ██║ ██║██╔══██║██║╚██╗██║
|
|
███████╗╚██████╔╝██║ ██║██║ ╚████║
|
|
╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝
|
|
*/
|
|
|
|
#region PMItemLoan
|
|
|
|
/// <summary>
|
|
/// Create PMItemLoan
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemLoan level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemLoan object (no descendants)</returns>
|
|
[HttpPost("items/loans")]
|
|
public async Task<IActionResult> PostPMItemLoan([FromBody] PMItemLoan newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemLoan o = await biz.LoanCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemLoan), new { PMItemLoanId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemLoan object
|
|
/// </summary>
|
|
/// <param name="PMItemLoanId"></param>
|
|
/// <returns>A single PMItemLoan</returns>
|
|
[HttpGet("items/loans/{PMItemLoanId}")]
|
|
public async Task<IActionResult> GetPMItemLoan([FromRoute] long PMItemLoanId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.LoanGetAsync(PMItemLoanId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemLoan
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemLoan - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/loans")]
|
|
public async Task<IActionResult> PutPMItemLoan([FromBody] PMItemLoan updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.LoanPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemLoan
|
|
/// </summary>
|
|
/// <param name="PMItemLoanId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/loans/{PMItemLoanId}")]
|
|
public async Task<IActionResult> DeletePMItemLoan([FromRoute] long PMItemLoanId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemLoan) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.LoanDeleteAsync(PMItemLoanId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemLoan
|
|
|
|
|
|
/*
|
|
|
|
██████╗ ██╗ ██╗████████╗███████╗██╗██████╗ ███████╗ ███████╗███████╗██████╗ ██╗ ██╗██╗ ██████╗███████╗
|
|
██╔═══██╗██║ ██║╚══██╔══╝██╔════╝██║██╔══██╗██╔════╝ ██╔════╝██╔════╝██╔══██╗██║ ██║██║██╔════╝██╔════╝
|
|
██║ ██║██║ ██║ ██║ ███████╗██║██║ ██║█████╗ ███████╗█████╗ ██████╔╝██║ ██║██║██║ █████╗
|
|
██║ ██║██║ ██║ ██║ ╚════██║██║██║ ██║██╔══╝ ╚════██║██╔══╝ ██╔══██╗╚██╗ ██╔╝██║██║ ██╔══╝
|
|
╚██████╔╝╚██████╔╝ ██║ ███████║██║██████╔╝███████╗ ███████║███████╗██║ ██║ ╚████╔╝ ██║╚██████╗███████╗
|
|
╚═════╝ ╚═════╝ ╚═╝ ╚══════╝╚═╝╚═════╝ ╚══════╝ ╚══════╝╚══════╝╚═╝ ╚═╝ ╚═══╝ ╚═╝ ╚═════╝╚══════╝
|
|
|
|
*/
|
|
|
|
|
|
#region PMItemOutsideService
|
|
|
|
/// <summary>
|
|
/// Create PMItemOutsideService
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemOutsideService level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemOutsideService object (no descendants)</returns>
|
|
[HttpPost("items/outside-services")]
|
|
public async Task<IActionResult> PostPMItemOutsideService([FromBody] PMItemOutsideService newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemOutsideService o = await biz.OutsideServiceCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemOutsideService), new { PMItemOutsideServiceId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemOutsideService object
|
|
/// </summary>
|
|
/// <param name="PMItemOutsideServiceId"></param>
|
|
/// <returns>A single PMItemOutsideService</returns>
|
|
[HttpGet("items/outside-services/{PMItemOutsideServiceId}")]
|
|
public async Task<IActionResult> GetPMItemOutsideService([FromRoute] long PMItemOutsideServiceId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsSubContractorFull || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.OutsideServiceGetAsync(PMItemOutsideServiceId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemOutsideService
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemOutsideService - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/outside-services")]
|
|
public async Task<IActionResult> PutPMItemOutsideService([FromBody] PMItemOutsideService updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.OutsideServicePutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemOutsideService
|
|
/// </summary>
|
|
/// <param name="PMItemOutsideServiceId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/outside-services/{PMItemOutsideServiceId}")]
|
|
public async Task<IActionResult> DeletePMItemOutsideService([FromRoute] long PMItemOutsideServiceId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemOutsideService) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.OutsideServiceDeleteAsync(PMItemOutsideServiceId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemOutsideService
|
|
|
|
|
|
|
|
/*
|
|
██████╗ █████╗ ██████╗ ████████╗███████╗
|
|
██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔════╝
|
|
██████╔╝███████║██████╔╝ ██║ ███████╗
|
|
██╔═══╝ ██╔══██║██╔══██╗ ██║ ╚════██║
|
|
██║ ██║ ██║██║ ██║ ██║ ███████║
|
|
╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚══════╝
|
|
*/
|
|
|
|
#region PMItemPart
|
|
|
|
/// <summary>
|
|
/// Create PMItemPart
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemPart level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemPart object (no descendants)</returns>
|
|
[HttpPost("items/parts")]
|
|
public async Task<IActionResult> PostPMItemPart([FromBody] PMItemPart newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemPart o = await biz.CreatePartAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemPart), new { PMItemPartId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemPart object
|
|
/// </summary>
|
|
/// <param name="PMItemPartId"></param>
|
|
/// <returns>A single PMItemPart</returns>
|
|
[HttpGet("items/parts/{PMItemPartId}")]
|
|
public async Task<IActionResult> GetPMItemPart([FromRoute] long PMItemPartId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.PartGetAsync(PMItemPartId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemPart
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemPart - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/parts")]
|
|
public async Task<IActionResult> PutPMItemPart([FromBody] PMItemPart updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.PartPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemPart
|
|
/// </summary>
|
|
/// <param name="PMItemPartId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/parts/{PMItemPartId}")]
|
|
public async Task<IActionResult> DeletePMItemPart([FromRoute] long PMItemPartId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemPart) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.PartDeleteAsync(PMItemPartId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemPart
|
|
|
|
|
|
|
|
/*
|
|
███████╗ ██████╗██╗ ██╗███████╗██████╗ ██╗ ██╗██╗ ███████╗██████╗ ██╗ ██╗███████╗███████╗██████╗ ███████╗
|
|
██╔════╝██╔════╝██║ ██║██╔════╝██╔══██╗██║ ██║██║ ██╔════╝██╔══██╗ ██║ ██║██╔════╝██╔════╝██╔══██╗██╔════╝
|
|
███████╗██║ ███████║█████╗ ██║ ██║██║ ██║██║ █████╗ ██║ ██║█████╗██║ ██║███████╗█████╗ ██████╔╝███████╗
|
|
╚════██║██║ ██╔══██║██╔══╝ ██║ ██║██║ ██║██║ ██╔══╝ ██║ ██║╚════╝██║ ██║╚════██║██╔══╝ ██╔══██╗╚════██║
|
|
███████║╚██████╗██║ ██║███████╗██████╔╝╚██████╔╝███████╗███████╗██████╔╝ ╚██████╔╝███████║███████╗██║ ██║███████║
|
|
╚══════╝ ╚═════╝╚═╝ ╚═╝╚══════╝╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚═════╝ ╚═════╝ ╚══════╝╚══════╝╚═╝ ╚═╝╚══════╝
|
|
*/
|
|
|
|
#region PMItemScheduledUser
|
|
|
|
/// <summary>
|
|
/// Create PMItemScheduledUser
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemScheduledUser level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemScheduledUser object (no descendants)</returns>
|
|
[HttpPost("items/scheduled-users")]
|
|
public async Task<IActionResult> PostPMItemScheduledUser([FromBody] PMItemScheduledUser newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemScheduledUser o = await biz.ScheduledUserCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemScheduledUser), new { PMItemScheduledUserId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemScheduledUser object
|
|
/// </summary>
|
|
/// <param name="PMItemScheduledUserId"></param>
|
|
/// <returns>A single PMItemScheduledUser</returns>
|
|
[HttpGet("items/scheduled-users/{PMItemScheduledUserId}")]
|
|
public async Task<IActionResult> GetPMItemScheduledUser([FromRoute] long PMItemScheduledUserId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemScheduledUser))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.ScheduledUserGetAsync(PMItemScheduledUserId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemScheduledUser
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemScheduledUser - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/scheduled-users")]
|
|
public async Task<IActionResult> PutPMItemScheduledUser([FromBody] PMItemScheduledUser updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.ScheduledUserPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemScheduledUser
|
|
/// </summary>
|
|
/// <param name="PMItemScheduledUserId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/scheduled-users/{PMItemScheduledUserId}")]
|
|
public async Task<IActionResult> DeletePMItemScheduledUser([FromRoute] long PMItemScheduledUserId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemScheduledUser) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.ScheduledUserDeleteAsync(PMItemScheduledUserId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemScheduledUser
|
|
|
|
|
|
/*
|
|
████████╗ █████╗ ███████╗██╗ ██╗
|
|
╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
|
|
██║ ███████║███████╗█████╔╝
|
|
██║ ██╔══██║╚════██║██╔═██╗
|
|
██║ ██║ ██║███████║██║ ██╗
|
|
╚═╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝
|
|
*/
|
|
|
|
#region PMItemtask
|
|
|
|
/// <summary>
|
|
/// Create PMItemTask
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemTask level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemTask object (no descendants)</returns>
|
|
[HttpPost("items/tasks")]
|
|
public async Task<IActionResult> PostPMItemTask([FromBody] PMItemTask newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemTask) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemTask o = await biz.TaskCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemTask), new { PMItemTaskId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemTask object
|
|
/// </summary>
|
|
/// <param name="PMItemTaskId"></param>
|
|
/// <returns>A single PMItemTask</returns>
|
|
[HttpGet("items/tasks/{PMItemTaskId}")]
|
|
public async Task<IActionResult> GetPMItemTask([FromRoute] long PMItemTaskId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemTask))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.TaskGetAsync(PMItemTaskId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemTask
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemTask - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/tasks")]
|
|
public async Task<IActionResult> PutPMItemTask([FromBody] PMItemTask updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemTask))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.TaskPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemTask
|
|
/// </summary>
|
|
/// <param name="PMItemTaskId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/tasks/{PMItemTaskId}")]
|
|
public async Task<IActionResult> DeletePMItemTask([FromRoute] long PMItemTaskId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemTask) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.TaskDeleteAsync(PMItemTaskId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemTask
|
|
|
|
|
|
/*
|
|
████████╗██████╗ █████╗ ██╗ ██╗███████╗██╗
|
|
╚══██╔══╝██╔══██╗██╔══██╗██║ ██║██╔════╝██║
|
|
██║ ██████╔╝███████║██║ ██║█████╗ ██║
|
|
██║ ██╔══██╗██╔══██║╚██╗ ██╔╝██╔══╝ ██║
|
|
██║ ██║ ██║██║ ██║ ╚████╔╝ ███████╗███████╗
|
|
╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═══╝ ╚══════╝╚══════╝
|
|
*/
|
|
|
|
#region PMItemTravel
|
|
|
|
/// <summary>
|
|
/// Create PMItemTravel
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemTravel level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemTravel object (no descendants)</returns>
|
|
[HttpPost("items/travels")]
|
|
public async Task<IActionResult> PostPMItemTravel([FromBody] PMItemTravel newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemTravel))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemTravel o = await biz.TravelCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemTravel), new { PMItemTravelId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemTravel object
|
|
/// </summary>
|
|
/// <param name="PMItemTravelId"></param>
|
|
/// <returns>A single PMItemTravel</returns>
|
|
[HttpGet("items/travels/{PMItemTravelId}")]
|
|
public async Task<IActionResult> GetPMItemTravel([FromRoute] long PMItemTravelId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemTravel))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.TravelGetAsync(PMItemTravelId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemTravel
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemTravel - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/travels")]
|
|
public async Task<IActionResult> PutPMItemTravel([FromBody] PMItemTravel updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemTravel))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.TravelPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemTravel
|
|
/// </summary>
|
|
/// <param name="PMItemTravelId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/travels/{PMItemTravelId}")]
|
|
public async Task<IActionResult> DeletePMItemTravel([FromRoute] long PMItemTravelId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemTravel))
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.TravelDeleteAsync(PMItemTravelId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemTravel
|
|
|
|
|
|
/*
|
|
██╗ ██╗███╗ ██╗██╗████████╗
|
|
██║ ██║████╗ ██║██║╚══██╔══╝
|
|
██║ ██║██╔██╗ ██║██║ ██║
|
|
██║ ██║██║╚██╗██║██║ ██║
|
|
╚██████╔╝██║ ╚████║██║ ██║
|
|
╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝
|
|
*/
|
|
|
|
#region PMItemUnit
|
|
|
|
/// <summary>
|
|
/// Create PMItemUnit
|
|
/// </summary>
|
|
/// <param name="newObject">PMItemUnit level only no descendants</param>
|
|
/// <param name="apiVersion"></param>
|
|
/// <returns>PMItemUnit object (no descendants)</returns>
|
|
[HttpPost("items/units")]
|
|
public async Task<IActionResult> PostPMItemUnit([FromBody] PMItemUnit newObject, ApiVersion apiVersion)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasCreateRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMItemUnit o = await biz.UnitCreateAsync(newObject);
|
|
if (o == null)
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return CreatedAtAction(nameof(PMController.GetPMItemUnit), new { PMItemUnitId = o.Id, version = apiVersion.ToString() }, new ApiCreatedResponse(o));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Get PMItemUnit object
|
|
/// </summary>
|
|
/// <param name="PMItemUnitId"></param>
|
|
/// <returns>A single PMItemUnit</returns>
|
|
[HttpGet("items/units/{PMItemUnitId}")]
|
|
public async Task<IActionResult> GetPMItemUnit([FromRoute] long PMItemUnitId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasReadFullRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsSubContractorRestricted)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
var o = await biz.UnitGetAsync(PMItemUnitId);
|
|
if (o == null)
|
|
return NotFound(new ApiErrorResponse(ApiErrorCode.NOT_FOUND));
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update PMItemUnit
|
|
///
|
|
/// </summary>
|
|
/// <param name="updatedObject">PMItemUnit - top level only, no descendants</param>
|
|
/// <returns>New concurrency token</returns>
|
|
[HttpPut("items/units")]
|
|
public async Task<IActionResult> PutPMItemUnit([FromBody] PMItemUnit updatedObject)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasModifyRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
var o = await biz.UnitPutAsync(updatedObject);
|
|
if (o == null)
|
|
{
|
|
if (biz.Errors.Exists(z => z.Code == ApiErrorCode.CONCURRENCY_CONFLICT))
|
|
return StatusCode(409, new ApiErrorResponse(biz.Errors));
|
|
else
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
}
|
|
return Ok(ApiOkResponse.Response(o));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete PMItemUnit
|
|
/// </summary>
|
|
/// <param name="PMItemUnitId"></param>
|
|
/// <returns>NoContent</returns>
|
|
[HttpDelete("items/units/{PMItemUnitId}")]
|
|
public async Task<IActionResult> DeletePMItemUnit([FromRoute] long PMItemUnitId)
|
|
{
|
|
if (!serverState.IsOpen)
|
|
return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(new ApiErrorResponse(ModelState));
|
|
PMBiz biz = PMBiz.GetBiz(ct, HttpContext);
|
|
if (!Authorized.HasDeleteRole(HttpContext.Items, AyaType.PMItemUnit) || biz.UserIsRestrictedType)
|
|
return StatusCode(403, new ApiNotAuthorizedResponse());
|
|
if (!await biz.UnitDeleteAsync(PMItemUnitId))
|
|
return BadRequest(new ApiErrorResponse(biz.Errors));
|
|
return NoContent();
|
|
}
|
|
|
|
#endregion PMItemUnit
|
|
|
|
|
|
|
|
|
|
//------------
|
|
|
|
|
|
}//eoc
|
|
}//eons |