cms_thermo_active/Step/Controllers/WebApi/NcToolManagerController.cs

using Step.Database.Controllers;
using Step.Model.DatabaseModels;
using Step.Model.DTOModels.ToolModels;
using Step.NC;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web.Http;
using static Step.Config.ServerConfig;

namespace Step.Controllers.WebApi
{
    [RoutePrefix("api/tool_manager/nc")]
    public class NcToolManagerApiController : ApiController
    {
        #region Tools

        [Route("tools"), HttpGet]
        public IHttpActionResult GetNcToolTable()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<NcToolModel> tools = toolsManager.GetToolsWithDependencies();

                return Ok(tools);
            }
        }

        [Route("tool"), HttpPost]
        public IHttpActionResult AddTool([FromBody][Required]DTONcToolModel dtoTool)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcFamilyModel fam = toolsManager.FindFamily(dtoTool.FamilyId);
                if (fam == null)
                    return BadRequest("error_incorrect_parameters");

                NcShankModel shank = toolsManager.FindShank(dtoTool.ShankId);
                if (shank == null)
                    return BadRequest("error_incorrect_parameters");
            }

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                NcToolModel newTool = ncHandler.AddTool(dtoTool);

                return Ok(newTool);
            }
        }

        [Route("tool/{toolId:int}"), HttpPut]
        public IHttpActionResult PutTool(int toolId, [FromBody][Required]DTONcToolModel dtoTool)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcToolModel tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    NcToolModel newTool = ncHandler.UpdateTool(tool, dtoTool);

                    return Ok(newTool);
                }
            }
        }

        [Route("tool/{toolId:int}"), HttpDelete]
        public IHttpActionResult DeleteTool(int toolId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcToolModel tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();

                    ncHandler.DeleteNcTool(tool);

                    return Ok();
                }
            }
        }

        #endregion Tools

        #region Shanks

        [Route("shanks"), HttpGet]
        public IHttpActionResult GetShanks()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                return Ok(toolsManager.GetShanks());
            }
        }

        [Route("shank"), HttpPost]
        public IHttpActionResult AddShank([FromBody][Required] DTONcShankModel dtoShank)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                NcShankModel shank = ncHandler.AddShank(dtoShank);
                return Ok(shank);
            }
        }

        [Route("shank/{shankId:int}"), HttpPut]
        public IHttpActionResult PutShank(int shankId, [FromBody][Required]DTONcShankModel dtoShank)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcShankModel shank = toolsManager.FindShank(shankId);
                if (shank == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    shank = ncHandler.UpdateShank(shank, dtoShank);

                    return Ok(shank);
                }
            }
        }

        [Route("shank/{shankId:int}"), HttpDelete]
        public IHttpActionResult DeleteShank(int shankId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcShankModel shank = toolsManager.FindShank(shankId);
                if (shank == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();

                    ncHandler.DeleteNcShank(shank);

                    return Ok();
                }
            }
        }

        #endregion Shanks

        #region Families

        [Route("family"), HttpPost]
        public IHttpActionResult AddFamily([FromBody][Required]DTONcFamilyModel dtoFamily)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                NcFamilyModel newFamily = ncHandler.AddFamily(dtoFamily);

                return Ok(newFamily);
            }
        }

        [Route("families"), HttpGet]
        public IHttpActionResult GetFamilies()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<NcFamilyModel> families = toolsManager.GetFamilies();

                return Ok(families);
            }
        }

        [Route("family/{famlyId:int}"), HttpPut]
        public IHttpActionResult PutFamily(int familyId, [FromBody][Required]DTONcToolModel dtoTool)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcToolModel tool = toolsManager.FindTool(familyId);
                if (tool == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    NcToolModel newTool = ncHandler.UpdateTool(tool, dtoTool);

                    return Ok(newTool);
                }
            }
        }

        [Route("family/{familyId:int}"), HttpDelete]
        public IHttpActionResult DeleteFamily(int familyId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcFamilyModel family = toolsManager.FindFamily(familyId);
                if (family == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();

                    ncHandler.DeleteNcFamily(family);

                    return Ok();
                }
            }
        }

        #endregion Families

        #region Magazine positions

        [Route("magazines_positions"), HttpGet]
        public IHttpActionResult GetMagazinesPositions()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<NcMagazinePositionModel> magazines = toolsManager.GetPositions();

                return Ok(magazines);
            }
        }

        [Route("magazine/{magazineId:int}/positions"), HttpGet]
        public IHttpActionResult GetMagazinesPositions(byte magazineId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<NcMagazinePositionModel> magazine = toolsManager.GetMagazinePositions(magazineId);

                return Ok(magazine);
            }
        }

        [Route("magazine/{magazineId}/position/{positionId}"), HttpPut]
        public IHttpActionResult PutMagazinePosition([Required]byte magazineId, [Required]byte positionId, [FromBody]DTONcMagazinesPositionsModel dtoPos)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if magazine&position exists
                NcMagazinePositionModel pos = toolsManager.GetMagazinePosition(magazineId, positionId);
                if (pos == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    pos = ncHandler.UpdateMagazinePosition(pos, dtoPos);
                    return Ok(pos);
                }
            }
        }

        #endregion Magazine positions

        [Route("magazine/{magazineId:int}/mounted_tools"), HttpGet]
        public IHttpActionResult GetMagazineTools(byte magazineId)
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if magazine exists
                List<NcMagazinePositionModel> pos = toolsManager.GetMagazinePositions(magazineId);
                if (pos.Count <= 0)
                    return NotFound();

                List<DTONcShankModel> mountedShank = toolsManager.GetMountedShanks(magazineId);

                return Ok(mountedShank);
            }
        }

        [Route("magazine/available_tools"), HttpGet]
        public IHttpActionResult GetAvailableTools()
        {
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                List<DTONcShankModel> shanks = toolsManager.GetAvailableShanks();

                return Ok(shanks);
            }
        }

        [Route("magazine/{magazineId:int}/load/position/{positionId:int}"), HttpPut]
        public IHttpActionResult LoadToolInToMagazine(byte magazineId, byte positionId, [FromBody][Required] DTOUpdateMagazineModel shankId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);
            if (shankId.ToolId == 0)
                return BadRequest("error_incorrect_parameters");

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcShankModel shank = toolsManager.FindShank(shankId.ToolId);
                if (shank == null)
                    return BadRequest("error_incorrect_parameters");

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    DTONcShankModel responseShank = ncHandler.LoadToolInMagazine(magazineId, positionId, shank);

                    return Ok(responseShank);
                }
            }
        }

        [Route("magazine/{magazineId:int}/unload/position/{positionId:int}"), HttpPut]
        public IHttpActionResult UnloadToolInToMagazine(byte magazineId, byte positionId, [FromBody][Required] DTOUpdateMagazineModel shankId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);
            if (shankId.ToolId == 0)
                return BadRequest("error_incorrect_parameters");

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                NcShankModel shank = toolsManager.FindShank(shankId.ToolId);
                if (shank == null)
                    return BadRequest("error_incorrect_parameters");

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    DTONcShankModel responseShank = ncHandler.UnloadToolInMagazine(magazineId, positionId, shank);

                    return Ok(responseShank);
                }
            }
        }
    }
}