KillMachine.cs

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Text;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.IoTGateway.WebResources;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Files.Searching;
using Waher.Security;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class KillMachine : HttpSynchronousResource, IHttpPostMethod
    {
        public KillMachine()
            : base("/KillMachine")
        {
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            IUser User = Gateway.AssertUserAuthenticated(Request, "Admin.Notarius.NeuroFeatures");
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> Obj) ||
                !Obj.TryGetValue("tokenId", out object Obj2) || !(Obj2 is string TokenId) ||
                !Obj.TryGetValue("tabId", out Obj2) || !(Obj2 is string TabId))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            Token Token = await Database.FindFirstIgnoreRest<Token>(
                new FilterFieldEqualTo("TokenId", TokenId));
 
            if (Token is null)
            {
                await Response.SendResponse(new NotFoundException());
                return;
            }
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
 
            string LegalId = null;
            int? Result = null;
 
            if (User is Security.Users.User AdminUser)
            {
                if (string.IsNullOrEmpty(AdminUser.LegalId))
                    Result = -2;
                else
                    LegalId = AdminUser.LegalId;
            }
            else if (User is AccountUser AccountUser)
            {
                if (CaseInsensitiveString.IsNullOrEmpty(AccountUser.Account.LatestIdentity))
                    Result = -2;
                else if (!AccountUser.Account.LatestIdentityState.HasValue)
                    Result = -3;
                else if (AccountUser.Account.LatestIdentityState.Value != Legal.Identity.IdentityState.Approved)
                    Result = -4;
                else
                    LegalId = AccountUser.Account.LatestIdentity;
            }
            else if (User.GetType().FullName == typeof(Login).FullName + "+InternalUser")
                LegalId = LegalIdentityConfiguration.LatestApprovedLegalIdentity?.Id;
            else
                Result = -1;
 
            if (!Result.HasValue)
            {
                if (string.IsNullOrEmpty(LegalId))
                    Result = -2;
                else
                {
                    Result = await StateMachineProcessor.KillMachine(Token, User,
                        LegalId, Request.RemoteEndPoint,
                        (_, e) =>
                        {
                            return ClientEvents.PushEvent(new string[] { TabId },
                                e.Response ? "RequestAccepted" : "RequestRejected", null);
                        }, null);
                }
            }
 
            await Response.Return(new Dictionary<string, object>()
            {
                { "result", Result.Value }
            });
        }
    }
}