245 lines
11 KiB
C#
245 lines
11 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.SignalR;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using RobotNet.RobotManager.Controllers;
|
|
using RobotNet.RobotManager.Data;
|
|
using RobotNet.RobotManager.Services;
|
|
using RobotNet.RobotManager.Services.OpenACS;
|
|
using RobotNet.RobotShares.Models;
|
|
using RobotNet.Shares;
|
|
|
|
namespace RobotNet.RobotManager.Hubs;
|
|
|
|
[Authorize]
|
|
public class RobotManagerHub(RobotEditorDbContext RobotDb, MapManager MapManager, Services.RobotManager RobotManager, TrafficACS TrafficACS, ILogger<RobotManagerController> Logger) : Hub
|
|
{
|
|
public async Task<MessageResult> MoveToNode(RobotMoveToNodeModel model)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(model.NodeName)) return new(false, "NodeName cannot be empty..");
|
|
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == model.RobotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
|
|
var map = await MapManager.GetMapData(robot.MapId);
|
|
if (!map.IsSuccess) return new(false, map.Message);
|
|
if (map is null || map.Data is null) return new(false, "The robot has not been assigned a map.");
|
|
|
|
var node = map.Data.Nodes.FirstOrDefault(n => n.Name == model.NodeName && n.MapId == map.Data.Id);
|
|
if (node is null) return new(false, "This Node does not exist.");
|
|
|
|
if (robotController.IsWorking) return new(false, "The robot is busy.");
|
|
|
|
var move = await robotController.MoveToNode(node.Name, model.Actions, model.OverrideLastAngle ? model.LastAngle : null);
|
|
if (move.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} di chuyển tới node {model.NodeName} thành công ");
|
|
return new(true);
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} di chuyển tới node {model.NodeName} không thành công thành công do {move.Message}");
|
|
return new(false, move.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi MoveToNode Robot {RobotId} di chuyển tới node {NodeName} xảy ra lỗi: {Message}", model.RobotId, model.NodeName, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult> MoveStraight(RobotMoveStraightModel model)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == model.RobotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
if (robotController.IsWorking) return new(false, "The robot is busy.");
|
|
|
|
var move = robotController.MoveStraight(model.X, model.Y);
|
|
if (move.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} di chuyển tới tọa độ [{model.X} - {model.Y}] thành công ");
|
|
return new(true);
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} di chuyển tới tọa độ [{model.X} - {model.Y}] không thành công thành công do {move.Message}");
|
|
return new(false, "Request failed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi Rotate Robot {RobotId} di chuyển tới tọa độ [{model.X} - {model.Y}] xảy ra lỗi: {Message}", model.RobotId, model.X, model.Y, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult> Rotate(RobotRotateModel model)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == model.RobotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
if (robotController.IsWorking) return new(false, "The robot is busy.");
|
|
|
|
var move = robotController.Rotate(model.Angle);
|
|
if (move.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} quay tới góc {model.Angle} thành công ");
|
|
return new(true);
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Goi Robot {model.RobotId} quay tới góc {model.Angle} không thành công thành công do {move.Message}");
|
|
return new(false, "Request failed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi Rotate Robot {RobotId} quay tới góc {model.Angle} xảy ra lỗi: {Message}", model.RobotId, model.Angle, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult> CancelOrder(string robotId)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == robotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
|
|
var cancel = await robotController.CancelOrder();
|
|
if (cancel.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Hủy bỏ nhiệm vụ của Robot {robotId} thành công ");
|
|
return new(true);
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Hủy bỏ nhiệm vụ của Robot {robotId} không thành công do {cancel.Message}");
|
|
return new(false, "Request failed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi Cancel Order Robot {RobotId} xảy ra lỗi: {Message}", robotId, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult> CancelAction(string robotId)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == robotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
|
|
var cancel = await robotController.CancelAction();
|
|
if (cancel.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Hủy bỏ nhiệm vụ của Robot {robotId} thành công ");
|
|
return new(true);
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Hủy bỏ nhiệm vụ của Robot {robotId} không thành công do {cancel.Message}");
|
|
return new(false, "Request failed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi Cancel Order Robot {RobotId} xảy ra lỗi: {Message}", robotId, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult<string>> InstantAction(RobotInstantActionModel model)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == model.RobotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null || !robotController.IsOnline) return new(false, "The robot is not online.");
|
|
|
|
var instantAction = await robotController.InstantAction(model.Action, false);
|
|
if (instantAction.IsSuccess)
|
|
{
|
|
robotController.Log($"RobotManager API Controller Log: Gửi Action Robot {model.RobotId} thành công ");
|
|
return instantAction;
|
|
}
|
|
robotController.Log($"RobotManager API Controller Log: Gửi Action Robot {model.RobotId} không thành công do {instantAction.Message}");
|
|
return new(false, "Request failed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi InstantAction Robot {RobotId}, Action type {action} xảy ra lỗi: {Message}", model.RobotId, model.Action.ActionType, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<MessageResult<RobotStateModel>> GetState(string robotId)
|
|
{
|
|
try
|
|
{
|
|
var robot = await RobotDb.Robots.FirstOrDefaultAsync(r => r.RobotId == robotId);
|
|
if (robot is null) return new(false, "RobotId does not exist.");
|
|
|
|
var robotController = RobotManager[robot.RobotId];
|
|
if (robotController is null) return new(true, "")
|
|
{
|
|
Data = new()
|
|
{
|
|
RobotId = robotId,
|
|
IsOnline = false,
|
|
MapId = robot.MapId,
|
|
}
|
|
};
|
|
|
|
return new(true)
|
|
{
|
|
Data = new()
|
|
{
|
|
RobotId = robotId,
|
|
MapId = robot.MapId,
|
|
IsOnline = robotController.IsOnline,
|
|
State = robotController.State,
|
|
OrderState = robotController.OrderState,
|
|
NewBaseRequest = robotController.StateMsg.NewBaseRequest,
|
|
NodeStates = [.. robotController.StateMsg.NodeStates],
|
|
EdgeStates = [.. robotController.StateMsg.EdgeStates],
|
|
Loads = [.. robotController.StateMsg.Loads],
|
|
ActionStates = robotController.ActionStates,
|
|
BatteryState = robotController.StateMsg.BatteryState,
|
|
Errors = [.. robotController.StateMsg.Errors],
|
|
Information = [.. robotController.StateMsg.Information],
|
|
SafetyState = robotController.StateMsg.SafetyState,
|
|
AgvPosition = robotController.VisualizationMsg.AgvPosition,
|
|
Velocity = robotController.VisualizationMsg.Velocity,
|
|
}
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("RobotManager API Controller Log: Goi GetState Robot {RobotId} xảy ra lỗi: {Message}", robotId, ex.Message);
|
|
return new(false, "An error occurred.");
|
|
}
|
|
}
|
|
|
|
public async Task<bool> RequestACSIn(string robotId, string id)
|
|
{
|
|
var result = await TrafficACS.RequestIn(robotId, id);
|
|
return result.Data;
|
|
}
|
|
|
|
public async Task<bool> RequestACSOut(string robotId, string id)
|
|
{
|
|
var result = await TrafficACS.RequestOut(robotId, id);
|
|
return result.Data;
|
|
}
|
|
}
|