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.Linq;
using System.Web.Http;
using static CMS_CORE_Library.DataStructures;

namespace Step.Controllers.WebApi
{
    [RoutePrefix("api/tool_table")]
    public class ToolTableController : ApiController
    {
        [Route("configuration"), HttpGet]
        public IHttpActionResult GetToolTableConfiguration()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetToolTableConfiguration(out ToolTableConfiguration toolTableConfiguration);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        return BadRequest(libraryError.message);

                return Ok(toolTableConfiguration);
            }
        }

        [Route("tools"), HttpGet]
        public IHttpActionResult GetToolTable()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError libraryError = ncHandler.GetToolTableData(out List<SiemensToolModel> tools);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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 = ConvertFromDTOtoSiemensModel(tool);

                ncHandler.Connect();
                CmsError libraryError = ncHandler.AddTool(ref siemensModel);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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 = ConvertFromDTOtoSiemensModel(tool);
                siemensModel.Id = id;

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

                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        return BadRequest(libraryError.message);

                return Ok();
            }
        }

        private SiemensToolModel ConvertFromDTOtoSiemensModel(DTOSiemensToolModel dtoModel)
        {
            return new SiemensToolModel()
            {
                MagazinePositionType = dtoModel.MagazinePositionType,
                ToolType = dtoModel.ToolType,

                FamilyName = dtoModel.FamilyName,

                IsActive = dtoModel.IsActive,
                IsInhibited = dtoModel.IsInhibited,
                IsInUse = dtoModel.IsInUse,
                IsMeasured = dtoModel.IsMeasured,
                InChangeTool = dtoModel.InChangeTool,
                InFixedPlace = dtoModel.InFixedPlace,
                PreAlarm = dtoModel.PreAlarm,

                Cooling1 = dtoModel.Cooling1,
                Cooling2 = dtoModel.Cooling2,
                LeftSize = dtoModel.LeftSize,
                RightSize = dtoModel.RightSize,
                Rotation = dtoModel.Rotation
            };
        }

        [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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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<PositionsModel> magazines);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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
                PositionsModel pos = new PositionsModel()
                {
                    Id = positionId,
                    MagazineId = magazineId,
                    Type = Convert.ToInt32(magazinesPos.Type)
                };
                // Update
                CmsError libraryError = ncHandler.UpdateMagazinePosition(pos);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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<MagazinePositionsModel> magazinePos);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        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())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        return BadRequest(libraryError.message);

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

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

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

                List<NewToolInMagazineModel> libraryMag = newMag.Select(x => new NewToolInMagazineModel { PositionId = x.PositionId, ToolId = x.ToolId }).ToList();
                // Call delete library function
                CmsError libraryError = ncHandler.UpdateMagazine(magazineId, libraryMag);
                if (libraryError.IsError())
                    if (libraryError.errorCode != CMS_ERROR_CODES.NOT_CONNECTED)
                        return BadRequest(libraryError.message);

                return Ok(newMag);
            }
        }
    }
}