UploadPackage.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.HeaderFields;
using Waher.Runtime.Temporary;
using Waher.Script;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class UploadPackage : HttpSynchronousResource, IHttpPostMethod
    {
        internal static readonly Dictionary<string, UploadRec> packageFilePerSession = new Dictionary<string, UploadRec>();
        private static int expectedBlockPackage = 0;
 
        public UploadPackage()
            : base("/UploadPackage")
        {
        }
 
        internal class UploadRec
        {
            public TemporaryFile File;
            public bool MakeDownloadable;
        }
 
        public override bool HandlesSubPaths => false;
        public override bool UserSessions => true;
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            KeyValuePair<bool, int> P = await Upload(Request, Response, expectedBlockPackage, packageFilePerSession, "package", true);
            expectedBlockPackage = P.Value;
        }
 
        internal static void RemoveFile(string Key, Dictionary<string, UploadRec> Files)
        {
            lock (Files)
            {
                if (Files.TryGetValue(Key, out UploadRec Rec))
                {
                    Files.Remove(Key);
                    Rec.File.Dispose();
                }
            }
        }
 
        internal static async Task<KeyValuePair<bool, int>> Upload(HttpRequest Request, HttpResponse Response, int ExpectedBlockNr,
            Dictionary<string, UploadRec> Files, string Name, bool PushToClient)
        {
            Gateway.AssertUserAuthenticated(Request, "Admin.Software.Upload");
 
            UploadRec Rec;
            string TabID;
            string HttpSessionID;
            string FileName;
 
            if (!Request.HasData ||
                !Request.Header.TryGetHeaderField("X-TabID", out HttpField F) || string.IsNullOrEmpty(TabID = F.Value) ||
                !Request.Header.TryGetHeaderField("X-BlockNr", out F) || !int.TryParse(F.Value, out int BlockNr) ||
                !Request.Header.TryGetHeaderField("X-More", out F) || !CommonTypes.TryParse(F.Value, out bool More) ||
                string.IsNullOrEmpty(HttpSessionID = GetSessionId(Request, Response)))
            {
                throw new BadRequestException();
            }
 
            if (!Request.Header.TryGetHeaderField("X-Downloadable", out F) || !CommonTypes.TryParse(F.Value, out bool Downloadable))
                Downloadable = false;
 
            if (!Request.Header.TryGetHeaderField("X-GenSign", out F) || !CommonTypes.TryParse(F.Value, out bool GenerateSignature))
                GenerateSignature = false;
 
            if (BlockNr == 0)
            {
                ExpectedBlockNr = 0;
                RemoveFile(HttpSessionID, Files);
 
                if (Request.Header.TryGetHeaderField("X-FileName", out F) && !string.IsNullOrEmpty(FileName = F.Value))
                    Request.Session[Name + "FileName"] = F.Value;
                else
                    throw new BadRequestException();
            }
            else if (Request.Session.TryGetVariable(Name + "FileName", out Variable v))
                FileName = v.ValueObject as string;
            else
                throw new BadRequestException();
 
            if (BlockNr != ExpectedBlockNr)
                throw new BadRequestException();
 
            ExpectedBlockNr++;
 
            lock (Files)
            {
                if (!Files.TryGetValue(HttpSessionID, out Rec))
                {
                    Rec = new UploadRec()
                    {
                        File = new TemporaryFile(),
                        MakeDownloadable = Downloadable
                    };
 
                    Files[HttpSessionID] = Rec;
                }
                else
                    Rec.MakeDownloadable |= Downloadable;
            }
 
            try
            {
                await Request.DataStream.CopyToAsync(Rec.File);
 
                long FileLength = Rec.File.Length;
 
                if (!More)
                {
                    Rec.File.Flush();
 
                    if (GenerateSignature)
                    {
                        Rec.File.Position = 0;
                        byte[] Signature = XmppServerModule.Legal.Sign(Rec.File);
 
                        await UploadSignature.CopyPackage(Rec, Signature, TabID, FileName, Request.RemoteEndPoint);
 
                        RemoveFile(HttpSessionID, Files);
                    }
                }
 
                if (PushToClient)
                {
                    await ClientEvents.PushEvent(new string[] { TabID }, "UpdatePackage",
                        "{\"fileName\":\"" + CommonTypes.JsonStringEncode(FileName) +
                        "\", \"bytes\": \"" + Export.FormatBytes(FileLength) + "\"}", true, "User");
                }
 
                Response.StatusCode = 200;
            }
            catch (Exception ex)
            {
                await ClientEvents.PushEvent(new string[] { TabID }, "UploadFailed",
                    "{\"fileName\":\"" + CommonTypes.JsonStringEncode(FileName) +
                    "\", \"message\": \"" + CommonTypes.JsonStringEncode(ex.Message) +
                    "\", \"remove\": " + CommonTypes.Encode(PushToClient) + "}", true, "User");
            }
 
            return new KeyValuePair<bool, int>(!More, ExpectedBlockNr);
        }
 
    }
}