QuickLoginAttachment.cs

using SkiaSharp;
using System;
using System.Security.Cryptography;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Networking.HTTP;
using Waher.Persistence.Attributes;
using Waher.Runtime.IO;
 
namespace Waher.Service.IoTBroker.Legal.MFA
{
    [CollectionName("QuickLoginAttachments")]
    [Index("AttachmentId", "Width", "Height")]
    public class QuickLoginAttachment
    {
        public QuickLoginAttachment()
        {
        }
 
        [ObjectId]
        public string ObjectId { get; set; }
 
        public string AttachmentId { get; set; }
 
        public int? Width { get; set; }
 
        public int? Height { get; set; }
 
        public string ETag { get; set; }
 
        public string FileName { get; set; }
 
        public string ContentType { get; set; }
 
        public byte[] Key { get; set; }
 
        public byte[] IV { get; set; }
 
        internal async Task<byte[]> Load()
        {
            Aes Aes = Aes.Create();
 
            Aes.BlockSize = 128;
            Aes.KeySize = 256;
            Aes.Mode = CipherMode.CBC;
            Aes.Padding = PaddingMode.PKCS7;
 
            byte[] Encrypted = await Files.ReadAllBytesAsync(this.FileName);
            using ICryptoTransform Decryptor = Aes.CreateDecryptor(this.Key, this.IV);
 
            return Decryptor.TransformFinalBlock(Encrypted, 0, Encrypted.Length);
        }
 
        internal async Task Return(HttpRequest Request, HttpResponse Response)
        {
            if (!(Request.Header.IfNoneMatch is null) && Request.Header.IfNoneMatch.Value == this.ETag)
                await Response.SendResponse(new NotModifiedException());
            else
            {
                Response.SetHeader("ETag", "\"" + this.ETag + "\"");
 
                byte[] Decrypted = await this.Load();
 
                await Response.Return(this.ContentType, true, Decrypted);
            }
        }
 
        internal async Task<ContentResponse> Scale(int Width, int Height)
        {
            if (!this.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
                return new ContentResponse(new UnsupportedMediaTypeException("Not an image attachment."));
 
            byte[] Original = await this.Load();
 
            ContentResponse Decoded = await InternetContent.DecodeAsync(this.ContentType, Original, null);
            if (Decoded.HasError)
                return Decoded;
 
            if (!(Decoded.Decoded is SKImage Image))
                return new ContentResponse(new UnsupportedMediaTypeException("Not an image attachment."));
 
            double ScaleX = ((double)Width) / Image.Width;
            double ScaleY = ((double)Height) / Image.Height;
            double Scale = Math.Min(ScaleX, ScaleY);
            int W = (int)(Image.Width * Scale + 0.5);
            int H = (int)(Image.Height * Scale + 0.5);
 
            using SKSurface Surface = SKSurface.Create(new SKImageInfo(W, H, SKImageInfo.PlatformColorType, SKAlphaType.Premul));
 
            SKCanvas Canvas = Surface.Canvas;
            SKPaint Paint = new SKPaint()
            {
                IsAntialias = true
            };
 
            SKSamplingOptions Options = new SKSamplingOptions(SKCubicResampler.Mitchell);
 
            Canvas.DrawImage(Image, new SKRect(0, 0, W, H), Options, Paint);
 
            using SKImage ScaledImage = Surface.Snapshot();
 
            return await InternetContent.EncodeAsync(ScaledImage, null);
        }
 
    }
}