data_organizer/DataOrganizer/FileViewer.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DataOrganizer
{
    public partial class FileViewer : Form
    {
        private Dictionary<string, DB.Profile> Profiles { get; } = new Dictionary<string, DB.Profile>();
        private Dictionary<string, DB.FolderGroup> FolderGroups { get; } = new Dictionary<string, DB.FolderGroup>();
        //private Dictionary<string, Folder> Folders { get; } = new Dictionary<string, Folder>();

        public FileViewer()
        {
            InitializeComponent();
            var db = new DB();

            var profiles = db.GetProfiles();

            foreach(var profile in profiles)
            {
                ProfileComboBox.Items.Add(profile.Name);
                Profiles.Add(profile.Name, profile);
            }

            ProfileComboBox.SelectedIndexChanged += ProfileComboBox_SelectedIndexChanged;
            RootFolderComboBox.SelectedIndexChanged += SelectedFolderComboBox_SelectedIndexChanged;

            ProfileComboBox.SelectedIndex = 0;
        }

        private void SelectedFolderComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var folder = FolderGroups[RootFolderComboBox.Text];
            var rootDepth = folder.Path.Split(new char[] { Path.DirectorySeparatorChar }).Length;
            var profile = Profiles[ProfileComboBox.Text];
            var includedFolders = new Dictionary<string, TreeNode>();
            var db = new DB();

            PrimaryFilesTreeView.Nodes.Clear();

            var files = db.GetFilesForProfileByFolderGroup(profile.Id, folder.Id);
            var d = new Snapshot(files, profile, folder);

            var currentShowNode = new TreeNode();

            foreach (var file in files)
            {
                var folders = file.FullPath.Split(new char[] { Path.DirectorySeparatorChar });
                var currentPath = folder.Path;

                if(folders.Length == rootDepth + 1)
                {
                    PrimaryFilesTreeView.Nodes.Add(new TreeNode(folders[rootDepth]) { Name = Path.Combine(currentPath, folders[rootDepth]), ToolTipText = Path.Combine(currentPath, folders[rootDepth]) });
                    continue;
                }

                var previousPath = string.Empty;

                if (folders.Length >= rootDepth + 1)
                {
                    if (currentShowNode.Text != folders[rootDepth])
                    {
                        currentShowNode = new TreeNode(folders[rootDepth]) { Name = Path.Combine(currentPath, folders[rootDepth]), ToolTipText = Path.Combine(currentPath, folders[rootDepth]) };
                        includedFolders.Add(Path.Combine(currentPath, folders[rootDepth]), currentShowNode);
                        PrimaryFilesTreeView.Nodes.Add(currentShowNode);
                    }
                }
                
                for(var i = rootDepth; i < folders.Length - 1; i++)
                {
                    previousPath = currentPath;
                    currentPath = Path.Combine(currentPath, folders[i]);

                    if(!includedFolders.ContainsKey(currentPath))
                    {
                        var newNode = new TreeNode(folders[i]) { Name = currentPath, ToolTipText = currentPath };

                        if (includedFolders.ContainsKey(previousPath))
                        {
                            includedFolders[previousPath].Nodes.Add(newNode);
                            includedFolders.Add(currentPath, newNode);
                        }
                    }
                }

                var node = includedFolders[currentPath];
                node.Nodes.Add(new TreeNode(folders[folders.Length - 1]) { Name = Path.Combine(currentPath, folders[folders.Length - 1]), ToolTipText = Path.Combine(currentPath, folders[folders.Length - 1]) });
            }
        }

        private void ProfileComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var profile = Profiles[ProfileComboBox.Text];

            RootFolderComboBox.Items.Clear();
            FolderGroups.Clear();

            if (profile.FolderGroups.Count > 0)
            {
                foreach (var folder in profile.FolderGroups)
                {
                    RootFolderComboBox.Items.Add(folder.Name);
                    FolderGroups.Add(folder.Name, folder);
                }

                RootFolderComboBox.SelectedIndex = 0;
            }

            RootFolderComboBox.Enabled = true;
        }

        private void FolderSelectButton_Click(object sender, EventArgs e)
        {
            //var folder = FolderGroups[RootFolderComboBox.Text];
            //var profile = Profiles[ProfileComboBox.Text];
            //var db = new DB();

            //StatusLabel.Text = $"{db.GetNamingPatternById(folder.PatternId)}";
            //StatusStrip.Refresh();

            //PrimaryFilesTreeView.Nodes.Clear();

            //var files = db.GetFilesForProfileByFolderGroup(profile.Id, folder.Id);

            //if (files.Count == 0) return;

            //var fileInfos = new List<FileInfo>();

            //foreach(var file in files)
            //{
            //    fileInfos.Add(new FileInfo(file.FullPath));
            //}
        }

        private void ScanRootFolderButton_Click(object sender, EventArgs e)
        {
            var folder = FolderGroups[RootFolderComboBox.Text];
            //var db = new DB();
            //var pattern = db.GetNamingPatternById(folder.PatternId);
            //var regex = new Regex(pattern);
            //PrimaryFilesTreeView.Nodes.Clear();

            //var dirs = Directory.EnumerateDirectories(folder.Path);

            //foreach (var dir in dirs)
            //{
            //    var dirInfo = new DirectoryInfo(dir);
            //    PrimaryFilesTreeView.Nodes.Add(CreateNode(dirInfo, pattern));
            //}

            //foreach(var file in Directory.EnumerateFiles(folder.Path))
            //{
            //    var fileInfo = new FileInfo(file);
            //    var fileNode = new TreeNode(fileInfo.Name) { Name = fileInfo.FullName };

            //    if (!regex.IsMatch(fileInfo.Name))
            //    {
            //        fileNode.ForeColor = Color.DarkOrange;
            //    }

            //    PrimaryFilesTreeView.Nodes.Add(fileNode);
            //}

            WriteFilesToDb(folder.Path);
        }

        private TreeNode CreateNode(DirectoryInfo dir, string pattern)
        {
            var folder = FolderGroups[RootFolderComboBox.Text];
            var profile = Profiles[ProfileComboBox.Text];
            var namingViolation = false;
            var node = new TreeNode(dir.Name) { Name = dir.FullName };
            var regex = new Regex(pattern);
            var db = new DB();

            var files = Directory.EnumerateFiles(dir.FullName);

            foreach (var file in files)
            {
                var fileInfo = new FileInfo(file);
                var fileNode = new TreeNode(fileInfo.Name) { Name = fileInfo.FullName };
                //var match = regex.Match(fileInfo.Name);
                //var stringBuilder = new StringBuilder();

                //if (!match.Groups[1].Success)
                //    stringBuilder.Append($"Failed to match {regex.GroupNameFromNumber(1)} ");//match.Groups[0].Name}");
                //if (!match.Groups[2].Success)
                //    stringBuilder.Append($"Failed to match {regex.GroupNameFromNumber(2)} ");

                if (!regex.IsMatch(fileInfo.Name))
                {
                    namingViolation = true;
                    fileNode.ForeColor = Color.DarkOrange;
                }

                node.Nodes.Add(fileNode);
                db.InsertNewFileRecord(GetFileSnapshots(dir.FullName), profile.Id, folder.Id, folder.Path);
            }

            if (namingViolation) node.ForeColor = Color.DarkOrange;

            var dirs = Directory.EnumerateDirectories(dir.FullName);

            foreach(var f in dirs)
            {
                var child = CreateNode(new DirectoryInfo(f), pattern);
                node.ForeColor = child.ForeColor;
                node.Nodes.Add(child);
            }

            return node;
        }

        private void WriteFilesToDb(string root)
        {
            var dir = new DirectoryInfo(root);
            var folder = FolderGroups[RootFolderComboBox.Text];
            var profile = Profiles[ProfileComboBox.Text];
            //var db = new DB();
            //var pattern = db.GetNamingPatternById(folder.PatternId);

            WriteFilesInFolderToDb(dir.FullName, profile.Id, folder.Id, root);
            UpdateStatusStrip("Finished processing files.");
        }

        private void WriteFilesInFolderToDb(string path, int profileId, int folderId, string root)
        {
            var dir = new DirectoryInfo(path);
            var db = new DB();

            var files = GetFileSnapshots(dir.FullName);

            if(files.Count > 0 ) db.InsertNewFileRecord(files, profileId, folderId, root);

            foreach(var d in dir.EnumerateDirectories())
            {
                UpdateStatusStrip($"Processing {d.FullName}");

                WriteFilesInFolderToDb(d.FullName, profileId, folderId, root);
            }
        }

        private List<DB.FileSnapshot> GetFileSnapshots(string path)
        {
            var dir = new DirectoryInfo(path);
            var profile = GetCurrentProfile();
            var folderGroup = GetCurrentFolderGroup();

            var snapshots = new List<DB.FileSnapshot>();

            foreach(var file in dir.EnumerateFiles())
            {
                snapshots.Add(new DB.FileSnapshot
                {
                    FullPath = file.FullName,
                    Name = file.Name,
                    CreationDate = file.CreationTimeUtc,
                    ModifiedDate = file.LastWriteTimeUtc,
                    ProfileId = profile.Id,
                    RootFolderId = folderGroup.Id,
                    Size = file.Length,
                    PatternId = 0 //TODO: Add something that let's the user override the global pattern.
                });
            }

            return snapshots;
        }

        private DB.Profile GetCurrentProfile()
        {
            return Profiles[ProfileComboBox.Text];
        }

        private DB.FolderGroup GetCurrentFolderGroup()
        {
            return FolderGroups[RootFolderComboBox.Text];
        }

        private void UpdateStatusStrip(string message)
        {
            StatusLabel.Text = message;
            StatusStrip.Refresh();
        }
    }
}