XmlFileEventSink.cs

using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Threading.Tasks;
using Waher.Content;
 
namespace Waher.Events.Files
{
    public class XmlFileEventSink : XmlWriterEventSink
    {
        private readonly XmlWriterSettings settings;
        private StreamWriter file;
        private readonly string fileName;
        private string lastFileName = null;
        private readonly string transform = null;
        private readonly int deleteAfterDays;
 
        public XmlFileEventSink(string ObjectID, string FileName)
            : this(ObjectID, FileName, string.Empty, 7)
        {
        }
 
        public XmlFileEventSink(string ObjectID, string FileName, int DeleteAfterDays)
            : this(ObjectID, FileName, string.Empty, DeleteAfterDays)
        {
        }
 
        public XmlFileEventSink(string ObjectID, string FileName, string Transform)
            : this(ObjectID, FileName, Transform, 7)
        {
        }
 
        public XmlFileEventSink(string ObjectID, string FileName, string Transform, int DeleteAfterDays)
            : base(ObjectID, null)
        {
            this.file = null;
            this.output = null;
            this.fileName = FileName;
            this.transform = Transform;
            this.deleteAfterDays = DeleteAfterDays;
 
            this.settings = new XmlWriterSettings
            {
                CloseOutput = true,
                ConformanceLevel = ConformanceLevel.Document,
                Encoding = Encoding.UTF8,
                Indent = true,
                IndentChars = "\t",
                NewLineChars = "\r\n",
                NewLineHandling = NewLineHandling.Replace,
                NewLineOnAttributes = false,
                OmitXmlDeclaration = false,
                WriteEndDocumentOnClose = true
            };
 
            string FolderName = Path.GetDirectoryName(FileName);
 
            if (!Directory.Exists(FolderName))
            {
                Log.Informational("Creating folder.", FolderName);
                Directory.CreateDirectory(FolderName);
            }
        }
 
        public static string GetFileName(string TemplateFileName)
        {
            DateTime TP = DateTime.Now;
            return TemplateFileName.
                Replace("%YEAR%", TP.Year.ToString("D4")).
                Replace("%MONTH%", TP.Month.ToString("D2")).
                Replace("%DAY%", TP.Day.ToString("D2")).
                Replace("%HOUR%", TP.Hour.ToString("D2")).
                Replace("%MINUTE%", TP.Minute.ToString("D2")).
                Replace("%SECOND%", TP.Second.ToString("D2"));
        }
 
        public static void MakeUnique(ref string FileName)
        {
            if (File.Exists(FileName))
            {
                int i = FileName.LastIndexOf('.');
                int j = 2;
 
                if (i < 0)
                    i = FileName.Length;
 
                string s;
 
                do
                {
                    s = FileName.Insert(i, " (" + (j++).ToString() + ")");
                }
                while (File.Exists(s));
 
                FileName = s;
            }
        }
 
        protected override async Task BeforeWrite()
        {
            string s = GetFileName(this.fileName);
            if (!(this.lastFileName is null) && this.lastFileName == s && !(this.file is null) && this.file.BaseStream.CanWrite)
                return;
 
            try
            {
                this.output?.WriteEndElement();
                this.output?.WriteEndDocument();
                this.output?.Flush();
                this.file?.Dispose();
            }
            catch (Exception)
            {
                try
                {
                    this.DisposeOutput();
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            this.file = null;
            this.output = null;
 
            string s2 = s;
 
            MakeUnique(ref s2);
            this.file = File.CreateText(s2);
            this.lastFileName = s;
 
            this.output = XmlWriter.Create(this.file, this.settings);
            this.output.WriteStartDocument();
 
            if (!string.IsNullOrEmpty(this.transform))
            {
                if (File.Exists(this.transform))
                {
                    try
                    {
                        byte[] XsltBin = await Resources.ReadAllBytesAsync(this.transform);
 
                        this.output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"data:text/xsl;base64," +
                            Convert.ToBase64String(XsltBin) + "\"");
                    }
                    catch (Exception)
                    {
                        this.output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"" + this.transform + "\"");
                    }
                }
                else
                    this.output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"" + this.transform + "\"");
            }
 
            this.output.WriteStartElement("EventOutput", EventExtensions.LogNamespace);
            this.output.Flush();
 
            if (this.deleteAfterDays < int.MaxValue)
            {
                string FolderName = Path.GetDirectoryName(s);
                if (string.IsNullOrEmpty(FolderName))
                    FolderName = ".";
 
                string[] Files = Directory.GetFiles(FolderName, "*.*");
 
                foreach (string FileName in Files)
                {
                    if ((DateTime.Now - File.GetLastWriteTime(FileName)).TotalDays >= this.deleteAfterDays)
                    {
                        try
                        {
                            File.Delete(FileName);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
            }
        }
 
        public override void DisposeOutput()
        {
            base.DisposeOutput();
 
            this.file?.Dispose();
            this.file = null;
        }
    }
}