SetContractState.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Json;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Threading;
using Waher.Script.Constants;
using Waher.Script.Persistence.Functions;
using Waher.Security;
using Waher.Service.IoTBroker.Legal.Contracts;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class SetContractState : HttpSynchronousResource, IHttpPostMethod
    {
        public SetContractState()
            : base("/SetContractState")
        {
        }
 
        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.Contracts");
 
            if (!Request.HasData)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is Dictionary<string, object> Form))
                throw new BadRequestException();
 
            if (!Form.TryGetValue("contractId", out Obj) || !(Obj is string ContractId) ||
                !Form.TryGetValue("state", out Obj) || !(Obj is string StateStr) ||
                !Enum.TryParse(StateStr, out ContractState State))
            {
                throw new BadRequestException();
            }
 
            Dictionary<string, object> Result = await SetState(ContractId, State, User);
 
            Response.StatusCode = 200;
            Response.ContentType = JsonCodec.DefaultContentType;
 
            await Response.Write(JSON.Encode(Result, false));
        }
 
        internal static async Task<Dictionary<string, object>> SetState(string ContractId, ContractState State, IUser User)
        {
            using (Semaphore Semaphore = await Semaphores.BeginWrite("iotsc:" + ContractId.ToLower()))
            {
                Contract Contract = await Database.FindFirstIgnoreRest<Contract>(new FilterFieldEqualTo("ContractId", ContractId))
                    ?? throw new NotFoundException("Contract not found.");
 
                if (Contract.State == State)
                {
                    return new Dictionary<string, object>()
                    {
                        { "message", null }
                    };
                }
 
                DateTime Now = DateTime.Now;
                string Message;
 
                Contract.State = State;
                Contract.Sign(XmppServerModule.Legal);
 
                if (State == ContractState.Deleted)
                {
                    await Database.Delete(Contract);
                    Message = "Contract deleted.";
                }
                else
                {
                    await Database.Update(Contract);
                    Message = "Contract state changed to " + State.ToString() + ".";
                }
 
                await XmppServerModule.Legal.SendContractUpdatedEvent(Contract, false);
 
                Log.Informational(Message, ContractId, User.UserName,
                    new KeyValuePair<string, object>("State", State));
 
                return new Dictionary<string, object>()
                {
                    { "date",  Now.ToShortDateString() },
                    { "time",  Now.ToLongTimeString() },
                    { "type",  EventType.Informational },
                    { "object",  ContractId },
                    { "actor",  User.UserName },
                    { "message",  Message },
                    { "signDate",  Contract.ServerSignature.Timestamp.ToShortDateString() },
                    { "signTime",  Contract.ServerSignature.Timestamp.ToLongTimeString() },
                    { "signature",  Convert.ToBase64String(Contract.ServerSignature.DigitalSignature) }
                };
            }
        }
    }
}