UploadInformation.cs

using System;
using System.Collections.Generic;
using Waher.Persistence;
 
namespace Waher.Networking.XMPP.Server.HttpFileUpload
{
    internal enum CanUploadResult
    {
        Permitted,
 
        FileQuotaReached,
 
        ByteQuotaReached
    }
 
    internal class UploadInformation
    {
        private readonly CaseInsensitiveString bareJid;
        private long byteCount;
        private int fileCount;
        private DateTime startedAt;
        private readonly object synchObject;
        private LinkedList<SpecialFile> specialFiles;
 
        public UploadInformation(CaseInsensitiveString BareJid)
        {
            this.bareJid = BareJid;
            this.byteCount = 0;
            this.fileCount = 0;
            this.startedAt = DateTime.MinValue;
            this.synchObject = new object();
            this.specialFiles = null;
        }
 
        public CaseInsensitiveString BareJid => this.bareJid;
 
        public CanUploadResult CanUploadFile(long Size, FilePurpose Purpose, HttpFileUploadSettings Settings)
        {
            lock (this.synchObject)
            {
                switch (Purpose)
                {
                    case FilePurpose.Temporary:
                        DateTime Now = DateTime.Now;
                        TimeSpan TS = Now - this.startedAt;
 
                        if (TS.TotalMinutes >= 1.0)
                        {
                            this.startedAt = Now;
                            this.byteCount = 0;
                            this.fileCount = 0;
                        }
 
                        if (this.fileCount >= Settings.MaxFilesPerMinute)
                            return CanUploadResult.FileQuotaReached;
 
                        if (this.byteCount + Size > Settings.MaxBytesPerMinute)
                            return CanUploadResult.ByteQuotaReached;
 
                        break;
 
                    case FilePurpose.Backup:
                        if (string.IsNullOrEmpty(Settings.KeyFolder) || string.IsNullOrEmpty(Settings.BackupFolder))
                            return CanUploadResult.FileQuotaReached;
                        break;
 
                    case FilePurpose.Encrypted:
                        if (string.IsNullOrEmpty(Settings.EncryptedStorageFolder) || string.IsNullOrEmpty(Settings.EncryptedStorageRoot))
                            return CanUploadResult.FileQuotaReached;
                        break;
 
                    case FilePurpose.PubSub:
                        if (string.IsNullOrEmpty(Settings.PubSubStorageFolder) || string.IsNullOrEmpty(Settings.PubSubStorageRoot))
                            return CanUploadResult.FileQuotaReached;
                        break;
 
                    case FilePurpose.InternalTransfer:
                        if (string.IsNullOrEmpty(Settings.InternalTransferFolder) || string.IsNullOrEmpty(Settings.InternalTransferRoot))
                            return CanUploadResult.FileQuotaReached;
                        break;
                }
 
                this.fileCount++;
                this.byteCount += Size;
 
                return 0;
            }
        }
 
        public bool TryGetSpecialFile(string FileName, string FileContentType, long FileSize, out SpecialFile Result)
        {
            lock (this.synchObject)
            {
                if (!(this.specialFiles is null))
                {
                    foreach (SpecialFile Rec in this.specialFiles)
                    {
                        if (Rec.FileName == FileName && Rec.FileContentType == FileContentType && Rec.FileSize == FileSize)
                        {
                            Result = Rec;
                            return true;
                        }
                    }
                }
            }
 
            Result = null;
            return false;
        }
 
        public void AddSpecialFile(string FileName, string FileContentType, long FileSize, FilePurpose Purpose)
        {
            lock (this.synchObject)
            {
                if (!(this.specialFiles is null))
                {
                    foreach (SpecialFile Rec in this.specialFiles)
                    {
                        if (Rec.FileName == FileName && Rec.FileContentType == FileContentType && Rec.FileSize == FileSize)
                        {
                            Rec.Purpose = Purpose;
                            return;
                        }
                    }
                }
 
                if (this.specialFiles is null)
                    this.specialFiles = new LinkedList<SpecialFile>();
 
                this.specialFiles.AddLast(new SpecialFile(Purpose, FileName, FileContentType, FileSize));
            }
        }
 
        public bool RemoveSpecialFile(string FileName, string FileContentType, long FileSize)
        {
            lock (this.synchObject)
            {
                if (!(this.specialFiles is null))
                {
                    LinkedListNode<SpecialFile> Loop = this.specialFiles.First;
 
                    while (!(Loop is null) &&
                        (Loop.Value.FileName != FileName ||
                        Loop.Value.FileContentType != FileContentType ||
                        Loop.Value.FileSize != FileSize))
                    {
                        Loop = Loop.Next;
                    }
 
                    if (!(Loop is null))
                    {
                        this.specialFiles.Remove(Loop);
                        return true;
                    }
                }
 
                return false;
            }
        }
 
    }
}