CancelMachineHandler

src/api/NetworkResurrector.Api.Application/CommandHandlers/CancelActionHandler.cs

@@ -0,0 +1,64 @@
+using MediatR;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using NetworkResurrector.Agent.PublishedLanguage.Dto;
+using NetworkResurrector.Agent.Wrapper.Services;
+using NetworkResurrector.Api.Domain.Constants;
+using NetworkResurrector.Api.Domain.Repositories;
+using NetworkResurrector.Api.PublishedLanguage.Commands;
+using NetworkResurrector.Api.PublishedLanguage.Events;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NetworkResurrector.Api.Application.CommandHandlers
+{
+    public class CancelMachineHandler : IRequestHandler<CancelAction, ActionCanceled>
+    {
+        private readonly ILogger<CancelMachineHandler> _logger;
+        private readonly INetworkRepository _repository;
+        private readonly IResurrectorAgentService _resurrectorAgentService;
+        private readonly IConfiguration _configuration;
+
+        public CancelMachineHandler(ILogger<CancelMachineHandler> logger, INetworkRepository repository, IResurrectorAgentService resurrectorAgentService, IConfiguration configuration)
+        {
+            _logger=logger;
+            _repository=repository;
+            _resurrectorAgentService=resurrectorAgentService;
+            _configuration=configuration;
+        }
+
+        public async Task<ActionCanceled> Handle(CancelAction command, CancellationToken cancellationToken)
+        {
+            var powerConfiguration = await _repository.GetPowerActionConfiguration(command.MachineId, command.ActionId);
+            _logger.LogDebug($"Start canceling action '{powerConfiguration.PowerAction.PowerActionCode}' for machine {command.MachineId}");
+
+            var machine = await _repository.GetMachine(command.MachineId);
+
+            //log activity
+
+            var ipAddressOrMachineName = machine.IPv4Address ?? machine.MachineName;
+            ActionCanceled result;
+
+            switch (powerConfiguration.Performer.PerformerCode)
+            {
+                case PowerActionPerformers.NETWORK_RESURRECTOR_AGENT:
+                    if (machine.Agent == null)
+                        throw new Exception($"Cannot use network resurrector agent as cancel performer for action '{powerConfiguration.PowerAction.PowerActionCode}' and machine '{ipAddressOrMachineName}' because it is not configured.");
+
+                    var owner = new ActionOwner(_configuration.GetValue<string>("Service:Code"));
+                    var cancelResultByAgent = await _resurrectorAgentService.Cancel(ipAddressOrMachineName, machine.Agent.AgentPort, owner);
+                    var status = cancelResultByAgent.Success ? $"Action '{powerConfiguration.PowerAction.PowerActionCode}' successfully canceled for machine '{ipAddressOrMachineName}'." : $"Action '{powerConfiguration.PowerAction.PowerActionCode}' could not be canceled for machine '{ipAddressOrMachineName}'.";
+                    result = new ActionCanceled(cancelResultByAgent.Success, status);
+                    break;
+
+                default:
+                    throw new Exception($"Power action performer {powerConfiguration.Performer.PerformerCode} is not implemented.");
+            }
+
+            _logger.LogDebug($"Action '{powerConfiguration.PowerAction.PowerActionCode}' cancellation finished for machine {command.MachineId}. Success: {result.Success}; Status: {result.Status}");
+
+            return result;
+        }
+    }
+}

src/api/NetworkResurrector.Api.Application/CommandHandlers/LogoutUserHandler.cs

@@ -46,9 +46,9 @@ namespace NetworkResurrector.Api.Application.CommandHandlers
                         throw new Exception($"Cannot use network resurrector agent as logout performer for machine '{ipAddressOrMachineName}' because it is not configured.");
 
                     var owner = new ActionOwner(_configuration.GetValue<string>("Service:Code"));
-                    var LogoutResultByAgent = await _resurrectorAgentService.Logout(ipAddressOrMachineName, machine.Agent.AgentPort, owner);
+                    var logoutResultByAgent = await _resurrectorAgentService.Logout(ipAddressOrMachineName, machine.Agent.AgentPort, owner);
-                    var status = LogoutResultByAgent.Success ? $"The user from machine '{ipAddressOrMachineName}' was successfully logged out." : $"The user from machine '{ipAddressOrMachineName}' could not be logged out.";
+                    var status = logoutResultByAgent.Success ? $"The user from machine '{ipAddressOrMachineName}' was successfully logged out." : $"The user from machine '{ipAddressOrMachineName}' could not be logged out.";
-                    result = new UserLoggedOut(LogoutResultByAgent.Success, status);
+                    result = new UserLoggedOut(logoutResultByAgent.Success, status);
                     break;
 
                 default:

src/api/NetworkResurrector.Api.Domain.Data/Repositories/NetworkRepository.cs

@@ -43,5 +43,18 @@ namespace NetworkResurrector.Api.Domain.Data.Repositories
 
             return config;
         }
+
+        public async Task<PowerActionConfiguration> GetPowerActionConfiguration(int machineId, int actionId)
+        {
+            var config = await _dbContext.PowerActionConfigurations
+                .Include(z => z.PowerAction)
+                .Include(z => z.Performer)
+                .FirstOrDefaultAsync(z => z.MachineId == machineId && z.PowerActionId == actionId);
+
+            if (config == null)
+                throw new Exception($"Action '{actionId}' is not configured for machine '{machineId}'.");
+
+            return config;
+        }
     }
 }

src/api/NetworkResurrector.Api.Domain/Repositories/INetworkRepository.cs

@@ -9,5 +9,6 @@ namespace NetworkResurrector.Api.Domain.Repositories
         Task<Machine[]> GetMachines();
         Task<Machine> GetMachine(int machineId);
         Task<PowerActionConfiguration> GetPowerActionConfiguration(int machineId, string actionCode);
+        Task<PowerActionConfiguration> GetPowerActionConfiguration(int machineId, int actionId);
     }
 }

src/api/NetworkResurrector.Api.PublishedLanguage/Commands/CancelAction.cs

@@ -0,0 +1,11 @@
+using NDB.Application.DataContracts;
+using NetworkResurrector.Api.PublishedLanguage.Events;
+
+namespace NetworkResurrector.Api.PublishedLanguage.Commands
+{
+    public class CancelAction : Command<ActionCanceled>
+    {
+        public int MachineId { get; set; }
+        public int ActionId { get; set; }
+    }
+}

src/api/NetworkResurrector.Api.PublishedLanguage/Events/ActionCanceled.cs

@@ -0,0 +1,4 @@
+namespace NetworkResurrector.Api.PublishedLanguage.Events
+{
+    public record ActionCanceled(bool Success, string Status);
+}

src/api/NetworkResurrector.Api/Controllers/ResurrectorController.cs

@@ -53,11 +53,25 @@ namespace NetworkResurrector.Api.Controllers
             return Ok(result);
         }
 
+        [HttpPost("logout")]
+        public async Task<IActionResult> LogoutUser([FromBody] LogoutUser logoutUser)
+        {
+            var result = await _mediator.Send(logoutUser);
+            return Ok(result);
+        }
+
         [HttpPost("lock")]
         public async Task<IActionResult> LockMachine([FromBody] LockMachine lockMachine)
         {
             var result = await _mediator.Send(lockMachine);
             return Ok(result);
         }
+
+        [HttpPost("cancel")]
+        public async Task<IActionResult> CancelAction([FromBody] CancelAction cancelAction)
+        {
+            var result = await _mediator.Send(cancelAction);
+            return Ok(result);
+        }
     }
 }