AttachmentInfo.cs

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using Waher.Networking.XMPP.Contracts;
using Waher.Runtime.Temporary;
 
namespace LegalLab.Models.Legal.Items
{
    public class AttachmentInfo : Model
    {
        private readonly ContractModel contractModel;
        private readonly Attachment attachment;
        private readonly Property<string> id;
        private readonly Property<string> legalId;
        private readonly Property<string> contentType;
        private readonly Property<string> fileName;
        private readonly Property<string> url;
        private readonly Property<byte[]> signature;
        private readonly Property<DateTime> timestamp;
 
        private readonly Command downloadAttachment;
        private readonly Command removeAttachment;
 
        public AttachmentInfo(ContractModel ContractModel, Attachment Attachment)
        {
            this.contractModel = ContractModel;
            this.attachment = Attachment;
 
            this.id = new Property<string>(nameof(this.Id), Attachment.Id, this);
            this.legalId = new Property<string>(nameof(this.LegalId), Attachment.LegalId, this);
            this.contentType = new Property<string>(nameof(this.ContentType), Attachment.ContentType, this);
            this.fileName = new Property<string>(nameof(this.FileName), Attachment.FileName, this);
            this.url = new Property<string>(nameof(this.Url), Attachment.Url, this);
            this.signature = new Property<byte[]>(nameof(this.Signature), Attachment.Signature, this);
            this.timestamp = new Property<DateTime>(nameof(this.Timestamp), Attachment.Timestamp, this);
 
            this.downloadAttachment = new Command(this.CanExecuteDownloadAttachment, this.ExecuteDownloadAttachment);
            this.removeAttachment = new Command(this.CanExecuteRemoveAttachment, this.ExecuteRemoveAttachment);
        }
 
        public Attachment Attachment => this.attachment;
 
        public string Id
        {
            get => this.id.Value;
            set => this.id.Value = value;
        }
 
        public string LegalId
        {
            get => this.legalId.Value;
            set => this.legalId.Value = value;
        }
 
        public string ContentType
        {
            get => this.contentType.Value;
            set => this.contentType.Value = value;
        }
 
        public string FileName
        {
            get => this.fileName.Value;
            set => this.fileName.Value = value;
        }
 
        public string Url
        {
            get => this.url.Value;
            set => this.url.Value = value;
        }
 
        public byte[] Signature
        {
            get => this.signature.Value;
            set => this.signature.Value = value;
        }
 
        public DateTime Timestamp
        {
            get => this.timestamp.Value;
            set => this.timestamp.Value = value;
        }
 
        public ICommand DownloadAttachment => this.downloadAttachment;
 
        public bool CanExecuteDownloadAttachment()
        {
            return this.contractModel?.CanDownloadAttachment ?? false;
        }
 
        public async Task ExecuteDownloadAttachment()
        {
            try
            {
                string Extension = Path.GetExtension(this.FileName);
                if (Extension.StartsWith("."))
                    Extension = Extension[1..];
 
                SaveFileDialog Dialog = new()
                {
                    AddExtension = true,
                    CheckFileExists = false,
                    CheckPathExists = true,
                    CreatePrompt = false,
                    DefaultExt = Extension,
                    Filter = "Similar Files (*." + Extension + ")|*." + Extension,
                    OverwritePrompt = true,
                    Title = "Save Attachment"
                };
 
                bool? Result = Dialog.ShowDialog(MainWindow.currentInstance);
                if (!Result.HasValue || !Result.Value)
                    return;
 
                MainWindow.MouseHourglass();
 
                KeyValuePair<string, TemporaryFile> P = await this.contractModel.ContractsClient.GetAttachmentAsync(this.Url, SignWith.CurrentKeys);
 
                using TemporaryFile Temp = P.Value;
                using FileStream Destination = File.Create(Dialog.FileName);
 
                Temp.Position = 0;
                await Temp.CopyToAsync(Destination);
 
                MainWindow.SuccessBox("Attachment successfully downloaded.");
            }
            catch (Exception ex)
            {
                MainWindow.ErrorBox(ex.Message);
            }
        }
 
        public ICommand RemoveAttachment => this.removeAttachment;
 
        public bool CanExecuteRemoveAttachment()
        {
            return this.contractModel?.CanUploadAttachment ?? false;
        }
 
        public async Task ExecuteRemoveAttachment()
        {
            try
            {
                if (MessageBox.Show("Are you sure you want to remove the attachment " + this.Id + "?", "Confirm",
                    MessageBoxButton.YesNoCancel, MessageBoxImage.Question, MessageBoxResult.No) != MessageBoxResult.Yes)
                {
                    return;
                }
                
                MainWindow.MouseHourglass();
 
                Contract Contract = await this.contractModel.ContractsClient.RemoveContractAttachmentAsync(this.Id);
 
                await this.contractModel.SetContract(Contract);
 
                MainWindow.SuccessBox("Attachment successfully removed.");
            }
            catch (Exception ex)
            {
                MainWindow.ErrorBox(ex.Message);
            }
        }
    }
}