cms_thermo_active/Step/Controllers/WebApi/ToolTableController.cs

using Step.Model.DTOModels.ToolModels;
using Step.NC;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Linq;
using System.Web.Http;
using static CMS_CORE_Library.DataStructures;

namespace Step.Controllers.WebApi
{
    [RoutePrefix("api/tool_manager")]
    public class ToolTableController : ApiController
    {
        [Route("tools"), HttpGet]
        public IHttpActionResult GetToolTable()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetToolTableData(out List<SiemensToolModel> tools);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);
                
                return Ok(tools);
            }
        }

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

            using (NcHandler ncHandler = new NcHandler())
            {
                // Convert from DTOModel to library model
                SiemensToolModel siemensModel = (SiemensToolModel)tool; ;

                ncHandler.Connect();
                CmsError libraryError = ncHandler.AddTool(ref siemensModel);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(siemensModel);
            }
        }

        [Route("siemens/tool/{id}"), HttpPut]
        public IHttpActionResult UpdateTool(int id, [FromBody][Required]DTOSiemensToolModel tool)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcHandler ncHandler = new NcHandler())
            {
                // Convert from DTOModel to library model
                SiemensToolModel siemensModel = (SiemensToolModel)tool;
                siemensModel.Id = id;

                ncHandler.Connect();
                CmsError libraryError = ncHandler.UpdateTool(ref siemensModel);

                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(siemensModel);
            }
        }

        [Route("tool/{id:int}"), HttpDelete]
        public IHttpActionResult DeleteTool(int id)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.DeleteTool(id);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("families"), HttpGet]
        public IHttpActionResult GetFamilies()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetFamiliesData(out List<FamilyModel> families);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(families);
            }
        }

        [Route("family"), HttpPost]
        public IHttpActionResult AddFamily([FromBody] DTOFamilyModel family)
        {
            if (String.IsNullOrEmpty(family.Name))
                return BadRequest();

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.AddFamily(family.Name, out FamilyModel newFamily);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(newFamily);
            }
        }

        [Route("family/{oldName}"), HttpPut]
        public IHttpActionResult PutFamily(string oldName, [FromBody]DTOFamilyModel family)
        {
            if (String.IsNullOrEmpty(family.Name))
                return BadRequest();

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

                CmsError libraryError = ncHandler.UpdateFamilyName(oldName, family.Name);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(family);
            }
        }

        [Route("family/{name}"), HttpDelete]
        public IHttpActionResult DeleteFamily(string name)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.DeleteFamily(name);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("magazines_positions"), HttpGet]
        public IHttpActionResult GetMagazinesPositions()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetMagazinesPositionsData(out List<PositionModel> magazines);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(magazines);
            }
        }


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

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

                // Create Library model
                PositionModel pos = new PositionModel()
                {
                    PositionId = positionId,
                    MagazineId = magazineId,
                    Disabled = magazinesPos.Disabled
                };
                // Update
                CmsError libraryError = ncHandler.UpdateMagazinePosition(pos);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("shanks"), HttpGet]
        public IHttpActionResult GetShanks()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetShanksData(out List<ShankModel> shanks);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(shanks);
            }
        }

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

            using (NcHandler ncHandler = new NcHandler())
            {
                ShankModel shank = (ShankModel)dtoShank;

                ncHandler.Connect();
                CmsError libraryError = ncHandler.AddShank(ref shank);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(shank);
            }
        }

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

            using (NcHandler ncHandler = new NcHandler())
            {
                ShankModel shank = (ShankModel)dtoShank;
                shank.Id = shankId;

                ncHandler.Connect();
                CmsError libraryError = ncHandler.UpdateShank(ref shank);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(shank);
            }
        }

        [Route("shank/{id:int}"), HttpDelete]
        public IHttpActionResult DeleteShank(int id)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.DeleteShank(id);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("tool/{toolId:int}/edge"), HttpPost]
        public IHttpActionResult AddEdge(int toolId, [FromBody][Required]DTOEdgeModel dtoEdge)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

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

                EdgeModel edge = (EdgeModel)dtoEdge;

                // Call library add methods
                CmsError libraryError = ncHandler.AddEdge(toolId, ref edge);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(edge);
            }
        }

        [Route("tool/{toolId:int}/edge/{edgeId:int}"), HttpPut]
        public IHttpActionResult UpdateEdge(int toolId, int edgeId, [FromBody][Required]DTOEdgeModel dtoEdge)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

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

                EdgeModel edge = (EdgeModel)dtoEdge;
                edge.Id = edgeId;

                // Call library add methods
                CmsError libraryError = ncHandler.UpdateEdge(toolId, ref edge);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(edge);
            }
        }

        [Route("tool/{toolId:int}/edge/{edgeId:int}"), HttpDelete]
        public IHttpActionResult DeleteEdge(int toolId, int edgeId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.DeleteEdge(toolId, edgeId);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("magazine/{magazineId:int}"), HttpGet]
        public IHttpActionResult GetMagazineTools(int magazineId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.GetMagazinePositionsAndTools(magazineId, out List<PositionModel> magazinePos);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(magazinePos);
            }
        }

        [Route("magazine/available_tools"), HttpGet]
        public IHttpActionResult GetAvailableTools()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Call delete library function
                CmsError libraryError = ncHandler.GetNotInMagazinesTools(out List<MountedMultiToolModel> multiTools, out List<MountedToolModel> tools);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(new
                {
                    MultiTools = multiTools,
                    Tools = tools
                });
            }
        }

        [Route("magazine/{magazineId:int}/load"), HttpPut]
        public IHttpActionResult LoadToolInToMagazine(int magazineId, [FromBody][Required] DTOUpdateMagazineModel newMag)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

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

                NewToolInMagazineModel libraryMag =  new NewToolInMagazineModel { PositionId = newMag.PositionId, ToolId = newMag.ToolId };
                // Call delete library function
                CmsError libraryError = ncHandler.LoadToolInMagazine(magazineId, libraryMag);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok(newMag);
            }
        }

        [Route("magazine/{magazineId:int}/unload/{positionId:int}"), HttpPut]
        public IHttpActionResult UnloadToolFromMagazine(int magazineId, int positionId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

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

                // Call delete library function
                CmsError libraryError = ncHandler.UnloadToolInMagazine(magazineId, positionId);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("shank/{shankId:int}/load/{positionId:int}/tool/{toolId:int}"), HttpPut]
        public IHttpActionResult LoadToolFromShank(int shankId, int positionId, int toolId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                
                CmsError libraryError = ncHandler.LoadTooolFromShank(shankId, positionId, toolId);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        [Route("shank/{shankId:int}/unload/{positionId:int}/{toolId:int}"), HttpPut]
        public IHttpActionResult UnloadToolFromShank(int shankId, int positionId, int toolId)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                
                CmsError libraryError = ncHandler.UnloadTooolFromShank(shankId, positionId, toolId);
                if (libraryError.IsError())
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }
    }
}