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.Linq;
using System.Web.Http;
using static CMS_CORE_Library.DataStructures;
using static Step.Config.ServerConfig;
using static Step.Model.Constants;

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

        [Route("tools"), HttpGet]
        public IHttpActionResult GetNcToolTable()
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                CmsError cmsError = ncHandler.GetToolsData(out List<DTONcToolModel> tools);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok(tools);
            }
        }

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

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if family exists
                DbNcFamilyModel fam = toolsManager.FindFamily(dtoTool.FamilyId);
                if (fam == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // If option is active check if shank exists
                if (ToolManagerConfig.ShankOptIsActive)
                {
                    DbNcShankModel shank = toolsManager.FindShankWithTools(dtoTool.ShankId.Value);
                    if (shank == null)
                        return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                }
            }

            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();
                // Check option
                if (!ToolManagerConfig.ShankOptIsActive)
                {
                    // if option is not active create a shank
                    DTONcShankModel newShank = new DTONcShankModel()
                    {
                        Balluf = 0, 
                        MagazinePositionType = 0
                    };
                    // Add new shank
                    DTONcShankModel ncShank = ncHandler.AddShank(newShank);
                    // Set tool shank id
                    dtoTool.ShankId = ncShank.Id;
                }
                // Add tool
                DTONcToolModel newTool = ncHandler.AddTool(dtoTool);

                return Ok(newTool);
            }
        }

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

            DbNcToolModel tool = null;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if tool exists
                tool = toolsManager.FindTool(toolId);
                if (tool == null)
                    return NotFound();

                if(tool.FamilyId != dtoTool.FamilyId)
                {
                    // Check if family exists
                    DbNcFamilyModel fam = toolsManager.FindFamily(dtoTool.FamilyId);
                    if (fam == null)
                        return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                }

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    // Update
                    CmsError cmsError = ncHandler.UpdateTool(toolId, dtoTool, out DTONcToolModel newTool);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newTool);
                }
            }
        }

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

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

                    if (!ToolManagerConfig.ShankOptIsActive && tool.ShankId != null)
                    {
                        // If option is active find & delete tool shank
                        DbNcShankModel shank = toolsManager.FindShankWithTools(tool.ShankId.Value);

                        ncHandler.DeleteNcShank(shank.ShankId);
                    }

                    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] DTONewNcShankModel dtoShank)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            if (!ToolManagerConfig.ShankOptIsActive)
                return BadRequest(API_ERROR_KEYS.OPTION_NOT_ACTIVE);

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

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

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    // Update shank
                    CmsError cmsError = ncHandler.UpdateShank(shankId, dtoShank, out DTONcShankModel newShank);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newShank);
                }
            }
        }

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

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

                    ncHandler.DeleteNcShank(shank.ShankId);

                    return Ok();
                }
            }
        }

        #endregion Shanks

        #region Families

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

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

                return Ok(newFamily);
            }
        }

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

                return Ok(families);
            }
        }

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

            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if family exists
                DbNcFamilyModel family = toolsManager.FindFamily(familyId);
                if (family == null)
                    return NotFound();

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    // Update into db and NC
                    CmsError cmsError = ncHandler.UpdateFamily(familyId, dtoFamily, out DTONcFamilyModel newFamily);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newFamily);
                }
            }
        }

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

                using (NcHandler ncHandler = new NcHandler())
                {
                    ncHandler.Connect();
                    //Delete
                    ncHandler.DeleteNcFamily(family);

                    return Ok();
                }
            }
        }

        #endregion Families

        #region Magazine positions

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

                return Ok(magazines);
            }
        }

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

                return Ok(magazine);
            }
        }

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

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

                using (NcHandler ncHandler = new NcHandler())
                {
                    CmsError cmsError = ncHandler.UpdateMagazinePosition(pos, dtoPos, out DTONcMagazinePositionModel newPos);
                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);

                    return Ok(newPos);
                }
            }
        }

        #endregion Magazine positions

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

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

                return Ok(mountedShank);
            }
        }

        [Route("magazine/available_shanks"), 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(API_ERROR_KEYS.INCORRECT_PARAMETERS);

            // Check data
            DbNcShankModel shank;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                shank = toolsManager.FindShankWithTools(shankId.ToolId);
                if (shank == null)

                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                // Check if shank is already loaded somewhere
                if (shank.MagazineId != null)
                    return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);

                // Check if magazine position exists
                DbNcMagazinePositionModel magPos = toolsManager.FindMagazinePosition(magazineId, positionId);
                if(magPos == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                // Check if the mag pos is disabled
                if(magPos.Disabled == true)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                using (NcHandler ncHandler = new NcHandler())
                {
                    // Get Configuration
                    ncHandler.Connect();


                    // Check if shank can fit
                    CmsError cmsError = ncHandler.CheckIfShankCanFit(
                        magazineId,
                        positionId,
                        shank // Get mounted tools
                        );

                    if (cmsError.IsError())
                        return BadRequest(cmsError.localizationKey);
                }

                // Update shank data
                DTONcMagazinePositionModel magazinePos = (DTONcMagazinePositionModel)toolsManager.LoadShankInMagazine(magazineId, positionId, shank);
                // Set shankId
                magazinePos.ShankId = shank.ShankId;

                return Ok(magazinePos);
            }


        }

        [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(API_ERROR_KEYS.INCORRECT_PARAMETERS);

            // Check data
            DbNcShankModel shank;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                shank = toolsManager.FindShankWithTools(shankId.ToolId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // Check if magazine position exists
                DbNcMagazinePositionModel magPos = toolsManager.FindMagazinePosition(magazineId, positionId);
                if (magPos == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
                // Check if the mag pos is disabled
                if (magPos.Disabled == true)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                // Check if magazine position is occupied
                DbNcShankModel shankMounted = toolsManager.FindShanksByPositions(magazineId, positionId);
                if (shankMounted != null)
                    return BadRequest(API_ERROR_KEYS.MAGAZINE_POSITION_OCCUPIED);

                DTONcShankModel responseShank = toolsManager.UnloadShankInMagazine(magazineId, positionId, shank);

                return Ok(responseShank);
            }
        }
        

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

            DbNcToolModel tool;
            using (NcToolManagerController toolsManager = new NcToolManagerController())
            {
                // Check if shank exists
                DbNcShankModel shank = toolsManager.FindShankWithTools(shankId);
                if (shank == null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);

                tool = toolsManager.FindTool(toolId);
                if(tool== null)
                    return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
            }

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

                DTONcShankModel shank = ncHandler.LoadIntoShank(tool, shankId);

                return Ok(shank);
            }
        }

        //[Route("start_edit_data"), HttpPut]
        //public IHttpActionResult StartEditData()
        //{
        //    using (NcHandler ncHandler = new NcHandler())
        //    {
        //        ncHandler.Connect();

        //        CmsError cmsError = ncHandler.StartEditData();
        //        if (cmsError.IsError())
        //            return BadRequest(cmsError.localizationKey);


        //        return Ok();
        //    }
        //}
        
        //[Route("stop_edit_data"), HttpPut]
        //public IHttpActionResult StopEdit()
        //{
        //    using (NcHandler ncHandler = new NcHandler())
        //    {
        //        ncHandler.Connect();

        //        CmsError cmsError = ncHandler.StopEditData();
        //        if (cmsError.IsError())
        //            return BadRequest(cmsError.localizationKey);

        //        return Ok();
        //    }
        //}

        [Route("start_edit_tooling/{magazineId:int}"), HttpPut]
        public IHttpActionResult StartEditTooling(int magazineId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.StartEditTooling(magazineId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);


                return Ok();
            }
        }

        [Route("stop_edit_tooling/{magazineId:int}"), HttpPut]
        public IHttpActionResult StopEditTooling(int magazineId)
        {
            using (NcHandler ncHandler = new NcHandler())
            {
                ncHandler.Connect();

                CmsError cmsError = ncHandler.StopEditTooling(magazineId);
                if (cmsError.IsError())
                    return BadRequest(cmsError.localizationKey);

                return Ok();
            }
        }
    }
}