AttachmentCacheService.cs

using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Inventory;
 
namespace NeuroAccessMaui.Services.AttachmentCache
{
    [Singleton]
    internal sealed partial class AttachmentCacheService : LoadableService, IAttachmentCacheService
    {
        private static readonly TimeSpan expiryTemporary = TimeSpan.FromHours(24);
        private const string cacheFolderName = "Attachments";
 
        public AttachmentCacheService()
        {
        }
 
        public override async Task Load(bool IsResuming, CancellationToken CancellationToken)
        {
            if (this.BeginLoad(IsResuming, CancellationToken))
            {
                try
                {
                    CreateCacheFolderIfNeeded();
 
                    if (!IsResuming)
                        await EvictOldEntries();
 
                    this.EndLoad(true);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    this.EndLoad(false);
                }
            }
        }
 
        public async Task<(byte[]?, string)> TryGet(string Url)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(Url) || !Uri.IsWellFormedUriString(Url, UriKind.RelativeOrAbsolute))
                    return (null, string.Empty);
 
                CacheEntry Entry = await Database.FindFirstDeleteRest<CacheEntry>(new FilterFieldEqualTo("Url", Url));
 
                if (Entry is null)
                    return (null, string.Empty);
 
                bool Exists = File.Exists(Entry.LocalFileName);
 
                if (DateTime.UtcNow >= Entry.Expires || !Exists)
                {
                    if (Exists)
                        File.Delete(Entry.LocalFileName);
 
                    await Database.Delete(Entry);
                    await Database.Provider.Flush();
 
                    return (null, string.Empty);
                }
 
                return (File.ReadAllBytes(Entry.LocalFileName), Entry.ContentType);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                return (null, string.Empty);
            }
        }
 
        public async Task Add(string Url, string ParentId, bool Permanent, byte[] Data, string ContentType)
        {
            if (string.IsNullOrWhiteSpace(Url) ||
                !Uri.IsWellFormedUriString(Url, UriKind.RelativeOrAbsolute) ||
                Data is null ||
                string.IsNullOrWhiteSpace(ContentType))
            {
                return;
            }
 
            string CacheFolder = CreateCacheFolderIfNeeded();
 
            CacheEntry Entry = await Database.FindFirstDeleteRest<CacheEntry>(new FilterFieldEqualTo("Url", Url));
            DateTime Expires = Permanent ? DateTime.MaxValue : (DateTime.UtcNow + expiryTemporary);
 
            if (Entry is null)
            {
                Entry = new CacheEntry()
                {
                    Expires = Expires,
                    ParentId = ParentId,
                    LocalFileName = Path.Combine(CacheFolder, Guid.NewGuid().ToString() + ".bin"),
                    Url = Url,
                    ContentType = ContentType
                };
 
                await Database.Insert(Entry);
            }
            else
            {
                Entry.Expires = Expires;
                Entry.ParentId = ParentId;
                Entry.ContentType = ContentType;
 
                await Database.Update(Entry);
            }
 
            File.WriteAllBytes(Entry.LocalFileName, Data);
 
            await Database.Provider.Flush();
        }
 
        public async Task<bool> Remove(string Url)
        {
            if (string.IsNullOrWhiteSpace(Url) || !Uri.IsWellFormedUriString(Url, UriKind.RelativeOrAbsolute))
                return false;
 
            CacheEntry Entry = await Database.FindFirstDeleteRest<CacheEntry>(new FilterFieldEqualTo("Url", Url));
            if (Entry is null)
                return false;
 
            try
            {
                if (File.Exists(Entry.LocalFileName))
                    File.Delete(Entry.LocalFileName);
 
                await Database.Delete(Entry);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return true;
        }
 
        public async Task<bool> RemoveAttachments(Attachment[]? Attachments)
        {
            if (Attachments is null)
                return false;
 
            bool Removed = false;
 
            foreach (Attachment Attachment in Attachments)
            {
                if (!Attachment.ContentType.StartsWith("image/", StringComparison.Ordinal))
                    continue;
 
                if (await this.Remove(Attachment.Url))
                    Removed = true;
            }
 
            return Removed;
        }
 
        private static string CreateCacheFolderIfNeeded()
        {
            string CacheFolder = GetCacheFolder();
 
            if (!Directory.Exists(CacheFolder))
                Directory.CreateDirectory(CacheFolder);
 
            return CacheFolder;
        }
 
        private static string GetCacheFolder()
        {
            return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), cacheFolderName);
        }
 
        private static async Task EvictOldEntries()
        {
            try
            {
                foreach (CacheEntry Entry in await Database.FindDelete<CacheEntry>(
                    new FilterFieldLesserOrEqualTo("Expires", DateTime.UtcNow)))
                {
                    try
                    {
                        if (File.Exists(Entry.LocalFileName))
                            File.Delete(Entry.LocalFileName);
                    }
                    catch (Exception ex)
                    {
                        ServiceRef.LogService.LogException(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task MakeTemporary(string ParentId)
        {
            foreach (CacheEntry Entry in await Database.Find<CacheEntry>(new FilterFieldEqualTo("ParentId", ParentId)))
            {
                if (Entry.Expires == DateTime.MaxValue)
                {
                    Entry.Expires = DateTime.UtcNow + expiryTemporary;
                    await Database.Update(Entry);
                }
            }
 
            await Database.Provider.Flush();
        }
 
        public async Task MakePermanent(string ParentId)
        {
            foreach (CacheEntry Entry in await Database.Find<CacheEntry>(new FilterFieldEqualTo("ParentId", ParentId)))
            {
                if (Entry.Expires != DateTime.MaxValue)
                {
                    Entry.Expires = DateTime.MaxValue;
                    await Database.Update(Entry);
                }
            }
 
            await Database.Provider.Flush();
        }
    }
}