CreateReport.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines;
using Waher.Service.IoTBroker.WebServices.Agent.Tokens;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.StateMachines
{
    public enum ReportType
    {
        Present,
 
        History,
 
        StateDiagram,
 
        Profiling
    }
 
    public class CreateReport : AgentPostResource
    {
        public CreateReport()
            : base("StateMachines/CreateReport",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(CreateReport).Namespace + ".JSON.CreateReport.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(CreateReport).Namespace + ".XML.CreateReport.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
            string TokenId = (string)Parameters["PTokenId"].AssociatedObjectValue;
            string ReportTypeStr = (string)Parameters["PReportType"].AssociatedObjectValue;
            string ReportFormatStr = (string)Parameters["PReportFormat"].AssociatedObjectValue;
 
            if (!Enum.TryParse(ReportTypeStr, out ReportType ReportType))
                throw new BadRequestException("Invalid report type.");
 
            if (!Enum.TryParse(ReportFormatStr, out ReportFormat ReportFormat))
                throw new BadRequestException("Invalid report format.");
 
            string BareJid = User.UserName + "@" + Gateway.Domain;
 
            Token Token = await NeuroFeaturesProcessor.GetToken(TokenId, true)
                ?? throw new NotFoundException("Token not found.");
 
            await GetToken.AssertAuthorization(Token, new XmppAddress(BareJid));
 
            StateMachineProcessor.CacheRecord _ = await StateMachineProcessor.GetStateMachine(Token.MachineId)
                ?? throw new NotFoundException("State-Machine not found.");
 
            string Report;
 
            switch (ReportType)
            {
                case ReportType.Present:
                    Report = await StateMachineProcessor.GetPresentReportAsync(Token, ReportFormat);
                    break;
 
                case ReportType.History:
                    Report = await StateMachineProcessor.GetHistoryReportAsync(Token, ReportFormat);
                    break;
 
                case ReportType.StateDiagram:
                    Report = await StateMachineProcessor.GetStateDiagramAsync(Token, ReportFormat);
                    break;
 
                case ReportType.Profiling:
                    Report = await StateMachineProcessor.GetProfilingReportAsync(TokenId, ReportFormat);
                    break;
 
                default:
                    throw new BadRequestException("Unrecognized report type.");
            }
 
            await Response.Return(new NamedDictionary<string, object>("ReportResult", AgentNamespace)
            {
                { "report", Report }
            });
        }
    }
}