PersistedHashes.cs

using System;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.HashStore.HashObjects;
using Waher.Runtime.Threading;
 
namespace Waher.Runtime.HashStore
{
    public static class PersistedHashes
    {
        public static Task<bool> AddHash(byte[] Hash)
        {
            return AddHash(string.Empty, DateTime.MaxValue, Hash);
        }
 
        public static Task<bool> AddHash(DateTime ExpiresUtc, byte[] Hash)
        {
            return AddHash(string.Empty, ExpiresUtc, Hash);
        }
 
        public static Task<bool> AddHash(string Realm, byte[] Hash)
        {
            return AddHash(Realm, DateTime.MaxValue, Hash);
        }
 
        public static Task<bool> AddHash(string Realm, DateTime ExpiresUtc, byte[] Hash)
        {
            return AddHash(Realm, ExpiresUtc, Hash, null);
        }
 
        public static Task<bool> AddHash(string Realm, byte[] Hash, object AssociatedObject)
        {
            return AddHash(Realm, DateTime.MaxValue, Hash, AssociatedObject);
        }
 
        public static async Task<bool> AddHash(string Realm, DateTime ExpiresUtc, byte[] Hash,
            object AssociatedObject)
        {
            using (Semaphore Semaphore = await Semaphores.BeginWrite("hashrealm:" + Realm))
            {
                PersistedHash Obj = await Database.FindFirstDeleteRest<PersistedHash>(
                    new FilterAnd(
                        new FilterFieldEqualTo("Realm", Realm),
                        new FilterFieldEqualTo("Hash", Hash)));
 
                if (!(Obj is null))
                    return false;
 
                Obj = new PersistedHash()
                {
                    Realm = Realm,
                    ExpiresUtc = ExpiresUtc.ToUniversalTime(),
                    Hash = Hash,
                    AssociatedObject = AssociatedObject
                };
 
                await Database.Insert(Obj);
 
                return true;
            }
        }
 
        public static Task<bool> VerifyHash(byte[] Hash)
        {
            return VerifyHash(string.Empty, Hash);
        }
 
        public static async Task<bool> VerifyHash(string Realm, byte[] Hash)
        {
            using (Semaphore Semaphore = await Semaphores.BeginRead("hashrealm:" + Realm))
            {
                PersistedHash Obj = await Database.FindFirstDeleteRest<PersistedHash>(
                    new FilterAnd(
                        new FilterFieldEqualTo("Realm", Realm),
                        new FilterFieldEqualTo("Hash", Hash)));
 
                return !(Obj is null);
            }
        }
 
        public static Task<object> TryGetAssociatedObject(byte[] Hash)
        {
            return TryGetAssociatedObject(string.Empty, Hash);
        }
 
        public static async Task<object> TryGetAssociatedObject(string Realm, byte[] Hash)
        {
            using (Semaphore Semaphore = await Semaphores.BeginRead("hashrealm:" + Realm))
            {
                PersistedHash Obj = await Database.FindFirstDeleteRest<PersistedHash>(
                    new FilterAnd(
                        new FilterFieldEqualTo("Realm", Realm),
                        new FilterFieldEqualTo("Hash", Hash)));
 
                return Obj?.AssociatedObject;
            }
        }
    }
}