Ready for release

New endpoint to upload song with metadata and cover art as separate entities

Authorization/Handlers/HasScopeHandler.cs

@@ -8,25 +8,24 @@ using Icarus.Authorization;
 
 namespace Icarus.Authorization.Handlers
 {
-	public class HasScopeHandler : AuthorizationHandler<HasScopeRequirement>
+    public class HasScopeHandler : AuthorizationHandler<HasScopeRequirement>
-	{
+    {
-		protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, HasScopeRequirement requirement)
-													  HasScopeRequirement requirement)
+        {
-		{
+            if (!context.User.HasClaim(c => c.Type == "scope" && c.Issuer == requirement.Issuer))
-			if (!context.User.HasClaim(c => c.Type == "scope" && c.Issuer == requirement.Issuer))
+            {
-			{
+                return Task.CompletedTask;
-				return Task.CompletedTask;
+            }
-			}
 
-			var scopes = context.User.FindFirst(c => c.Type == "scope" && 
+            var scopes = context.User.FindFirst(c =>
-											   c.Issuer == requirement.Issuer).Value.Split(' ');
+                c.Type == "scope" && c.Issuer == requirement.Issuer).Value.Split(' ');
 
-			if (scopes.Any(s => s == requirement.Scope))
+            if (scopes.Any(s => s == requirement.Scope))
-			{
+            {
-				context.Succeed(requirement);
+                context.Succeed(requirement);
-			}
+            }
 
-			return Task.CompletedTask;
+            return Task.CompletedTask;
-		}
+        }
-	}
+    }
 }

Authorization/HasScopeRequirement.cs

@@ -4,16 +4,16 @@ using Microsoft.AspNetCore.Authorization;
 
 namespace Icarus.Authorization
 {
-	public class HasScopeRequirement : IAuthorizationRequirement
+    public class HasScopeRequirement : IAuthorizationRequirement
-	{
+    {
-		public string Issuer { get; }
+        public string Issuer { get; }
-		public string Scope { get; }
+        public string Scope { get; }
 
 
-		public HasScopeRequirement(string scope, string issuer)
+        public HasScopeRequirement(string scope, string issuer)
-		{
+        {
-			Scope = scope ?? throw new ArgumentNullException(nameof(scope));
+            Scope = scope ?? throw new ArgumentNullException(nameof(scope));
-			Issuer = issuer ?? throw new ArgumentNullException(nameof(issuer));
+            Issuer = issuer ?? throw new ArgumentNullException(nameof(issuer));
-		}
+        }
-	}
+    }
 }

Constants/DirectoryPaths.cs

@@ -0,0 +1,11 @@
+using System;
+using System.IO;
+
+namespace Icarus.Constants
+{
+    public class DirectoryPaths
+    {
+        public static string CoverArtPath =>
+            Directory.GetCurrentDirectory() + "/Images/Stock/CoverArt.png";
+    }
+}

Controllers/Managers/AlbumManager.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
+
+using Microsoft.Extensions.Configuration;
 
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
@@ -8,21 +11,145 @@ using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.Managers
 {
-	public class AlbumManager : BaseManager
+    public class AlbumManager : BaseManager
-	{
+    {
-		#region Fields
+    	#region Fields
-		#endregion
+		private AlbumContext _albumContext;
+    	#endregion
 
 
-		#region Properties
+    	#region Properties
-		#endregion
+    	#endregion
 
 
-		#region Constructors
+    	#region Constructors
-		#endregion
+		public AlbumManager(IConfiguration config)
+		{
+			_config = config;
+			_connectionString = _config.GetConnectionString("DefaultConnection");
+			_albumContext = new AlbumContext(_connectionString);
+		}
+    	#endregion
 
 
-		#region Methods
+    	#region Methods
-		#endregion
+        public void SaveAlbumToDatabase(ref Song song)
-	}
+        {
+            _logger.Info("Starting process to save the album record of the song to the database");
+
+            var album = new Album();
+
+            album.Title = song.AlbumTitle;
+            album.AlbumArtist = song.Artist;
+            album.Year = song.Year.Value;
+            var albumTitle = song.AlbumTitle;
+            var albumArtist = song.Artist;
+
+            var albumRetrieved = _albumContext.Albums.FirstOrDefault(alb => alb.Title.Equals(albumTitle) && alb.AlbumArtist.Equals(albumArtist));
+
+            if (albumRetrieved == null)
+            {
+                album.SongCount = 1;
+                _albumContext.Add(album);
+                _albumContext.SaveChanges();
+
+                Console.WriteLine($"Album Id {album.AlbumID}");
+            }
+            else
+            {
+                album.AlbumID = albumRetrieved.AlbumID;
+            }
+
+            song.AlbumID = album.AlbumID;
+        }
+
+
+		public void DeleteAlbumFromDatabase(Song song)
+		{
+            var album = _albumContext.Albums.FirstOrDefault(alb => alb.Title.Equals(song.AlbumTitle));
+
+            if (album == null)
+            {
+                _logger.Info("Cannot delete the album record because it does not exist");
+                return;
+            }
+
+			DeleteAlbumFromDb(album);
+        }
+
+
+		public Album UpdateAlbumInDatabase(Song oldSong, Song newSong)
+		{
+            var albumRecord = _albumContext.Albums.FirstOrDefault(alb => alb.Title.Equals(oldSong.AlbumTitle));
+            var oldAlbumTitle = oldSong.AlbumTitle;
+            var oldAlbumArtist = oldSong.Artist;
+            var newAlbumTitle = newSong.AlbumTitle;
+            var newAlbumArtist = newSong.Artist;
+
+            var info = string.Empty;
+
+            if (string.IsNullOrEmpty(newAlbumArtist))
+                newAlbumArtist = oldAlbumArtist;
+            if (string.IsNullOrEmpty(newAlbumTitle))
+                newAlbumTitle = oldAlbumTitle;
+
+            if ((string.IsNullOrEmpty(newAlbumTitle) && string.IsNullOrEmpty(newAlbumArtist) || 
+                        oldAlbumTitle.Equals(newAlbumTitle) && oldAlbumArtist.Equals(newAlbumArtist)))
+            {
+                _logger.Info("No change to the song's album");
+                return albumRecord;
+            }
+
+            info = "Change to the song's album";
+            _logger.Info(info);
+
+            var existingAlbumRecord = _albumContext.Albums.FirstOrDefault(alb => alb.Title.Equals(oldSong.AlbumTitle));
+            if (existingAlbumRecord == null)
+            {
+                _logger.Info("Creating new album record");
+
+                var newAlbumRecord = new Album
+                {
+                    Title = newAlbumTitle,
+                    AlbumArtist = newAlbumArtist,
+                    Year = newSong.Year.Value
+                };
+
+                _albumContext.Add(newAlbumRecord);
+				_albumContext.SaveChanges();
+
+                return newAlbumRecord;
+            }
+            else
+            {
+                _logger.Info("Updating existing album record");
+
+            	existingAlbumRecord = _albumContext.Albums.FirstOrDefault(alb => alb.Title.Equals(newSong.AlbumTitle));
+                existingAlbumRecord.AlbumArtist = newAlbumArtist;
+
+                _albumContext.Update(existingAlbumRecord);
+                _albumContext.SaveChanges();
+
+                return existingAlbumRecord;
+            }
+        }
+
+		private void DeleteAlbumFromDb(Album album)
+		{
+			if (SongsInAlbum(album) <= 1)
+			{
+                _albumContext.Remove(album);
+                _albumContext.SaveChanges();
+			}
+		}
+
+		private int SongsInAlbum(Album album)
+		{
+			var sngContext = new SongContext(_connectionString);
+			var songs = sngContext.Songs.Where(sng => sng.AlbumID == album.AlbumID).ToList();
+
+			return songs.Count;
+		}
+    	#endregion
+    }
 }

Controllers/Managers/ArtistManager.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
+
+using Microsoft.Extensions.Configuration;
 
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
@@ -8,21 +11,127 @@ using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.Managers
 {
-	public class ArtistManager : BaseManager
+    public class ArtistManager : BaseManager
-	{
+    {
-		#region Fields
+    	#region Fields
-		#endregion
+		private ArtistContext _artistContext;
+    	#endregion
 
 
-		#region Properties
+    	#region Properties
-		#endregion
+    	#endregion
 
 
-		#region Constructors
+    	#region Constructors
-		#endregion
+		public ArtistManager(IConfiguration config)
+		{
+			_config = config;
+			_connectionString = _config.GetConnectionString("DefaultConnection");
+			_artistContext = new ArtistContext(_connectionString);
+		}
+    	#endregion
 
 
-		#region Methods
+    	#region Methods
-		#endregion
+        public void SaveArtistToDatabase(ref Song song)
-	}
+        {
+            _logger.Info("Starting process to save the artist record of the song to the database");
+
+            var artist = new Artist();
+
+            artist.Name = song.Artist;
+            artist.SongCount = 1;
+            var artistTitle = artist.Name;
+
+            var artistRetrieved = _artistContext.Artists.FirstOrDefault(art => art.Name.Equals(artistTitle));
+
+            if (artistRetrieved == null)
+            {
+                artist.SongCount = 1;
+                _artistContext.Add(artist);
+                _artistContext.SaveChanges();
+            }
+            else
+            {
+                artist.ArtistID = artistRetrieved.ArtistID;
+            }
+
+            song.ArtistID = artist.ArtistID;
+        }
+
+        public Artist UpdateArtistInDatabase(Song oldSongRecord, Song newSongRecord)
+        {
+            var oldArtistRecord = _artistContext.Artists.FirstOrDefault(art => art.Name.Equals(oldSongRecord.AlbumTitle));
+            var oldArtistName = oldArtistRecord.Name;
+            var newArtistName = newSongRecord.Artist;
+
+            if (string.IsNullOrEmpty(newArtistName) || oldArtistName.Equals(newArtistName))
+            {
+                _logger.Info("No change to the song's Artist");
+                return oldArtistRecord;
+            }
+
+            _logger.Info("Change to the song's record found");
+
+            if (oldArtistRecord.SongCount <= 1)
+            {
+                _logger.Info("Deleting artist record that no longer has any songs");
+
+                _artistContext.Remove(oldArtistRecord);
+                _artistContext.SaveChanges();
+            }
+
+            if (!(_artistContext.Artists.FirstOrDefault(art => art.Name.Equals(oldSongRecord.AlbumTitle)) != null))
+            {
+                _logger.Info("Creating new artist record");
+
+                var newArtistRecord = new Artist
+                {
+                    Name = newArtistName
+                };
+
+                _artistContext.Add(newArtistRecord);
+                _artistContext.SaveChanges();
+                
+                return newArtistRecord;
+            }
+            else
+            {
+                _logger.Info("Updating existing artist record");
+
+                var existingArtistRecord = _artistContext.Artists.FirstOrDefault(art => art.Name.Equals(newSongRecord.AlbumTitle));
+
+                _artistContext.Update(existingArtistRecord);
+                _artistContext.SaveChanges();
+
+                return existingArtistRecord;
+            }
+        }
+
+        public void DeleteArtistFromDatabase(Song song)
+        {
+            if (!(_artistContext.Artists.FirstOrDefault(art => art.Name.Equals(song.Artist)) != null))
+            {
+                _logger.Info("Cannot delete the artist record because it does not exist");
+                return;
+            }
+
+            var artist = _artistContext.Artists.FirstOrDefault(art => art.Name.Equals(song.Artist));
+
+            if (SongsOfArtist(artist) <= 1)
+            {
+                _artistContext.Remove(artist);
+                _artistContext.SaveChanges();
+            }
+        }
+
+		private int SongsOfArtist(Artist artist)
+		{
+			var sngContext = new SongContext(_connectionString);
+			var songs = sngContext.Songs.Where(sng => sng.ArtistID == artist.ArtistID).ToList();
+
+			return songs.Count;
+		}
+    	#endregion
+    }
 }

Controllers/Managers/BaseManagers.cs

@@ -1,13 +1,16 @@
 using System;
 
+using Microsoft.Extensions.Configuration;
 using NLog;
 
 namespace Icarus.Controllers.Managers
 {
-	public class BaseManager
+    public class BaseManager
-	{
+    {
-		#region Fields
+    	#region Fields
-		protected static Logger _logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
+    	protected static Logger _logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
-		#endregion
+        protected IConfiguration _config;
-	}
+        protected string _connectionString;
+    	#endregion
+    }
 }

Controllers/Managers/CoverArtManager.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+
+using Icarus.Constants;
+using Icarus.Controllers.Utilities;
+using Icarus.Database.Contexts;
+using Icarus.Models;
+using Icarus.Types;
+
+namespace Icarus.Controllers.Managers
+{
+    public class CoverArtManager : BaseManager
+    {
+        #region Fields
+        private string _rootCoverArtPath;
+        private CoverArtContext _coverArtContext;
+        private byte[] _stockCoverArt = null;
+        #endregion
+
+
+        #region Constructors
+        public CoverArtManager(IConfiguration config)
+        {
+            _config = config;
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+            _rootCoverArtPath = _config.GetValue<string>("CoverArtPath");
+            Initialize();
+        }
+        #endregion
+
+
+        #region Methods
+        public void SaveCoverArtToDatabase(ref Song song, ref CoverArt coverArt)
+        {
+            _logger.Info("Saving cover art record to the database");
+            _coverArtContext.Add(coverArt);
+            _coverArtContext.SaveChanges();
+
+            song.CoverArtID = coverArt.CoverArtID;
+        }
+        public void DeleteCoverArtFromDatabase(CoverArt coverArt)
+        {
+            _logger.Info("Attempting to delete cover art from the database");
+
+            _coverArtContext.Remove(coverArt);
+            _coverArtContext.SaveChanges();
+        }
+        public void DeleteCoverArt(CoverArt coverArt)
+        {
+            try
+            {
+                var stockCoverArtPath = _rootCoverArtPath + "CoverArt.png";
+                if (!string.Equals(stockCoverArtPath, coverArt.ImagePath, 
+                            StringComparison.CurrentCultureIgnoreCase))
+                {
+                    _logger.Info("Song does not contain the stock cover art");
+                    File.Delete(coverArt.ImagePath);
+                    _logger.Info("Cover art deleted from the filesystem");
+                }
+                else
+                {
+                    _logger.Info("Song contains the stock cover art");
+                    _logger.Info("Will not delete from from the filesystem");
+                }
+            }
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                _logger.Error(msg, "An error occurred");
+            }
+        }
+
+        public CoverArt SaveCoverArt(Song song)
+        {
+            try
+            {
+                var dirMgr = new DirectoryManager(_rootCoverArtPath);
+                var defaultExtension = ".png";
+                dirMgr.CreateDirectory(song);
+
+                var coverArt = new CoverArt
+                {
+                    SongTitle = song.Title
+                };
+
+                var segment = coverArt.GenerateFilename(0);
+                var imagePath = dirMgr.SongDirectory + segment + defaultExtension;
+
+                coverArt.ImagePath = imagePath;
+
+                var metaData = new MetadataRetriever();
+                var imgBytes = metaData.RetrieveCoverArtBytes(song);
+                
+                if (imgBytes != null)
+                {
+                    _logger.Info("Saving cover art to the filesystem");
+                    File.WriteAllBytes(coverArt.ImagePath, imgBytes);
+                }
+                else
+                {
+                    _logger.Info("Song has no cover art, applying stock cover art");
+                    coverArt.ImagePath = _rootCoverArtPath + $"{segment}{defaultExtension}";
+                    metaData.UpdateCoverArt(song, coverArt);
+                    File.WriteAllBytes(coverArt.ImagePath, _stockCoverArt);
+                }
+
+                return coverArt;
+            }
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                _logger.Error(msg, "An error occurred");
+            }
+            
+            return null;
+        }
+
+        public CoverArt SaveCoverArt(IFormFile data, Song song)
+        {
+            var cover = new CoverArt { SongTitle = song.Title };
+
+            try
+            {
+                var dirMgr = new DirectoryManager(_rootCoverArtPath);
+                var defaultExtension = ".png";
+                dirMgr.CreateDirectory(song);
+
+                var segment = cover.GenerateFilename(0);
+                var imagePath = dirMgr.SongDirectory + segment + defaultExtension;
+
+                cover.ImagePath = imagePath;
+
+                using (var fileStream = new FileStream(imagePath, FileMode.Create))
+                {
+                    data.CopyTo(fileStream);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex.Message, "An error occurred");
+            }
+
+            return cover;
+        }
+
+        public CoverArt GetCoverArt(Song song)
+        {
+            return _coverArtContext.CoverArtImages.FirstOrDefault(cov => cov.SongTitle.Equals(song.Title));
+        }
+
+        private void Initialize()
+        {
+            _coverArtContext = new CoverArtContext(_connectionString);
+
+            if (System.IO.File.Exists(DirectoryPaths.CoverArtPath))
+                _stockCoverArt = File.ReadAllBytes(DirectoryPaths.CoverArtPath);
+
+            if (!File.Exists(_rootCoverArtPath + "CoverArt.png"))
+            {
+                File.WriteAllBytes(_rootCoverArtPath + "CoverArt.png", 
+                        _stockCoverArt);
+                Console.WriteLine("Copied Stock Cover Art");
+            }
+        }
+        #endregion
+    }
+}

Controllers/Managers/DirectoryManager.cs

@@ -5,201 +5,228 @@ using System.Linq;
 using Microsoft.Extensions.Configuration;
 
 using Icarus.Models;
+using Icarus.Types;
 
 namespace Icarus.Controllers.Managers
 {
-	public class DirectoryManager : BaseManager
+    // NOTE: Do not use metadata for the song's metadata
-    	{
+    public class DirectoryManager : BaseManager
- 		#region Fields
+    {
-		private IConfiguration _config;
+        #region Fields
-        	private Song _song;
+        private Song _song;
-		private string _rootSongDirectory;
+        private string _rootSongDirectory;
-		private string _songDirectory;
+        private string _songDirectory;
-		#endregion
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		public string SongDirectory
+        public string SongDirectory
-		{
+        {
-	    		get => _songDirectory;
+            get => _songDirectory;
-	    		set => _songDirectory = value;
+            set => _songDirectory = value;
-		}
+        }
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		public DirectoryManager(IConfiguration config, Song song)
+        public DirectoryManager(IConfiguration config, Song song)
-		{
+        {
-	    		_config = config;
+            _config = config;
-	    		_song = song;
+            _song = song;
-	    		Initialize();
+            Initialize();
-		}
+        }
-		public DirectoryManager(IConfiguration config)
+        public DirectoryManager(IConfiguration config)
-		{
+        {
-			_config = config;
+            _config = config;
-			Initialize();
+            Initialize();
-		}
+        }
-		#endregion
+        public DirectoryManager(string rootDirectory)
+        {
+            _rootSongDirectory = rootDirectory;
+        }
+        #endregion
 
 
-		#region Methods
+        #region Methods
-		public void CreateDirectory()
+        public void CreateDirectory()
-		{
+        {
-	    		try
+            CreateDirectory(_song);
-	    		{
+        }
-	        		_songDirectory = AlbumDirectory();
+        public void CreateDirectory(Song song)
+        {
+            _song = song;
 
-                		if (!Directory.Exists(_songDirectory))
+            try
-				{
+            {
-		    			Directory.CreateDirectory(_songDirectory);
+                _songDirectory = AlbumDirectory();
-		    			Console.WriteLine("The directory has been created");
-				}
 
+                if (!Directory.Exists(_songDirectory))
+                {
+                    Directory.CreateDirectory(_songDirectory);
+                    Console.WriteLine($"The directory has been created");
+                }
 
-				Console.WriteLine($"The song will be saved in the following" +
+                Console.WriteLine($"The song will be saved in the following" +
-				  $" directory: {_songDirectory}");
+                        $" directory: {_songDirectory}");
-	    		}
+            }
-	    		catch (Exception ex)
+            catch (Exception ex)
-	    		{
+            {
-	        		Console.WriteLine($"An error occurred {ex.Message}");
+                var msg = ex.Message;
-	    		}
+                _logger.Error(msg, "An error occurred");
-		}
+            }
-		public void DeleteEmptyDirectories()
+        }
-		{
+        public void DeleteEmptyDirectories()
-	    		try
+        {
-	    		{
+            try
-	        		var albumDirectory = AlbumDirectory();
+            {
-				var artistDirectory = ArtistDirectory();
+                var albumDirectory = AlbumDirectory();
-				if (IsDirectoryEmpty(albumDirectory))
+                var artistDirectory = ArtistDirectory();
-				{
+                if (IsDirectoryEmpty(albumDirectory))
-		    			Directory.Delete(albumDirectory);
+                {
-		    			Console.WriteLine($"directory {albumDirectory} deleted");
+                        Directory.Delete(albumDirectory);
-				}
+                        Console.WriteLine($"directory {albumDirectory} deleted");
-				if (IsDirectoryEmpty(artistDirectory))
+                }
-				{
+                if (IsDirectoryEmpty(artistDirectory))
-		    			Directory.Delete(artistDirectory);
+                {
-		    			Console.WriteLine($"directory {artistDirectory} deleted");
+                        Directory.Delete(artistDirectory);
-				}
+                        Console.WriteLine($"directory {artistDirectory} deleted");
-	    		}
+                }
-	    		catch (Exception ex)
+            }
-	    		{
+            catch (Exception ex)
-	        		var exMsg = ex.Message;
+            {
-				Console.WriteLine($"An error occurred {exMsg}");
+                var exMsg = ex.Message;
-	    		}
+                Console.WriteLine($"An error occurred {exMsg}");
-		}
+            }
-		public void DeleteEmptyDirectories(Song song)
+        }
-		{
+        public void DeleteEmptyDirectories(Song song)
-			try
+        {
-			{
+            try
-				var albumDirectory = AlbumDirectory(song);
+            {
-				var artistDirectory = ArtistDirectory(song);
+                var albumDirectory = AlbumDirectory(song);
+                var artistDirectory = ArtistDirectory(song);
 
-				if (IsDirectoryEmpty(albumDirectory))
+                if (IsDirectoryEmpty(albumDirectory))
-				{
+                {
-		    			Directory.Delete(albumDirectory);
+                        Directory.Delete(albumDirectory);
-					_logger.Info("Album directory deleted");
+                    _logger.Info("Album directory deleted");
-				}
+                }
-				if (IsDirectoryEmpty(artistDirectory))
+                if (IsDirectoryEmpty(artistDirectory))
-				{
+                {
-		    			Directory.Delete(artistDirectory);
+                        Directory.Delete(artistDirectory);
-					_logger.Info("Artist directory deleted");
+                    _logger.Info("Artist directory deleted");
-				}
+                }
-			}
+            }
-			catch (Exception ex)
+            catch (Exception ex)
-			{
+            {
-				var msg = ex.Message;
+                var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
+                _logger.Error(msg, "An error occurred");
-			}
+            }
-		}
+        }
 
-		public string RetrieveAlbumPath(Song song)
+        public string RetrieveAlbumPath(Song song)
-		{
+        {
-			_logger.Info("Retrieving album song path");
+            _logger.Info("Retrieving album song path");
 
-			var albumPath = string.Empty;
+            var albumPath = string.Empty;
-			albumPath = AlbumDirectory(song);
+            albumPath = AlbumDirectory(song);
 
-			return albumPath;
+            return albumPath;
-		}
+        }
-		public string RetrieveArtistPath(Song song)
+        public string RetrieveArtistPath(Song song)
-		{
+        {
-			_logger.Info("Retrieving artist path");
+            _logger.Info("Retrieving artist path");
 
-			var artistPath = string.Empty;
+            var artistPath = string.Empty;
-			artistPath = ArtistDirectory(song);
+            artistPath = ArtistDirectory(song);
 
-			return artistPath;
+            return artistPath;
-		}
+        }
-		public string GenerateSongPath(Song song)
-		{
-			_logger.Info("Generating song path");
 
-			var songPath = string.Empty;
+        public string GenerateSongPath(Song song)
-			var artistPath = ArtistDirectory(song);
+        {
-			var albumPath = AlbumDirectory(song);
+            _logger.Info("Generating song path");
 
-			if (!Directory.Exists(artistPath))
+            var songPath = string.Empty;
-			{
+            var artistPath = ArtistDirectory(song);
-				_logger.Info("Artist path does not exist");
+            var albumPath = AlbumDirectory(song);
 
-				Directory.CreateDirectory(artistPath);
+            if (!Directory.Exists(artistPath))
+            {
+                _logger.Info("Artist path does not exist");
 
-				_logger.Info("Creating artist path");
+                Directory.CreateDirectory(artistPath);
-			}
-			if (!Directory.Exists(albumPath))
-			{
-				_logger.Info("Album path does not exist");
 
-				Directory.CreateDirectory(albumPath);
+                _logger.Info("Creating artist path");
+            }
+            if (!Directory.Exists(albumPath))
+            {
+                _logger.Info("Album path does not exist");
 
-				_logger.Info("Created album path");
+                Directory.CreateDirectory(albumPath);
-			}
 
-			songPath = albumPath;
+                _logger.Info("Created album path");
+            }
 
-			return songPath;
+            songPath = albumPath;
-		}
 
-		private void Initialize()
+            return songPath;
-		{
+        }
-	    		_rootSongDirectory = _config.GetValue<string>("RootMusicPath");
-		}
 
-		private bool IsDirectoryEmpty(string path)
+        private void Initialize(DirectoryType dirTypes = DirectoryType.Music)
-		{
+        {
-    	    		return !Directory.EnumerateFileSystemEntries(path).Any();
+            switch (dirTypes)
-		}
+            {
+                case DirectoryType.Music:
+                    _rootSongDirectory = _config.GetValue<string>("RootMusicPath");
+                    break;
+                case DirectoryType.CoverArt:
+                    _rootSongDirectory = _config.GetValue<string>("CoverArtPath");
+                    break;
+            }
+        }
 
-		private string AlbumDirectory()
+        private bool IsDirectoryEmpty(string path)
-		{
+        {
-	    		string directory = _rootSongDirectory;
+            return !Directory.EnumerateFileSystemEntries(path).Any();
-	    		directory += $@"{_song.Artist}/{_song.AlbumTitle}/";
+        }
 
-            		return directory;
+        private string AlbumDirectory()
-		}
+        {
-		private string AlbumDirectory(Song song)
+            return AlbumDirectory(_song);
-		{
+        }
-			var directory = _rootSongDirectory;
+        private string AlbumDirectory(Song song)
-			directory += $@"{song.Artist}/{song.AlbumTitle}/";
+        {
-			Console.WriteLine($"Album directory {directory}");
+            var directory = ArtistDirectory(song);
+            var segment = SerializeValue(song.AlbumTitle);
+            directory += $@"{segment}/";
+            Console.WriteLine($"Album directory {directory}");
 
-			return directory;
+            return directory;
-		}
+        }
-		private string ArtistDirectory()
+        private string ArtistDirectory()
-		{
+        {
-	    		var directory = _rootSongDirectory;
+            return ArtistDirectory(_song);
-	    		directory += $@"{_song.Artist}/";
+        }
+        private string ArtistDirectory(Song song)
+        {
+            var directory = _rootSongDirectory;
+            var segment = SerializeValue(song.Artist);
+            directory += $@"{segment}/";
+            Console.WriteLine($"Artist directory {directory}");
 
-	    		return directory;
+            return directory;
-		}
+        }
-		private string ArtistDirectory(Song song)
-		{
-			var directory = _rootSongDirectory;
-			directory += $@"{song.Artist}/";
-			Console.WriteLine($"Artist directory {directory}");
 
-			return directory;
+        private string SerializeValue(string value)
-		}
+        {
-		#endregion
+            const int length = 15;
-    	}
+            const string chars = "ABCDEF0123456789";
+            var random = new Random();
+            var output = new string(Enumerable.Repeat(chars, length).Select(s =>
+                s[random.Next(s.Length)]).ToArray());
+
+            return output;
+        }
+        #endregion
+    }
 }

Controllers/Managers/GenreManager.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
+
+using Microsoft.Extensions.Configuration;
 
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
@@ -8,21 +11,127 @@ using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.Managers
 {
-	public class GenreManager : BaseManager
+    public class GenreManager : BaseManager
-	{
+    {
-		#region Fields
+    	#region Fields
-		#endregion
+		private GenreContext _genreContext;
+    	#endregion
 
 
-		#region Properties
+    	#region Properties
-		#endregion
+    	#endregion
 
 
-		#region Constructors
+    	#region Constructors
-		#endregion
+		public GenreManager(IConfiguration config)
+		{
+			_config = config;
+			_connectionString = _config.GetConnectionString("DefaultConnection");
+			_genreContext = new GenreContext(_connectionString);
+		}
+    	#endregion
 
 
-		#region Methods
+    	#region Methods
-		#endregion
+        public void SaveGenreToDatabase(ref Song song)
-	}
+        {
+            _logger.Info("Starting process to save the genre record of the song to the database");
+
+            var genre = new Genre
+            {
+                GenreName = song.Genre,
+                SongCount = 1
+            };
+
+            var genreName = song.Genre;
+            var genreRetrieved = _genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(genreName));
+
+            if (genreRetrieved == null)
+            {
+                _genreContext.Add(genre);
+                _genreContext.SaveChanges();
+            }
+            else
+            {
+                genre.GenreID = genreRetrieved.GenreID;
+            }
+
+            song.GenreID = genre.GenreID;
+        }
+
+        public Genre UpdateGenreInDatabase(Song oldSongRecord, Song newSongRecord)
+        {
+            var oldGenreRecord = _genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(oldSongRecord.Genre));
+            var oldGenreName = oldGenreRecord.GenreName;
+            var newGenreName = newSongRecord.Genre;
+
+            if (string.IsNullOrEmpty(newGenreName) || oldGenreName.Equals(newGenreName))
+            {
+                _logger.Info("No change to the song's Genre");
+                return oldGenreRecord;
+            }
+
+            _logger.Info("Change to the song's genre found");
+
+            if (oldGenreRecord.SongCount <= 1)
+            {
+                _logger.Info("Deleting genre record");
+
+                _genreContext.Remove(oldGenreRecord);
+                _genreContext.SaveChanges();
+            }
+
+            if (!(_genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(oldSongRecord.Genre)) != null))
+            {
+                _logger.Info("Creating new genre record");
+
+                var newGenreRecord = new Genre
+                {
+                    GenreName = newGenreName
+                };
+
+                _genreContext.Add(newGenreRecord);
+                _genreContext.SaveChanges();
+
+                return newGenreRecord;
+            }
+            else
+            {
+                _logger.Info("Updating existing genre record");
+
+                var existingGenreRecord = _genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(oldGenreRecord.GenreName));
+
+                _genreContext.Update(existingGenreRecord);
+                _genreContext.SaveChanges();
+
+                return existingGenreRecord;
+            }
+        }
+
+        public void DeleteGenreFromDatabase(Song song)
+        {
+            if (!(_genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(song.Genre)) != null))
+            {
+                _logger.Info("Cannot delete the genre record because it does not exist");
+                return;
+            }
+
+            var genre = _genreContext.Genres.FirstOrDefault(gnr => gnr.GenreName.Equals(song.Genre));
+
+            if (SongsInGenre(genre) <= 1)
+            {
+                _genreContext.Remove(genre);
+                _genreContext.SaveChanges();
+            }
+        }
+
+		private int SongsInGenre(Genre genre)
+		{
+			var sngContext = new SongContext(_connectionString);
+			var songs = sngContext.Songs.Where(sng => sng.GenreID == genre.GenreID).ToList();
+
+			return songs.Count;
+		}
+    	#endregion
+    }
 }

Controllers/Managers/TokenManager.cs

@@ -10,132 +10,124 @@ using Icarus.Models;
 
 namespace Icarus.Controllers.Managers
 {
-	public class TokenManager : BaseManager
+    public class TokenManager : BaseManager
-	{
+    {
-		#region Fields
+        #region Fields
-		private IConfiguration _config;
+        private string _clientId;
-		private string _clientId;
+        private string _clientSecret;
-		private string _clientSecret;
+        private string _audience;
-		private string _audience;
+        private string _grantType;
-		private string _grantType;
+        private string _url;
-		private string _url;
+        #endregion
-		#endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		public TokenManager(IConfiguration config)
+        public TokenManager(IConfiguration config)
-		{
+        {
-			_config = config;
+            _config = config;
-			InitializeValues();
+            InitializeValues();
-		}
+        }
-		#endregion
+        #endregion
 
 
-		#region Methods
+        #region Methods
-		public LoginResult RetrieveLoginResult(User user)
+        public LoginResult RetrieveLoginResult(User user)
-		{
+        {
-			_logger.Info("Preparing Auth0 API request");
+            _logger.Info("Preparing Auth0 API request");
 
-			var client = new RestClient(_url);
+            var client = new RestClient(_url);
-			var request = new RestRequest("oauth/token", Method.POST);
+            var request = new RestRequest("oauth/token", Method.POST);
-			var tokenRequest = RetrieveTokenRequest();
+            var tokenRequest = RetrieveTokenRequest();
 
-			_logger.Info("Serializing token object into JSON");
+            _logger.Info("Serializing token object into JSON");
-			var tokenObject = JsonConvert.SerializeObject(tokenRequest);
+            var tokenObject = JsonConvert.SerializeObject(tokenRequest);
-			Console.WriteLine(tokenObject);
-			request.AddParameter("application/json; charset=utf-8", 
-					tokenObject, ParameterType.RequestBody);
 
-			request.RequestFormat = DataFormat.Json;
+            request.AddParameter("application/json; charset=utf-8", 
+                tokenObject, ParameterType.RequestBody);
 
-			_logger.Info("Sending request");
+            request.RequestFormat = DataFormat.Json;
-			IRestResponse response = client.Execute(request);
+
-			_logger.Info("Response received");
+            _logger.Info("Sending request");
+            IRestResponse response = client.Execute(request);
+            _logger.Info("Response received");
 
 
-			_logger.Info("Deserializing response");
+            _logger.Info("Deserializing response");
-			var tokenResult = JsonConvert
+            var tokenResult = JsonConvert
-				.DeserializeObject<Token>(response.Content);
+                .DeserializeObject<Token>(response.Content);
-			_logger.Info("Response deserialized");
+            _logger.Info("Response deserialized");
-			Console.WriteLine(response.Content);
 
-			return new LoginResult
+            return new LoginResult
-			{
+            {
-				UserId = user.Id,
+                UserID = user.UserID, Username = user.Username, Token = tokenResult.AccessToken,
-				Username = user.Username,
+                TokenType = tokenResult.TokenType, Expiration = tokenResult.Expiration,
-				Token = tokenResult.AccessToken,
+                Message = "Successfully retrieved token"
-				TokenType = tokenResult.TokenType,
+            };
-				Expiration = tokenResult.Expiration,
+        }
-				Message = "Successfully retrieved token"
-			};
-		}
         
-		private TokenRequest RetrieveTokenRequest()
+        private TokenRequest RetrieveTokenRequest()
-		{
+        {
-			_logger.Info("Retrieving token object");
+            _logger.Info("Retrieving token object");
 
-			return new TokenRequest
+            return new TokenRequest
-			{
+            {
-				ClientId = _clientId,
+                ClientId = _clientId, ClientSecret = _clientSecret,
-				ClientSecret = _clientSecret,
+                Audience = _audience, GrantType = _grantType
-				Audience = _audience,
+            };
-				GrantType = _grantType
+        }
-			};
-		}
 
-		private void InitializeValues()
+        private void InitializeValues()
-		{
+        {
-			_logger.Info("Analyzing Auth0 information");
+            _logger.Info("Analyzing Auth0 information");
 
-			_clientId = _config["Auth0:ClientId"];
+            _clientId = _config["Auth0:ClientId"];
-			_clientSecret = _config["Auth0:ClientSecret"];
+            _clientSecret = _config["Auth0:ClientSecret"];
-			_audience = _config["Auth0:ApiIdentifier"];
+            _audience = _config["Auth0:ApiIdentifier"];
-			_grantType = "client_credentials";
+            _grantType = "client_credentials";
-			_url = $"https://{_config["Auth0:Domain"]}";
+            _url = $"https://{_config["Auth0:Domain"]}";
 
-			PrintCredentials();
+            PrintCredentials();
+        }
 
-		}
+        #region Testing Methods
-
+        // For testing purposes
-		#region Testing Methods
+        private void PrintCredentials()
-		// For testing purposes
+        {
-		private void PrintCredentials()
+            Console.WriteLine("Auth0 credentials:");
-		{
+            Console.WriteLine($"Client Id: {_clientId}");
-			Console.WriteLine("Auth0 credentials:");
+            Console.WriteLine($"Client Secret: {_clientSecret}");
-			Console.WriteLine($"Client Id: {_clientId}");
+            Console.WriteLine($"Audience: {_audience}");
-			Console.WriteLine($"Client Secret: {_clientSecret}");
+            Console.WriteLine($"Url: {_url}");
-			Console.WriteLine($"Audience: {_audience}");
+        }
-			Console.WriteLine($"Url: {_url}");
+        #endregion
-		}
+        #endregion
-		#endregion
-		#endregion
 
 
-		#region Classes
+        #region Classes
-		private class TokenRequest
+        private class TokenRequest
-		{
+        {
-			[JsonProperty("client_id")]
+            [JsonProperty("client_id")]
-			public string ClientId { get; set; }
+            public string ClientId { get; set; }
-			[JsonProperty("client_secret")]
+            [JsonProperty("client_secret")]
-			public string ClientSecret { get; set; }
+            public string ClientSecret { get; set; }
-			[JsonProperty("audience")]
+            [JsonProperty("audience")]
-			public string Audience { get; set; }
+            public string Audience { get; set; }
-			[JsonProperty("grant_type")]
+            [JsonProperty("grant_type")]
-			public string GrantType { get; set; }
+            public string GrantType { get; set; }
-		}
+        }
-		private class Token
+        private class Token
-		{
+        {
-			[JsonProperty("access_token")]
+            [JsonProperty("access_token")]
-			public string AccessToken { get; set; }
+            public string AccessToken { get; set; }
-			[JsonProperty("expires_in")]
+            [JsonProperty("expires_in")]
-			public int Expiration { get; set; }
+            public int Expiration { get; set; }
-			[JsonProperty("token_type")]
+            [JsonProperty("token_type")]
-			public string TokenType { get; set; }
+            public string TokenType { get; set; }
-		}
+        }
-		#endregion
+        #endregion
-	}
+    }
 }

Controllers/Managers/YearManager.cs

@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Configuration;
-
-using Icarus.Controllers.Utilities;
-using Icarus.Models;
-using Icarus.Database.Contexts;
-
-namespace Icarus.Controllers.Managers
-{
-	public class YearManager : BaseManager
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		#endregion
-
-
-		#region Methods
-		#endregion
-	}
-}

Controllers/Utilities/MetadataRetriever.cs

@@ -9,284 +9,337 @@ using Icarus.Models;
 
 namespace Icarus.Controllers.Utilities
 {
-	public class MetadataRetriever
+    public class MetadataRetriever
-	{
+    {
-		#region Fields
+        #region Fields
-		private static NLog.Logger _logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
+        private static NLog.Logger _logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
-		private Song _updatedSong;
+        private Song _updatedSong;
-		private string _message;
+        private string _message;
-		private string _title;
+        private string _title;
-		private string _artist;
+        private string _artist;
-		private string _album;
+        private string _album;
-		private string _genre;
+        private string _genre;
-		private int _year;
+        private int _year;
-		private int _duration;
+        private int _duration;
-		#endregion
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		public Song UpdatedSongRecord
+        public Song UpdatedSongRecord
-		{
+        {
-			get => _updatedSong;
+            get => _updatedSong;
-			set => _updatedSong = value;
+            set => _updatedSong = value;
-		}
+        }
-		public string Message
+        public string Message
-		{
+        {
-			get => _message;
+            get => _message;
-			set => _message = value;
+            set => _message = value;
-		}
+        }
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		#endregion
+        #endregion
 
 
-		#region Methods
+        #region Methods
-		public static void PrintMetadata(Song song)
+        public static void PrintMetadata(Song song)
-		{
+        {
-			Console.WriteLine("\n\nMetadata of the song:");
+            Console.WriteLine("\n\nMetadata of the song:");
-			Console.WriteLine($"Id: {song.Id}");
+            Console.WriteLine($"ID: {song.SongID}");
-			Console.WriteLine($"Title: {song.Title}");
+            Console.WriteLine($"Title: {song.Title}");
-			Console.WriteLine($"Artist: {song.Artist}");
+            Console.WriteLine($"Artist: {song.Artist}");
-			Console.WriteLine($"Album: {song.AlbumTitle}");
+            Console.WriteLine($"Album: {song.AlbumTitle}");
-			Console.WriteLine($"Genre: {song.Genre}");
+            Console.WriteLine($"Genre: {song.Genre}");
-			Console.WriteLine($"Year: {song.Year}");
+            Console.WriteLine($"Year: {song.Year}");
-			Console.WriteLine($"Duration: {song.Duration}");
+            Console.WriteLine($"Duration: {song.Duration}");
-			Console.WriteLine($"AlbumId: {song.AlbumId}");
+            Console.WriteLine($"AlbumID: {song.AlbumID}");
-			Console.WriteLine($"ArtistId: {song.ArtistId}");
+            Console.WriteLine($"ArtistID: {song.ArtistID}");
-			Console.WriteLine($"GenreId: {song.GenreId}");
+            Console.WriteLine($"GenreID: {song.GenreID}");
-			Console.WriteLine($"YearId: {song.YearId}");
+            Console.WriteLine($"Song Path: {song.SongPath()}");
-			Console.WriteLine($"Song Path: {song.SongPath}");
+            Console.WriteLine($"Filename: {song.Filename}");
-			Console.WriteLine($"Filename: {song.Filename}");
+            Console.WriteLine("\n");
-			Console.WriteLine("\n");
 
-			_logger.Info("Metadata of the song");
+            _logger.Info("Metadata of the song");
-			_logger.Info($"Title: {song.Title}");
+            _logger.Info($"Title: {song.Title}");
-			_logger.Info($"Artist: {song.Artist}");
+            _logger.Info($"Artist: {song.Artist}");
-			_logger.Info($"Album: {song.AlbumTitle}");
+            _logger.Info($"Album: {song.AlbumTitle}");
-			_logger.Info($"Genre: {song.Genre}");
+            _logger.Info($"Genre: {song.Genre}");
-			_logger.Info($"Year: {song.Year}");
+            _logger.Info($"Year: {song.Year}");
-			_logger.Info($"Duration: {song.Duration}");
+            _logger.Info($"Duration: {song.Duration}");
-		}
+        }
-		public Song RetrieveMetaData(string filePath)
+        public Song RetrieveMetaData(string filePath)
-		{
+        {
-			Song song = new Song();
+            Song song = new Song();
 
-			try
+            try
-			{
+            {
-				TagLib.File fileTag = TagLib.File.Create(filePath);
+                TagLib.File fileTag = TagLib.File.Create(filePath);
-				_title = fileTag.Tag.Title;
+                _title = fileTag.Tag.Title;
-				_artist = string.Join("", fileTag.Tag.Performers);
+                _artist = string.Join("", fileTag.Tag.Performers);
-				_album = fileTag.Tag.Album;
+                _album = fileTag.Tag.Album;
-				_genre = string.Join("", fileTag.Tag.Genres);
+                _genre = string.Join("", fileTag.Tag.Genres);
-				_year = (int)fileTag.Tag.Year;
+                _year = (int)fileTag.Tag.Year;
-				_duration = (int)fileTag.Properties.Duration.TotalSeconds;
+                _duration = (int)fileTag.Properties.Duration.TotalSeconds;
+                var albumArtist = string.Join("", fileTag.Tag.AlbumArtists);
+                var track = (int)fileTag.Tag.Track;
+                var disc = (int)fileTag.Tag.Disc;
 
-				song.Title = _title;
+                song.Title = _title;
-				song.Artist = _artist;
+                song.Artist = _artist;
-				song.AlbumTitle = _album;
+                song.AlbumTitle = _album;
-				song.Genre = _genre;
+                song.AlbumArtist = albumArtist;
-				song.Year = _year;
+                song.Genre = _genre;
-				song.Duration = _duration;
+                song.Year = _year;
-			}
+                song.Duration = _duration;
-			catch (Exception ex)
+                song.Track = track;
-			{
+                song.Disc = disc;
-				var msg = ex.Message;
+                song.TrackCount = (int)fileTag.Tag.TrackCount;
-				Console.WriteLine("An error occurred in MetadataRetriever");
+                song.DiscCount = (int)fileTag.Tag.DiscCount;
-				Console.WriteLine(msg);
+            }
-				_logger.Error(msg, "An error occurred in MetadataRetriever");
+            catch (Exception ex)
-			}
+            {
+                var msg = ex.Message;
+                Console.WriteLine("An error occurred in MetadataRetriever");
+                Console.WriteLine(msg);
+                _logger.Error(msg, "An error occurred in MetadataRetriever");
+            }
 
-			return song;
+            return song;
-		}
+        }
 
-		public void UpdateMetadata(Song song)
+        public int RetrieveSongDuration(string filepath)
-		{
+        {
-			try
+            var duration = 0;
-			{
+            var fileTag = TagLib.File.Create(filepath);
-				Console.WriteLine("Updating song metadata"); 
+            duration = (int)fileTag.Properties.Duration.TotalSeconds;
-				_logger.Info("Updating song metadata");
-				var filePath = song.SongPath;
-				TagLib.File fileTag = TagLib.File.Create(filePath);
-				fileTag.Tag.Title = song.Title;
-				fileTag.Tag.Genres = new []{song.Genre};
-				fileTag.Save();
-				Console.WriteLine("Song metadata updated");
-				_logger.Info("Song metadata updated");
 
-			}
+            return duration;
-			catch (Exception ex)
+        }
-			{
-				var msg = ex.Message;
-				Console.WriteLine($"An error occurred: \n{msg}");
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void UpdateMetadata(Song updatedSong, Song oldSong)
-		{
-			try
-			{
-				InitializeUpdatedSong(oldSong);
-				var songValues = CheckSongValues(updatedSong);
-				PerformUpdate(updatedSong, songValues);
-				Message = "Successfully updated metadata";
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				Console.WriteLine($"An error occurred: {msg}");
-				_logger.Error(msg, "An error occurred");
-				Message = "Failed to update metadata";
-			}
-		}
 
-		private void PerformUpdate(Song updatedSong, SortedDictionary<string, bool> checkedValues)
+        public byte[] RetrieveCoverArtBytes(Song song)
-		{
+        {
-			var filePath = updatedSong.SongPath;
+            try
-			var title = updatedSong.Title;
+            {
-			var artist = updatedSong.Artist;
+                Console.WriteLine("Fetching image");
-			var album = updatedSong.AlbumTitle;
+                var tag = TagLib.File.Create(song.SongPath());
-			var genre = updatedSong.Genre;
+                byte[] imgBytes = tag.Tag.Pictures[0].Data.Data;
-			var year = updatedSong.Year;
-			TagLib.File fileTag = TagLib.File.Create(filePath);
-			try
-			{
-				Console.WriteLine($"Updating metadata of {title}");
-				_logger.Info($"Updating metadata of {title}");
             
-				foreach (var key in checkedValues.Keys)
+                return imgBytes;
-				{
+            }
-					bool result = checkedValues[key];
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                _logger.Error(msg, "An error occurred in MetadataRetriever");
+            }
+
+            return null;
+        }
 
         
-					if (!result)
+        public void UpdateMetadata(Song updatedSong, Song oldSong)
-					{
+        {
-						switch (key.ToLower())
+            try
-						{
+            {
-							case "title":
+                InitializeUpdatedSong(oldSong);
-								_updatedSong.Title = title;
+                var songValues = CheckSongValues(updatedSong);
-								fileTag.Tag.Title = title;
+                PerformUpdate(updatedSong, songValues);
-								break;
+                Message = "Successfully updated metadata";
-							case "artists":
+            }
-								_updatedSong.Artist = artist;
+            catch (Exception ex)
-								fileTag.Tag.Performers = new []{artist};
+            {
-								break;
+                var msg = ex.Message;
-							case "album":
+                Console.WriteLine($"An error occurred: {msg}");
-								_updatedSong.AlbumTitle = album;
+                _logger.Error(msg, "An error occurred");
-								fileTag.Tag.Album = album;
+                Message = "Failed to update metadata";
-								break;
+            }
-							case "genre":
+        }
-								_updatedSong.Genre = genre;
+        public void UpdateCoverArt(Song song, CoverArt coverArt)
-								fileTag.Tag.Genres = new []{genre};
+        {
-								break;
+            Console.WriteLine("Updating song's cover art");
-							case "year":
-								_updatedSong.Year = year;
-								fileTag.Tag.Year = (uint)year;
-								break;
-						}
-					}
-				}
 
-				fileTag.Save();
+            var tag = TagLib.File.Create(song.SongPath());
+            var pics = tag.Tag.Pictures;
+            Array.Resize(ref pics, 1);
 
-				Console.WriteLine("Successfully updated metadata");
+            pics[0] = new Picture(coverArt.ImagePath)
-				_logger.Info("Successfully updated metadata");
+            {
-			}
+                Description = "Cover Art"
-			catch (Exception ex)
+            };
-			{
-				var msg = ex.Message;
-				Console.WriteLine($"An error occurred:\n{msg}");
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		private void InitializeUpdatedSong(Song song)
-		{
-			_updatedSong = new Song
-			{
-				Id = song.Id,
-				Title = song.Title,
-			     	AlbumTitle = song.AlbumTitle,
-		     	     	Artist = song.Artist,
-				Genre = song.Genre,
-				Year = song.Year,
-				Duration = song.Duration,
-				Filename = song.Filename,
-				SongPath = song.SongPath
-			};
-		}
-		private void PrintMetadata()
-		{
-			Console.WriteLine("\n\nMetadata of the song:");
-			Console.WriteLine($"Title: {_title}");
-			Console.WriteLine($"Artist: {_artist}");
-			Console.WriteLine($"Album: {_album}");
-			Console.WriteLine($"Genre: {_genre}");
-			Console.WriteLine($"Year: {_year}");
-			Console.WriteLine($"Duration: {_duration}\n\n");
 
-			_logger.Info("Metadata of the song");
+            tag.Tag.Pictures = pics;
-			_logger.Info($"Title: {_title}");
+            tag.Save();
-			_logger.Info($"Artist: {_artist}");
+        }
-			_logger.Info($"Album: {_album}");
-			_logger.Info($"Genre: {_genre}");
-			_logger.Info($"Year: {_year}");
-			_logger.Info($"Duration: {_duration}");
-		}
-		private void PrintMetadata(Song song, string message)
-		{
-			Console.WriteLine($"\n\n{message}");
-			Console.WriteLine($"Title: {song.Title}");
-			Console.WriteLine($"Artist: {song.Artist}");
-			Console.WriteLine($"Album: {song.Album}");
-			Console.WriteLine($"Genre: {song.Genre}");
-			Console.WriteLine($"Year: {song.Year}");
-			Console.WriteLine($"Duration: {song.Duration}\n\n");
 
-			_logger.Info(message);
+        private void PerformUpdate(Song updatedSong, SortedDictionary<string, bool> checkedValues)
-			_logger.Info($"Title: {_title}");
+        {
-			_logger.Info($"Artist: {_artist}");
+            var filePath = updatedSong.SongPath();
-			_logger.Info($"Album: {_album}");
+            var title = updatedSong.Title;
-			_logger.Info($"Genre: {_genre}");
+            var artist = updatedSong.Artist;
-			_logger.Info($"Year: {_year}");
+            var album = updatedSong.AlbumTitle;
-			_logger.Info($"Duration: {_duration}");
+            var genre = updatedSong.Genre;
-		}
+            var year = updatedSong.Year;
+            var albumArtist = updatedSong.AlbumArtist;
+            var track = updatedSong.Track;
+            var trackCount = updatedSong.TrackCount;
+            var disc = updatedSong.Disc;
+            var discCount = updatedSong.DiscCount;
+            TagLib.File fileTag = TagLib.File.Create(filePath);
 
-		private SortedDictionary<string, bool> CheckSongValues(Song song)
+            try
-		{
+            {
-			var songValues = new SortedDictionary<string, bool>();
+                Console.WriteLine($"Updating metadata of {title}");
-			Console.WriteLine("Checking for null data");
+                _logger.Info($"Updating metadata of {title}");
-			_logger.Info("Checking for null data");
-			try
-			{
-				songValues["Title"] = String.IsNullOrEmpty(song.Title);
-				songValues["Artists"] = String.IsNullOrEmpty(song.Artist);
-				songValues["Album"] = String.IsNullOrEmpty(song.AlbumTitle);
-				songValues["Genre"] = String.IsNullOrEmpty(song.Genre);
-				if (song.Year == null)
-				{
-					songValues["Year"] = true;
-				}
-				else if (song.Year==0)
-				{
-					songValues["Year"] = true;
-				}
-				else
-				{
-					songValues["Year"] = false;
-				}
-				Console.WriteLine("Checking for null data completed");
-				_logger.Info("Checking for null data completed");
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				Console.WriteLine($"An error occurred: \n{msg}");
-				_logger.Error(msg, "An error occurred");
-			}
 
-			return songValues;
+                foreach (var key in checkedValues.Keys)
-		}	
+                {
-		#endregion
+                    bool result = checkedValues[key];
-	}
+
+                    if (!result)
+                        switch (key.ToLower())
+                        {
+                            case "title":
+                                _updatedSong.Title = title;
+                                fileTag.Tag.Title = title;
+                                break;
+                            case "artists":
+                                _updatedSong.Artist = artist;
+                                fileTag.Tag.Performers = new []{artist};
+                                break;
+                            case "album":
+                                _updatedSong.AlbumTitle = album;
+                                fileTag.Tag.Album = album;
+                                break;
+                            case "genre":
+                                _updatedSong.Genre = genre;
+                                fileTag.Tag.Genres = new []{genre};
+                                break;
+                            case "year":
+                                _updatedSong.Year = year;
+                                fileTag.Tag.Year = (uint)year;
+                                break;
+                            case "albumartist":
+                                _updatedSong.AlbumArtist = albumArtist;
+                                fileTag.Tag.AlbumArtists = new []{albumArtist};
+                                break;
+                            case "track":
+                                _updatedSong.Track = track;
+                                fileTag.Tag.Track = (uint)(track);
+                                break;
+                            case "trackcount":
+                                _updatedSong.TrackCount = trackCount;
+                                fileTag.Tag.TrackCount = (uint)(trackCount);
+                                break;
+                            case "disc":
+                                _updatedSong.Disc = disc;
+                                fileTag.Tag.Disc = (uint)(disc);
+                                break;
+                            case "disccount":
+                                _updatedSong.DiscCount = discCount;
+                                fileTag.Tag.DiscCount = (uint)(discCount);
+                                break;
+                        }
+                }
+
+                fileTag.Save();
+
+                Console.WriteLine("Successfully updated metadata");
+                _logger.Info("Successfully updated metadata");
+            }
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                Console.WriteLine($"An error occurred:\n{msg}");
+                _logger.Error(msg, "An error occurred");
+            }
+        }
+        private void InitializeUpdatedSong(Song song)
+        {
+            _updatedSong = song;
+        }
+        private void PrintMetadata()
+        {
+            Console.WriteLine("\n\nMetadata of the song:");
+            Console.WriteLine($"Title: {_title}");
+            Console.WriteLine($"Artist: {_artist}");
+            Console.WriteLine($"Album: {_album}");
+            Console.WriteLine($"Genre: {_genre}");
+            Console.WriteLine($"Year: {_year}");
+            Console.WriteLine($"Duration: {_duration}\n\n");
+
+            _logger.Info("Metadata of the song");
+            _logger.Info($"Title: {_title}");
+            _logger.Info($"Artist: {_artist}");
+            _logger.Info($"Album: {_album}");
+            _logger.Info($"Genre: {_genre}");
+            _logger.Info($"Year: {_year}");
+            _logger.Info($"Duration: {_duration}");
+        }
+        private void PrintMetadata(Song song, string message)
+        {
+            Console.WriteLine($"\n\n{message}");
+            Console.WriteLine($"Title: {song.Title}");
+            Console.WriteLine($"Artist: {song.Artist}");
+            Console.WriteLine($"Album: {song.AlbumTitle}");
+            Console.WriteLine($"Genre: {song.Genre}");
+            Console.WriteLine($"Year: {song.Year}");
+            Console.WriteLine($"Duration: {song.Duration}\n\n");
+
+            _logger.Info(message);
+            _logger.Info($"Title: {_title}");
+            _logger.Info($"Artist: {_artist}");
+            _logger.Info($"Album: {_album}");
+            _logger.Info($"Genre: {_genre}");
+            _logger.Info($"Year: {_year}");
+            _logger.Info($"Duration: {_duration}");
+        }
+
+        private SortedDictionary<string, bool> CheckSongValues(Song song)
+        {
+            var songValues = new SortedDictionary<string, bool>();
+            Console.WriteLine("Checking for null data");
+            _logger.Info("Checking for null data");
+
+            try
+            {
+                songValues["Title"] = String.IsNullOrEmpty(song.Title);
+                songValues["Artists"] = String.IsNullOrEmpty(song.Artist);
+                songValues["Album"] = String.IsNullOrEmpty(song.AlbumTitle);
+                songValues["Genre"] = String.IsNullOrEmpty(song.Genre);
+                songValues["AlbumArtist"] = String.IsNullOrEmpty(song.AlbumArtist);
+
+                songValues["Year"] = CheckIntField(song.Year);
+                songValues["Track"] = CheckIntField(song.Track);
+                songValues["TrackCount"] = CheckIntField(song.TrackCount);
+                songValues["Disc"] = CheckIntField(song.Disc);
+                songValues["DiscCount"] = CheckIntField(song.Disc);
+
+                Console.WriteLine("Checking for null data completed");
+                _logger.Info("Checking for null data completed");
+            }
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                Console.WriteLine($"An error occurred: \n{msg}");
+                _logger.Error(msg, "An error occurred");
+            }
+
+            return songValues;
+        }    
+
+        private bool CheckIntField(int? value)
+        {
+            if (value == null)
+            {
+                return true;
+            }
+            else if (value == 0)
+            {
+                return true;
+            }
+
+            return false;
+        }
+        #endregion
+    }
 }

Controllers/Utilities/PasswordEncryption.cs

@@ -9,85 +9,82 @@ using Icarus.Models;
 
 namespace Icarus.Controllers.Utilities
 {
-	public class PasswordEncryption
+    public class PasswordEncryption
-	{
+    {
-		#region Fields
+        #region Fields
-		private static Logger _logger = NLog.LogManager.GetCurrentClassLogger();
+        private static Logger _logger = NLog.LogManager.GetCurrentClassLogger();
-		#endregion
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		#endregion
+        #endregion
 
 
-		#region Methods
+        #region Methods
-		public bool VerifyPassword(User user, string password)
+        public bool VerifyPassword(User user, string password)
-		{
+        {
-			try
+            try
-			{
+            {
-				var result = BCrypt.Net.BCrypt.Verify(password, user.Password);
+                var result = BCrypt.Net.BCrypt.Verify(password, user.Password);
 
-				return result;
+                return result;
-			}
+            }
-			catch (Exception ex)
+            catch (Exception ex)
-			{
+            {
-				var msg = ex.Message;
+                var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
+                _logger.Error(msg, "An error occurred");
-			}
+            }
 
-			return false;
+            return false;
-		}
+        }
 
-		public string HashPassword(User user)
+        public string HashPassword(User user)
-		{
+        {
-			try
+            try
-			{
+            {
-				string hashedPassword = string.Empty;
+                string hashedPassword = string.Empty;
-				hashedPassword = BCrypt.Net.BCrypt.HashPassword(user.Password);
+                hashedPassword = BCrypt.Net.BCrypt.HashPassword(user.Password);
 
-				_logger.Info("Successfully hashed password");
+                _logger.Info("Successfully hashed password");
 
-				return hashedPassword;
+                return hashedPassword;
 
-			}
+            }
-			catch (Exception ex)
+            catch (Exception ex)
-			{
+            {
-				var exMsg = ex.Message;
+                var exMsg = ex.Message;
-				_logger.Error(exMsg, "An error occurred");
+                _logger.Error(exMsg, "An error occurred");
-			}
+            }
 
-			return null;
+            return null;
-		}
+        }
 
-		string GenerateHash(string password, byte[] salt)
+        string GenerateHash(string password, byte[] salt)
-		{
+        {
 
-			string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+            string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-						password: password,
+                password: password, salt: salt,
-						salt: salt,
+                prf: KeyDerivationPrf.HMACSHA1,
-						prf: KeyDerivationPrf.HMACSHA1,
+                iterationCount: 10000,
-						iterationCount: 10000,
+                numBytesRequested: 256/8));
-						numBytesRequested: 256/8));
 
-			return hashed;
+            return hashed;
-		}
+        }
 
-		byte[] GenerateSalt()
+        byte[] GenerateSalt()
-		{
+        {
-			byte[] salt = new byte[128/8];
+            byte[] salt = new byte[128/8];
 
-			using (var rng = RandomNumberGenerator.Create())
+            using (var rng = RandomNumberGenerator.Create())
-			{
+                rng.GetBytes(salt);
-				rng.GetBytes(salt);
-			}
 
 
-			return salt;
+            return salt;
-		}
+        }
-		#endregion
+        #endregion
-	}
+    }
 }

Controllers/Utilities/SongCompression.cs

@@ -13,18 +13,18 @@ namespace Icarus.Controllers.Utilities
     public class SongCompression
     {
         #region Fields
-	string _compressedSongFilename;
+        string _compressedSongFilename;
-	string _tempDirectory;
+        string _tempDirectory;
         byte[] _uncompressedSong;
         #endregion
 
 
         #region Propterties
-	public string CompressedSongFilename
+        public string CompressedSongFilename
-	{
+        {
-	    get => _compressedSongFilename;
+            get => _compressedSongFilename;
-	    set => _compressedSongFilename = value;
+            set => _compressedSongFilename = value;
-	}
+        }
         #endregion
 
 
@@ -32,10 +32,10 @@ namespace Icarus.Controllers.Utilities
         public SongCompression()
         {
         }
-	public SongCompression(string tempDirectory)
+        public SongCompression(string tempDirectory)
-	{
+        {
-	    _tempDirectory = tempDirectory;
+            _tempDirectory = tempDirectory;
-	}
+        }
         public SongCompression(byte[] uncompressedSong)
         {
             _uncompressedSong = uncompressedSong;
@@ -44,60 +44,61 @@ namespace Icarus.Controllers.Utilities
 
 
         #region Methods
-	public async Task<SongData> RetrieveCompressedSong(Song song)
+        public async Task<SongData> RetrieveCompressedSong(Song song)
-	{
+        {
-	    SongData songData = new SongData();
+            SongData songData = new SongData();
-	    try
+            try
-	    {
+            {
-	       var archivePath = RetrieveCompressesSongPath(song);
+                var archivePath = RetrieveCompressesSongPath(song);
-	       Console.WriteLine($"Compressed song saved to: {archivePath}");
+                Console.WriteLine($"Compressed song saved to: {archivePath}");
                 
-	       songData.Data = System.IO.File.ReadAllBytes(archivePath);
+                songData.Data = await System.IO.File.ReadAllBytesAsync(archivePath);
-	    }
+            }
-	    catch(Exception ex)
+            catch(Exception ex)
-	    {
+            {
-	        var exMsg = ex.Message;
+                var exMsg = ex.Message;
-		Console.WriteLine($"An error ocurred: \n{exMsg}");
+                Console.WriteLine($"An error ocurred: \n{exMsg}");
-	    }
+            }
 
-	    return songData;
+            return songData;
-	}
+        }
 
-	public string RetrieveCompressesSongPath(Song songDetails)
+        public string RetrieveCompressesSongPath(Song songDetails)
-	{
+        {
-	    string tmpZipFilePath = _tempDirectory + songDetails.Filename;
+            string tmpZipFilePath = _tempDirectory + songDetails.Filename;
 
-	    try
+            try
-	    {
+            {
-	        using (ZipFile zip = new ZipFile())
+                using (ZipFile zip = new ZipFile())
-		{
+                {
-		    zip.AddFile(songDetails.SongPath);
+                    zip.AddFile(songDetails.SongPath());
-		    zip.Save(tmpZipFilePath);
+                    zip.Save(tmpZipFilePath);
-		}
+                }
-		Console.WriteLine("Successfully compressed");
-		}
-	    catch (Exception ex)
-	    {
-	        var exMsg = ex.Message;
-		Console.WriteLine("An error ocurred");
-		Console.WriteLine(exMsg);
-	    }
 
-	    if (songDetails.Filename.Contains(".mp3"))
+                Console.WriteLine("Successfully compressed");
-	    {
+            }
-	        _compressedSongFilename = StripMP3Extension(songDetails.Filename);
+            catch (Exception ex)
-	    }
+            {
+                var exMsg = ex.Message;
+                Console.WriteLine("An error ocurred");
+                Console.WriteLine(exMsg);
+            }
 
-	    return tmpZipFilePath;
+            if (songDetails.Filename.Contains(".mp3"))
-	}
+            {
+                _compressedSongFilename = StripMP3Extension(songDetails.Filename);
+            }
 
-	// Method not being used
+            return tmpZipFilePath;
+        }
+
+        // Method not being used
         public byte[] CompressedSong(byte[] uncompressedSong)
         {
             byte[] compressedSong = null;
             try
             {
-		Console.WriteLine("Song has been successfully compressed");
+                Console.WriteLine("Song has been successfully compressed");
             }
             catch (Exception ex)
             {
@@ -110,20 +111,20 @@ namespace Icarus.Controllers.Utilities
         }
 
 
-	string StripMP3Extension(string filename)
+        string StripMP3Extension(string filename)
-	{
+        {
-	    Console.WriteLine($"Before: {filename}");
+            Console.WriteLine($"Before: {filename}");
-	    int filenameLength = filename.Length;
+            int filenameLength = filename.Length;
-	    Console.WriteLine($"Filename length {filenameLength}");
+            Console.WriteLine($"Filename length {filenameLength}");
-	    var endIndex = filenameLength - 1;
+            var endIndex = filenameLength - 1;
-	    var startIndex = endIndex - 3;
+            var startIndex = endIndex - 3;
-	    Console.WriteLine($"Starting index {startIndex} and ending index {endIndex}");
+            Console.WriteLine($"Starting index {startIndex} and ending index {endIndex}");
-	    var stripped = filename.Remove(startIndex, 4);
+            var stripped = filename.Remove(startIndex, 4);
-	    stripped += ".zip";
+            stripped += ".zip";
-	    Console.WriteLine($"After {stripped}");
+            Console.WriteLine($"After {stripped}");
 
-	    return stripped;
+            return stripped;
-	}
+        }
         #endregion
     }
 }

Controllers/v1/AlbumController.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
 
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -8,78 +9,73 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
+// using Icarus.Database.Repositories;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/album")]
+    [Route("api/v1/album")]
-	[ApiController]
+    [ApiController]
-	public class AlbumController : ControllerBase
+    public class AlbumController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-		private readonly ILogger<AlbumController> _logger;
+        private readonly ILogger<AlbumController> _logger;
-		#endregion
+        private string _connectionString;
+        private IConfiguration _config;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		public AlbumController(ILogger<AlbumController> logger)
+        public AlbumController(ILogger<AlbumController> logger, IConfiguration config)
-		{
+        {
-			_logger = logger;
+            _logger = logger;
-		}
+            _config = config;
-		#endregion
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+        }
+        #endregion
 
 
-		#region HTTP Routes
+        #region HTTP Routes
-		[HttpGet]
+        [HttpGet]
-		[Authorize("read:albums")]
+        [Authorize("read:albums")]
-		public IActionResult Get()
+        public IActionResult Get()
-		{
+        {
-			List<Album> albums = new List<Album>();
+            List<Album> albums = new List<Album>();
 
-			AlbumRepository albumStoreContext = HttpContext
+            var albumContext = new AlbumContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(AlbumRepository)) as AlbumRepository;
 
-			albums = albumStoreContext.GetAlbums();
+            albums = albumContext.Albums.ToList();
 
-			if (albums.Count > 0)
+            if (albums.Count > 0)
-			{
+                return Ok(albums);
-				return Ok(albums);
+            else
-			}
+                return NotFound();
-			else
+        }
-			{
-				return NotFound();
-			}
-		}
 
-		[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("read:albums")]
+        [Authorize("read:albums")]
-		public IActionResult Get(int id)
+        public IActionResult Get(int id)
-		{
+        {
-			Album album = new Album
+            Album album = new Album
-			{
+            {
-				AlbumId = id
+                AlbumID = id
-			};
+            };
 
-			AlbumRepository albumStoreContext = HttpContext
+            var albumContext = new AlbumContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(AlbumRepository)) as AlbumRepository;
 
-			if (albumStoreContext.DoesAlbumExist(album))
+            if (albumContext.DoesRecordExist(album))
-			{
+            {
-				album = albumStoreContext.GetAlbum(album);
+                album = albumContext.RetrieveRecord(album);
 
-				return Ok(album);
+                return Ok(album);
-			}
+            }
-			else
+            else
-			{
+                return NotFound();
-				return NotFound();
+        }
-			}
+        #endregion
-		}
+    }
-		#endregion
-	}
 }

Controllers/v1/ArtistController.cs

@@ -9,77 +9,70 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/artist")]
+    [Route("api/v1/artist")]
-	[ApiController]
+    [ApiController]
-	public class ArtistController : ControllerBase
+    public class ArtistController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-		private readonly ILogger<ArtistController> _logger;
+        private readonly ILogger<ArtistController> _logger;
-		#endregion
+        private string _connectionString;
+        private IConfiguration _config;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		public ArtistController(ILogger<ArtistController> logger)
+        public ArtistController(ILogger<ArtistController> logger, IConfiguration config)
-		{
+        {
-			_logger = logger;
+            _logger = logger;
-		}
+            _config = config;
-		#endregion
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+        }
+        #endregion
 
 
-		#region HTTP Routes
+        #region HTTP Routes
-		[HttpGet]
+        [HttpGet]
-		[Authorize("read:artists")]
+        [Authorize("read:artists")]
-		public IActionResult Get()
+        public IActionResult Get()
-		{
+        {
-			ArtistRepository artistStoreContext = HttpContext
+            var artistContext = new ArtistContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(ArtistRepository)) as ArtistRepository;
 
-			var artists = artistStoreContext.GetArtists();
+            var artists = artistContext.Artists.ToList();
 
-			if (artists.Count > 0)
+            if (artists.Count > 0)
-			{
+                return Ok(artists);
-				return Ok(artists);
+            else
-			}
+                return NotFound();
-			else
+        }
-			{
-				return NotFound();
-			}
-		}
 
-		[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("read:artists")]
+        [Authorize("read:artists")]
-		public IActionResult Get(int id)
+        public IActionResult Get(int id)
-		{
+        {
-			Artist artist = new Artist
+            Artist artist = new Artist
-			{
+            {
-				ArtistId = id
+                ArtistID = id
-			};
+            };
             
-			ArtistRepository artistStoreContext = HttpContext
+            var artistContext = new ArtistContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(ArtistRepository)) as ArtistRepository;
 
-			if (artistStoreContext.DoesArtistExist(artist))
+            if (artistContext.DoesRecordExist(artist))
-			{
+            {
-				artist = artistStoreContext.GetArtist(artist);
+                artist = artistContext.RetrieveRecord(artist);
 
-
+                return Ok(artist);
-				return Ok(artist);
+            }
-			}
+            else
-			else
+                return NotFound();
-			{
+        }
-				return NotFound();
+        #endregion
-			}
+    }
-		}
-		#endregion
-	}
 }

Controllers/v1/CoverArtController.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+using Icarus.Controllers.Managers;
+using Icarus.Database.Contexts;
+using Icarus.Models;
+
+namespace Icarus.Controllers.V1
+{
+    [Route("api/v1/coverart")]
+    [ApiController]
+    public class CoverArtController : ControllerBase
+    {
+        #region Fields
+        private readonly ILogger<CoverArtController> _logger;
+        private string _connectionString;
+        private IConfiguration _config;
+        #endregion
+
+
+        #region Constructors
+        public CoverArtController(ILogger<CoverArtController> logger, IConfiguration config)
+        {
+            _logger = logger;
+            _config = config;
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+        }
+        #endregion
+
+
+        #region HTTP Routes
+        public IActionResult Get()
+        {
+            var coverArtContext = new CoverArtContext(_connectionString);
+
+            var coverArtRecords = coverArtContext.CoverArtImages.ToList();
+
+            if (coverArtRecords == null)
+            {
+                _logger.LogInformation("No cover art records");
+                return NotFound();
+            }
+            else
+            {
+                _logger.LogInformation("Found cover art records");
+                return Ok(coverArtRecords);
+            }
+        }
+
+        [HttpGet("{id}")]
+        [Authorize("download:cover_art")]
+        public async Task<IActionResult> Get(int id)
+        {
+            var coverArt = new CoverArt { CoverArtID = id };
+
+            var coverArtContext = new CoverArtContext(_connectionString);
+
+            coverArt = coverArtContext.RetrieveRecord(coverArt);
+
+            if (coverArt != null)
+            {
+                _logger.LogInformation("Found cover art record");
+                var coverArtBytes = await System.IO.File.ReadAllBytesAsync(
+                        coverArt.ImagePath);
+
+                return File(coverArtBytes, "application/x-msdownload", 
+                        coverArt.SongTitle);
+            }
+            else
+            {
+                _logger.LogInformation("Cover art not found");
+                return NotFound();
+            }
+        }
+        #endregion
+    }
+}

Controllers/v1/GenreController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -7,78 +8,72 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/genre")]
+    [Route("api/v1/genre")]
-	[ApiController]
+    [ApiController]
-	public class GenreController : ControllerBase
+    public class GenreController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-		private readonly ILogger<GenreController> _logger;
+        private readonly ILogger<GenreController> _logger;
-		#endregion
+        private string _connectionString;
+        private IConfiguration _config;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructors
+        #region Constructors
-		public GenreController(ILogger<GenreController> logger)
+        public GenreController(ILogger<GenreController> logger, IConfiguration config)
-		{
+        {
-			_logger = logger;
+            _logger = logger;
-		}
+            _config = config;
-		#endregion
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+        }
+        #endregion
 
 
-		#region HTTP Routes
+        #region HTTP Routes
-		[HttpGet]
+        [HttpGet]
-		[Authorize("read:genre")]
+        [Authorize("read:genre")]
-		public IActionResult Get()
+        public IActionResult Get()
-		{
+        {
-			var genres = new List<Genre>();
+            var genres = new List<Genre>();
 
-			var genreStore = HttpContext
+            var genreStore = new GenreContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(GenreRepository)) as GenreRepository;
 
-			genres = genreStore.GetGenres();
+            genres = genreStore.Genres.ToList();
 
-			if (genres.Count > 0)
+            if (genres.Count > 0)
-			{
+                return Ok(genres);
-				return Ok(genres);
+            else
-			}
+                return NotFound(new List<Genre>());
-			else
+        }
-			{
-				return NotFound(new List<Genre>());
-			}
-		}
 
-		[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("read:genre")]
+        [Authorize("read:genre")]
-		public IActionResult Get(int id)
+        public IActionResult Get(int id)
-		{
+        {
-			var genre = new Genre
+            var genre = new Genre
-			{
+            {
-				GenreId = id
+                GenreID = id
-			};
+            };
 
-			var genreStore = HttpContext
+            var genreStore = new GenreContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(GenreRepository)) as GenreRepository;
 
-			if (genreStore.DoesGenreExist(genre))
+            if (genreStore.DoesRecordExist(genre))
-			{
+            {
-				genre =  genreStore.GetGenre(genre);
+                genre =  genreStore.RetrieveRecord(genre);
 
-				return Ok(genre);
+                return Ok(genre);
-			}
+            }
-			else
+            else
-			{
+                return NotFound(new Genre());
-				return NotFound(new Genre());
+        }
-			}
+        #endregion
-		}
+    }
-		#endregion
-	}
 }

Controllers/v1/LoginController.cs

@@ -11,79 +11,79 @@ using Microsoft.Extensions.Logging;
 using Icarus.Controllers.Managers;
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/login")]
+    [Route("api/v1/login")]
-	[ApiController]
+    [ApiController]
-	public class LoginController : ControllerBase
+    public class LoginController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-		private IConfiguration _config;
+        private string _connectionString;
-		private ILogger<LoginController> _logger;
+        private IConfiguration _config;
-		#endregion
+        private ILogger<LoginController> _logger;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Contructors
+        #region Contructors
-		public LoginController(IConfiguration config, ILogger<LoginController> logger)
+        public LoginController(IConfiguration config, ILogger<LoginController> logger)
-		{
+        {
-			_config = config;
+            _logger = logger;
-			_logger = logger;
+            _config = config;
-		}
+            _connectionString = _config.GetConnectionString("DefaultConnection");
-		#endregion
+        }
+        #endregion
 
 
-		#region HTTP endpoints
+        #region HTTP endpoints
-		public IActionResult Post([FromBody] User user)
+        public IActionResult Post([FromBody] User user)
-		{
+        {
-			UserRepository context = HttpContext
+            var context = new UserContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(UserRepository)) as UserRepository;
 
-			_logger.LogInformation("Starting process of validating credentials");
+            _logger.LogInformation("Starting process of validating credentials");
             
-			var message = "Invalid credentials";
+            var message = "Invalid credentials";
-			var password = user.Password;
+            var password = user.Password;
 
-			var loginRes = new LoginResult
+            var loginRes = new LoginResult
-			{
+            {
-				Username = user.Username
+                Username = user.Username
-			};
+            };
 
-			if (context.DoesUserExist(user))
+            if (context.Users.FirstOrDefault(usr => usr.Username.Equals(user.Username)) != null)
-			{
+            {
-				user = context.RetrieveUser(user);
+                user = context.Users.FirstOrDefault(usr => usr.Username.Equals(user.Username));
 
-				var validatePass = new PasswordEncryption();
+                var validatePass = new PasswordEncryption();
-				var validated = validatePass.VerifyPassword(user, password);
+                var validated = validatePass.VerifyPassword(user, password);
-				if (!validated)
+                if (!validated)
-				{
+                {
-					loginRes.Message = message;
+                    loginRes.Message = message;
-					_logger.LogInformation(message);
+                    _logger.LogInformation(message);
 
-					return Ok(loginRes);
+                    return Ok(loginRes);
-				}
+                }
 
-				_logger.LogInformation("Successfully validated user credentials");
+                _logger.LogInformation("Successfully validated user credentials");
 
-				TokenManager tk = new TokenManager(_config);
+                TokenManager tk = new TokenManager(_config);
 
-				loginRes = tk.RetrieveLoginResult(user);
+                loginRes = tk.RetrieveLoginResult(user);
 
-				return Ok(loginRes);
+                return Ok(loginRes);
-			}
+            }
-			else
+            else
-			{
+            {
-				loginRes.Message = message;
+                loginRes.Message = message;
 
-				return NotFound(loginRes);
+                return NotFound(loginRes);
-			}
+            }
-		}
+        }
-		#endregion
+        #endregion
-	}
+    }
 }

Controllers/v1/RegisterController.cs

@@ -10,62 +10,76 @@ using Microsoft.Extensions.Configuration;
 using Icarus.Controllers.Managers;
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-    	[Route("api/v1/register")]
+    [Route("api/v1/register")]
-    	[ApiController]
+    [ApiController]
-    	public class RegisterController : ControllerBase
+    public class RegisterController : ControllerBase
-    	{
+    {
-		#region Fields
+        #region Fields
-		private IConfiguration _config;
+        private string _connectionString;
-		#endregion
+        private IConfiguration _config;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		public RegisterController(IConfiguration config)
+        public RegisterController(IConfiguration config)
-		{
+        {
-	    		_config = config;
+            _config = config;
-		}
+            _connectionString = _config.GetConnectionString("DefaultConnection");
-		#endregion
+        }
+        #endregion
 
-		[HttpPost]
+        [HttpPost]
-        	public IActionResult Post([FromBody] User user)
+        public IActionResult Post([FromBody] User user)
-        	{
+        {
-			PasswordEncryption pe = new PasswordEncryption();
+            PasswordEncryption pe = new PasswordEncryption();
-			user.Password = pe.HashPassword(user);
+            user.Password = pe.HashPassword(user);
-			user.EmailVerified = false;
+            user.EmailVerified = false;
+            user.Status = "Registered";
+            user.DateCreated = DateTime.Now;
 
-			UserRepository context = HttpContext
+            UserContext context = null;
-				.RequestServices
-				.GetService(typeof(UserRepository)) as UserRepository;
 
-			context.SaveUser(user);
+            try
+            {
+                context = new UserContext(_config.GetConnectionString("DefaultConnection"));
+                context.Add(user);
+                context.SaveChanges();
+            }
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                var stackTrace = ex.StackTrace;
 
-			var registerResult = new RegisterResult
+                Console.WriteLine($"An error occurred: {msg}");
-			{
+            }
-				Username = user.Username
-			};
 
-			if (context.DoesUserExist(user))
+            var registerResult = new RegisterResult
-			{
+            {
-				registerResult.Message = "Successful registration";
+                Username = user.Username
-				registerResult.SuccessfullyRegistered = true;
+            };
 
-				return Ok(registerResult);
+            if (context.Users.FirstOrDefault(sng => sng.Username.Equals(user.Username)) != null)
-			}
+            {
-			else
+                registerResult.Message = "Successful registration";
-			{
+                registerResult.SuccessfullyRegistered = true;
-				registerResult.Message = "Registration failed";
-				registerResult.SuccessfullyRegistered = false;
 
-				return Ok(registerResult);
+                return Ok(registerResult);
-			}
+            }
-        	}
+            else
-    	}
+            {
+                registerResult.Message = "Registration failed";
+                registerResult.SuccessfullyRegistered = false;
+
+                return Ok(registerResult);
+            }
+        }
+    }
 }

Controllers/v1/SongCompressedDataControllers.cs

@@ -13,53 +13,53 @@ using Microsoft.Extensions.Configuration;
 using Icarus.Controllers.Managers;
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/song/compressed/data")]
+    [Route("api/v1/song/compressed/data")]
-	[ApiController]
+    [ApiController]
-	public class SongCompressedDataController : ControllerBase
+    public class SongCompressedDataController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-        	private IConfiguration _config;
+        private string _connectionString;
-		private string _songTempDir;
+        private IConfiguration _config;
-		private string _archiveDir;
+        private string _songTempDir;
-		#endregion
+        private string _archiveDir;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		public SongCompressedDataController(IConfiguration config)
+        public SongCompressedDataController(IConfiguration config)
-		{
+        {
-	    		_config = config;
+            _songTempDir = _config.GetValue<string>("TemporaryMusicPath");
-	    		_songTempDir = _config.GetValue<string>("TemporaryMusicPath");
+            _archiveDir = _config.GetValue<string>("ArchivePath");
-	    		_archiveDir = _config.GetValue<string>("ArchivePath");
+            _config = config;
-		}
+            _connectionString = _config.GetConnectionString("DefaultConnection");
-		#endregion
+        }
+        #endregion
 
 
-		#region API Routes
+        #region API Routes
-        	[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("download:songs")]
+        [Authorize("download:songs")]
-        	public async Task<IActionResult> Get(int id)
+        public async Task<IActionResult> Get(int id)
-        	{
+        {
-	   		 SongRepository context = HttpContext
+            var context = new SongContext(_connectionString);
-				 .RequestServices
-				 .GetService(typeof(SongRepository)) as SongRepository;
 
-  	    		SongCompression cmp = new SongCompression(_archiveDir);
+            SongCompression cmp = new SongCompression(_archiveDir);
         
-            		Console.WriteLine($"Archive directory root: {_archiveDir}");
+            Console.WriteLine($"Archive directory root: {_archiveDir}");
 
-	    		Console.WriteLine("Starting process of retrieving comrpessed song");
+            Console.WriteLine("Starting process of retrieving comrpessed song");
-	    		SongData song = await cmp.RetrieveCompressedSong(context.GetSong(id));
+            SongData song = await cmp.RetrieveCompressedSong(context.RetrieveRecord(new Song{ SongID = id }));
 
-	    		return File(song.Data, "application/x-msdownload", cmp.CompressedSongFilename);
+            return File(song.Data, "application/x-msdownload", cmp.CompressedSongFilename);
-        	}
+        }
-        	#endregion
+        #endregion
-    	}
+    }
 }

Controllers/v1/SongController.cs

@@ -12,122 +12,93 @@ using Microsoft.Extensions.Logging;
 using Icarus.Controllers.Managers;
 using Icarus.Controllers.Utilities;
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/song")]
+    [Route("api/v1/song")]
-	[ApiController]
+    [ApiController]
-    	public class SongController : ControllerBase
+    public class SongController : ControllerBase
-    	{
+    {
-		#region Fields
+        #region Fields
-		private readonly ILogger<SongController> _logger;
+        private readonly ILogger<SongController> _logger;
-		private IConfiguration _config;
+        private string _connectionString;
-		private SongManager _songMgr;
+        private IConfiguration _config;
-		#endregion
+        private SongManager _songMgr;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		public SongController(IConfiguration config, ILogger<SongController> logger)
+        public SongController(IConfiguration config, ILogger<SongController> logger)
-		{
+        {
-			_config = config;
+            _config = config;
-			_logger = logger;
+            _connectionString = _config.GetConnectionString("DefaultConnection");
-			_songMgr = new SongManager(config);
+            _logger = logger;
-		}
+            _songMgr = new SongManager(config);
-		#endregion
+        }
+        #endregion
 
 
-        	[HttpGet]
+        [HttpGet]
-		[Authorize("read:song_details")]
+        [Authorize("read:song_details")]
-        	public IActionResult Get()
+        public IActionResult Get()
-        	{
+        {
-			List<Song> songs = new List<Song>();
+            List<Song> songs = new List<Song>();
-			Console.WriteLine("Attemtping to retrieve songs");
+            Console.WriteLine("Attemtping to retrieve songs");
-			_logger.LogInformation("Attempting to retrieve songs");
+            _logger.LogInformation("Attempting to retrieve songs");
             
-			SongRepository context = HttpContext
+            var context = new SongContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
 
-			songs = context.GetAllSongs();
+            songs = context.Songs.ToList();
 
-			if (songs.Count > 0)
+            if (songs.Count > 0)
-			{
+                return Ok(songs);
-				return Ok(songs);
+            else
-			}
+                return NotFound();
-			else
+        }
-			{
-				return NotFound();
-			}
-        	}
 
-		[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("read:song_details")]
+        [Authorize("read:song_details")]
-		public IActionResult Get(int id)
+        public IActionResult Get(int id)
-		{
+        {
-			SongRepository context = HttpContext
+            var context = new SongContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
             
-			Song song = new Song { Id = id };
+            Song song = new Song { SongID = id };
-			song = context.GetSong(song);
+            song = context.RetrieveRecord(song);
 
-			Console.WriteLine("Here");
+            Console.WriteLine("Here");
 
-			if (song.Id != 0)
+            if (song.SongID != 0)
-			{
+                return Ok(song);
-				return Ok(song);
+            else
-			}
+                return NotFound();
-			else
+        }
-			{
-				return NotFound();
-			}
-		}
 
-		[Authorize("update:songs")]
+        [Authorize("update:songs")]
-        	[HttpPut("{id}")]
+        [HttpPut("{id}")]
-		public IActionResult Put(int id, [FromBody] Song song)
+        public IActionResult Put(int id, [FromBody] Song song)
-        	{
+        {
-			SongRepository context = HttpContext
+            var context = new SongContext(_connectionString);
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
 
-			ArtistRepository artistStore = HttpContext
+            song.SongID = id;
-				.RequestServices
+            Console.WriteLine("Retrieving filepath of song");
-				.GetService(typeof(ArtistRepository)) as ArtistRepository;
+            _logger.LogInformation("Retrieving filepath of song");
 
-			AlbumRepository albumStore = HttpContext
+            if (!_songMgr.DoesSongExist(song))
-				.RequestServices
+            {
-				.GetService(typeof(AlbumRepository)) as AlbumRepository;
+                return NotFound(new SongResult
+                {
+                    Message = "Song does not exist"
+                });
+            }
 
-			GenreRepository genreStore = HttpContext
+            var songRes = _songMgr.UpdateSong(song);
-				.RequestServices
-				.GetService(typeof(GenreRepository)) as GenreRepository;
 
-			YearRepository yearStore = HttpContext
+            return Ok(songRes);
-				.RequestServices
+        }
-				.GetService(typeof(YearRepository)) as YearRepository;
+    }
-
-			song.Id = id;
-			Console.WriteLine("Retrieving filepath of song");
-			_logger.LogInformation("Retrieving filepath of song");
-
-			if (!context.DoesSongExist(song))
-			{
-				return NotFound(new SongResult
-					{
-						Message = "Song does not exist"
-					});
-			}
-
-			var songRes = _songMgr.UpdateSong(song, context, albumStore, artistStore, genreStore, 
-					yearStore);
-
-			return Ok(songRes);
-        	}
-    	}
 }

Controllers/v1/SongDataController.cs

@@ -10,140 +10,165 @@ using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 
 using Icarus.Controllers.Managers;
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/song/data")]
+    [Route("api/v1/song/data")]
-	[ApiController]
+    [ApiController]
-	public class SongDataController : ControllerBase
+    public class SongDataController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-        	private IConfiguration _config;
+        private string _connectionString;
-		private ILogger<SongDataController> _logger;
+        private IConfiguration _config;
-		private SongManager _songMgr;
+        private ILogger<SongDataController> _logger;
-		private string _songTempDir;
+        private SongManager _songMgr;
-		#endregion
+        private string _songTempDir;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		public SongDataController(IConfiguration config, ILogger<SongDataController> logger)
+        public SongDataController(IConfiguration config, ILogger<SongDataController> logger)
-		{
+        {
-			_config = config;
+            _config = config;
-			_logger = logger;
+            _connectionString = _config.GetConnectionString("DefaultConnection");
-			_songTempDir = _config.GetValue<string>("TemporaryMusicPath");
+            _logger = logger;
-			_songMgr = new SongManager(config, _songTempDir);
+            _songTempDir = _config.GetValue<string>("TemporaryMusicPath");
-		}
+            _songMgr = new SongManager(config, _songTempDir);
-		#endregion
+        }
+        #endregion
 
 
-        	[HttpGet("{id}")]
-		[Route("private-scoped")]
-		[Authorize("download:songs")]
-        	public async Task<IActionResult> Get(int id)
-        	{
-			SongRepository context = HttpContext
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
-			var songMetaData = context.GetSong(id); 
 
-			SongData song = await _songMgr.RetrieveSong(songMetaData);
+        [HttpGet("download/{id}")]
+        [Route("private-scoped")]
+        [Authorize("download:songs")]
+        public async Task<IActionResult> Get(int id)
+        {
+            var songContext = new SongContext(_connectionString);
+            var songMetaData = songContext.RetrieveRecord(new Song { SongID = id});
             
-			return File(song.Data, "application/x-msdownload", songMetaData.Filename);
+            var song = await _songMgr.RetrieveSong(songMetaData);
-		}
             
-        	[HttpPost]
+            return File(song.Data, "application/x-msdownload", songMetaData.Filename);
-		[Authorize("upload:songs")]
+        }
-        	public async Task Post([FromForm(Name = "file")] List<IFormFile> songData)
-        	{
-			try
-			{
-				SongRepository songRepository = HttpContext
-					.RequestServices
-					.GetService(typeof(SongRepository)) as SongRepository;
-				AlbumRepository albumStoreContext = HttpContext
-					.RequestServices
-					.GetService(typeof(AlbumRepository)) as AlbumRepository;
-				ArtistRepository artistStoreContext = HttpContext
-					.RequestServices
-					.GetService(typeof(ArtistRepository)) as ArtistRepository;
-				GenreRepository genreStore = HttpContext
-					.RequestServices
-					.GetService(typeof(GenreRepository)) as GenreRepository;
-				YearRepository yearStore = HttpContext
-					.RequestServices
-					.GetService(typeof(YearRepository)) as YearRepository;
 
-				Console.WriteLine("Uploading song...");
+        // Assumes that the song already has metadata such as
-				_logger.LogInformation("Uploading song...");
+        // Title
+        // Artist
+        // Album
+        // Genre
+        // Year
+        // Track
+        // Track count
+        // Disc
+        // Disc count
+        // Cover art
+        //
+        [HttpPost("upload"), DisableRequestSizeLimit]
+        [Route("private-scoped")]
+        [Authorize("upload:songs")]
+        public async Task<IActionResult> Post([FromForm(Name = "file")] List<IFormFile> songData)
+        {
+            try
+            {
+                Console.WriteLine("Uploading song...");
+                _logger.LogInformation("Uploading song...");
 
-				var uploads = _songTempDir;
+                var uploads = _songTempDir;
-				Console.WriteLine($"Song Root Path {uploads}");
+                Console.WriteLine($"Song Root Path {uploads}");
-				_logger.LogInformation($"Song root path {uploads}");
+                _logger.LogInformation($"Song root path {uploads}");
-				foreach (var sng in songData)
-				{
-					if (sng.Length > 0) {
-						Console.WriteLine($"Song filename {sng.FileName}");
-						_logger.LogInformation($"Song filename {sng.FileName}");
 
-						await _songMgr.SaveSongToFileSystem(sng, songRepository,
+                foreach (var sng in songData)
-								albumStoreContext, artistStoreContext,
+                    if (sng.Length > 0) {
-								genreStore, yearStore);
+                        Console.WriteLine($"Song filename {sng.FileName}");
-					}
+                        _logger.LogInformation($"Song filename {sng.FileName}");
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.LogError(msg, "An error occurred");
-			}
-		}
 
-        	[HttpDelete("{id}")]
+                        await _songMgr.SaveSongToFileSystem(sng);
-		[Authorize("delete:songs")]
+                    }
-        	public IActionResult Delete(int id)
-        	{
-			SongRepository context = HttpContext
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
-			AlbumRepository albumStore = HttpContext
-				.RequestServices
-				.GetService(typeof(AlbumRepository)) as AlbumRepository;
-			ArtistRepository artistStore = HttpContext
-				.RequestServices
-				.GetService(typeof(ArtistRepository)) as ArtistRepository;
-			GenreRepository genreStore = HttpContext
-				.RequestServices
-				.GetService(typeof(GenreRepository)) as GenreRepository;
-			YearRepository yearStore = HttpContext
-				.RequestServices
-				.GetService(typeof(YearRepository)) as YearRepository;
 
-			var songMetaData = new Song{ Id = id };
+                return Ok();
-			Console.WriteLine($"Id {songMetaData.Id}");
+            }
-			songMetaData = context.GetSong(songMetaData);
+            catch (Exception ex)
+            {
+                var msg = ex.Message;
+                _logger.LogError(msg, "An error occurred");
+            }
 
-			if (string.IsNullOrEmpty(songMetaData.Title))
+            return NotFound();
-			{
+        }
-				_logger.LogInformation("Song does not exist");
-				return NotFound("Song does not exist");
-			}
-			else
-			{
-				_logger.LogInformation("Starting process of deleting song from the filesystem and database");
 
-				_songMgr.DeleteSong(songMetaData, context, albumStore, 
+        // The client is expected to send the file, metadata, and cover art separately.
-						artistStore, genreStore, yearStore);
+        // Any metadata already on the file will be overwritten with values from the metadata
+        // as well as the cover art
+        //
+        [HttpPost("upload/with/data")]
+        [Route("private-scoped")]
+        [Authorize("upload:songs")]
+        public async Task<IActionResult> Post ([FromForm] UploadSongWithDataForm up)
+        {
+            try
+            {
+                if (up.SongData.Length > 0 && up.CoverArtData.Length > 0 && !string.IsNullOrEmpty(up.SongFile))
+                {
+                    var song = Newtonsoft.Json.JsonConvert.DeserializeObject<Song>(up.SongFile);
+                    _logger.LogInformation($"Song title: {song.Title}");
 
-				return Ok();
+                    await _songMgr.SaveSongToFileSystem(up.SongData, up.CoverArtData, song);
-			}
+                }
-		}
+            }
-    	}
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, "An error occurred");
+            }
+
+            return Ok();
+        }
+
+        [HttpDelete("delete/{id}")]
+        [Authorize("delete:songs")]
+        public IActionResult Delete(int id)
+        {
+            var songContext = new SongContext(_connectionString);
+
+            var songMetaData = new Song{ SongID = id };
+            Console.WriteLine($"Id {songMetaData.SongID}");
+
+            songMetaData = songContext.RetrieveRecord(songMetaData);
+
+            if (string.IsNullOrEmpty(songMetaData.Title))
+            {
+                _logger.LogInformation("Song does not exist");
+                return NotFound("Song does not exist");
+            }
+            else
+            {
+                _logger.LogInformation("Starting process of deleting song from the filesystem and database");
+
+                _songMgr.DeleteSong(songMetaData);
+
+                return Ok();
+            }
+
+        }
+
+            public class UploadSongWithDataForm
+            {
+                [FromForm(Name = "file")]
+                public IFormFile SongData { get; set; }
+                // TODO: Think about making this optional and if it is not provided, use the stock cover art
+                [FromForm(Name = "cover")]
+                public IFormFile CoverArtData { get; set; }
+                [FromForm(Name = "metadata")]
+                public string SongFile { get; set; }
+            }
+    }
 }

Controllers/v1/SongStreamController.cs

@@ -9,59 +9,61 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 
 using Icarus.Models;
-using Icarus.Database.Repositories;
+using Icarus.Database.Contexts;
 
 namespace Icarus.Controllers.V1
 {
-	[Route("api/v1/song/stream")]
+    [Route("api/v1/song/stream")]
-	[ApiController]
+    [ApiController]
-	public class SongStreamController : ControllerBase
+    public class SongStreamController : ControllerBase
-	{
+    {
-		#region Fields
+        #region Fields
-		private ILogger<SongStreamController> _logger;
+        private ILogger<SongStreamController> _logger;
-		#endregion
+        private string _connectionString;
+        private IConfiguration _config;
+        #endregion
 
 
-		#region Properties
+        #region Properties
-		#endregion
+        #endregion
 
 
-		#region Constructor
+        #region Constructor
-		public SongStreamController(ILogger<SongStreamController> logger)
+        public SongStreamController(ILogger<SongStreamController> logger, IConfiguration config)
-		{
+        {
-			_logger = logger;
+            _logger = logger;
-		}
+            _config = config;
-		#endregion
+            _connectionString = _config.GetConnectionString("DefaultConnection");
+        }
+        #endregion
 
 
-		#region HTTP endpoints
+        #region HTTP endpoints
-		[HttpGet("{id}")]
+        [HttpGet("{id}")]
-		[Authorize("stream:songs")]
+        [Authorize("stream:songs")]
-		public async Task<IActionResult> Get(int id)
+        public async Task<IActionResult> Get(int id)
-		{
+        {
-			var songStore= HttpContext
+            var context = new SongContext(_config.GetConnectionString("DefaultConnection"));
-				.RequestServices
-				.GetService(typeof(SongRepository)) as SongRepository;
 
-			var song = songStore.GetSong(new Song { Id = id });
+            var song = context.Songs.FirstOrDefault(sng => sng.SongID == id);
 
-			var mem =  new MemoryStream();
+            var stream = new FileStream(song.SongPath(), FileMode.Open, FileAccess.Read);
+            stream.Position = 0;
+            var filename = $"{song.Title}.mp3";
 
-			using (var stream = new FileStream(song.SongPath, FileMode.Open, FileAccess.Read))
+            _logger.LogInformation("Starting to stream song...>");
-			{
+            Console.WriteLine("Starting to streamsong...");
-				await stream.CopyToAsync(mem);
-			}
 
-			mem.Position = 0;
+            var file = await Task.Run(() => {
+                return File(stream, "application/octet-stream", filename);
+            });
 
-			_logger.LogInformation("Starting to stream song...>");
+            return file;
-			Console.WriteLine("Starting to streamsong...");
+        }
-
+        #endregion
-			return File(mem, "application/octet-stream", Path.GetFileName(song.SongPath));
+    }
-		}
-		#endregion
-	}
 }

Controllers/v1/YearController.cs

@@ -1,84 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-
-using Icarus.Models;
-using Icarus.Database.Repositories;
-
-namespace Icarus.Controller.V1
-{
-	[Route("api/v1/year")]
-	[ApiController]
-	public class YearController : ControllerBase
-	{
-		#region Fields
-		private readonly ILogger<YearController> _logger;
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		public YearController(ILogger<YearController> logger)
-		{
-			_logger = logger;
-		}
-		#endregion
-
-
-		#region HTTP Routes
-		[HttpGet]
-		[Authorize("read:year")]
-		public IActionResult Get()
-		{
-			var yearValues = new List<Year>();
-
-			var yearStore = HttpContext
-				.RequestServices
-				.GetService(typeof(YearRepository)) as YearRepository;
-
-			yearValues = yearStore.GetSongYears();
-
-			if (yearValues.Count > 0)
-			{
-				return Ok(yearValues);
-			}
-			else
-			{
-				return NotFound(new List<Year>());
-			}
-		}
-
-		[HttpGet("{id}")]
-		[Authorize("read:year")]
-		public IActionResult Get(int id)
-		{
-			var year = new Year
-			{
-				YearId = id
-			};
-
-			var yearStore = HttpContext
-				.RequestServices
-				.GetService(typeof(YearRepository)) as YearRepository;
-
-			if (yearStore.DoesYearExist(year))
-			{
-				year = yearStore.GetSongYear(year);
-
-				return Ok(year);
-			}
-			else
-			{
-				return NotFound(new Year());
-			}
-		}
-		#endregion
-	}
-}

Database/Contexts/AlbumContext.cs

@@ -1,27 +1,37 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore.Extensions;
-using MySql.Data.MySqlClient;
 
 using Icarus.Models;
 
 namespace Icarus.Database.Contexts
 {
-	public class AlbumContext : DbContext
+    public class AlbumContext : DbContext
-	{
+    {
-		public DbSet<Album> Albums { get; set; }
+        public DbSet<Album> Albums { get; set; }
 
-		public AlbumContext(DbContextOptions<AlbumContext> options)
+        public AlbumContext(DbContextOptions<AlbumContext> options) : base(options) { }
-			: base(options)
+        public AlbumContext(string connString) : base(new DbContextOptionsBuilder<AlbumContext>()
-		{ }
+                            .UseMySQL(connString).Options)
+        {
+        }                        
 
-		protected override void OnModelCreating(ModelBuilder modelBuilder)
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
-		{
+        {
-			modelBuilder.Entity<Album>()
+            modelBuilder.Entity<Album>()
-				.ToTable("Album");
+                .ToTable("Album");
-		}
+        }
-	}
+
+        public Album RetrieveRecord(Album album)
+        {
+            return Albums.FirstOrDefault(alb => alb.AlbumID == album.AlbumID);
+        }
+
+        public bool DoesRecordExist(Album album)
+        {
+            return Albums.FirstOrDefault(alb => alb.AlbumID == album.AlbumID) != null ? true : false;
+        }
+    }
 }

Database/Contexts/ArtistContext.cs

@@ -1,27 +1,39 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore;
-using MySql.Data.MySqlClient;
 
 using Icarus.Models;
 
 namespace Icarus.Database.Contexts
 {
-	public class ArtistContext : DbContext
+    public class ArtistContext : DbContext
-	{
+    {
-		public DbSet<Artist> Artists { get; set; }
+        public DbSet<Artist> Artists { get; set; }
 
-		public ArtistContext(DbContextOptions<ArtistContext> options)
+		public ArtistContext(DbContextOptions<ArtistContext> options) : base (options) { }
-			: base (options)
+		public ArtistContext(string connString) : base(new DbContextOptionsBuilder<ArtistContext>()
-		{ }
+							.UseMySQL(connString).Options)
+		{
+		}                        
 
 		protected override void OnModelCreating(ModelBuilder modelBuilder)
 		{
 			modelBuilder.Entity<Artist>()
 				.ToTable("Artist");
 		}
-	}
+
+		public Artist RetrieveRecord(Artist artist)
+		{
+
+            return Artists.FirstOrDefault(arst => arst.ArtistID == artist.ArtistID);
+		}
+
+
+        public bool DoesRecordExist(Artist artist)
+        {
+            return Artists.FirstOrDefault(arst => arst.ArtistID == artist.ArtistID) != null ? true : false;
+        }
+    }
 }

Database/Contexts/CoverArtContext.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Microsoft.EntityFrameworkCore;
+
+using Icarus.Models;
+
+namespace Icarus.Database.Contexts
+{
+    public class CoverArtContext : DbContext
+    {
+        public DbSet<CoverArt> CoverArtImages { get; set; }
+
+        public CoverArtContext(DbContextOptions<CoverArtContext> options) : base(options) { }
+        public CoverArtContext(string connString) : base(new DbContextOptionsBuilder<CoverArtContext>()
+                            .UseMySQL(connString).Options)
+        {
+        }                        
+        
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<CoverArt>()
+                .ToTable("CoverArt");
+        }
+
+        public CoverArt RetrieveRecord(CoverArt cover)
+        {
+            return CoverArtImages.FirstOrDefault(cov => cov.CoverArtID == cover.CoverArtID);
+        }
+
+        public bool DoesRecordExist(CoverArt cover)
+        {
+            return CoverArtImages.FirstOrDefault(cov => cov.CoverArtID == cover.CoverArtID) != null ? true : false;
+        }
+    }
+}

Database/Contexts/GenreContext.cs

@@ -1,27 +1,37 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore.Extensions;
-using MySql.Data.MySqlClient;
 
 using Icarus.Models;
 
 namespace Icarus.Database.Contexts
 {
-	public class GenreContext : DbContext
+    public class GenreContext : DbContext
-	{
+    {
-		public DbSet<Genre> Genres { get; set; }
+        public DbSet<Genre> Genres { get; set; }
+        public GenreContext(DbContextOptions<GenreContext> options) : base(options) { }
+        public GenreContext(string connString) : base(new DbContextOptionsBuilder<GenreContext>()
+                            .UseMySQL(connString).Options)
+        {
+        }                        
 
-		public GenreContext(DbContextOptions<GenreContext> options)
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
-			: base(options)
+        {
-		{ }
+            modelBuilder.Entity<Genre>()
+                .ToTable("Genre");
+        }
 
-		protected override void OnModelCreating(ModelBuilder modelBuilder)
+
-		{
+        public Genre RetrieveRecord(Genre genre)
-			modelBuilder.Entity<Genre>()
+        {
-				.ToTable("Genre");
+            return Genres.FirstOrDefault(gnr => gnr.GenreID == genre.GenreID);
-		}
+        }
-	}
+
+        public bool DoesRecordExist(Genre genre)
+        {
+            return Genres.FirstOrDefault(gnr => gnr.GenreID == genre.GenreID) != null ? true : false;
+        }
+    }
 }

Database/Contexts/SongContext.cs

@@ -1,68 +1,89 @@
 using System;    
 using System.Collections.Generic;    
+using System.Linq;
 
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore.Extensions;
-using MySql.Data.MySqlClient;    
 
 using Icarus.Models;
         
 namespace Icarus.Database.Contexts
 {    
-	public class SongContext : DbContext
+    public class SongContext : DbContext
-    	{
+    {
-        	public DbSet<Song> Songs { get; set; }
+        public DbSet<Song> Songs { get; set; }
+
+		public SongContext(string connString) : base(new DbContextOptionsBuilder<SongContext>()
+							.UseMySQL(connString).Options)
+		{
+		}                        
 
 
-		public SongContext(DbContextOptions<SongContext> options)
+		public SongContext(DbContextOptions<SongContext> options) : base(options) { }
-            		: base(options)
-        	{ }
 
-        	protected override void OnModelCreating(ModelBuilder modelBuilder)
+		protected override void OnModelCreating(ModelBuilder modelBuilder)
-        	{
+		{
-            		modelBuilder.Entity<Song>()
+			modelBuilder.Entity<Song>()
 				.ToTable("Song");
 
+			/**
 			modelBuilder.Entity<Song>()
 				.HasOne(s => s.Album)
-				.WithMany(al => al.Songs)
+			.WithMany(al => al.Songs)
-				.HasForeignKey(s => s.AlbumId)
+			.HasForeignKey(s => s.AlbumID)
-				.OnDelete(DeleteBehavior.SetNull);
+			.OnDelete(DeleteBehavior.SetNull);
 
 			modelBuilder.Entity<Song>()
 				.HasOne(sa => sa.SongArtist)
-				.WithMany(ar => ar.Songs)
+			.WithMany(ar => ar.Songs)
-				.HasForeignKey(s => s.ArtistId)
+			.HasForeignKey(s => s.ArtistID)
-				.OnDelete(DeleteBehavior.SetNull);
+			.OnDelete(DeleteBehavior.SetNull);
 
 			modelBuilder.Entity<Song>()
 				.HasOne(s => s.SongGenre)
-				.WithMany(gnr => gnr.Songs)
+			.WithMany(gnr => gnr.Songs)
-				.HasForeignKey(s => s.GenreId)
+			.HasForeignKey(s => s.GenreID)
-				.OnDelete(DeleteBehavior.SetNull);
+			.OnDelete(DeleteBehavior.SetNull);
 
 			modelBuilder.Entity<Song>()
 				.HasOne(s => s.SongYear)
-				.WithMany(yr => yr.Songs)
+			.WithMany(yr => yr.Songs)
-				.HasForeignKey(s => s.YearId)
+			.HasForeignKey(s => s.YearID)
+			.OnDelete(DeleteBehavior.SetNull);
+
+			modelBuilder.Entity<Song>()
+				.HasOne(s => s.SongCoverArt)
+				.WithMany(ca => ca.Songs)
+				.HasForeignKey(s => s.CoverArtID)
 				.OnDelete(DeleteBehavior.SetNull);
+			*/
 
 			modelBuilder.Entity<Song>()
 				.Property(s => s.Year)
-				.IsRequired(false);
+			.IsRequired(false);
 			modelBuilder.Entity<Song>()
-				.Property(s => s.YearId)
+				.Property(s => s.GenreID)
-				.IsRequired(false);
+			.IsRequired(false);
 			modelBuilder.Entity<Song>()
-				.Property(s => s.GenreId)
+				.Property(s => s.ArtistID)
-				.IsRequired(false);
+			.IsRequired(false);
 			modelBuilder.Entity<Song>()
-				.Property(s => s.ArtistId)
+				.Property(s => s.AlbumID)
-				.IsRequired(false);
+			.IsRequired(false);
 			modelBuilder.Entity<Song>()
-				.Property(s => s.AlbumId)
+			.Property(s => s.CoverArtID)
-				.IsRequired(false);
+			.IsRequired(false);
-        	}
+		}
-    	}
+
+
+		public Song RetrieveRecord(Song song)
+		{
+            return Songs.FirstOrDefault(sng => sng.SongID == song.SongID);
+		}
+
+
+        public bool DoesRecordExist(Song song)
+        {
+            return Songs.FirstOrDefault(sng => sng.SongID == song.SongID) != null ? true : false;
+        }
+    }
 }  

Database/Contexts/UserContext.cs

@@ -1,32 +1,48 @@
 using System;    
 using System.Collections.Generic;    
+using System.Linq;
 
+// using MySql.Data.EntityFrameworkCore;
+// using MySql.Data;
+// using MySql.Data.EntityFrameworkCore.Extensions;
+// using MySql.Data.Entity;
+// using MySql.Data.MySqlClient;    
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore.Extensions;
-using MySql.Data.MySqlClient;    
 
 using Icarus.Models;
         
 namespace Icarus.Database.Contexts
 {    
-	public class UserContext : DbContext
+    public class UserContext : DbContext
-	{
+    {
-        	public DbSet<User> Users { get; set; }
+        public DbSet<User> Users { get; set; }
 
 
-		public UserContext(DbContextOptions<UserContext> options)
+        public UserContext(DbContextOptions<UserContext> options) : base(options) { }
-            		: base(options)
+        public UserContext(string connString) : base(new DbContextOptionsBuilder<UserContext>()
-        	{ }
+                            .UseMySQL(connString).Options)
+        {
+        }                        
 
-        	protected override void OnModelCreating(ModelBuilder modelBuilder)
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
-        	{
+        {
-			modelBuilder.Entity<User>()
+            modelBuilder.Entity<User>()
-				.ToTable("User");
+                .ToTable("User");
-            		modelBuilder.Entity<User>()
+            modelBuilder.Entity<User>()
-				.Property(u => u.LastLogin).IsRequired(false);
+                .Property(u => u.LastLogin).IsRequired(false);
-			modelBuilder.Entity<User>()
+            modelBuilder.Entity<User>()
-				.Property(u => u.DateCreated).HasDefaultValue(DateTime.Now);
+                .Property(u => u.DateCreated).HasDefaultValue(DateTime.Now);
-        	}
+        }
-    	}
+
+        
+        public User RetrieveRecord(User user)
+        {
+            return Users.FirstOrDefault(usr => usr.UserID == user.UserID);
+        }
+
+        public bool DoesRecordExist(User user)
+        {
+            return Users.FirstOrDefault(usr => usr.UserID == user.UserID) != null ? true : false;
+        }
+    }
 }  

Database/Contexts/YearContext.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-using Microsoft.EntityFrameworkCore;
-using MySql.Data;
-using MySql.Data.EntityFrameworkCore.Extensions;
-using MySql.Data.MySqlClient;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Contexts
-{
-	public class YearContext : DbContext
-	{
-		public DbSet<Year> YearValues { get; set; }
-
-		public YearContext(DbContextOptions<YearContext> options)
-			: base(options)
-		{ }
-
-		protected override void OnModelCreating(ModelBuilder modelBuilder)
-		{
-			modelBuilder.Entity<Year>()
-				.ToTable("Year");
-		}
-	}
-}

Database/Repositories/AlbumRepository.cs

@@ -1,411 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-using MySql.Data.MySqlClient;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{
-	public class AlbumRepository : BaseRepository
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		public AlbumRepository(string connectionString)
-		{
-			_connectionString = connectionString;
-		}
-		#endregion
-
-
-		#region Methods
-		public List<Album> GetAlbumWithoutCount()
-		{
-			var albums = new List<Album>();
-
-			if (AnyAlbums())
-			{
-				try
-				{
-					using (MySqlConnection conn = GetConnection())
-					{
-						conn.Open();
-						var query = "SELECT * FROM Album";
-						using (MySqlCommand cmd = new MySqlCommand(query, conn))
-						{
-							using (var reader = cmd.ExecuteReader())
-							{
-								albums = ParseData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return albums;
-		}
-		public List<Album> GetAlbums()
-		{
-			List<Album> albums = new List<Album>();
-
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT alb.*,COUNT(*) AS SongCount FROM Album alb " +
-						"LEFT JOIN Song sng ON alb.AlbumId=sng.AlbumId WHERE " +
-						"alb.AlbumId=sng.AlbumId GROUP BY alb.AlbumId";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						using (var reader = cmd.ExecuteReader())
-						{
-							albums = ParseData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return albums;
-		}
-
-		public Album GetAlbum(Album album)
-		{
-
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT alb.*, COUNT(*) AS SongCount FROM Album alb " + 
-						"LEFT JOIN Song sng ON alb.AlbumId=sng.AlbumId WHERE "+
-						"alb.AlbumId=@AlbumId LIMIT 1";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@AlbumId", album.AlbumId);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							album = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return album;
-		}
-		public Album GetAlbum(Song song)
-		{
-			var album = new Album();
-
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT alb.*, 0 AS SongCount FROM Album alb " +
-						"WHERE alb.Title=@Title LIMIT 1";
-					
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						Console.WriteLine($"Album title {song.AlbumTitle}");
-						cmd.Parameters.AddWithValue("@Title", song.AlbumTitle);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							album = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return album;
-		}
-		public Album GetAlbum(Song song, bool retrieveCount)
-		{
-			var album = new Album();
-
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = string.Empty;
-					if (retrieveCount)
-					{
-						query = "SELECT alb.*, COUNT(*) AS SongCount FROM Album alb " +
-							"LEFT JOIN Song sng ON alb.AlbumId=sng.AlbumId WHERE " +
-							"alb.Title=@Title GROUP BY alb.AlbumId LIMIT 1";
-					}
-					else
-					{
-						query = "SELECT alb.*, 0 AS SongCount FROM Album alb WHERE " +
-							"alb.Title=@Title LIMIT 1";
-					}
-					
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Title", song.AlbumTitle);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							album = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return album;
-		}
-
-		public bool DoesAlbumExist(Album album)
-		{
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT alb.*, 0 AS SongCount FROM Album alb WHERE alb.AlbumId=@AlbumId";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@AlbumId", album.AlbumId);
-						
-						using (var reader = cmd.ExecuteReader())
-						{
-							album =  ParseSingleData(reader);
-
-							if (album.Title != null)
-							{
-								_logger.Info($"Album {album.Title} exists");
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-			return false;
-		}
-		public bool DoesAlbumExist(Song song)
-		{
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT alb.*, 0 AS SongCount FROM Album alb WHERE alb.Title=@Title";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Title", song.AlbumTitle);
-						
-						using (var reader = cmd.ExecuteReader())
-						{
-							var album =  ParseSingleData(reader);
-
-							if (!String.IsNullOrEmpty(album.Title))
-							{
-								_logger.Info($"Album {album.Title} exists");
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-			return false;
-		}
-
-		public void SaveAlbum(Album album)
-		{
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "INSERT INTO Album(Title, AlbumArtist)" +
-						" VALUES (@Title, @AlbumArtist)";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Title", album.Title);
-						cmd.Parameters.AddWithValue("@AlbumArtist", album.AlbumArtist);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void UpdateAlbum(Album album)
-		{
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "UPDATE Album SET Title=@Title, AlbumArtist=" +
-						"@AlbumArtist WHERE AlbumId=@AlbumId";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Title", album.Title);
-						cmd.Parameters.AddWithValue("@AlbumArtist", album.AlbumArtist);
-						cmd.Parameters.AddWithValue("@AlbumId", album.AlbumId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteAlbum(Album album)
-		{
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-					var query = "DELETE FROM Album WHERE AlbumId=@AlbumId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@AlbumId", album.AlbumId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-
-		private List<Album> ParseData(MySqlDataReader reader)
-		{
-			List<Album> albums = new List<Album>();
-			_logger.Info("Retrieving album records");
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["AlbumId"]);
-				var title = reader["Title"].ToString();
-				var albumArtist = reader["AlbumArtist"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"]);
-				albums.Add(new Album
-				{
-					AlbumId = id,
-					Title = title,
-					AlbumArtist = albumArtist,
-					SongCount = songCount
-				});
-			}
-
-			_logger.Info("Album records retrieved");
-
-			return albums;
-		}
-		private Album ParseSingleData(MySqlDataReader reader)
-		{
-			Album album = new Album();
-			_logger.Info("Retrieving single album record");
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["AlbumId"]);
-				var title = reader["Title"].ToString();
-				var albumArtist = reader["AlbumArtist"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"]);
-				album = new Album
-				{
-					AlbumId = id,
-					Title = title,
-					AlbumArtist = albumArtist,
-					SongCount = songCount
-				};
-			}
-			_logger.Info("Single ablum retreived");
-
-			return album;
-		}
-
-		private bool AnyAlbums()
-		{
-			var albums = new List<Album>();
-
-			using (var conn = GetConnection())
-			{
-				conn.Open();
-
-				var query = "SELECT * FROM Album";
-
-				using (var cmd = new MySqlCommand(query, conn))
-				{
-					using (var reader = cmd.ExecuteReader())
-					{
-						albums = ParseData(reader);
-					}
-				}
-			}
-
-			if (albums.Count > 0)
-			{
-				return true;
-			}
-
-			return false;
-		}
-		#endregion
-	}
-}

Database/Repositories/ArtistRepository.cs

@@ -1,370 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-using Microsoft.Extensions.Logging;
-using MySql.Data.MySqlClient;
-//using NLog;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{
-	public class ArtistRepository : BaseRepository
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		public ArtistRepository(string connectionString)
-		{
-			_connectionString = connectionString;
-		}
-		#endregion
-
-
-		#region Methods
-		public List<Artist> GetArtists()
-		{
-			List<Artist> artists = new List<Artist>();
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT art.*, COUNT(*) AS SongCount FROM Artist " + 
-						"art LEFT JOIN Song sng ON art.ArtistId=sng.ArtistId " +
-						"GROUP BY art.ArtistId";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						using (var reader = cmd.ExecuteReader())
-						{
-
-							artists = ParseData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return artists;
-		}
-
-		public Artist GetArtist(Artist artist)
-		{
-			try
-			{
-				_logger.Info("Retrieving artist record from the database");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT art.*, COUNT(*) AS SongCount FROM Artist " +
-						"art LEFT JOIN Song sng ON art.ArtistId=sng.ArtistId " +
-						"WHERE art.ArtistId=@ArtistId";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@ArtistId", artist.ArtistId);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							artist = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return artist;
-		}
-		public Artist GetArtist(Song song)
-		{
-			Artist artist = new Artist();
-			try
-			{
-				_logger.Info("Retrieving artist record from the database");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT art.*, 0 AS SongCount FROM Artist " +
-						"art WHERE art.Name=@Name";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Name", song.Artist);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							artist = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return artist;
-		}
-		public Artist GetArtist(Song song, bool retrieveCount)
-		{
-			var artist = new Artist();
-
-			try
-			{
-				_logger.Info("Retrieving artist record from the database");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = string.Empty;
-
-					if (retrieveCount)
-					{
-						query = "SELECT art.*, COUNT(*) AS SongCount FROM Artist " +
-							"art LEFT JOIN Song sng ON art.ArtistId=sng.ArtistId " +
-							"WHERE art.Name=@Name GROUP BY art.ArtistId LIMIT 1";
-					}
-					else
-					{
-						query = "SELECT art.*, 0 AS SongCount FROM Artist art " +
-							"WHERE art.Name=@Name LIMIT 1";
-					}
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Name", song.Artist);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							artist = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return artist;
-		}
-
-		public bool DoesArtistExist(Artist artist)
-		{
-			try
-			{
-				_logger.Info("Checking to see if Artist exists");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT art.*, 0 AS SongCount FROM Artist art WHERE art.ArtistId=@ArtistId";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@ArtistId", artist.ArtistId);
-						
-						using (var reader = cmd.ExecuteReader())
-						{
-							artist =  ParseSingleData(reader);
-
-							if (artist.Name != null)
-							{
-								_logger.Info($"Artist {artist.Name} exists");
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-			
-			_logger.Info("Could not successfully retrieve Artist");
-
-			return false;
-		}
-		public bool DoesArtistExist(Song song)
-		{
-			try
-			{
-				_logger.Info("Checking to see if Artist exists");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT art.*, 0 AS SongCount FROM Artist art WHERE art.Name=@Name";
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Name", song.Artist);
-						
-						using (var reader = cmd.ExecuteReader())
-						{
-							var artist =  ParseSingleData(reader);
-
-							if (!String.IsNullOrEmpty(artist.Name))
-							{
-								_logger.Info($"Artist {artist.Name} exists");
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("Could not successfully retrieve Artist");
-
-			return false;
-		}
-
-
-		public void SaveArtist(Artist artist)
-		{
-			try
-			{
-				_logger.Info("Saving artist record");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "INSERT INTO Artist(Name) VALUES(@Name)";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Name", artist.Name);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-
-				_logger.Info("Artist record has successfully been saved");
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void UpdateArtist(Artist artist)
-		{
-			try
-			{
-				_logger.Info("Updating artist record");
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "UPDATE Artist SET Name=@Name WHERE ArtistId=@ArtistId";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Name", artist.Name);
-						cmd.Parameters.AddWithValue("@ArtistId", artist.ArtistId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-
-				_logger.Info("Artist record has successfully been saved");
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteArtist(Artist artist)
-		{
-			try
-			{
-				_logger.Info("Deleting artist record");
-
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "DELETE FROM Artist WHERE ArtistId=@ArtistId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@ArtistId", artist.ArtistId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-
-		private List<Artist> ParseData(MySqlDataReader reader)
-		{
-			List<Artist> artists = new List<Artist>();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["ArtistId"]);
-				var name = reader["Name"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-				artists.Add(new Artist
-				{
-					ArtistId = id,
-					Name = name,
-					SongCount = songCount
-				});
-			}
-
-			_logger.Info("Artist records retrieved");
-
-			return artists;
-		}
-
-		private Artist ParseSingleData(MySqlDataReader reader)
-		{
-			Artist artist = new Artist();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["ArtistId"]);
-				var name = reader["Name"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-				artist.ArtistId = id;
-				artist.Name = name;
-				artist.SongCount = songCount;
-			}
-
-			_logger.Info("Single artist record retrieved");
-
-			return artist;
-		}
-		#endregion
-	}
-}

Database/Repositories/BaseRepository.cs

@@ -1,23 +0,0 @@
-using System;
-
-using MySql.Data.MySqlClient;
-using NLog;
-
-namespace Icarus.Database.Repositories
-{
-	public class BaseRepository
-	{
-		#region Fields
-		protected string _connectionString;
-		protected static Logger _logger = NLog.LogManager.GetCurrentClassLogger();
-		#endregion
-
-
-		#region Methods
-		protected MySqlConnection GetConnection()
-		{
-			return new MySqlConnection(_connectionString);
-		}
-		#endregion
-	}
-}

Database/Repositories/GenreRepository.cs

@@ -1,469 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-using MySql.Data.MySqlClient;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{
-	public class GenreRepository : BaseRepository
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		public GenreRepository(string connectionString)
-		{
-			_connectionString = connectionString;
-		}
-		#endregion
-
-
-		#region Methods
-		public List<Genre> GetGenresWithoutCount()
-		{
-			_logger.Info("Retrieving all genre records without song counts");
-
-			var genres = new List<Genre>();
-
-			if (AnyGenre())
-			{
-
-				try
-				{
-					using (var conn = GetConnection())
-					{
-						conn.Open();
-
-						var query = "SELECT * FROM Genre";
-
-						using (var cmd = new MySqlCommand(query, conn))
-						{
-							using (var reader = cmd.ExecuteReader())
-							{
-								genres = ParseData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return genres;
-		}
-		public List<Genre> GetGenres()
-		{
-			_logger.Info("Retrieving Genre records");
-
-			var genres = new List<Genre>();
-
-			if (AnyGenre())
-			{
-
-				try
-				{
-					using (var conn = GetConnection())
-					{
-						conn.Open();
-
-						var query = "SELECT gnr.*, COUNT(*) AS SongCount FROM Genre " + 
-							"gnr LEFT JOIN Song sng ON gnr.GenreId=sng.GenreId " +
-							"GROUP BY gnr.GenreId";
-
-						using (var cmd = new MySqlCommand(query, conn))
-						{
-							using (var reader = cmd.ExecuteReader())
-							{
-								genres = ParseData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return genres;
-		}
-
-		public Genre GetGenre(Genre genre)
-		{
-			_logger.Info("Retrieving Genre record");
-
-			if (DoesGenreExist(genre))
-			{
-				try
-				{
-					using (var conn = GetConnection())
-					{
-						conn.Open();
-
-						var query = "SELECT gnr.*, COUNT(*) AS SongCount FROM Genre " +
-							"gnr LEFT JOIN Song sng ON gnr.GenreId=sng.GenreId  " +
-						       "WHERE gnr.GenreId=@GenreId";
-
-						using (var cmd = new MySqlCommand(query, conn))
-						{
-							cmd.Parameters.AddWithValue("@GenreId", genre.GenreId);
-
-							using (var reader = cmd.ExecuteReader())
-							{
-								genre = ParseSingleData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return genre;
-		}
-		public Genre GetGenre(Song song)
-		{
-			_logger.Info("Retrieving Genre record");
-
-			var genre = new Genre();
-
-			if (DoesGenreExist(song))
-			{
-				try
-				{
-					using (var conn = GetConnection())
-					{
-						conn.Open();
-
-						var query = "SELECT gnr.*, 0 AS SongCount FROM Genre " +
-							"gnr WHERE gnr.GenreName=@GenreName";
-
-						using (var cmd = new MySqlCommand(query, conn))
-						{
-							cmd.Parameters.AddWithValue("@GenreName", song.Genre);
-							_logger.Info($"Song genre:\n\n\n {song.Genre}");
-
-							using (var reader = cmd.ExecuteReader())
-							{
-								genre = ParseSingleData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return genre;
-		}
-		public Genre GetGenre(Song song, bool retrieveCount)
-		{
-			_logger.Info("Retrieving Genre record");
-
-			var genre = new Genre();
-
-			if (DoesGenreExist(song))
-			{
-				try
-				{
-					using (var conn = GetConnection())
-					{
-						conn.Open();
-
-						var query = string.Empty;
-
-						if (retrieveCount)
-						{
-							query = "SELECT gnr.*, COUNT(*) AS SongCount FROM Genre gnr " +
-								"LEFT JOIN Song sng ON gnr.GenreId=sng.GenreId " +
-								"WHERE gnr.GenreName=@GenreName GROUP BY gnr.GenreId " +
-								"LIMIT 1";
-						}
-						else
-						{
-							query = "SELECT gnr.*, 0 AS SongCount FROM Genre gnr " +
-								"WHERE gnr.GenreName=@GenreName LIMIT 1";
-						}
-
-						using (var cmd = new MySqlCommand(query, conn))
-						{
-							cmd.Parameters.AddWithValue("@GenreName", song.Genre);
-							_logger.Info($"Song genre:\n\n\n {song.Genre}");
-
-							using (var reader = cmd.ExecuteReader())
-							{
-								genre = ParseSingleData(reader);
-							}
-						}
-					}
-				}
-				catch (Exception ex)
-				{
-					var msg = ex.Message;
-					_logger.Error(msg, "An error occurred");
-				}
-			}
-
-			return genre;
-		}
-
-		public bool DoesGenreExist(Genre genre)
-		{
-			_logger.Info("Checking to see if Genre record exists");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT gnr.*, 0 AS SongCount FROM Genre gnr WHERE " +
-						"gnr.GenreId=@GenreId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@GenreId", genre.GenreId);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							genre = ParseSingleData(reader);
-							var genreName = genre.GenreName;
-
-							if (!string.IsNullOrEmpty(genreName))
-							{
-								_logger.Info("Genre exists");
-
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("Genre does not exist");
-
-			return false;
-		}
-		public bool DoesGenreExist(Song song)
-		{
-			_logger.Info("Checking to see if Genre record exists");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT gnr.*, 0 AS SongCount FROM Genre gnr WHERE " +
-						"gnr.GenreName=@GenreName";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@GenreName", song.Genre);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							var genre = ParseSingleData(reader);
-							var genreName = genre.GenreName;
-
-							if (!string.IsNullOrEmpty(genreName))
-							{
-								_logger.Info("Genre exists");
-
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("Genre does not exist");
-
-			return false;
-		}
-
-		public void SaveGenre(Genre genre)
-		{
-			_logger.Info("Saving Genre record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "INSERT INTO Genre(GenreName) VALUES(@GenreName)";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@GenreName", genre.GenreName);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void UpdateGenre(Genre genre)
-		{
-			_logger.Info("Updating Genre record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "UPDATE Genre SET GenreName=@GenreName " +
-						"WHERE GenreId=@GenreId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@GenreName", genre.GenreName);
-						cmd.Parameters.AddWithValue("@GenreId", genre.GenreId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteGenre(Genre genre)
-		{
-			_logger.Info("Deleting Genre record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "DELETE FROM Genre WHERE GenreId=@GenreId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@GenreId", genre.GenreId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-
-		private List<Genre> ParseData(MySqlDataReader reader)
-		{
-			var genres = new List<Genre>();
-			_logger.Info("Retrieving genre records");
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["GenreId"].ToString());
-				var genreName = reader["GenreName"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-
-				genres.Add(new Genre
-				{
-					GenreId = id,
-					GenreName = genreName,
-					SongCount = songCount
-				});
-			}
-
-			_logger.Info("Genre records retrieved");
-
-			return genres;
-		}
-
-		private Genre ParseSingleData(MySqlDataReader reader)
-		{
-			var genre = new Genre();
-			_logger.Info("Retrieving single genre record");
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["GenreId"].ToString());
-				var genreName = reader["GenreName"].ToString();
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-				genre.GenreId = id;
-				genre.GenreName = genreName;
-				genre.SongCount = songCount;
-			}
-
-			_logger.Info("Single genre record retrieved");
-
-			return genre;
-		}
-
-		private bool AnyGenre()
-		{
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT * FROM Genre";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						using (var reader = cmd.ExecuteReader())
-						{
-							return reader.HasRows;
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("No genre records found");
-
-			return false;
-		}
-		#endregion
-	}
-}

Database/Repositories/SongRepository.cs

@@ -1,326 +0,0 @@
-using System;    
-using System.Collections.Generic;    
-
-using MySql.Data.MySqlClient;    
-        
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{    
-	public class SongRepository : BaseRepository
-    	{    
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-    
-
-		#region Constructors
-        	public SongRepository(string connectionString)    
-        	{    
-            		_connectionString = connectionString;    
-        	}    
-		#endregion
-
-
-		#region Methods
-		public void SaveSong(Song song)
-		{
-	    		try
-	    		{
-				_logger.Info("Saving song to the database");
-	     	   		using (MySqlConnection conn = GetConnection())
-				{
-		    			conn.Open();
-		    			string query = "INSERT INTO Song(Title, AlbumTitle, Artist," +
-						" Year, Genre, Duration, Filename, SongPath, AlbumId, " +
-						"ArtistId, GenreId, YearId) VALUES(@Title, @AlbumTitle, " +
-						"@Artist, @Year, @Genre, @Duration, @Filename, @SongPath, " +
-						"@AlbumId, @ArtistId, @GenreId, @YearId)";
-		    			using (MySqlCommand cmd = new MySqlCommand(query, conn))
-		    			{
-		        			cmd.Parameters.AddWithValue("@Title", song.Title);
-						cmd.Parameters.AddWithValue("@AlbumTitle", song.AlbumTitle);
-						cmd.Parameters.AddWithValue("@Artist", song.Artist);
-						cmd.Parameters.AddWithValue("@Year", song.Year);
-						cmd.Parameters.AddWithValue("@Genre", song.Genre);
-						cmd.Parameters.AddWithValue("@Duration", song.Duration);
-						cmd.Parameters.AddWithValue("@Filename", song.Filename);
-						cmd.Parameters.AddWithValue("@SongPath", song.SongPath);
-						cmd.Parameters.AddWithValue("@AlbumId", song.AlbumId);
-						cmd.Parameters.AddWithValue("@ArtistId", song.ArtistId);
-						cmd.Parameters.AddWithValue("@GenreId", song.GenreId);
-						cmd.Parameters.AddWithValue("@YearId", song.YearId);
-
-						cmd.ExecuteNonQuery();
-		    			}
-				}
-				_logger.Info("Successfully saved song to the database");
-	    		}
-	    		catch(Exception ex)
-	    		{
-	        		var exMsg = ex.Message;
-				Console.WriteLine($"An error occurred:\n{exMsg}");
-				_logger.Error(exMsg, "An error occurred");
-	    		}
-		}
-		public void UpdateSong(Song song)
-		{
-			try
-			{
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-
-		    			string query = "UPDATE Song SET Title=@Title, AlbumTitle=@AlbumTitle, " + 
-						"Artist=@Artist, Year=@Year, Genre=@Genre, Duration=@Duration, " +
-						"Filename=@Filename, SongPath=@SongPath, AlbumId=@AlbumId, " +
-						"ArtistId=@ArtistId, GenreId=@GenreId, YearId=@YearId  WHERE Id=@Id";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-		        			cmd.Parameters.AddWithValue("@Title", song.Title);
-						cmd.Parameters.AddWithValue("@AlbumTitle", song.AlbumTitle);
-						cmd.Parameters.AddWithValue("@Artist", song.Artist);
-						cmd.Parameters.AddWithValue("@Year", song.Year);
-						cmd.Parameters.AddWithValue("@Genre", song.Genre);
-						cmd.Parameters.AddWithValue("@Duration", song.Duration);
-						cmd.Parameters.AddWithValue("@Filename", song.Filename);
-						cmd.Parameters.AddWithValue("@SongPath", song.SongPath);
-						cmd.Parameters.AddWithValue("@Id", song.Id);
-						cmd.Parameters.AddWithValue("@AlbumId", song.AlbumId);
-						cmd.Parameters.AddWithValue("@ArtistId", song.ArtistId);
-						cmd.Parameters.AddWithValue("@GenreId", song.GenreId);
-						cmd.Parameters.AddWithValue("@YearId", song.YearId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-				_logger.Info("Updated song");
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				Console.WriteLine("An error occurred in SongRepository:");
-				Console.WriteLine(msg);
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteSong(Song song)
-		{
-			try
-			{
-				_logger.Info("Deleting song record");
-
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "Delete FROM Song WHERE Id=@Id";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Id", song.Id);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteSong(int id)
-		{
-	    		try
-	    		{
-				_logger.Info("Deleting song record");
-
-	        		using (MySqlConnection conn = GetConnection())
-				{
-		    			conn.Open();
-			    		string query = "DELETE FROM Song WHERE Id=@Id";
-				   
-			    		using (MySqlCommand cmd = new MySqlCommand(query, conn))
-			    		{
-		        			cmd.Parameters.AddWithValue("@Id", id);
-
-						cmd.ExecuteNonQuery();
-		    			}
-				}
-	    		}
-	    		catch (Exception ex)
-	    		{
-	        		var exMsg = ex.Message;
-				Console.WriteLine($"An error occurred:\n{exMsg}");
-				_logger.Error(exMsg, "An error occurred");
-	    		}
-		}
-
-		public List<Song> GetAllSongs()
-		{
-	    		List<Song> songs = new List<Song>();
-
-	    		try
-	    		{
-				_logger.Info("Retrieving songs from the database");
-	        		using (MySqlConnection conn = GetConnection())
-				{
-		    			conn.Open();
-		    			var query = "SELECT * FROM Song";
-					Console.WriteLine("ffff");
-		    			MySqlCommand cmd = new MySqlCommand(query, conn);
-		    			using (var reader = cmd.ExecuteReader())
-		    			{
-						songs = ParseData(reader);
-		    			}
-				}
-	    		}
-	    		catch (Exception ex)
-	    		{
-	        		var exMsg = ex.Message;
-				Console.WriteLine($"An error ocurred:\n{exMsg}");
-				songs.Clear();
-				_logger.Error(exMsg, "An error occurred");
-	    		}
-
-	    		return songs;
-		}
-
-		public Song GetSong(Song song)
-		{
-			try
-			{
-				_logger.Info("Retrieving song from database");
-
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT * FROM Song WHERE Id=@Id";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Id", song.Id);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							song = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return song;
-		}
-		public Song GetSong(int id)
-		{
-	    		Song song = new Song();
-
-	    		try
-	    		{
-				_logger.Info("Retrieving song from database");
-	        		using (MySqlConnection conn = GetConnection())
-				{
-		    			conn.Open();
-		    			var query = "SELECT * FROM Song WHERE Id=@Id";
-
-		    			MySqlCommand cmd = new MySqlCommand(query, conn);
-		    			cmd.Parameters.AddWithValue("@Id", id);
-
-		    			using (var reader = cmd.ExecuteReader())
-		    			{
-						song = ParseSingleData(reader);
-		    			}
-				}
-				_logger.Info("Song found");
-	    		}
-	    		catch(Exception ex)
-	    		{
-	        		var exMsg = ex.Message;
-				Console.WriteLine($"An error ocurred: {exMsg}");
-				_logger.Error(exMsg, "An error occurred");
-	    		}
-
-	    		return song;
-		}
-
-		public bool DoesSongExist(Song song)
-		{
-			_logger.Info("Checking to see if the song exists");
-			var songInDatabase = GetSong(song);
-			var title = songInDatabase.Title;
-
-			if (!string.IsNullOrEmpty(title))
-			{
-				_logger.Info("Song exists");
-				return true;
-			}
-
-			_logger.Info("Song does not exists");
-
-			return false;
-		}
-        
-		private List<Song> ParseData(MySqlDataReader reader)
-		{
-
-			List<Song> songs = new List<Song>();
-			while (reader.Read())
-			{
-		        	songs.Add(new Song
-			    	{
-			    		Id = Convert.ToInt32(reader["Id"]),
-			        	Title = reader["Title"].ToString(),
-			        	AlbumTitle = reader["AlbumTitle"].ToString(),
-			        	Artist = reader["Artist"].ToString(),
-			        	Year = Convert.ToInt32(reader["Year"]),
-			        	Genre = reader["Genre"].ToString(),
-			        	Duration = Convert.ToInt32(reader["Duration"]),
-			        	Filename = reader["Filename"].ToString(),
-			        	SongPath = reader["SongPath"].ToString(),
-					AlbumId = Convert.ToInt32(reader["AlbumId"].ToString()),
-					ArtistId = Convert.ToInt32(reader["ArtistId"].ToString()),
-					GenreId = Convert.ToInt32(reader["GenreId"].ToString()),
-					YearId = Convert.ToInt32(reader["YearId"].ToString())
-			    	});
-			}
-
-			return songs;
-		}
-
-		private Song ParseSingleData(MySqlDataReader reader)
-		{
-			Song song = new Song();
-
-			while (reader.Read())
-			{
-		        	song.Id = Convert.ToInt32(reader["Id"]);
-				song.Title = reader["Title"].ToString();
-				song.AlbumTitle = reader["AlbumTitle"].ToString();
-				song.Artist = reader["Artist"].ToString();
-				song.Year = Convert.ToInt32(reader["Year"].ToString());
-				song.Genre = reader["Genre"].ToString();
-				song.Duration = Convert.ToInt32(reader["Duration"]);
-				song.Filename = reader["Filename"].ToString();
-				song.SongPath = reader["SongPath"].ToString();
-				song.AlbumId = Convert.ToInt32(reader["AlbumId"].ToString());
-				song.ArtistId = Convert.ToInt32(reader["ArtistId"].ToString());
-				song.GenreId = Convert.ToInt32(reader["GenreId"].ToString());
-				song.YearId = Convert.ToInt32(reader["YearId"].ToString());
-			}
-
-			return song;
-		}
-
-		#endregion
-    	}    
-}  

Database/Repositories/UserRepository.cs

@@ -1,231 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-using MySql.Data.MySqlClient;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{
-	public class UserRepository: BaseRepository
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructor
-		public UserRepository(string connectionString)
-		{
-			_connectionString = connectionString;
-		}
-		#endregion
-
-
-		#region Methods
-		public void SaveUser(User user)
-		{
-			try
-			{
-				_logger.Info("Saving user");
-
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					string query = "INSERT INTO User(Username, Password, Nickname, Email" +
-						", PhoneNumber, Firstname, Lastname, EmailVerified) " +
-						"VALUES(@Username, @Password, @Nickname, @Email, @PhoneNumber," +
-						" @Firstname, @Lastname, @EmailVerified)";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Username", user.Username);
-						cmd.Parameters.AddWithValue("@Password", user.Password);
-						cmd.Parameters.AddWithValue("@Nickname", user.Nickname);
-						cmd.Parameters.AddWithValue("@Email", user.Email);
-						cmd.Parameters.AddWithValue("@PhoneNumber", user.PhoneNumber);
-						cmd.Parameters.AddWithValue("@Firstname", user.Firstname);
-						cmd.Parameters.AddWithValue("@Lastname", user.Lastname);
-						cmd.Parameters.AddWithValue("@EmailVerified", user.EmailVerified);
-
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-
-				_logger.Info("Successfully saved user");
-			}
-			catch (Exception ex)
-			{
-				var exMsg = ex.Message;
-				Console.WriteLine($"An error occurred:\n{exMsg}");
-				_logger.Error(exMsg, "An error occurred");
-			}
-		}
-
-		public User RetrieveUser(User user)
-		{
-			try
-			{
-				_logger.Info("Retrieving user");
-
-				using (MySqlConnection conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT * FROM User WHERE Username=@Username";
-
-					using (MySqlCommand cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Username", user.Username);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							user = ParseSingleData(reader);
-						}
-					}
-				}
-
-				_logger.Info("Successfully retrieved user");
-
-				return user;
-			}
-			catch (Exception ex)
-			{
-				var exMsg = ex.Message;
-				Console.WriteLine($"An error occurred:\n{exMsg}");
-				_logger.Error(exMsg, "An error occurred");
-			}
-
-			return null;
-		}
-
-		public bool DoesUserExist(User user)
-		{
-			var username = user.Username;
-			try
-			{
-				_logger.Info($"Checking to see if {user.Username} exists");
-
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-					var query = "SELECT * FROM User WHERE Username=@Username";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@Username", user.Username);
-						
-						using (var reader = cmd.ExecuteReader())
-						{
-							user = ParseSingleData(reader, true);
-							username = user.Username;
-
-							if (!string.IsNullOrEmpty(username))
-							{
-								_logger.Info($"The user {username} exists");
-
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info($"The user {username} does not exists");
-
-			return false;
-		}
-
-		private User ParseSingleData(MySqlDataReader reader)
-		{
-			var user = new User();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["Id"].ToString());
-				var username = reader["Username"].ToString();
-				var password = reader["Password"].ToString();
-				var nickname = reader["Nickname"].ToString();
-				var email = reader["Email"].ToString();
-				var phoneNumber = reader["PhoneNumber"].ToString();
-				var emailVerified = reader["EmailVerified"].ToString() == "1";
-				var firstname = reader["Firstname"].ToString();
-				var lastname = reader["Lastname"].ToString();
-				var rawLastLogin = reader["LastLogin"].ToString();
-
-				var parsedDateCreated = DateTime.Parse(reader["DateCreated"].ToString());
-
-				var dateCreated = DateTime.Parse(parsedDateCreated.ToString("yyyy-MM-dd HH:mm:ss"));
-
-				if (!string.IsNullOrEmpty(rawLastLogin))
-				{
-					var parsedLastLogin = DateTime.Parse(rawLastLogin);
-					var lastLogin = DateTime.Parse(parsedLastLogin.ToString("yyyy-MM-dd HH:mm:ss"));
-					user.LastLogin = lastLogin;
-				}
-
-				user.Id = id;
-				user.Username = username;
-				user.Password = password;
-				user.Nickname = nickname;
-				user.Email = email;
-				user.PhoneNumber = phoneNumber;
-				user.EmailVerified = emailVerified;
-				user.Firstname = firstname;
-				user.Lastname = lastname;
-				user.DateCreated = dateCreated;
-			}
-
-			return user;
-		}
-		private User ParseSingleData(MySqlDataReader reader, bool ignoreLastLogin)
-		{
-			var user = new User();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["Id"].ToString());
-				var username = reader["Username"].ToString();
-				var nickname = reader["Nickname"].ToString();
-				var email = reader["Email"].ToString();
-				var phoneNumber = reader["PhoneNumber"].ToString();
-				var emailVerified = reader["EmailVerified"].ToString() == "1";
-				var firstname = reader["Firstname"].ToString();
-				var lastname = reader["Lastname"].ToString();
-
-				var parsedDateCreated = DateTime.Parse(reader["DateCreated"].ToString());
-
-				var dateCreated = DateTime.Parse(parsedDateCreated.ToString("yyyy-MM-dd HH:mm:ss"));
-
-				if (!ignoreLastLogin)
-				{
-					var parsedLastLogin = DateTime.Parse(reader["LastLogin"].ToString());
-					var lastLogin = DateTime.Parse(parsedLastLogin.ToString("yyyy-MM-dd HH:mm:ss"));
-					user.LastLogin = lastLogin;
-				}
-
-				user.Id = id;
-				user.Username = username;
-				user.Nickname = nickname;
-				user.Email = email;
-				user.PhoneNumber = phoneNumber;
-				user.EmailVerified = emailVerified;
-				user.Firstname = firstname;
-				user.Lastname = lastname;
-				user.DateCreated = dateCreated;
-			}
-
-			return user;
-		}
-		#endregion
-	}
-}

Database/Repositories/YearRepository.cs

@@ -1,381 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-using MySql.Data.MySqlClient;
-
-using Icarus.Models;
-
-namespace Icarus.Database.Repositories
-{
-	public class YearRepository : BaseRepository
-	{
-		#region Fields
-		#endregion
-
-
-		#region Properties
-		#endregion
-
-
-		#region Constructors
-		public YearRepository(string connectionString)
-		{
-			_connectionString = connectionString;
-		}
-		#endregion
-
-
-		#region Methods
-		public List<Year> GetSongYears()
-		{
-			_logger.Info("Retrieving Year records");
-
-			var yearValues = new List<Year>();
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT yr.*, COUNT(*) AS SongCount FROM Year " +
-						"yr LEFT JOIN Song sng ON yr.YearId=sng.YearId " +
-						"GROUP BY yr.YearId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						using (var reader = cmd.ExecuteReader())
-						{
-							yearValues = ParseData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return yearValues;
-		}
-
-		public Year GetSongYear(Year year)
-		{
-			_logger.Info("Retrieving Year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT yr.*, COUNT(*) AS SongCount FROM Year " +
-						"yr LEFT JOIN Song sng ON yr.YearId=sng.YearId WHERE " +
-						"YearId=@YearId GROUP BY yr.YearId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearId", year.YearId);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							year = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return year;
-		}
-		public Year GetSongYear(Song song)
-		{
-			var year = new Year();
-
-			_logger.Info("Retrieving Year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT yr.*, 0 AS SongCount FROM Year " +
-						"yr WHERE yr.YearValue=@YearValue";
-
-					using(var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearValue", song.Year);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							year = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return year;
-		}
-		public Year GetSongYear(Song song, bool retrieveCount)
-		{
-			var year = new Year();
-
-			_logger.Info("Retrieving year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = string.Empty;
-
-					if (retrieveCount)
-					{
-						query = "SELECT yr.*, COUNT(*) AS SongCount FROM Year yr " +
-							"LEFT JOIN Song sng ON yr.YearValue=sng.Year WHERE " +
-							"yr.YearValue=@YearValue GROUP BY yr.YearId LIMIT 1";
-					}
-					else
-					{
-						query = "SELECT yr.*, 0 AS SongCount FROM Year yr " +
-							"WHERE yr.YearValue=@YearValue LIMIT 1";
-					}
-
-					using(var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearValue", song.Year);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							year = ParseSingleData(reader);
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			return year;
-		}
-
-		public bool DoesYearExist(Year year)
-		{
-			_logger.Info("Checking to see if Year record exists");
-			
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT yr.*, 0 AS SongCount FROM Year yr WHERE " +
-						"yr.YearId=@YearId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearId", year.YearId);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							year = ParseSingleData(reader);
-
-							if (year.YearValue > 0)
-							{
-								_logger.Info("Year record exists");
-
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("Year record does not exist");
-
-			return false;
-		}
-		public bool DoesYearExist(Song song)
-		{
-			_logger.Info("Checking to see if Year record exists");
-			
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "SELECT yr.*, 0 AS SongCount FROM Year yr WHERE " +
-						"yr.YearValue=@YearValue";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearValue", song.Year);
-
-						using (var reader = cmd.ExecuteReader())
-						{
-							var year = ParseSingleData(reader);
-
-							if (year.YearValue > 0)
-							{
-								_logger.Info("Year record exists");
-
-								return true;
-							}
-						}
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-
-			_logger.Info("Year record does not exist");
-
-			return false;
-		}
-
-		public void SaveYear(Year year)
-		{
-			_logger.Info("Saving Year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "INSERT INTO Year(YearValue) VALUES(@YearValue)";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearValue", year.YearValue);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void UpdateYear(Year year)
-		{
-			_logger.Info("Deleting Year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "UPDATE Year SET YearValue=@YearValue WHERE YearId=@YearId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearId", year.YearId);
-						cmd.Parameters.AddWithValue("@YearValue", year.YearValue);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-		public void DeleteYear(Year year)
-		{
-			_logger.Info("Deleting Year record");
-
-			try
-			{
-				using (var conn = GetConnection())
-				{
-					conn.Open();
-
-					var query = "DELETE FROM Year WHERE YearId=@YearId";
-
-					using (var cmd = new MySqlCommand(query, conn))
-					{
-						cmd.Parameters.AddWithValue("@YearId", year.YearId);
-
-						cmd.ExecuteNonQuery();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				var msg = ex.Message;
-				_logger.Error(msg, "An error occurred");
-			}
-		}
-
-		private List<Year> ParseData(MySqlDataReader reader)
-		{
-			var yearValues = new List<Year>();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["YearId"].ToString());
-				var year = Convert.ToInt32(reader["YearValue"].ToString());
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-
-				yearValues.Add(new Year
-				{
-					YearId = id,
-					YearValue = year,
-					SongCount = songCount
-				});
-			}
-
-
-			return yearValues;
-		}
-
-		private Year ParseSingleData(MySqlDataReader reader)
-		{
-			var yearValue = new Year();
-
-			while (reader.Read())
-			{
-				var id = Convert.ToInt32(reader["YearId"].ToString());
-				var year = Convert.ToInt32(reader["YearValue"].ToString());
-				var songCount = Convert.ToInt32(reader["SongCount"].ToString());
-
-				yearValue.YearId = id;
-				yearValue.YearValue = year;
-				yearValue.SongCount = songCount;
-			}
-
-			return yearValue;
-		}
-		#endregion
-	}
-}

Icarus.csproj

@@ -1,35 +1,34 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
     <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
+    <Version>0.1.9</Version>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BCrypt.Net-Next" Version="3.1.3" />
+    <PackageReference Include="BCrypt.Net-Next" Version="4.0.2" />
-    <PackageReference Include="DotNetZip" Version="1.13.3" />
+    <PackageReference Include="DotNetZip" Version="1.15.0" />
-    <PackageReference Include="EntityFramework" Version="6.2.0" />
+    <PackageReference Include="EntityFramework" Version="6.4.4" />
     <PackageReference Include="ID3" Version="0.6.0" />
-    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.1" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.1" />
-    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.2.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.8" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.2.3">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.8">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="mysql.data" Version="8.0.15" />
+    <PackageReference Include="MySql.EntityFrameworkCore" Version="5.0.8" />
-    <PackageReference Include="MySql.Data.Entity" Version="7.0.7-m61" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="MySql.Data.EntityFrameworkCore" Version="8.0.15" />
+    <PackageReference Include="NLog.Web.AspNetCore" Version="4.14.0" />
-    <PackageReference Include="MySql.Data.EntityFrameworkCore.Design" Version="8.0.15" />
+    <PackageReference Include="RestSharp" Version="106.15.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="NLog.Web.AspNetCore" Version="4.8.1" />
-    <PackageReference Include="RestSharp" Version="106.6.9" />
     <PackageReference Include="SevenZip" Version="19.0.0" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="5.4.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.15.0" />
     <PackageReference Include="taglib" Version="2.1.0" />
   </ItemGroup>
   <ItemGroup>
     <Content Update="nlog.config" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="Images/Stock/*.*" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
 </Project>

Icarus.csproj.user

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ActiveDebugProfile>Icarus</ActiveDebugProfile>
-  </PropertyGroup>
-</Project>

Icarus.sln

@@ -1,34 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.26124.0
-MinimumVisualStudioVersion = 15.0.26124.0
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Icarus", "Icarus.csproj", "{3BEBAB33-17BF-4183-9664-3D537A684138}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|Any CPU = Release|Any CPU
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|x64.Build.0 = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Debug|x86.Build.0 = Debug|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|x64.ActiveCfg = Release|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|x64.Build.0 = Release|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|x86.ActiveCfg = Release|Any CPU
-		{3BEBAB33-17BF-4183-9664-3D537A684138}.Release|x86.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal

Icarus.txt

@@ -1,313 +0,0 @@
-2019-05-23 20:25:46.2420 Info Message Template Auto Format enabled
-2019-05-23 20:25:46.2666 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:25:46.3926 Info Adding target File Target[allfile]
-2019-05-23 20:25:46.4144 Info Adding target File Target[ownFile-web]
-2019-05-23 20:25:46.4351 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:25:46.4703 Info Found 45 configuration items
-2019-05-23 20:26:13.6466 Info Message Template Auto Format enabled
-2019-05-23 20:26:13.6651 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:26:13.8165 Info Adding target File Target[allfile]
-2019-05-23 20:26:13.8351 Info Adding target File Target[ownFile-web]
-2019-05-23 20:26:13.8552 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:26:13.8939 Info Found 45 configuration items
-2019-05-23 20:33:39.8295 Info Message Template Auto Format enabled
-2019-05-23 20:33:39.8438 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:33:39.9198 Info Adding target File Target[allfile]
-2019-05-23 20:33:39.9238 Info Adding target File Target[ownFile-web]
-2019-05-23 20:33:39.9238 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:33:39.9871 Info Found 45 configuration items
-2019-05-23 20:33:40.2458 Info Configuration initialized.
-2019-05-23 20:33:40.2602 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:33:42.2086 Info Shutting down logging...
-2019-05-23 20:33:42.2458 Info Logger has been shut down.
-2019-05-23 20:34:06.6746 Info Message Template Auto Format enabled
-2019-05-23 20:34:06.6896 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:34:06.7827 Info Adding target File Target[allfile]
-2019-05-23 20:34:06.7827 Info Adding target File Target[ownFile-web]
-2019-05-23 20:34:06.8010 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:34:06.8321 Info Found 45 configuration items
-2019-05-23 20:34:06.8673 Info Configuration initialized.
-2019-05-23 20:34:06.8673 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:34:07.7083 Info Shutting down logging...
-2019-05-23 20:34:07.7346 Info Logger has been shut down.
-2019-05-23 20:35:03.8649 Info Message Template Auto Format enabled
-2019-05-23 20:35:03.8783 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:35:03.9596 Info Adding target File Target[allfile]
-2019-05-23 20:35:03.9596 Info Adding target File Target[ownFile-web]
-2019-05-23 20:35:03.9745 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:35:03.9958 Info Found 45 configuration items
-2019-05-23 20:35:04.0200 Info Configuration initialized.
-2019-05-23 20:35:04.0200 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:35:04.5747 Info Shutting down logging...
-2019-05-23 20:35:04.6042 Info Logger has been shut down.
-2019-05-23 20:35:41.2884 Info Message Template Auto Format enabled
-2019-05-23 20:35:41.3011 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:35:41.3629 Info Adding target File Target[allfile]
-2019-05-23 20:35:41.3629 Info Adding target File Target[ownFile-web]
-2019-05-23 20:35:41.3755 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:35:41.3973 Info Found 45 configuration items
-2019-05-23 20:35:41.4257 Info Configuration initialized.
-2019-05-23 20:35:41.4257 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:35:42.0181 Info Shutting down logging...
-2019-05-23 20:35:42.0437 Info Logger has been shut down.
-2019-05-23 20:36:03.3664 Info Message Template Auto Format enabled
-2019-05-23 20:36:03.3803 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:36:03.4469 Info Adding target File Target[allfile]
-2019-05-23 20:36:03.4469 Info Adding target File Target[ownFile-web]
-2019-05-23 20:36:03.4634 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:36:03.4897 Info Found 45 configuration items
-2019-05-23 20:36:03.5214 Info Configuration initialized.
-2019-05-23 20:36:03.5214 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:36:04.0862 Info Shutting down logging...
-2019-05-23 20:36:04.1162 Info Logger has been shut down.
-2019-05-23 20:37:13.4449 Info Message Template Auto Format enabled
-2019-05-23 20:37:13.4578 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:37:13.5222 Info Adding target File Target[allfile]
-2019-05-23 20:37:13.5222 Info Adding target File Target[ownFile-web]
-2019-05-23 20:37:13.5349 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:37:13.5575 Info Found 45 configuration items
-2019-05-23 20:37:13.5870 Info Configuration initialized.
-2019-05-23 20:37:13.5870 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:37:14.1141 Info Shutting down logging...
-2019-05-23 20:37:14.1395 Info Logger has been shut down.
-2019-05-23 20:37:38.9373 Info Message Template Auto Format enabled
-2019-05-23 20:37:38.9373 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:37:39.0239 Info Adding target File Target[allfile]
-2019-05-23 20:37:39.0239 Info Adding target File Target[ownFile-web]
-2019-05-23 20:37:39.0371 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:37:39.0624 Info Found 45 configuration items
-2019-05-23 20:37:39.0916 Info Configuration initialized.
-2019-05-23 20:37:39.0984 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:37:39.2254 Info Shutting down logging...
-2019-05-23 20:37:39.2461 Info Logger has been shut down.
-2019-05-23 20:38:15.2217 Info Message Template Auto Format enabled
-2019-05-23 20:38:15.2426 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:38:15.3307 Info Adding target File Target[allfile]
-2019-05-23 20:38:15.3307 Info Adding target File Target[ownFile-web]
-2019-05-23 20:38:15.3434 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:38:15.3733 Info Found 45 configuration items
-2019-05-23 20:38:15.4046 Info Configuration initialized.
-2019-05-23 20:38:15.4103 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:38:16.3887 Info Shutting down logging...
-2019-05-23 20:38:16.4170 Info Logger has been shut down.
-2019-05-23 20:38:56.3096 Info Message Template Auto Format enabled
-2019-05-23 20:38:56.3228 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:38:56.3991 Info Adding target File Target[allfile]
-2019-05-23 20:38:56.3991 Info Adding target File Target[ownFile-web]
-2019-05-23 20:38:56.4137 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:38:56.4412 Info Found 45 configuration items
-2019-05-23 20:38:56.4662 Info Configuration initialized.
-2019-05-23 20:38:56.4711 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:38:57.5659 Info Shutting down logging...
-2019-05-23 20:38:57.5921 Info Logger has been shut down.
-2019-05-23 20:39:33.6137 Info Message Template Auto Format enabled
-2019-05-23 20:39:33.6328 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:39:33.7158 Info Adding target File Target[allfile]
-2019-05-23 20:39:33.7209 Info Adding target File Target[ownFile-web]
-2019-05-23 20:39:33.7349 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\NLog.config...
-2019-05-23 20:39:33.7661 Info Found 45 configuration items
-2019-05-23 20:39:33.7984 Info Configuration initialized.
-2019-05-23 20:39:33.7984 Info NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c. File version: 4.5.11.8645. Product version: 4.5.11.
-2019-05-23 20:39:35.3535 Info Shutting down logging...
-2019-05-23 20:39:35.3853 Info Logger has been shut down.
-2019-05-23 20:41:03.9531 Info Message Template Auto Format enabled
-2019-05-23 20:41:04.0224 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:41:04.2489 Info Adding target File Target[allfile]
-2019-05-23 20:41:04.2638 Info Adding target File Target[ownFile-web]
-2019-05-23 20:41:04.2801 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:41:04.3178 Info Found 45 configuration items
-2019-05-23 20:42:20.8771 Info Message Template Auto Format enabled
-2019-05-23 20:42:20.8771 Info Found 45 configuration items
-2019-05-23 20:42:20.8771 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:42:20.8771 Info Adding target File Target[allfile]
-2019-05-23 20:42:20.8771 Info Adding target File Target[ownFile-web]
-2019-05-23 20:42:20.8771 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:42:20.8912 Info Closing old configuration.
-2019-05-23 20:42:20.9264 Info Found 45 configuration items
-2019-05-23 20:44:09.2436 Info Message Template Auto Format enabled
-2019-05-23 20:44:09.2625 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:44:09.5033 Info Adding target File Target[allfile]
-2019-05-23 20:44:09.5221 Info Adding target File Target[ownFile-web]
-2019-05-23 20:44:09.5436 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:44:09.5955 Info Found 45 configuration items
-2019-05-23 20:44:22.9386 Info Message Template Auto Format enabled
-2019-05-23 20:44:22.9386 Info Found 45 configuration items
-2019-05-23 20:44:22.9386 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:44:22.9525 Info Adding target File Target[allfile]
-2019-05-23 20:44:22.9525 Info Adding target File Target[ownFile-web]
-2019-05-23 20:44:22.9525 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:44:22.9525 Info Closing old configuration.
-2019-05-23 20:44:22.9920 Info Found 45 configuration items
-2019-05-23 20:45:56.3589 Info Message Template Auto Format enabled
-2019-05-23 20:45:56.3781 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:45:56.5714 Info Adding target File Target[allfile]
-2019-05-23 20:45:56.5830 Info Adding target File Target[ownFile-web]
-2019-05-23 20:45:56.5944 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:45:56.6232 Info Found 45 configuration items
-2019-05-23 20:46:59.8334 Info Message Template Auto Format enabled
-2019-05-23 20:46:59.8559 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:47:00.0588 Info Adding target File Target[allfile]
-2019-05-23 20:47:00.0756 Info Adding target File Target[ownFile-web]
-2019-05-23 20:47:00.1007 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:47:00.1455 Info Found 45 configuration items
-2019-05-23 20:48:14.1040 Info Message Template Auto Format enabled
-2019-05-23 20:48:14.1282 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:48:14.2899 Info Adding target File Target[allfile]
-2019-05-23 20:48:14.3059 Info Adding target File Target[ownFile-web]
-2019-05-23 20:48:14.3273 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:48:14.3764 Info Found 45 configuration items
-2019-05-23 20:49:07.1970 Info Message Template Auto Format enabled
-2019-05-23 20:49:07.2494 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:49:07.4433 Info Adding target File Target[allfile]
-2019-05-23 20:49:07.4565 Info Adding target File Target[ownFile-web]
-2019-05-23 20:49:07.4760 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:49:07.5338 Info Found 45 configuration items
-2019-05-23 20:49:20.7109 Info Message Template Auto Format enabled
-2019-05-23 20:49:20.7109 Info Found 45 configuration items
-2019-05-23 20:49:20.7109 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 20:49:20.7184 Info Adding target File Target[allfile]
-2019-05-23 20:49:20.7184 Info Adding target File Target[ownFile-web]
-2019-05-23 20:49:20.7184 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 20:49:20.7184 Info Closing old configuration.
-2019-05-23 20:49:20.7514 Info Found 45 configuration items
-2019-05-23 21:24:18.4464 Info Message Template Auto Format enabled
-2019-05-23 21:24:18.4889 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:24:18.7399 Info Adding target File Target[allfile]
-2019-05-23 21:24:18.7604 Info Adding target File Target[ownFile-web]
-2019-05-23 21:24:18.7838 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:24:18.8238 Info Found 45 configuration items
-2019-05-23 21:25:06.3861 Info Message Template Auto Format enabled
-2019-05-23 21:25:06.3904 Info Found 45 configuration items
-2019-05-23 21:25:06.3904 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:25:06.4052 Info Adding target File Target[allfile]
-2019-05-23 21:25:06.4052 Info Adding target File Target[ownFile-web]
-2019-05-23 21:25:06.4052 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:25:06.4243 Info Closing old configuration.
-2019-05-23 21:25:06.4727 Info Found 45 configuration items
-2019-05-23 21:26:26.1707 Info Message Template Auto Format enabled
-2019-05-23 21:26:26.1964 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:26:26.3688 Info Adding target File Target[allfile]
-2019-05-23 21:26:26.3866 Info Adding target File Target[ownFile-web]
-2019-05-23 21:26:26.4195 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:26:26.4805 Info Found 45 configuration items
-2019-05-23 21:27:58.0534 Info Message Template Auto Format enabled
-2019-05-23 21:27:58.0751 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:27:58.2630 Info Adding target File Target[allfile]
-2019-05-23 21:27:58.2786 Info Adding target File Target[ownFile-web]
-2019-05-23 21:27:58.2977 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:27:58.3440 Info Found 45 configuration items
-2019-05-23 21:28:30.3852 Info Message Template Auto Format enabled
-2019-05-23 21:28:30.3901 Info Found 45 configuration items
-2019-05-23 21:28:30.3901 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:28:30.4094 Info Adding target File Target[allfile]
-2019-05-23 21:28:30.4094 Info Adding target File Target[ownFile-web]
-2019-05-23 21:28:30.4094 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:28:30.4256 Info Closing old configuration.
-2019-05-23 21:28:30.4744 Info Found 45 configuration items
-2019-05-23 21:28:35.1110 Info Message Template Auto Format enabled
-2019-05-23 21:28:35.1110 Info Found 45 configuration items
-2019-05-23 21:28:35.1110 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:28:35.1110 Info Adding target File Target[allfile]
-2019-05-23 21:28:35.1110 Info Adding target File Target[ownFile-web]
-2019-05-23 21:28:35.1110 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:28:35.1110 Info Closing old configuration.
-2019-05-23 21:28:35.1110 Info Found 45 configuration items
-2019-05-23 21:33:27.3097 Info Message Template Auto Format enabled
-2019-05-23 21:33:27.3317 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:33:27.6071 Info Adding target File Target[allfile]
-2019-05-23 21:33:27.6230 Info Adding target File Target[ownFile-web]
-2019-05-23 21:33:27.6409 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:33:27.6860 Info Found 45 configuration items
-2019-05-23 21:34:21.2749 Info Message Template Auto Format enabled
-2019-05-23 21:34:21.2749 Info Found 45 configuration items
-2019-05-23 21:34:21.2822 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:34:21.2822 Info Adding target File Target[allfile]
-2019-05-23 21:34:21.2977 Info Adding target File Target[ownFile-web]
-2019-05-23 21:34:21.2977 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:34:21.2977 Info Closing old configuration.
-2019-05-23 21:34:21.3496 Info Found 45 configuration items
-2019-05-23 21:34:44.8361 Info Message Template Auto Format enabled
-2019-05-23 21:34:44.8361 Info Found 45 configuration items
-2019-05-23 21:34:44.8361 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:34:44.8475 Info Adding target File Target[allfile]
-2019-05-23 21:34:44.8475 Info Adding target File Target[ownFile-web]
-2019-05-23 21:34:44.8475 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:34:44.8475 Info Closing old configuration.
-2019-05-23 21:34:49.8402 Info Found 45 configuration items
-2019-05-23 21:36:39.6643 Info Message Template Auto Format enabled
-2019-05-23 21:36:39.6956 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:36:39.9527 Info Adding target File Target[allfile]
-2019-05-23 21:36:39.9527 Info Adding target File Target[ownFile-web]
-2019-05-23 21:36:39.9854 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:36:40.0214 Info Found 45 configuration items
-2019-05-23 21:37:11.5126 Info Message Template Auto Format enabled
-2019-05-23 21:37:11.5149 Info Found 45 configuration items
-2019-05-23 21:37:11.5149 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:37:11.5149 Info Adding target File Target[allfile]
-2019-05-23 21:37:11.5149 Info Adding target File Target[ownFile-web]
-2019-05-23 21:37:11.5149 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:37:11.5149 Info Closing old configuration.
-2019-05-23 21:37:11.5688 Info Found 45 configuration items
-2019-05-23 21:37:55.3893 Info Message Template Auto Format enabled
-2019-05-23 21:37:55.3912 Info Found 45 configuration items
-2019-05-23 21:37:55.3912 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:37:55.3912 Info Adding target File Target[allfile]
-2019-05-23 21:37:55.4088 Info Adding target File Target[ownFile-web]
-2019-05-23 21:37:55.4088 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:37:55.4088 Info Closing old configuration.
-2019-05-23 21:37:55.4088 Info Found 45 configuration items
-2019-05-23 21:44:40.0208 Info Message Template Auto Format enabled
-2019-05-23 21:44:40.0474 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:44:40.2073 Info Adding target File Target[allfile]
-2019-05-23 21:44:40.2186 Info Adding target File Target[ownFile-web]
-2019-05-23 21:44:40.2186 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:44:40.2868 Info Found 45 configuration items
-2019-05-23 21:45:19.6595 Info Message Template Auto Format enabled
-2019-05-23 21:45:19.6595 Info Found 45 configuration items
-2019-05-23 21:45:19.6595 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:45:19.6595 Info Adding target File Target[allfile]
-2019-05-23 21:45:19.6595 Info Adding target File Target[ownFile-web]
-2019-05-23 21:45:19.6595 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:45:19.6740 Info Closing old configuration.
-2019-05-23 21:45:19.7116 Info Found 45 configuration items
-2019-05-23 21:51:00.1698 Info Message Template Auto Format enabled
-2019-05-23 21:51:00.1840 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:51:00.2721 Info Adding target File Target[allfile]
-2019-05-23 21:51:00.2721 Info Adding target File Target[ownFile-web]
-2019-05-23 21:51:00.2920 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:51:00.3152 Info Found 45 configuration items
-2019-05-23 21:51:25.1256 Info Message Template Auto Format enabled
-2019-05-23 21:51:25.1256 Info Found 45 configuration items
-2019-05-23 21:51:25.1256 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:51:25.1256 Info Adding target File Target[allfile]
-2019-05-23 21:51:25.1256 Info Adding target File Target[ownFile-web]
-2019-05-23 21:51:25.1256 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:51:25.1412 Info Closing old configuration.
-2019-05-23 21:51:25.1648 Info Found 45 configuration items
-2019-05-23 21:51:25.2103 Info Message Template Auto Format enabled
-2019-05-23 21:51:25.2103 Info Found 45 configuration items
-2019-05-23 21:51:25.2103 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:51:25.2103 Info Adding target File Target[allfile]
-2019-05-23 21:51:25.2103 Info Adding target File Target[ownFile-web]
-2019-05-23 21:51:25.2103 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:51:25.2103 Info Closing old configuration.
-2019-05-23 21:51:25.2182 Info Found 45 configuration items
-2019-05-23 21:53:11.2368 Info Logger closing down...
-2019-05-23 21:53:11.2368 Info Closing old configuration.
-2019-05-23 21:53:11.2368 Info Logger has been closed down.
-2019-05-23 21:53:11.2368 Info Shutting down logging...
-2019-05-23 21:53:11.2555 Info Logger has been shut down.
-2019-05-23 21:54:25.6441 Info Message Template Auto Format enabled
-2019-05-23 21:54:25.6761 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:54:25.9546 Info Adding target File Target[allfile]
-2019-05-23 21:54:25.9757 Info Adding target File Target[ownFile-web]
-2019-05-23 21:54:25.9951 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:54:26.0361 Info Found 45 configuration items
-2019-05-23 21:54:55.6086 Info Message Template Auto Format enabled
-2019-05-23 21:54:55.6086 Info Found 45 configuration items
-2019-05-23 21:54:55.6086 Info Loading assembly: NLog.Web.AspNetCore
-2019-05-23 21:54:55.6086 Info Adding target File Target[allfile]
-2019-05-23 21:54:55.6086 Info Adding target File Target[ownFile-web]
-2019-05-23 21:54:55.6086 Info Configured from an XML element in C:\Users\user0\Programming\C#\Icarus\bin\Debug\netcoreapp2.2\nlog.config...
-2019-05-23 21:54:55.6280 Info Closing old configuration.
-2019-05-23 21:54:55.6926 Info Found 45 configuration items

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Kun Deng
+Copyright (c) 2021 Kun Deng
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Models/Album.cs

@@ -6,19 +6,23 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class Album
+    public class Album
-	{
+    {
-		[JsonProperty("id")]
+        [JsonProperty("album_id")]
-		public int AlbumId { get; set; }
+        public int AlbumID { get; set; }
-		[JsonProperty("title")]
+        [JsonProperty("title")]
-		public string Title { get; set; }
+        public string Title { get; set; }
-		[JsonProperty("album_artist")]
+        [JsonProperty("album_artist")]
-		public string AlbumArtist { get; set; }
+        [Column("Artist")]
-		[JsonProperty("song_count")]
+        public string AlbumArtist { get; set; }
-		[NotMapped]
+        [JsonProperty("song_count")]
-		public int SongCount { get; set; }
+        [NotMapped]
+        public int SongCount { get; set; }
+        [JsonProperty("year")]
+        public int Year { get; set; }
 
-		[JsonIgnore]
+        [JsonIgnore]
-		public List<Song> Songs { get; set; }
+        [NotMapped]
-	}
+        public List<Song> Songs { get; set; }
+    }
 }

Models/Artist.cs

@@ -6,17 +6,19 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class Artist
+    public class Artist
-	{
+    {
-		[JsonProperty("id")]
+        [JsonProperty("artist_id")]
-		public int ArtistId { get; set; }
+        public int ArtistID { get; set; }
-		[JsonProperty("name")]
+        [JsonProperty("name")]
-		public string Name { get; set; }
+        [Column("Artist")]
-		[JsonProperty("song_count")]
+        public string Name { get; set; }
-		[NotMapped]
+        [JsonProperty("song_count")]
-		public int SongCount { get; set; }
+        [NotMapped]
+        public int SongCount { get; set; }
 
-		[JsonIgnore]
+        [JsonIgnore]
-		public List<Song> Songs { get; set; }
+        [NotMapped]
-	}
+        public List<Song> Songs { get; set; }
+    }
 }

Models/BaseResult.cs

@@ -4,9 +4,9 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class BaseResult
+    public class BaseResult
-	{
+    {
-		[JsonProperty("message")]
+        [JsonProperty("message")]
-		public string Message { get; set; }
+        public string Message { get; set; }
-	}
+    }
 }

Models/CoverArt.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Text;
+
+using Newtonsoft.Json;
+
+namespace Icarus.Models
+{
+    public class CoverArt
+    {
+        #region Properties
+        [JsonProperty("cover_art_id")]
+        public int CoverArtID { get; set; }
+        [JsonProperty("title")]
+        public string SongTitle { get; set; }
+        [JsonIgnore]
+        public string ImagePath { get; set; }
+        [JsonIgnore]
+        [NotMapped]
+        public int SongID { get; set; }
+        [JsonIgnore]
+        [NotMapped]
+        public List<Song> Songs { get; set; }
+        #endregion
+
+
+        #region Methods
+        public string GenerateFilename(int flag)
+        {
+            const int length = 25;
+            const string chars = "ABCDEF0123456789";
+            var random = new Random();
+            var filename = new string(Enumerable.Repeat(chars, length).Select(s =>
+                s[random.Next(s.Length)]).ToArray());
+            var extension = ".mp3";
+
+            return (flag == 0) ? filename : $"{filename}{extension}";
+        }
+        #endregion
+    }
+}

Models/Genre.cs

@@ -6,17 +6,18 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class Genre
+    public class Genre
-	{
+    {
-		[JsonProperty("id")]
+        [JsonProperty("genre_id")]
-		public int GenreId { get; set; }
+        public int GenreID { get; set; }
-		[JsonProperty("genre")]
+        [JsonProperty("genre")]
-		public string GenreName { get; set; }
+        [Column("Category")]
-		[JsonProperty("song_count")]
+        public string GenreName { get; set; }
-		[NotMapped]
+        [JsonProperty("song_count")]
-		public int SongCount { get; set; }
+        [NotMapped]
-
+        public int SongCount { get; set; }
-		[JsonIgnore]
+        [JsonIgnore]
-		public List<Song> Songs { get; set; }
+        [NotMapped]
-	}
+        public List<Song> Songs { get; set; }
+    }
 }

Models/LoginResult.cs

@@ -4,17 +4,17 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class LoginResult : BaseResult
+    public class LoginResult : BaseResult
-	{
+    {
-		[JsonProperty("id")]
+        [JsonProperty("user_id")]
-		public int UserId { get; set; }
+        public int UserID { get; set; }
-		[JsonProperty("username")]
+        [JsonProperty("username")]
-		public string Username { get; set; }
+        public string Username { get; set; }
-		[JsonProperty("token")]
+        [JsonProperty("token")]
-		public string Token { get; set; }
+        public string Token { get; set; }
-		[JsonProperty("token_type")]
+        [JsonProperty("token_type")]
-		public string TokenType { get; set; }
+        public string TokenType { get; set; }
-		[JsonProperty("expiration")]
+        [JsonProperty("expiration")]
-		public int Expiration { get; set; }
+        public int Expiration { get; set; }
-	}
+    }
 }

Models/RegisterResult.cs

@@ -4,11 +4,11 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class RegisterResult : BaseResult
+    public class RegisterResult : BaseResult
-	{
+    {
-		[JsonProperty("username")]
+        [JsonProperty("username")]
-		public string Username { get; set; }
+        public string Username { get; set; }
-		[JsonProperty("successfully_registered")]
+        [JsonProperty("successfully_registered")]
-		public bool SuccessfullyRegistered { get; set; }
+        public bool SuccessfullyRegistered { get; set; }
-	}
+    }
 }

Models/Song.cs

@@ -1,49 +1,86 @@
 using System;
 using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
 
 using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class Song
+    public class Song
-	{
+    {
-		[JsonProperty("id")]
+        #region Properties
-		public int Id { get; set; }
+        [JsonProperty("song_id")]
-		[JsonProperty("title")]
+        public int SongID { get; set; }
-		public string Title { get; set; }
+        [JsonProperty("title")]
-		[JsonProperty("album")]
+        public string Title { get; set; }
-		public string AlbumTitle { get; set; }
+        [JsonProperty("album")]
-		[JsonProperty("artist")]
+        [Column("Album")]
-		public string Artist { get; set; }
+        public string AlbumTitle { get; set; }
-		[JsonProperty("year")]
+        [JsonProperty("artist")]
-		public int? Year { get; set; }
+        public string Artist { get; set; }
-		[JsonProperty("genre")]
+        [JsonProperty("album_artist")]
-		public string Genre { get; set; }
+        public string AlbumArtist { get; set; }
-		[JsonProperty("duration")]
+        [JsonProperty("year")]
-		public int Duration { get; set; }
+        public int? Year { get; set; }
-		[JsonProperty("filename")]
+        [JsonProperty("genre")]
-		public string Filename { get; set; }
+        public string Genre { get; set; }
-		[JsonProperty("song_path")]
+        [JsonProperty("duration")]
-		public string SongPath { get; set; }
+        public int Duration { get; set; }
+        [JsonProperty("filename")]
+        public string Filename { get; set; }
+        [JsonIgnore]
+        public string SongDirectory { get; set; }
+        [JsonProperty("track")]
+        public int Track { get; set; } = 0;
+        [JsonProperty("track_count")]
+        public int TrackCount { get; set; } = 0;
+        [JsonProperty("disc")]
+        public int Disc { get; set; } = 0;
+        [JsonProperty("disc_count")]
+        public int DiscCount { get; set; } = 0;
+        [JsonIgnore]
+        public int? AlbumID { get; set; }
+        [JsonIgnore]
+        public int? ArtistID { get; set; }
+        [JsonIgnore]
+        public int? GenreID { get; set; }
+        [JsonIgnore]
+        public int? CoverArtID { get; set; }
+        [JsonProperty("date_created")]
+        public DateTime DateCreated { get; set; }
+        #endregion
 
-		[JsonIgnore]
-		public Album Album { get; set; }
-		[JsonIgnore]
-		public int? AlbumId { get; set; }
 
-		[JsonIgnore]
+        #region Constructors
-		public Artist SongArtist { get; set; }
+        #endregion
-		[JsonIgnore]
-		public int? ArtistId { get; set; }
 
-		[JsonIgnore]
-		public Genre SongGenre { get; set; }
-		[JsonIgnore]
-		public int? GenreId { get; set; }
 
-		[JsonIgnore]
+        #region Methods
-		public Year SongYear { get; set; }
+        public string SongPath()
-		[JsonIgnore]
+        {
-		public int? YearId { get; set; }
+            var fullPath = SongDirectory;
-	}
+
+            if (fullPath[fullPath.Length -1] != '/')
+            {
+                fullPath += "/";
+            }
+
+            fullPath += Filename;
+
+            return fullPath;
+        }
+
+        public string GenerateFilename(int flag = 0)
+        {
+            const int length = 25;
+            const string chars = "ABCDEF0123456789";
+            var random = new Random();
+            var filename = new string(Enumerable.Repeat(chars, length).Select(s =>
+                s[random.Next(s.Length)]).ToArray());
+            var extension = ".mp3";
+
+            return flag == 0 ? filename : $"{filename}{extension}";
+        }
+        #endregion
+    }
 }

Models/SongData.cs

@@ -3,10 +3,10 @@ using System.Text;
 
 namespace Icarus.Models
 {
-	public class SongData
+    public class SongData
-	{
+    {
-		public int Id { get; set; }
+        public int ID { get; set; }
-		public byte[] Data { get; set; }
+        public byte[] Data { get; set; }
-		public int SongId { get; set; }
+        public int SongID { get; set; }
-	}
+    }
 }

Models/SongResult.cs

@@ -4,11 +4,11 @@ using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class SongResult
+    public class SongResult
-	{
+    {
-		[JsonProperty("message")]
+        [JsonProperty("message")]
-		public string Message { get; set; }
+        public string Message { get; set; }
-		[JsonProperty("song_title")]
+        [JsonProperty("song_title")]
-		public string SongTitle { get; set; }
+        public string SongTitle { get; set; }
-	}
+    }
 }

Models/User.cs

@@ -1,32 +1,39 @@
 using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 
 using Newtonsoft.Json;
 
 namespace Icarus.Models
 {
-	public class User
+    [Table("User")]
-	{
+    public class User
-		[JsonProperty("id")]
+    {
-		public int Id { get; set; }
+        [JsonProperty("user_id")]
-		[JsonProperty("username")]
+        [Column("UserID")]
-		public string Username { get; set; }
+        [Key]
-		[JsonProperty("nickname")]
+        public int UserID { get; set; }
-		public string Nickname { get; set; }
+        [JsonProperty("username")]
-		[JsonProperty("password")]
+        public string Username { get; set; }
-		public string Password { get; set; }
+        [JsonProperty("password")]
-		[JsonProperty("email")]
+        public string Password { get; set; }
-		public string Email { get; set; }
+        [JsonProperty("email")]
-		[JsonProperty("phone_number")]
+        public string Email { get; set; }
-		public string PhoneNumber { get; set; }
+        [JsonProperty("phone")]
-		[JsonProperty("first_name")]
+        [Column("Phone")]
-		public string Firstname { get; set; }
+        public string Phone { get; set; }
-		[JsonProperty("last_name")]
+        [JsonProperty("firstname")]
-		public string Lastname { get; set; }
+        public string Firstname { get; set; }
-		[JsonProperty("email_verified")]
+        [JsonProperty("lastname")]
-		public bool EmailVerified { get; set; }
+        public string Lastname { get; set; }
-		[JsonProperty("date_created")]
+        [JsonProperty("email_verified")]
-		public DateTime DateCreated { get; set; }
+        [NotMapped]
-		[JsonProperty("last_login")]
+        public bool EmailVerified { get; set; }
-		public DateTime? LastLogin { get; set; }
+        [JsonProperty("date_created")]
-	}
+        public DateTime DateCreated { get; set; }
+        [JsonProperty("status")]
+        public string Status { get; set; }
+        [JsonProperty("last_login")]
+        public DateTime? LastLogin { get; set; }
+    }
 }

Models/Year.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations.Schema;
-
-using Newtonsoft.Json;
-
-namespace Icarus.Models
-{
-	public class Year
-	{
-		[JsonProperty("id")]
-		public int YearId { get; set; }
-		[JsonProperty("year")]
-		public int YearValue { get; set; }
-		[JsonProperty("song_count")]
-		[NotMapped]
-		public int SongCount { get; set; }
-
-		[JsonIgnore]
-		public List<Song> Songs { get; set; }
-	}
-}

Program.cs

@@ -7,42 +7,40 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using NLog.Web;
 
 namespace Icarus
 {
-	public class Program
+    public class Program
-    	{
+    {
-        	public static void Main(string[] args)
+        public static void Main(string[] args)
-        	{
+        {
-			var logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
+            var logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
 
-			try
+            try
-			{
+            {
-				logger.Debug("init main");
+                logger.Debug("init main");
-            			CreateWebHostBuilder(args).Build().Run();
-			}
-			catch (Exception ex)
-			{
-				logger.Error(ex, "An error occurred");
-				throw;
-			}
-			finally
-			{
-				NLog.LogManager.Shutdown();
-			}
-        	}
 
-        	public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+                CreateHostBuilder(args).Build().Run();
-            		WebHost.CreateDefaultBuilder(args)
+            }
-                	.UseStartup<Startup>()
+            catch (Exception ex)
-			.UseUrls("http://localhost:5002")
+            {
-			.ConfigureLogging(logging =>
+                logger.Error(ex, "An error occurred");
-			{
+                throw;
-				logging.ClearProviders();
+            }
-				logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
+            finally
-			})
+            {
-			.UseNLog() ;
+                NLog.LogManager.Shutdown();
+            }
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
     }
 }

README.md

@@ -14,9 +14,7 @@ One can interface with Icarus the music server either by:
 ## Built With
 
 
-* C#
+* C# [.NET](https://dotnet.microsoft.com/) 6
-* [.NET Core](https://dotnet.microsoft.com/) 2.2
-* .NET Web RESTful API
 * [MySql](https://www.nuget.org/packages/MySql.Data/)
 * [Newtonsoft.Json](https://www.newtonsoft.com/json)
 * [TagLib#](https://github.com/mono/taglib-sharp)
@@ -150,7 +148,7 @@ Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the code of conduc
 
 ## Versioning
 
-Currently under development. No version has been released
+* [v0.1](https://github.com/amazing-username/Icarus/releases/tag/v0.1)
 
 ## Authors
 

Scripts/Migrations/Linux/AddUpdate.sh

@@ -11,6 +11,8 @@ echo "Adding Genre migration"
 dotnet ef migrations add Genre --context GenreContext
 echo "Adding Year migration"
 dotnet ef migrations add Year --context YearContext
+echo "Adding Cover art migration"
+dotnet ef migrations add CoverArt --context CoverArtContext
 
 echo "Updating migrations.."
 echo "Updating User migration"
@@ -20,4 +22,5 @@ echo "Updating Album migration"
 echo "Updating Artist migration"
 echo "Updating Genre migration"
 echo "Updating Year migration"
+echo "Updating Cover art migration"
 dotnet ef database update --context SongContext

Scripts/MySQL/create_database.sql

@@ -0,0 +1,99 @@
+CREATE DATABASE Icarus;
+
+USE Icarus;
+
+CREATE TABLE CoverArt (
+    CoverArtID INT NOT NULL AUTO_INCREMENT,
+    SongTitle TEXT NOT NULL,
+    ImagePath TEXT NOT NULL,
+
+    PRIMARY KEY (CoverArtID)
+);
+
+CREATE TABLE Album (
+    AlbumID INT NOT NULL AUTO_INCREMENT,
+    Title TEXT NOT NULL,
+    Artist TEXT NOT NULL,
+    Year INT NOT NULL,
+
+    PRIMARY KEY (AlbumID)
+);
+
+CREATE TABLE Artist (
+    ArtistID INT NOT NULL AUTO_INCREMENT,
+    Artist TEXT NOT NULL,
+
+    PRIMARY KEY (ArtistID)
+);
+
+CREATE TABLE Genre (
+    GenreID INT NOT NULL AUTO_INCREMENT,
+    Category TEXT NOT NULL,
+
+    PRIMARY KEY (GenreID)
+);
+
+
+CREATE TABLE Song (
+    SongID INT NOT NULL AUTO_INCREMENT,
+    Title TEXT NOT NULL,
+    Artist TEXT NOT NULL,
+    Album TEXT NOT NULL,
+    AlbumArtist TEXT NOT NULL,
+    Genre TEXT NOT NULL,
+    Year INT NOT NULL,
+    Duration INT NOT NULL,
+    Track INT NOT NULL,
+    TrackCount INT NOT NULL,
+    Disc INT NOT NULL,
+    DiscCount INT NOT NULL,
+    SongDirectory TEXT NOT NULL,
+    Filename TEXT NOT NULL,
+    CoverArtID INT NOT NULL,
+    ArtistID INT NOT NULL,
+    AlbumID INT NOT NULL,
+    GenreID INT NOT NULL,
+    DateCreated DATETIME DEFAULT CURRENT_TIMESTAMP,
+
+    PRIMARY KEY (SongID),
+    CONSTRAINT FK_Song_CoverArtID FOREIGN KEY (CoverArtID) REFERENCES CoverArt (CoverArtID),
+    CONSTRAINT FK_Song_ArtistID FOREIGN KEY (ArtistID) REFERENCES Artist (ArtistID),
+    CONSTRAINT FK_Song_AlbumID FOREIGN KEY (AlbumID) REFERENCES Album (AlbumID),
+    CONSTRAINT FK_Song_GenreID FOREIGN KEY (GenreID) REFERENCES Genre (GenreID)
+);
+
+CREATE TABLE User (
+    UserID INT NOT NULL AUTO_INCREMENT,
+    Firstname TEXT NOT NULL,
+    Lastname TEXT NOT NULL,
+    Email TEXT NOT NULL,
+    Phone TEXT NOT NULL,
+    Username TEXT NOT NULL,
+    Password TEXT NOT NULL,
+    DateCreated DATETIME DEFAULT CURRENT_TIMESTAMP,
+    Status TEXT DEFAULT 'Active',
+    LastLogin DATETIME NULL,
+
+    PRIMARY KEY (UserID)
+);
+
+CREATE TABLE Salt (
+    SaltID INT NOT NULL AUTO_INCREMENT,
+    Salt TEXT NOT NULL,
+    UserID INT NOT NULL,
+
+    PRIMARY KEY (SaltID),
+    CONSTRAINT FK_Salt_UserID FOREIGN KEY (UserID) REFERENCES User (UserID)
+);
+
+CREATE TABLE Token (
+    TokenID INT NOT NULL AUTO_INCREMENT,
+    AccessToken TEXT NOT NULL,
+    TokenType TEXT NOT NULL,
+    Expires DATETIME DEFAULT CURRENT_TIMESTAMP,
+    Issued DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UserID INT NOT NULL,
+
+    PRIMARY KEY (TokenID),
+    CONSTRAINT FK_Token_UserID FOREIGN KEY (UserID) REFERENCES User (UserID)
+);

Scripts/MySQL/delete_all.sql

@@ -1,3 +1,5 @@
-delete from Song where Id>0;
+delete from Song;
-delete from Album where AlbumId>0;
+delete from Album;
-delete from Artist where ArtistId>0;
+delete from Artist;
+delete from Genre;
+delete from CoverArt;

Scripts/MySQL/drop_database.sql

@@ -0,0 +1 @@
+drop database Icarus;

Startup.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
 
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Authorization;
@@ -15,9 +16,8 @@ using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Microsoft.EntityFrameworkCore;
-using MySql.Data;
+using Microsoft.IdentityModel.Tokens;
-using MySql.Data.EntityFrameworkCore.Extensions;
+using Newtonsoft.Json;
-using MySql.Data.MySqlClient;    
 using NLog;
 using NLog.Web;
 using NLog.Web.AspNetCore;
@@ -25,144 +25,111 @@ using NLog.Web.AspNetCore;
 using Icarus.Authorization;
 using Icarus.Authorization.Handlers;
 using Icarus.Database.Contexts;
-using Icarus.Database.Repositories;
 
 namespace Icarus
 {
-	public class Startup
+    public class Startup
-    	{
+    {
-        	public Startup(IConfiguration configuration)
+        public Startup(IConfiguration configuration)
-        	{
+        {
-            		Configuration = configuration;
+            Configuration = configuration;
-        	}
+        }
 
-        	public IConfiguration Configuration { get; }
+        public IConfiguration Configuration { get; }
 
-        	// This method gets called by the runtime. Use this method to add services to the container.
+        // This method gets called by the runtime. Use this method to add services to the container.
-        	public void ConfigureServices(IServiceCollection services)
+        public void ConfigureServices(IServiceCollection services)
-        	{
+        {
-			services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
+            services.AddControllers();
-			services.AddSingleton<IConfiguration>(Configuration);
 
-			string domain = $"https://{Configuration["Auth0:Domain"]}/";
+            var auth_id = Configuration["Auth0:Domain"];
+            var domain = $"https://{auth_id}/";
+            var audience = Configuration["Auth0:ApiIdentifier"];
 
-			services.AddAuthentication(options =>
+            services
-			{
+                .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
-				options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                .AddJwtBearer(options => 
-				options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+                {
-			}).AddJwtBearer(options =>
+                    options.Authority = domain;
-			{
+                    options.Audience = audience;
-				options.Authority = domain;
+                });
-				options.Audience = Configuration["Auth0:ApiIdentifier"];
-			});
 
-			services.AddAuthorization(options =>
+            services.AddAuthorization(options =>
-			{
+            {
-				options.AddPolicy("download:songs", policy => 
+                options.AddPolicy("download:songs", policy => 
-						policy
+                policy.Requirements
-						.Requirements
+                .Add(new HasScopeRequirement("download:songs", domain)));
-						.Add(new HasScopeRequirement("download:songs", domain)));
 
-				options.AddPolicy("upload:songs", policy => 
+                options.AddPolicy("download:cover_art", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("download:cover_art", domain)));
-						.Add(new HasScopeRequirement("upload:songs", domain)));
 
-				options.AddPolicy("delete:songs", policy =>
+                options.AddPolicy("upload:songs", policy => 
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("upload:songs", domain)));
-						.Add(new HasScopeRequirement("delete:songs", domain)));
 
-				options.AddPolicy("read:song_details", policy => 
+                options.AddPolicy("delete:songs", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("delete:songs", domain)));
-						.Add(new HasScopeRequirement("read:song_details", domain)));
 
-				options.AddPolicy("update:songs", policy =>
+                options.AddPolicy("read:song_details", policy => 
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("read:song_details", domain)));
-						.Add(new HasScopeRequirement("update:songs", domain)));
 
-				options.AddPolicy("read:artists", policy =>
+                options.AddPolicy("update:songs", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("update:songs", domain)));
-						.Add(new HasScopeRequirement("read:artists", domain)));
 
-				options.AddPolicy("read:albums", policy =>
+                options.AddPolicy("read:artists", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("read:artists", domain)));
-						.Add(new HasScopeRequirement("read:albums", domain)));
 
-				options.AddPolicy("read:genre", policy =>
+                options.AddPolicy("read:albums", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("read:albums", domain)));
-						.Add(new HasScopeRequirement("read:genre", domain)));
 
-				options.AddPolicy("read:year", policy =>
+                options.AddPolicy("read:genre", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("read:genre", domain)));
-						.Add(new HasScopeRequirement("read:year", domain)));
 
-				options.AddPolicy("stream:songs", policy =>
+                options.AddPolicy("read:year", policy =>
-						policy
+                    policy.Requirements
-						.Requirements
+                    .Add(new HasScopeRequirement("read:year", domain)));
-						.Add(new HasScopeRequirement("stream:songs", domain)));
+
-			});
+                options.AddPolicy("stream:songs", policy =>
+                    policy.Requirements
+                    .Add(new HasScopeRequirement("stream:songs", domain)));
+            });
 
 
-			services.AddSingleton<IAuthorizationHandler, HasScopeHandler>();
+            services.AddSingleton<IAuthorizationHandler, HasScopeHandler>();
 
-			var connString = Configuration.GetConnectionString("DefaultConnection");
+            var connString = Configuration.GetConnectionString("DefaultConnection");
 
-	    		services.Add(new ServiceDescriptor(typeof(SongRepository), 
-						new SongRepository(Configuration
-							.GetConnectionString("DefaultConnection"))));  
 
-			services.Add(new ServiceDescriptor(typeof(AlbumRepository),
+            services.AddDbContext<SongContext>(options => options.UseMySQL(connString));
-						new AlbumRepository(Configuration
+            services.AddDbContext<AlbumContext>(options => options.UseMySQL(connString));
-							.GetConnectionString("DefaultConnection"))));
+            services.AddDbContext<ArtistContext>(options => options.UseMySQL(connString));
+            services.AddDbContext<UserContext>(options => options.UseMySQL(connString));
+            services.AddDbContext<GenreContext>(options => options.UseMySQL(connString));
+            services.AddDbContext<CoverArtContext>(options => options.UseMySQL(connString));
 
-			services.Add(new ServiceDescriptor(typeof(ArtistRepository),
+            services.AddControllers()
-						new ArtistRepository(Configuration
+                .AddNewtonsoftJson();
-							.GetConnectionString("DefaultConnection"))));
+        }
 
-			services.Add(new ServiceDescriptor(typeof(GenreRepository),
+        // Called by the runtime. Use this method to configure the HTTP request pipeline.
-						new GenreRepository(Configuration
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-							.GetConnectionString("DefaultConnection"))));
+        {
+            // NOTE: Dev-related configuration can be done when env.IsDevelopment() evaluated to true
 
-			services.Add(new ServiceDescriptor(typeof(YearRepository),
+            app.UseRouting();
-						new YearRepository(Configuration
+            app.UseAuthentication();
-							.GetConnectionString("DefaultConnection"))));
+            app.UseAuthorization();
-
+            app.UseEndpoints(endpoints =>
-			services.Add(new ServiceDescriptor(typeof(UserRepository), 
+            {
-						new UserRepository(Configuration
+                endpoints.MapControllers();
-							.GetConnectionString("DefaultConnection"))));
+            });
-
+        }
-			services.AddDbContext<SongContext>(options => options.UseMySQL(connString));
+    }
-			services.AddDbContext<AlbumContext>(options => options.UseMySQL(connString));
-			services.AddDbContext<ArtistContext>(options => options.UseMySQL(connString));
-			services.AddDbContext<UserContext>(options => options.UseMySQL(connString));
-			services.AddDbContext<GenreContext>(options => options.UseMySQL(connString));
-			services.AddDbContext<YearContext>(options => options.UseMySQL(connString));
-        	}
-
-        	// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-        	public void Configure(IApplicationBuilder app, IHostingEnvironment env)
-        	{
-            		if (env.IsDevelopment())
-            		{
-                		app.UseDeveloperExceptionPage();
-            		}
-            		else
-            		{
-                		// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
-               			 app.UseHsts();
-            		}
-
-			app.UseAuthentication();
-
-            		app.UseHttpsRedirection();
-            		app.UseMvc();
-        	}
-    	}
 }

Types/CoverArtTypes.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Icarus.Types
+{
+    public enum CoverArtField
+    {
+        SongTitle = 0,
+        ImagePath
+    };
+}

Types/DirectoryTypes.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Icarus.Types
+{
+    public enum DirectoryType
+    {
+        Music = 0,
+        CoverArt
+    };
+}

appsettings.Development.json

@@ -9,13 +9,14 @@
   "Auth0": {
 	  "Domain": "[domain].auth0.com", 
 	  "ApiIdentifier": "https://[identifier]/api",
-	  "ClientId":"",
+	  "ClientId": "",
-	  "ClientSecret":""
+	  "ClientSecret": ""
   },
   "ConnectionStrings": {
 	  "DefaultConnection": "Server=;Database=;Uid=;Pwd=;"
   },
   "RootMusicPath": "/music/path/",
   "TemporaryMusicPath": "/music/temp/path/",
-  "ArchivePath": "/archive/path/"
+  "ArchivePath": "/archive/path/",
+  "CoverArtPath": "/cover/art/path/"
 }

appsettings.json

@@ -9,13 +9,14 @@
   "Auth0": {
 	  "Domain": "[domain].auth0.com",
 	  "ApiIdentifier": "https://[identifier]/api",
-	  "ClientId":"",
+	  "ClientId": "",
-	  "ClientSecret":""
+	  "ClientSecret": ""
   },
   "ConnectionStrings": {
 	  "DefaultConnection": "Server=;Database=;Uid=;Pwd=;"
   },
   "RootMusicPath": "/music/path/",
   "TemporaryMusicPath": "/music/temp/path/",
-  "ArchivePath": "/archive/path/"
+  "ArchivePath": "/archive/path/",
+  "CoverArtPath": "/cover/art/path/"
 }