Merge pull request #8 from dtwk2/development_2

Development 2

Author: Dirkster99

source/Demos/CachedPathSuggest/CachedPathSuggest.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net5.0</TargetFramework>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="LiteDB" Version="5.0.11" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\Infrastructure\Infrastructure.csproj" />
+	</ItemGroup>
+
+</Project>

source/Demos/CachedPathSuggest/Infrastructure/DirectoryHelper.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace CachedPathSuggest.Infrastructure
+{
+    public static class DirectoryHelper
+    {
+        public static IEnumerable<(string path, string? label)>? EnumerateSubDirectories(string input)
+        {
+            var subDirs = EnumerateLogicalDriveOrSubDirectories(input);
+
+            // ReSharper disable PossibleMultipleEnumeration
+            return subDirs != null
+                ? subDirs.Any() 
+                ? subDirs.Select(a => (a, (string?)null)) : EnumerateChildren(input)
+                : new[] { (input, (string?)"Unauthorized Access") };
+
+            // Find last separator and list directories underneath with * search-pattern
+            static IEnumerable<(string, string?)> EnumerateChildren(string input)
+            {
+                var sepIdx = input.LastIndexOf('\\');
+
+                if (sepIdx >= input.Length)
+                    return EnumerateLogicalDrives();
+
+                string folder = input.Substring(0, sepIdx + 1);
+                string searchPattern = input.Substring(sepIdx + 1) + "*";
+                try
+                {
+                    return Directory
+                            .GetDirectories(folder, searchPattern)
+                            .Select(a => (a, (string?)null)).ToList();
+                }
+                catch
+                {
+                    // Catch invalid path exceptions here ...
+                    return Array.Empty<(string, string?)>();
+                }
+            }
+
+            static IEnumerable<string>? EnumerateLogicalDriveOrSubDirectories(string testDrive)
+            {
+                if (testDrive.Length < 3) return Enumerate(testDrive);
+
+                return Directory.Exists(testDrive) ? TryGetDirectories(testDrive) : Array.Empty<string>();
+
+                static string[]? TryGetDirectories(string testDrive)
+                {
+                    try
+                    {
+                        return Directory.GetDirectories(testDrive);
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        return null;
+                    }
+                }
+
+                static IEnumerable<string>? Enumerate(string input)
+                {
+                    return (input.Length, input.TryGetUpper(0), input.TryGetUpper(1), input.TryGetUpper(2)) switch
+                    {
+                        (1, >= 'A' and <= 'Z', _, _) => new[] { input + ":\\" }.Concat(EnumerateLogicalDriveOrSubDirectories(input + ":\\") ?? Array.Empty<string>()),
+                        (2, >= 'A' and <= 'Z', ':', _) => new[] { input + ":\\" }.Concat(EnumerateLogicalDriveOrSubDirectories(input + "\\") ?? Array.Empty<string>()),
+                        (3, >= 'A' and <= 'Z', ':', '\\') => EnumerateLogicalDriveOrSubDirectories(input),
+                        _ => Array.Empty<string>()
+                    };
+                }
+            }
+        }
+
+        public static IEnumerable<(string path, string? label)> EnumerateLogicalDrives()
+        {
+            foreach (var driveName in Environment.GetLogicalDrives())
+            {
+                if (string.IsNullOrEmpty(driveName))
+                    continue;
+
+                string? volumeLabel = null;
+
+                try
+                {
+                    if (new DriveInfo(driveName) is { IsReady: true } driveInfo)
+                        volumeLabel = driveInfo.VolumeLabel;
+                }
+                catch (IOException)
+                {
+                    // network path not found
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    // can't access path
+                }
+
+                yield return (driveName, volumeLabel);
+            }
+        }
+    }
+
+    internal static class StringHelper
+    {
+        public static char TryGetUpper(this string value, int index)
+        {
+            return char.ToUpper(value.ElementAtOrDefault(index));
+        }
+    }
+}

source/Demos/CachedPathSuggest/Infrastructure/LiteRepository.cs

@@ -0,0 +1,85 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using LiteDB;
+
+namespace CachedPathSuggest.Infrastructure
+{
+    /// <summary>
+    ///     Implements a static service provider for searching and editing a LiteDB file.
+    /// </summary>
+    public class LiteRepository
+    {
+        private const string DbPath = @"..\..\..\Data\KeyValue.litedb";
+
+        // Collection needs a name because object, keyvaluepair<string,string> is generic.
+        private const string CollectionName = "collection";
+
+        /// <summary>
+        ///     Class constructor
+        /// </summary>
+        public LiteRepository()
+        {
+            (Directory.GetParent(DbPath) ?? throw new Exception("Can't create directory")).Create();
+            BsonMapper.Global.Entity<KeyValuePair<string, DateTime>>().Id(x => x.Key);
+        }
+
+        public event Action? Change;
+
+        /// <summary>
+        ///     Inserts a new string into the collection of bookmarked strings.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="collectionName"></param>
+        public void Insert(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            col.Upsert(new KeyValuePair<string, DateTime>(key, DateTime.Now));
+            Change?.Invoke();
+        }
+
+        /// <summary>
+        ///     Inserts a new string into the collection of bookmarked strings.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="collectionName"></param>
+        public void Remove(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+
+            // Make sure string is already present
+            if (col.FindOne(x => x.Key == key) is { } one)
+                col.Delete(key);
+
+            Change?.Invoke();
+        }
+
+        /// <summary>
+        /// </summary>
+        public KeyValuePair<string, DateTime>? Find(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            var one = col.FindOne(x => x.Key == key);
+            return one;
+        }
+
+        /// <summary>
+        ///     Filters the collection of bookmark strings by the given string and
+        ///     returns the resulting collection.
+        /// </summary>
+        public IEnumerable<KeyValuePair<string, DateTime>> Filter(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            return string.IsNullOrWhiteSpace(key)
+                ? col.Query().ToArray()
+                : col.Find(Query.Contains(nameof(KeyValuePair<string, DateTime>.Key), key)).ToArray();
+        }
+    }
+}

source/Demos/CachedPathSuggest/ViewModels/BaseItem.cs

@@ -0,0 +1,38 @@
+using Infrastructure;
+
+namespace CachedPathSuggest.ViewModels
+{
+    /// <summary>
+    ///     This class is the parent root class of other lsit item related classes.
+    ///     It exists simple for methods to produce something like IEnumerable{<see cref="BaseItem" />}
+    ///     where 'BaseItem' cen be any class inheriting from <see cref="BaseItem" />.
+    ///     This enables us to use Converters, DataTemplates or other tools in WPF to display different
+    ///     UI bits for different types of classes.
+    /// </summary>
+    public class BaseItem : ViewModelBase
+    {
+        private bool isHitTestVisible;
+
+        public BaseItem(string value)
+        {
+            Value = value;
+            IsHitTestVisible = true;
+        }
+
+        public string Value { get; }
+
+        /// <summary>
+        ///     Gets/sets a property that indicates to the UI whether the resulting list item
+        ///     should be click-able to process data or not (a separator is part of the list but should not be clicked).
+        /// </summary>
+        public bool IsHitTestVisible
+        {
+            get => isHitTestVisible;
+            set
+            {
+                isHitTestVisible = value;
+                NotifyPropertyChanged();
+            }
+        }
+    }
+}

source/Demos/CachedPathSuggest/ViewModels/ItemSeperator.cs

@@ -0,0 +1,21 @@
+namespace CachedPathSuggest.ViewModels
+{
+    /// <summary>
+    ///     Implements a simple viewmodel for an item that should act as separator
+    ///     between 2 sub-sequent blocks of 2 different types of items.
+    ///     This type of item is usually useful in a WPF list of items where quickly
+    ///     different types of items appear with a need for displaying their content
+    ///     with a different UI (eg.: using a Converter or DataTemplate).
+    /// </summary>
+    public class ItemSeparator : BaseItem
+    {
+        /// <summary>
+        ///     Class constructor
+        /// </summary>
+        public ItemSeparator() : base(string.Empty)
+        {
+            // a separator is part of the list but should not be clicked
+            IsHitTestVisible = false;
+        }
+    }
+}

source/Demos/CachedPathSuggest/ViewModels/PathInformation.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+
+namespace CachedPathSuggest.ViewModels
+{
+    public class CachedPathInformation : PathInformation
+    {
+        public CachedPathInformation(DateTime storageDate, string path) : base(path)
+        {
+            StorageDate = storageDate;
+        }
+
+        public DateTime StorageDate { get; }
+
+        public TimeSpan StorageLength => StorageDate - DateTime.Now;
+    }
+
+    /// <summary>
+    ///     Implements a simple path information object to keep track of its full name and path etc.
+    /// </summary>
+    public class PathInformation : BaseItem, IEquatable<PathInformation>
+    {
+        /// <summary>
+        ///     Class constructor
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="information"></param>
+        public PathInformation(string path, string? information = null) : base(path)
+        {
+            Parent = new DirectoryInfo(path).Parent == null ? path :
+                path.EndsWith("\\") ? Path.GetDirectoryName(path) ?? string.Empty :
+                string.Empty;
+
+            FullName = path;
+            Information = information;
+        }
+
+        /// <summary>
+        ///     Gets the name of a directory (without the path)
+        /// </summary>
+        public string Parent { get; }
+
+        /// <summary>
+        ///     Gets the full name (including path) for a directory
+        /// </summary>
+        public string FullName { get; }
+
+        /// <summary>
+        /// Any other information e.g volume-information
+        /// </summary>
+        public string? Information { get; }
+
+        public bool Equals(PathInformation? other)
+        {
+            if (other is null) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Parent == other.Parent && FullName == other.FullName;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (obj is null) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            return obj.GetType() == GetType() && Equals((PathInformation) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Parent, FullName);
+        }
+    }
+}