Samuele Locatelli
1088 lines
41 KiB
C#
1088 lines
41 KiB
C#
using CMS_CORE_Library.Models;
|
|
using Newtonsoft.Json;
|
|
using Step.Database.Controllers;
|
|
using Step.Model.DatabaseModels;
|
|
using Step.Model.DTOModels;
|
|
using Step.Model.DTOModels.ToolModels;
|
|
using Step.NC;
|
|
using Step.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
using System.Web.Http;
|
|
using static Step.Config.ServerConfig;
|
|
using static Step.Listeners.SignalRStaticObjects;
|
|
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 (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
CmsError cmsError = ncAdapter.GetToolsData(true, out List<DTONcToolModel> tools);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
// Add family data to tools
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Get families
|
|
List<DTONcFamilyModel> families = toolsManager.GetFamilies();
|
|
|
|
List<DTONcToolWithFamilyModel> toolsWithFamilies = new List<DTONcToolWithFamilyModel>();
|
|
// Create tool&family return objecs
|
|
foreach (var tool in tools)
|
|
{
|
|
toolsWithFamilies.Add
|
|
(
|
|
CreateToolAndFamilyObj( // Create return model with family data & tool data
|
|
tool,
|
|
families.Where(x => x.Id == tool.FamilyId).FirstOrDefault() // Find matching family
|
|
)
|
|
);
|
|
}
|
|
|
|
return Ok(toolsWithFamilies);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Route("tools_without_offsets"), HttpGet]
|
|
public IHttpActionResult GetNcToolTableWithoutOffset()
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
CmsError cmsError = ncAdapter.GetToolsData(false, out List<DTONcToolModel> tools);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
// Add family data to tools
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Get families
|
|
List<DTONcFamilyModel> families = toolsManager.GetFamilies();
|
|
|
|
List<DTONcToolWithFamilyModel> toolsWithFamilies = new List<DTONcToolWithFamilyModel>();
|
|
// Create tool&family return objecs
|
|
foreach (var tool in tools)
|
|
{
|
|
toolsWithFamilies.Add
|
|
(
|
|
CreateToolAndFamilyObj( // Create return model with family data & tool data
|
|
tool,
|
|
families.Where(x => x.Id == tool.FamilyId).FirstOrDefault() // Find matching family
|
|
)
|
|
);
|
|
}
|
|
|
|
return Ok(toolsWithFamilies);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Route("tool/{toolId:int}/{familyId:int}"), HttpPost]
|
|
public IHttpActionResult AddToolWithId(short toolId, short familyId)
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Check if exists a tool with the same id
|
|
DbNcToolModel dbTool = toolsManager.FindTool(toolId);
|
|
if (dbTool != null)
|
|
return BadRequest(API_ERROR_KEYS.ID_ALREADY_EXIST);
|
|
|
|
// Create default family
|
|
DTONcFamilyModel defaultFamily = new DTONcFamilyModel();
|
|
// Copy data from static obj preconfigured
|
|
SupportFunctions.CopyProperties(DTO_TOOL_WITH_FAM, defaultFamily);
|
|
|
|
// Overwrite the custom model id
|
|
defaultFamily.Id = familyId;
|
|
|
|
// Check if FAMILY option is active
|
|
if (ToolManagerConfig.FamilyOpt)
|
|
{
|
|
// Check if id is already occupied
|
|
DbNcFamilyModel dbFam = null;
|
|
|
|
// Check Family id
|
|
// 0 : Create new family
|
|
// N : Set tool familyId with input id
|
|
|
|
if (familyId == 0)
|
|
// Add new family
|
|
dbFam = toolsManager.AddFamily(defaultFamily);
|
|
else
|
|
{
|
|
// check if family exist & set da
|
|
dbFam = toolsManager.FindFamily(familyId);
|
|
if (dbFam == null)
|
|
return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
}
|
|
|
|
// Set return value
|
|
//DTO_TOOL_WITH_FAM.FamilyId = dbFam.FamilyId;
|
|
//DTO_TOOL_WITH_FAM.Name = dbFam.Name;
|
|
|
|
SupportFunctions.CopyProperties(dbFam, DTO_TOOL_WITH_FAM);
|
|
}
|
|
else
|
|
{
|
|
defaultFamily.Id = toolId;
|
|
// Add new family
|
|
DbNcFamilyModel dbFam = toolsManager.AddFamily(defaultFamily);
|
|
|
|
// Set return value
|
|
DTO_TOOL_WITH_FAM.FamilyId = dbFam.FamilyId;
|
|
DTO_TOOL_WITH_FAM.Name = dbFam.Name;
|
|
}
|
|
|
|
// Check if option is active
|
|
if (!ToolManagerConfig.ShankOpt)
|
|
{
|
|
// If option is not active create a shank
|
|
DTONewNcShankModel newShank = new DTONewNcShankModel()
|
|
{
|
|
Balluf = 0,
|
|
MagazinePositionType = 0
|
|
};
|
|
|
|
// Create a new shank
|
|
DbNcShankModel ncShank = toolsManager.AddShank(newShank, toolId);
|
|
// Connect tool to new shank
|
|
DTO_TOOL_WITH_FAM.ShankId = ncShank.ShankId;
|
|
}
|
|
else
|
|
DTO_TOOL_WITH_FAM.ShankId = null;
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
// Add tool
|
|
CmsError cmsError = ncAdapter.AddTool(DTO_TOOL_WITH_FAM, out DTONcToolModel newTool, toolId);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
// if offset option is disabled set first offset id equal to toolId
|
|
if (!ToolManagerConfig.OffsetOpt)
|
|
{
|
|
ncAdapter.UpdateToolOffsetId(newTool.Id, 1, newTool.Id, out DTONcToolModel toolWithOffset);
|
|
newTool.OffsetId1 = newTool.Id;
|
|
newTool.Offset1 = toolWithOffset.Offset1;
|
|
}
|
|
|
|
return Ok(CreateToolAndFamilyObj(newTool, DTO_TOOL_WITH_FAM));
|
|
}
|
|
}
|
|
|
|
[Route("tool/{toolId:int}"), HttpPut]
|
|
public IHttpActionResult PutTool(int toolId, [FromBody][Required]DTONewNcToolWithFamilyModel dtoToolWithFamily)
|
|
{
|
|
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();
|
|
|
|
// Check if tool is mounted in spindle
|
|
if (ToolIsInSpindle(toolId))
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
|
|
if (tool.FamilyId != dtoToolWithFamily.FamilyId)
|
|
{
|
|
// Check if family exists
|
|
DbNcFamilyModel fam = toolsManager.FindFamily(dtoToolWithFamily.FamilyId);
|
|
if (fam == null)
|
|
return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
// Change return fam data
|
|
if (ToolManagerConfig.FamilyOpt)
|
|
{
|
|
dtoToolWithFamily.Name = fam.Name;
|
|
}
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
// Update
|
|
CmsError cmsError = ncAdapter.UpdateTool(toolId, dtoToolWithFamily, out DTONcToolModel newTool, dtoToolWithFamily);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok(CreateToolAndFamilyObj(newTool, dtoToolWithFamily));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Route("tool/{toolId:int}"), HttpDelete]
|
|
public IHttpActionResult DeleteTool(int toolId)
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
DbNcToolModel tool = toolsManager.FindToolWithDependencies(toolId);
|
|
if (tool == null)
|
|
return NotFound();
|
|
|
|
// Check if tool is mounted in magazine (a tool to be mounted in spindle must be in magazine)
|
|
if(tool.Shank != null && tool.Shank.MagazineId != null && tool.Shank.PositionId != null)
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
|
|
// Check if tool is mounted in spindle
|
|
//if (ToolIsInSpindle(toolId))
|
|
// return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
CmsError cmsError;
|
|
cmsError = ncAdapter.DeleteNcTool(tool);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Tools
|
|
|
|
#region Offsets
|
|
|
|
[Route("offset/{offsetId:int}"), HttpPut]
|
|
public IHttpActionResult UpdateOffset(short offsetId, OffsetModel offsetData)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
CmsError cmsError = ncAdapter.UpdateOffset(offsetId, offsetData);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
offsetData.Id = offsetId;
|
|
|
|
return Ok(offsetData);
|
|
}
|
|
}
|
|
|
|
[Route("tool/{toolId:int}/position/{positionId:int}/offset/{offsetId:int}"), HttpPut]
|
|
public IHttpActionResult UpdateToolOffset(int toolId, int positionId, short offsetId)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
CmsError cmsError = ncAdapter.UpdateToolOffsetId(toolId, positionId, offsetId, out DTONcToolModel tool);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok(tool);
|
|
}
|
|
}
|
|
|
|
#endregion Offsets
|
|
|
|
#region Shanks
|
|
|
|
[Route("shanks"), HttpGet]
|
|
public IHttpActionResult GetShanks()
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
return Ok(toolsManager.GetShanksWithSpace());
|
|
}
|
|
}
|
|
|
|
[Route("shank/{shankId:int}"), HttpPost]
|
|
public IHttpActionResult AddShank(short shankId)
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Check if exists a tool with the same id
|
|
DbNcShankModel dbShank = toolsManager.FindShank(shankId);
|
|
if (dbShank != null)
|
|
return BadRequest(API_ERROR_KEYS.ID_ALREADY_EXIST);
|
|
}
|
|
|
|
if (!ToolManagerConfig.ShankOpt)
|
|
return BadRequest(API_ERROR_KEYS.OPTION_NOT_ACTIVE);
|
|
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
DTONewNcShankModel dtoShank = new DTONewNcShankModel()
|
|
{
|
|
Balluf = 0,
|
|
MagazinePositionType = 0
|
|
};
|
|
DTONcShankModel shank = (DTONcShankModel)toolsManager.AddShank(dtoShank, shankId);
|
|
|
|
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();
|
|
|
|
// Check if tools are mounted in spindle
|
|
foreach (var tool in shank.Tools)
|
|
{
|
|
if (ToolIsInSpindle(tool.ToolId))
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
// Update shank
|
|
cmsError = ncAdapter.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();
|
|
|
|
// Check if tools are mounted in spindle
|
|
foreach (var tool in shank.Tools)
|
|
{
|
|
if (ToolIsInSpindle(tool.ToolId))
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
cmsError = ncAdapter.DeleteNcShank(shank.ShankId);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Shanks
|
|
|
|
#region Families
|
|
|
|
[Route("families"), HttpGet]
|
|
public IHttpActionResult GetFamilies()
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
List<DTONcFamilyModel> families = toolsManager.GetFamilies();
|
|
|
|
return Ok(families);
|
|
}
|
|
}
|
|
|
|
[Route("family/{familyId:int}"), HttpPost]
|
|
public IHttpActionResult AddFamily(short familyId)
|
|
{
|
|
// Create default family
|
|
DTONcFamilyModel defaultFamily = new DTONcFamilyModel();
|
|
// Copy data from static obj configured
|
|
SupportFunctions.CopyProperties(DTO_TOOL_WITH_FAM, defaultFamily);
|
|
defaultFamily.Id = familyId;
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
DTONcFamilyModel newFamily = ncAdapter.AddFamily(defaultFamily);
|
|
|
|
return Ok(newFamily);
|
|
}
|
|
}
|
|
|
|
[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();
|
|
|
|
// Check if tools are mounted in spindle
|
|
foreach (var tool in family.Tools)
|
|
{
|
|
if (ToolIsInSpindle(tool.ToolId))
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
// Update into db and NC
|
|
cmsError = ncAdapter.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();
|
|
|
|
// Check if tools are mounted in spindle
|
|
foreach (var tool in family.Tools)
|
|
{
|
|
//
|
|
var t = toolsManager.FindToolWithDependencies(tool.ToolId);
|
|
if(t.Shank != null && t.Shank.MagazineId != null && t.Shank.PositionId != null)
|
|
return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
|
|
//if (ToolIsInSpindle(tool.ToolId))
|
|
// return BadRequest(API_ERROR_KEYS.TOOL_IS_MOUNTED);
|
|
}
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
//Delete
|
|
cmsError = ncAdapter.DeleteNcFamily(familyId);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Families
|
|
|
|
#region Magazine positions
|
|
|
|
[Route("magazines_positions"), HttpGet]
|
|
public IHttpActionResult GetMagazinesPositions()
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
List<DbNcMagazinePositionModel> magazines = toolsManager.FindMagazinesPositions();
|
|
|
|
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]ushort 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 (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
CmsError cmsError = ncAdapter.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 GetAvailableShanks()
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
List<DTONcShankModel> shanks = new List<DTONcShankModel>();
|
|
|
|
shanks = toolsManager.GetAvailableShanksWithChilds();
|
|
|
|
return Ok(shanks);
|
|
}
|
|
}
|
|
|
|
[Route("magazine/available_tools"), HttpGet]
|
|
public IHttpActionResult GetAvailableTools()
|
|
{
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
List<DTONcToolModel> tools = toolsManager.GetAvailableTools();
|
|
|
|
return Ok(tools);
|
|
}
|
|
}
|
|
|
|
[Route("magazine/{magazineId:int}/load/position/{positionId:int}"), HttpPut]
|
|
public IHttpActionResult LoadToolInToMagazine(byte magazineId, ushort positionId, [FromBody][Required] DTONcUpdateMagazineModel shankId)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
if (shankId.ShankId == 0)
|
|
return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
DTONcShankModel dtoShank = new DTONcShankModel();
|
|
|
|
// Check data
|
|
DbNcShankModel shank;
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Check if shank exists
|
|
shank = toolsManager.FindShankWithTools(shankId.ShankId);
|
|
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 position type
|
|
//if (shank.Tools.FirstOrDefault().Family.ToolType != magPos.Type)
|
|
// return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
// Check if the mag pos is disabled
|
|
if (magPos.Disabled == true)
|
|
return BadRequest(API_ERROR_KEYS.MAG_POS_DISABLED);
|
|
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
// Get Configuration
|
|
ncAdapter.Connect();
|
|
|
|
// Check if shank can fit
|
|
CmsError cmsError = ncAdapter.CheckIfShankCanFit(
|
|
magazineId,
|
|
positionId,
|
|
shank // mounted tools
|
|
);
|
|
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
dtoShank = toolsManager.GetShank(shank.ShankId);
|
|
}
|
|
|
|
// Update shank data
|
|
DTONcMagazinePositionModel magazinePos = (DTONcMagazinePositionModel)toolsManager.LoadShankInMagazine(magazineId, positionId, shank);
|
|
// Set shankId
|
|
magazinePos.ShankId = shank.ShankId;
|
|
|
|
dtoShank.MagazineId = magazineId;
|
|
dtoShank.PositionId = positionId;
|
|
dtoShank.OriginMagazineId = magazineId;
|
|
dtoShank.OriginPositionId = positionId;
|
|
|
|
return Ok(dtoShank);
|
|
}
|
|
}
|
|
|
|
[Route("magazine/{magazineId:int}/unload/position/{positionId:int}"), HttpPut]
|
|
public IHttpActionResult UnloadToolInToMagazine(byte magazineId, ushort positionId, [FromBody][Required] DTONcUpdateMagazineModel shankId)
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
if (shankId.ShankId == 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.ShankId);
|
|
if (shank == null)
|
|
return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
// Check if tools are mounted in spindle
|
|
foreach (var tool in shank.Tools)
|
|
{
|
|
if (ToolIsInSpindle(tool.ToolId))
|
|
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);
|
|
|
|
// Check if magazine position is not occupied
|
|
DbNcShankModel shankMounted = toolsManager.FindShanksByPositions(magazineId, positionId);
|
|
if (shankMounted == null)
|
|
return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
DTONcMagazinePositionModel magazinePos = (DTONcMagazinePositionModel)toolsManager.UnloadShankInMagazine(magazineId, positionId, shank);
|
|
|
|
return Ok(magazinePos);
|
|
}
|
|
}
|
|
|
|
[Route("shank/{shankId:int}/load/tool/{toolId:int}"), HttpPut]
|
|
public IHttpActionResult LoadToolIntoShank(short 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 (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
DTONcShankModel shank = ncAdapter.LoadIntoShank(tool, shankId);
|
|
|
|
return Ok(shank);
|
|
}
|
|
}
|
|
|
|
[Route("shank/{shankId:int}/unload/tool/{toolId:int}"), HttpPut]
|
|
public IHttpActionResult UnloadToolIntoShank(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 (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
DTONcShankModel shank = ncAdapter.UnloadFromShank(tool);
|
|
|
|
return Ok(shank);
|
|
}
|
|
}
|
|
|
|
[Route("start_edit_tooling/{magazineId:int}"), HttpPut]
|
|
public IHttpActionResult StartEditTooling(int magazineId)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
CmsError cmsError = ncAdapter.StartEditTooling(magazineId);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
|
|
[Route("stop_edit_tooling/{magazineId:int}"), HttpPut]
|
|
public IHttpActionResult StopEditTooling(int magazineId)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
Stopwatch st = new Stopwatch();
|
|
st.Restart();
|
|
CmsError cmsError = ncAdapter.StopEditTooling(magazineId);
|
|
Console.WriteLine("TOOL TABLE WRITE TIME " + st.ElapsedMilliseconds);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
|
|
[Route("assisted_tooling/"), HttpPost]
|
|
public IHttpActionResult StartAssistedTooling(DTOAssistedToolingModel data)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
ncAdapter.Connect();
|
|
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
var tool = toolsManager.FindTool(data.ToolId);
|
|
if (tool == null)
|
|
return BadRequest();
|
|
|
|
CmsError cmsError = ncAdapter.StartAssistedToolingProcedure(data.ToolId, (ushort)tool.FamilyId, (ushort)tool.ShankId, data.MagazineId, data.PositionId, data.Action);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
}
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
|
|
[Route("export"), HttpPost]
|
|
public IHttpActionResult ExportToolTable()
|
|
{
|
|
if (!ModelState.IsValid)
|
|
return BadRequest(ModelState);
|
|
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
DTOExportToolTableModel expData = toolsManager.GetExportData();
|
|
|
|
return Ok(expData);
|
|
}
|
|
}
|
|
|
|
[Route("import"), HttpPost]
|
|
public async Task<IHttpActionResult> ImportToolTable()
|
|
{
|
|
// Check whether the POST operation is MultiPart?
|
|
if (!Request.Content.IsMimeMultipartContent())
|
|
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
|
|
|
|
var filesReadToProvider = await Request.Content.ReadAsMultipartAsync();
|
|
|
|
var stream = filesReadToProvider.Contents.FirstOrDefault();
|
|
if (stream == null)
|
|
return BadRequest();
|
|
|
|
var fileBytes = await stream.ReadAsByteArrayAsync();
|
|
|
|
// Convert bytes into json string
|
|
string jsonString = Encoding.UTF8.GetString(fileBytes);
|
|
|
|
bool val = IsValidJson(jsonString, out DTOExportToolTableModel importData);
|
|
if (!val)
|
|
return BadRequest(API_ERROR_KEYS.IMPORT_FILE_NOT_VALID);
|
|
|
|
if(importData.Families == null || importData.Shanks == null || importData.Tools == null)
|
|
return BadRequest(API_ERROR_KEYS.IMPORT_FILE_NOT_VALID);
|
|
|
|
using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
{
|
|
// Import data in the database
|
|
List <DTOImportStatusModel> importStatus = toolsManager.ImportData(importData);
|
|
|
|
return Ok(importStatus);
|
|
}
|
|
}
|
|
|
|
[Route("selfadaptivepathstep"), HttpGet]
|
|
public IHttpActionResult GetSelfAdaptivePathStep()
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
DTOSelfAdaptiveModel sam;
|
|
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
cmsError = ncAdapter.GetSelfAdaptiveStep(out sam);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok(sam);
|
|
}
|
|
}
|
|
|
|
[Route("selfadaptivepathstep"), HttpPut]
|
|
public IHttpActionResult SetSelfAdaptivePathStep([FromBody][Required]DTOSelfAdaptiveModel dtoSelfAdaptiveModel)
|
|
{
|
|
using (NcToolTableAdapter ncAdapter = new NcToolTableAdapter())
|
|
{
|
|
CmsError cmsError = ncAdapter.Connect();
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
cmsError = ncAdapter.SetSelfAdaptiveStep(dtoSelfAdaptiveModel);
|
|
if (cmsError.IsError())
|
|
return BadRequest(cmsError.localizationKey);
|
|
|
|
return Ok();
|
|
}
|
|
}
|
|
#region Private Functions
|
|
|
|
private static DTONcToolWithFamilyModel DTO_TOOL_WITH_FAM = new DTONcToolWithFamilyModel()
|
|
{
|
|
Id = 0,
|
|
Name = DEFAULT_FAM_NAME,
|
|
OffsetId1 = null,
|
|
OffsetId2 = null,
|
|
OffsetId3 = null,
|
|
LeftSize = 1,
|
|
RightSize = 1
|
|
};
|
|
|
|
private bool IsValidJson(string jsonString, out DTOExportToolTableModel data)
|
|
{
|
|
data = new DTOExportToolTableModel();
|
|
if (string.IsNullOrWhiteSpace(jsonString))
|
|
return false;
|
|
|
|
try
|
|
{
|
|
// Deserialize the string into DTO object
|
|
data = JsonConvert.DeserializeObject<DTOExportToolTableModel>(jsonString);
|
|
return true;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONewNcToolWithFamilyModel familyData)
|
|
{
|
|
DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
|
|
// Copy family fields
|
|
SupportFunctions.CopyProperties(familyData, familyTool);
|
|
// Copy tool fields
|
|
SupportFunctions.CopyProperties(tool, familyTool);
|
|
|
|
return familyTool;
|
|
}
|
|
|
|
private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONcToolWithFamilyModel familyData)
|
|
{
|
|
DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
|
|
// Copy family fields
|
|
SupportFunctions.CopyProperties(familyData, familyTool);
|
|
// Copy tool fields
|
|
SupportFunctions.CopyProperties(tool, familyTool);
|
|
|
|
return familyTool;
|
|
}
|
|
|
|
private DTONcToolWithFamilyModel CreateToolAndFamilyObj(DTONcToolModel tool, DTONcFamilyModel familyData)
|
|
{
|
|
DTONcToolWithFamilyModel familyTool = new DTONcToolWithFamilyModel();
|
|
// Copy family fields
|
|
SupportFunctions.CopyProperties(familyData, familyTool);
|
|
// Copy tool fields
|
|
SupportFunctions.CopyProperties(tool, familyTool);
|
|
|
|
return familyTool;
|
|
}
|
|
|
|
private bool ToolIsInSpindle(int toolId)
|
|
{
|
|
foreach (var head in LastHeadsData.ToList())
|
|
{
|
|
if (head is DTOSpindleModel)
|
|
{
|
|
var spindle = head as DTOSpindleModel;
|
|
if (!spindle.FixedHead && spindle.MountedTool == toolId)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
//[Route("tool_old"), HttpPost]
|
|
//public IHttpActionResult AddTool([FromBody][Required]DTONewNcToolWithFamilyModel dtoToolWithFamily)
|
|
//{
|
|
// if (!ModelState.IsValid)
|
|
// return BadRequest(ModelState);
|
|
|
|
// short familyId = 0;
|
|
// using (NcToolManagerController toolsManager = new NcToolManagerController())
|
|
// {
|
|
// // Check if option is active
|
|
// if (ToolManagerConfig.FamilyOpt)
|
|
// {
|
|
// if (dtoToolWithFamily.FamilyId == 0)
|
|
// {
|
|
// // If param equal to 0 create a new family
|
|
// DTONcFamilyModel newFamily = new DTONcFamilyModel() { Name = "NewFamily", LeftSize = 1, RightSize = 1 };
|
|
// // Add new family & update family id
|
|
// DbNcFamilyModel newFam = toolsManager.AddFamily(newFamily);
|
|
// dtoToolWithFamily.FamilyId = newFam.FamilyId;
|
|
// dtoToolWithFamily.Name = newFam.Name;
|
|
// }
|
|
// else
|
|
// {
|
|
// // Check if family exists
|
|
// DbNcFamilyModel fam = toolsManager.FindFamily(dtoToolWithFamily.FamilyId);
|
|
// if (fam == null)
|
|
// return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
|
|
// // Update return data
|
|
// if (ToolManagerConfig.FamilyOpt)
|
|
// {
|
|
// dtoToolWithFamily.Name = fam.Name;
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// // Copy only family data from tool&fam model
|
|
// DTONcFamilyModel newFamily = new DTONcFamilyModel();
|
|
// SupportFunctions.CopyProperties(dtoToolWithFamily, newFamily);
|
|
|
|
// // Add new family
|
|
// DbNcFamilyModel dbFam = toolsManager.AddFamily(newFamily);
|
|
// if (dbFam == null)
|
|
// return BadRequest(API_ERROR_KEYS.INCORRECT_PARAMETERS);
|
|
// dtoToolWithFamily.FamilyId = dbFam.FamilyId;
|
|
|
|
// // Set common id
|
|
// familyId = dbFam.FamilyId;
|
|
// }
|
|
|
|
// // Check if option is active
|
|
// if (!ToolManagerConfig.ShankOpt)
|
|
// {
|
|
// // If option is not active create a shank
|
|
// DTONewNcShankModel newShank = new DTONewNcShankModel()
|
|
// {
|
|
// Balluf = 0,
|
|
// MagazinePositionType = 0
|
|
// };
|
|
|
|
// // Create a new shank
|
|
// DbNcShankModel ncShank = toolsManager.AddShank(newShank, familyId);
|
|
// // Connect tool to new shank
|
|
// dtoToolWithFamily.ShankId = ncShank.ShankId;
|
|
// }
|
|
// else
|
|
// dtoToolWithFamily.ShankId = null;
|
|
// }
|
|
|
|
// using (ncAdapter ncAdapter = new ncAdapter())
|
|
// {
|
|
// ncAdapter.Connect();
|
|
|
|
// // Add tool
|
|
// CmsError cmsError = ncAdapter.AddTool(dtoToolWithFamily, out DTONcToolModel newTool, familyId);
|
|
// if (cmsError.IsError())
|
|
// return BadRequest(cmsError.localizationKey);
|
|
|
|
// return Ok(CreateToolAndFamilyObj(newTool, dtoToolWithFamily));
|
|
// }
|
|
//}
|
|
|
|
} |