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.Counters;
using Waher.Runtime.Threading;
using Waher.Security;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.StateMachines;
 
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)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> Form))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.TryGetValue("contractId", out object Obj) || !(Obj is string ContractId) ||
                !Form.TryGetValue("state", out Obj) || !(Obj is string StateStr) ||
                !Enum.TryParse(StateStr, out ContractState State))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            Dictionary<string, object> Result = await SetState(ContractId, State, User);
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
            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;
            await Contract.Sign(XmppServerModule.Legal);
 
            if (State == ContractState.Deleted)
            {
                await Database.Delete(Contract);
                Message = "Contract deleted.";
 
                if (!(XmppServerModule.Geo is null))
                    await XmppServerModule.Geo.Delete(Contract);
            }
            else
            {
                await Database.Update(Contract);
                Message = "Contract state changed to " + State.ToString() + ".";
 
                switch (State)
                {
                    case ContractState.Approved:
                        if (Contract.CanActAsTemplate)
                            await StateMachineProcessor.ContractTemplateApproved(Contract);
                        break;
 
                    case ContractState.Signed:
                        if (!(XmppServerModule.Geo is null))
                            await XmppServerModule.Geo.Publish(Contract);
                        break;
 
                    case ContractState.Obsoleted:
                    case ContractState.Rejected:
                    case ContractState.Failed:
                        if (!(XmppServerModule.Geo is null))
                            await XmppServerModule.Geo.Publish(Contract);
                        break;
                }
            }
 
            await XmppServerModule.Legal.SendContractUpdatedEvent(Contract, false);
 
            Log.Informational(Message, ContractId, User.UserName,
                new KeyValuePair<string, object>("State", State));
 
            if (Contract.CanActAsTemplate)
                await RuntimeCounters.IncrementCounter("Legal.Template." + Contract.State.ToString());
            else
                await RuntimeCounters.IncrementCounter("Legal.Contract." + Contract.State.ToString());
 
            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) }
                };
        }
    }
}