Merge pull request 'feature/logging' (#3) from feature/logging into main

Reviewed-on: #3

.editorconfig

@@ -0,0 +1,26 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# C# files
+[*.cs]
+
+# Indentation and spacing
+indent_size = 4
+indent_style = space
+tab_width = 4
+
+# Naming Conventions
+dotnet_naming_style.camel_case.capitalization = camel_case
+
+# New line preferences
+csharp_new_line_before_open_brace = none
+csharp_new_line_before_else = false
+csharp_new_line_before_catch = false
+csharp_new_line_before_finally = false
+
+# Wrapping preferences
+csharp_preserve_single_line_statements = true
+csharp_preserve_single_line_blocks = true
+
+# Switch case
+csharp_indent_case_contents = true

.gitignore

@@ -1,3 +1,4 @@
 .vscode/
 obj/
 bin/
+Libraries/

Program.cs

@@ -1,50 +0,0 @@
-// Go into folder
-// Check if any file is in there
-// If there is a file. Calculate md5sum > filename.md5
-// If there is no file. Repeat
-public class Program {
-    static void Main(string[] args) {
-
-        // int getDirectoryCount() {
-        //     int folderCount = Directory.GetDirectories(Directory.GetCurrentDirectory()).Length; // Get folder count in current directory
-        //     return folderCount;
-        // }
-
-        int getFileCount() {
-            int fileCount = Directory.GetFiles(Directory.GetCurrentDirectory()).Length; // Get file count in current directory
-            return fileCount;
-        }
-
-        // string getParentFolder() {
-        //     string parentFolder = Directory.GetParent(Directory.GetCurrentDirectory()).ToString(); // Get parent folder of current directory
-        //     return parentFolder;
-        // }
-
-        string CalculateMD5(string filename) {
-            using (var md5 = System.Security.Cryptography.MD5.Create())
-            {
-                using (var stream = File.OpenRead(filename))
-                {
-                    var hash = md5.ComputeHash(stream);
-                    return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
-                }
-            }
-        }
-
-        foreach (var directory in Directory.GetDirectories(Directory.GetCurrentDirectory())) {
-            string parentFolder = directory;
-            Directory.SetCurrentDirectory(directory); // Set new root
-            if (getFileCount() >= 1) {
-                DirectoryInfo dir = new DirectoryInfo(Directory.GetCurrentDirectory());
-                FileInfo[] files = dir.GetFiles();
-                foreach (FileInfo file in files) {
-                    string fileName = file.Name;
-                    string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
-                    string checksumFile = Directory.GetCurrentDirectory() + "/" + fileNameWithoutExtension + ".md5";
-                    File.AppendAllText(checksumFile, CalculateMD5(fileName) + "  " + fileName);
-                }
-            }
-            Directory.SetCurrentDirectory(parentFolder); // Go back to the original root
-        }
-    }
-}

README.md

@@ -7,7 +7,7 @@ Checksums every file under the current directory
 Clone the project
 
 ```bash
-git clone http://192.168.0.69:3000/ProfessionalUwU/chksum.git
+git clone https://gitea.hopeless-cloud.xyz/ProfessionalUwU/chksum.git
 ```
 
 Go to the project directory
@@ -25,22 +25,37 @@ pacman -S dotnet-runtime dotnet-sdk
 Build project
 
 ```bash
-dotnet build chksum.csproj 
+just build
 ```
 
 Publish project
 
 ```bash
-dotnet publish --configuration Release --arch x64 --use-current-runtime --self-contained 
+just publish
 ```
 
 Go to the publish folder
 ```bash
-cd bin/Release/net7.0/linux-x64/publish
+cd src/Chksum/bin/Release/net7.0/linux-x64/publish
 ```
 
 Run executable
 
 ```bash
-./chksum
+./Chksum
 ```
+
+## Enabling verbose output for troubleshooting
+
+1. Open the file called chksum.cs with your editor of choice.
+2. At the top there will be the logger configuration which you can change. Should look like this.
+```cs
+private ILogger logger = new LoggerConfiguration()
+            .MinimumLevel.Debug()
+            .WriteTo.Console(restrictedToMinimumLevel: LogEventLevel.Error)
+            .WriteTo.File("chksum.log")
+            .CreateLogger();
+```
+3. Change the minimum level of the logger to Verbose.
+4. Compile the program
+5. Profit. Now you will be able to see how what the program is doing in detail.

chksum.csproj

@@ -1,14 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
-    <PublishSingleFile>true</PublishSingleFile>
-    <SelfContained>true</SelfContained>
-    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
-    <PublishTrimmed>true</PublishTrimmed>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-</Project>

justfile

@@ -0,0 +1,31 @@
+default:
+    @just --list
+
+project_name := `printf '%s\n' "${PWD##*/}"`
+uppercase_project_name := capitalize(project_name)
+
+setup:
+    @mkdir src
+    @dotnet new sln --name src/{{project_name}}
+    @dotnet new classlib -o  src/{{uppercase_project_name}}
+    @dotnet new xunit -o src/{{uppercase_project_name}}.Tests
+    @dotnet sln add src/{{uppercase_project_name}}/{{uppercase_project_name}}.csproj
+    @dotnet sln add src/{{uppercase_project_name}}.Tests/{{uppercase_project_name}}.Tests.csproj
+    @dotnet add src/{{uppercase_project_name}}/{{uppercase_project_name}}.csproj reference src/{{uppercase_project_name}}.Tests/{{uppercase_project_name}}.Tests.csproj
+
+run:
+    @dotnet run
+
+build:
+    @dotnet build src/{{uppercase_project_name}}/{{uppercase_project_name}}.csproj
+    @dotnet build src/{{uppercase_project_name}}.Tests/{{uppercase_project_name}}.Tests.csproj
+
+publish:
+    @dotnet publish --configuration Release src/{{uppercase_project_name}}/{{uppercase_project_name}}.csproj
+
+format:
+    @dotnet format src/{{uppercase_project_name}}
+    @dotnet format src/{{uppercase_project_name}}.Tests
+
+test: build
+    @dotnet test src/{{uppercase_project_name}}.Tests

src/Chksum.Tests/Chksum.Tests.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

src/Chksum.Tests/Usings.cs

@@ -0,0 +1,2 @@
+global using Xunit;
+global using FluentAssertions;

src/Chksum.Tests/doTheThingTest.cs

@@ -0,0 +1,8 @@
+namespace Chksum.Tests;
+
+public class doTheThingTest {
+    [Fact]
+    public void doTheThing_willNotThrowAnException() {
+
+    }
+}

src/Chksum/Chksum.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Chksum.Tests\Chksum.Tests.csproj" />
+    <EmbeddedResource Include="Libraries/libe_sqlite3.so" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+    <PublishSingleFile>true</PublishSingleFile>
+    <SelfContained>true</SelfContained>
+    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
+    <PublishTrimmed>true</PublishTrimmed>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="7.0.8" />
+    <PackageReference Include="Serilog" Version="3.0.1" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+  </ItemGroup>
+
+</Project>

src/Chksum/Program.cs

@@ -0,0 +1,73 @@
+using Chksum.Utils;
+
+public class Program {
+    static void Main(string[] args) {
+
+        Console.ForegroundColor = ConsoleColor.Red;
+        if (args.Length == 0) {
+            Console.WriteLine("Please specify an option.");
+            PrintAvailableOptions();
+            return;
+        } else if (args.Length > 1 && args[0] != "compareDatabases") {
+            Console.WriteLine("Too many options.");
+            return;
+        }
+
+        ChksumUtils utils = new ChksumUtils();
+
+        utils.getBaseDir();
+
+        utils.ExtractEmbeddedLibrary();
+
+        Console.ForegroundColor = ConsoleColor.Green;
+        switch (args[0]) {
+            case "checksum":
+                Console.WriteLine("Starting the checksum process.");
+                Console.ResetColor();
+
+                utils.doTheThing();
+
+                Console.ForegroundColor = ConsoleColor.Green;
+                Console.WriteLine("Checksum process finished");
+                break;
+            case "compareDatabases":
+                Console.ResetColor();
+
+                utils.compareDatabases(args[1]);
+                break;
+            case "createDB":
+                utils.initializeDB();
+                break;
+            case "checkIfFileWasDeleted":
+                Console.ResetColor();
+                utils.checkIfFileWasDeleted();
+                break;
+            case "help":
+                PrintAvailableOptions();
+                break;
+            default:
+                Console.ForegroundColor = ConsoleColor.Red;
+                Console.WriteLine("Invalid option. Maybe you mistyped it?");
+                PrintAvailableOptions();
+                break;
+        }
+
+        utils.cleanup();
+    }
+
+    static void PrintAvailableOptions() {
+        String[] options = {
+            "checksum",
+            "compareChecksums",
+            "createDB",
+            "checkIfFileWasDeleted",
+            "help"
+        };
+
+        Console.ResetColor();
+        Console.WriteLine("usage: chksum [option] \nHere is a list of all available options:");
+        foreach (String option in options) {
+            Console.WriteLine("\t" + option);
+        }
+    }
+}

src/Chksum/chksum.cs

@@ -0,0 +1,319 @@
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Security.Cryptography;
+using Microsoft.Data.Sqlite;
+using Serilog;
+using Serilog.Events;
+
+namespace Chksum.Utils;
+public class ChksumUtils {
+    private ILogger logger = new LoggerConfiguration()
+            .MinimumLevel.Debug()
+            .WriteTo.Console(restrictedToMinimumLevel: LogEventLevel.Error)
+            .WriteTo.File("chksum.log")
+            .CreateLogger();
+
+    private int getTotalFileCount() {
+        int totalFileCount = Directory.GetFiles(Directory.GetCurrentDirectory(), "*", SearchOption.AllDirectories).Length;
+        logger.Debug("Total file count is {totalFileCount}", totalFileCount);
+        return totalFileCount - 3; // Remove the program, datbase and library from the totalFileCount
+    }
+
+    private string[] indexFiles() {
+        string[] indexedFiles = Directory.GetFiles(Directory.GetCurrentDirectory(), "*", SearchOption.AllDirectories);
+        string[] filesToExclude = { "Chksum", "chksum.db", "libe_sqlite3.so" };
+        indexedFiles = indexedFiles.Where(file => !filesToExclude.Contains(Path.GetFileName(file))).ToArray();
+        logger.Information("All files were indexed");
+        return indexedFiles;
+    }
+
+    public string DatabaseRoot { get; set; } = string.Empty;
+    public void getBaseDir() {
+        DatabaseRoot = AppDomain.CurrentDomain.BaseDirectory;
+        logger.Debug("DatabaseRoot is {DatabaseRoot}", DatabaseRoot);
+    }
+
+    public string libraryPath { get; set; } = string.Empty;
+    public void ExtractEmbeddedLibrary() {
+        libraryPath = Path.Combine(DatabaseRoot, "libe_sqlite3.so");
+
+        using (Stream? resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Chksum.Libraries.libe_sqlite3.so")) {
+            if (resourceStream != null) {
+                byte[] buffer = new byte[resourceStream.Length];
+                resourceStream.Read(buffer, 0, buffer.Length);
+                File.WriteAllBytes(libraryPath, buffer);
+                logger.Debug("libe_sqlite3.so was successfully created");
+            } else {
+                logger.Error("libe_sqlite3.so could not be loaded");
+                throw new Exception(libraryPath + " could not be loaded");
+            }
+        }
+    }
+
+    public void initializeDB() {
+        if (File.Exists("chksum.db")) {
+            logger.Information("A database already exits");
+            return;
+        }
+
+        using (var connection = new SqliteConnection("Data Source=chksum.db")) {
+            connection.Open();
+
+            var command = connection.CreateCommand();
+            command.CommandText =
+            @"
+                CREATE TABLE file (
+                filehash TEXT NOT NULL PRIMARY KEY,
+                filename TEXT NOT NULL,
+                pathtofile TEXT NOT NULL,
+                artist TEXT,
+                playbacklength INTEGER
+                );
+            ";
+            command.ExecuteNonQuery();
+            logger.Information("Database was successfully created");
+        }
+    }
+
+    public void cleanDB() {
+        using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db")) {
+            var command = connection.CreateCommand();
+            command.CommandText =
+            @"
+                vacuum;
+            ";
+            command.ExecuteNonQuery();
+            logger.Debug("Database was successfully vacuumed");
+        }
+    }
+
+    private Dictionary<string, string> CalculateChecksums(string[] filenames) {
+        ConcurrentDictionary<string, string> checksums = new ConcurrentDictionary<string, string>();
+
+        Parallel.ForEach(filenames, (filename, state) => {
+            using (var md5 = MD5.Create()) {
+                using (var stream = File.OpenRead(filename)) {
+                    var hash = md5.ComputeHash(stream);
+                    var checksum = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
+
+                    lock (checksums) {
+                        checksums.TryAdd(filename, checksum);
+                    }
+                }
+            }
+        });
+
+        logger.Debug("All files were checksummed");
+        return new Dictionary<string, string>(checksums);
+    }
+
+    public void doTheThing() {
+        using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadWrite")) {
+            if (getTotalFileCount() < 1) {
+                logger.Information("There were no files to checksum");
+                return;
+            }
+            connection.Open();
+            Dictionary<string, string> fileHashes = CalculateChecksums(indexFiles());
+            
+            foreach (var file in fileHashes) {
+                string absolutePathToFile = file.Key;
+                string fileName = Path.GetFileName(absolutePathToFile);
+                string pathToFile = Path.GetRelativePath(DatabaseRoot, absolutePathToFile);
+                string fileHash = file.Value;
+                
+                if (checkIfFileMovedAndUpdatePathToFile(fileHash, fileName, pathToFile) == false && checkIfFileAlreadyExistsInDatabase(fileHash, fileName) == false) {
+                    var command = connection.CreateCommand();
+                    command.CommandText =
+                    @"
+                        INSERT INTO file (filehash, filename, pathtofile)
+                        VALUES ($filehash, $filename, $pathtofile)
+                    ";
+                    command.Parameters.AddWithValue("$filehash", fileHash);
+                    command.Parameters.AddWithValue("$filename", fileName);
+                    command.Parameters.AddWithValue("$pathtofile", pathToFile);
+                    command.ExecuteNonQuery();
+                    logger.Verbose("{fileName} which is located at {pathToFile} relative to the database with the hash {fileHash} was successfully inserted into the database", fileName, pathToFile, fileHash);
+                }
+            }
+            logger.Information("All files were successfully written to the database");
+        }
+    }
+
+    private bool checkIfFileAlreadyExistsInDatabase(string fileHash, string pathToFile) {
+        string filehash = string.Empty;
+        string pathtofile = string.Empty;
+        bool doesExist = false;
+
+        using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadOnly")) {
+            connection.Open();
+
+            var command = connection.CreateCommand();
+            command.CommandText =
+            @"
+                SELECT filehash, pathtofile FROM file WHERE filehash = $filehash
+            ";
+            command.Parameters.AddWithValue("$filehash", fileHash);
+
+            using (var reader = command.ExecuteReader()) {
+                while (reader.Read()) {
+                    filehash = reader.GetString(0);
+                    pathtofile = reader.GetString(1);
+                }
+            }
+            logger.Verbose("{pathToFile} with the hash {fileHash} was successfully loaded", pathToFile, fileHash);
+        }
+
+        if (fileHash == filehash) {
+            logger.Verbose("File with filehash {filehash} already exists in the database", filehash);
+            doesExist = true;
+        }
+        return doesExist;
+    }
+
+    private bool checkIfFileMovedAndUpdatePathToFile(string fileHash, string fileName, string pathToFile) {
+        string pathtofile = string.Empty;
+        bool wasMoved = false;
+
+        using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadWrite")) {
+            connection.Open();
+
+            var command = connection.CreateCommand();
+            command.CommandText =
+            @"
+                SELECT pathtofile FROM file WHERE filehash = $filehash
+            ";
+            command.Parameters.AddWithValue("$filehash", fileHash);
+
+            using (var reader = command.ExecuteReader()) {
+                while (reader.Read()) {
+                    pathtofile = reader.GetString(0);
+                }
+            }
+
+            if (pathToFile != pathtofile && pathtofile != "") {
+                var command2 = connection.CreateCommand();
+                command2.CommandText =
+                @"
+                    UPDATE file
+                    SET pathtofile = $newpathtofile
+                    WHERE filehash = $filehash
+                ";
+                command2.Parameters.AddWithValue("$newpathtofile", pathToFile);
+                command2.Parameters.AddWithValue("$filehash", fileHash);
+                command2.ExecuteNonQuery();
+
+                Console.WriteLine("File moved or is a duplicate:");
+                Console.WriteLine($"\tfrom\t{pathToFile}");
+                Console.WriteLine($"\tto  \t{pathtofile}\n");
+                wasMoved = true;
+            }
+            logger.Verbose("{fileName} which is located at {pathToFile} relative to the database with the hash {fileHash} was successfully checked", fileName, pathToFile, fileHash);
+        }
+        return wasMoved;
+    }
+
+    public void checkIfFileWasDeleted() {
+        string pathToFile = string.Empty;
+
+        using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadWrite")) {
+            connection.Open();
+
+            var selectCommand = connection.CreateCommand();
+            selectCommand.CommandText =
+            @"
+                Select pathtofile FROM file
+            ";
+
+            using (var reader = selectCommand.ExecuteReader()) {
+                while (reader.Read()) {
+                    pathToFile = reader.GetString(0);
+                    
+                    if (File.Exists(pathToFile)) {
+                        logger.Verbose("{pathToFile} exists", pathToFile);
+                        continue;
+                    }
+                    var deleteCommand = connection.CreateCommand();
+                    deleteCommand.CommandText =
+                    @"
+                        DELETE FROM file
+                        WHERE pathtofile = $pathtofile
+                    ";
+                    deleteCommand.Parameters.AddWithValue("$pathtofile", pathToFile);
+                    deleteCommand.ExecuteNonQuery();
+
+                    Console.WriteLine("File deleted:");
+                    Console.WriteLine($"\t{pathToFile}\n");
+                    logger.Verbose("File deleted: {pathToFile}", pathToFile);
+                }
+            }
+            logger.Information("All deleted files were successfully removed from the database");
+        }
+    }
+
+    private List<string> getFilehashesFromDatabase(string connectionString) {
+        List<string> filehashesFromDatabase = new List<string>();
+        
+        using (var connection = new SqliteConnection(connectionString)) {
+            string filehash = string.Empty;
+            
+            connection.Open();
+
+            var selectCommand = connection.CreateCommand();
+            selectCommand.CommandText =
+            @"
+                Select filehash FROM file
+            ";
+
+            using (var reader = selectCommand.ExecuteReader()) {
+                while (reader.Read()) {
+                    filehash = reader.GetString(0);
+                    filehashesFromDatabase.Add(filehash);
+                }
+            }
+        }
+
+        logger.Debug("All filehashes were successfully retrived from the database");
+        return filehashesFromDatabase;
+    }
+
+    public void compareDatabases(string filePathToOtherDatabase) {
+        if (!File.Exists(filePathToOtherDatabase)) {
+            logger.Error("No database could be found at {filePathToOtherDatabase}", filePathToOtherDatabase);
+            throw new Exception("No database could be found at " + filePathToOtherDatabase);
+        }
+
+        List<string> filesThatDoNotExistsInTheRemote = getFilehashesFromDatabase("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadOnly").Except(getFilehashesFromDatabase("Data Source=" + filePathToOtherDatabase + ";Mode=ReadOnly")).ToList();
+
+        foreach (string file in filesThatDoNotExistsInTheRemote) {
+            using (var connection = new SqliteConnection("Data Source=" + DatabaseRoot + "chksum.db;Mode=ReadOnly")) {
+                string filename = string.Empty;
+                
+                connection.Open();
+
+                var selectCommand = connection.CreateCommand();
+                selectCommand.CommandText =
+                @"
+                    Select filename FROM file WHERE filehash = $filehash
+                ";
+                selectCommand.Parameters.AddWithValue("$filehash", file);
+
+                using (var reader = selectCommand.ExecuteReader()) {
+                    while (reader.Read()) {
+                        filename = reader.GetString(0);
+                        
+                        Console.WriteLine("File not found in remote:");
+                        Console.WriteLine($"\t{filename}\n");
+                        logger.Verbose("{filename} could not be found in the remote database", filename);
+                    }
+                }
+            }
+        }
+        logger.Information("Compared both databases successfully");
+    }
+
+    public void cleanup() {
+        File.Delete(libraryPath);
+        logger.Debug("Successfully deleted libe_sqlite3.so");
+    }
+}

src/chksum.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Chksum", "Chksum\Chksum.csproj", "{BBC56294-03CF-42E0-A838-75AF41EEE32B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Chksum.Tests", "Chksum.Tests\Chksum.Tests.csproj", "{239727BC-7124-4985-A6F3-2700295AA06F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{BBC56294-03CF-42E0-A838-75AF41EEE32B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BBC56294-03CF-42E0-A838-75AF41EEE32B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BBC56294-03CF-42E0-A838-75AF41EEE32B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BBC56294-03CF-42E0-A838-75AF41EEE32B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{239727BC-7124-4985-A6F3-2700295AA06F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{239727BC-7124-4985-A6F3-2700295AA06F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{239727BC-7124-4985-A6F3-2700295AA06F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{239727BC-7124-4985-A6F3-2700295AA06F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal