Added versioning to the API, created namespace for the Reposiorites, Changed the StoreContexts to Repositories, moved the Contexts class to another namespace. #37

Database/Contexts/AlbumContext.cs

@@ -0,0 +1,27 @@
+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 AlbumContext : DbContext
+	{
+		public DbSet<Album> Albums { get; set; }
+
+		public AlbumContext(DbContextOptions<AlbumContext> options)
+			: base(options)
+		{ }
+
+		protected override void OnModelCreating(ModelBuilder modelBuilder)
+		{
+			modelBuilder.Entity<Album>()
+				.ToTable("Album");
+		}
+	}
+}

Database/Contexts/ArtistContext.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+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 DbSet<Artist> Artists { get; set; }
+
+		public ArtistContext(DbContextOptions<ArtistContext> options)
+			: base (options)
+		{ }
+
+		protected override void OnModelCreating(ModelBuilder modelBuilder)
+		{
+			modelBuilder.Entity<Artist>()
+				.ToTable("Artist");
+		}
+	}
+}

Database/Contexts/GenreContext.cs

@@ -0,0 +1,27 @@
+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 GenreContext : DbContext
+	{
+		public DbSet<Genre> Genres { get; set; }
+
+		public GenreContext(DbContextOptions<GenreContext> options)
+			: base(options)
+		{ }
+
+		protected override void OnModelCreating(ModelBuilder modelBuilder)
+		{
+			modelBuilder.Entity<Genre>()
+				.ToTable("Genre");
+		}
+	}
+}

Database/Contexts/SongContext.cs

@@ -0,0 +1,68 @@
+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 SongContext : DbContext
+    	{
+        	public DbSet<Song> Songs { get; set; }
+
+
+		public SongContext(DbContextOptions<SongContext> options)
+            		: base(options)
+        	{ }
+
+        	protected override void OnModelCreating(ModelBuilder modelBuilder)
+        	{
+            		modelBuilder.Entity<Song>()
+				.ToTable("Song");
+
+			modelBuilder.Entity<Song>()
+				.HasOne(s => s.Album)
+				.WithMany(al => al.Songs)
+				.HasForeignKey(s => s.AlbumId)
+				.OnDelete(DeleteBehavior.SetNull);
+
+			modelBuilder.Entity<Song>()
+				.HasOne(sa => sa.SongArtist)
+				.WithMany(ar => ar.Songs)
+				.HasForeignKey(s => s.ArtistId)
+				.OnDelete(DeleteBehavior.SetNull);
+
+			modelBuilder.Entity<Song>()
+				.HasOne(s => s.SongGenre)
+				.WithMany(gnr => gnr.Songs)
+				.HasForeignKey(s => s.GenreId)
+				.OnDelete(DeleteBehavior.SetNull);
+
+			modelBuilder.Entity<Song>()
+				.HasOne(s => s.SongYear)
+				.WithMany(yr => yr.Songs)
+				.HasForeignKey(s => s.YearId)
+				.OnDelete(DeleteBehavior.SetNull);
+
+			modelBuilder.Entity<Song>()
+				.Property(s => s.Year)
+				.IsRequired(false);
+			modelBuilder.Entity<Song>()
+				.Property(s => s.YearId)
+				.IsRequired(false);
+			modelBuilder.Entity<Song>()
+				.Property(s => s.GenreId)
+				.IsRequired(false);
+			modelBuilder.Entity<Song>()
+				.Property(s => s.ArtistId)
+				.IsRequired(false);
+			modelBuilder.Entity<Song>()
+				.Property(s => s.AlbumId)
+				.IsRequired(false);
+        	}
+    	}
+}  

Database/Contexts/UserContext.cs

@@ -0,0 +1,32 @@
+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 UserContext : DbContext
+	{
+        	public DbSet<User> Users { get; set; }
+
+
+		public UserContext(DbContextOptions<UserContext> options)
+            		: base(options)
+        	{ }
+
+        	protected override void OnModelCreating(ModelBuilder modelBuilder)
+        	{
+			modelBuilder.Entity<User>()
+				.ToTable("User");
+            		modelBuilder.Entity<User>()
+				.Property(u => u.LastLogin).IsRequired(false);
+			modelBuilder.Entity<User>()
+				.Property(u => u.DateCreated).HasDefaultValue(DateTime.Now);
+        	}
+    	}
+}  

Database/Contexts/YearContext.cs

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,411 @@
+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

@@ -0,0 +1,370 @@
+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 " +
+						"GROUPY 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 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 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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,475 @@
+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())
+						{
+							var genres = ParseData(reader);
+
+							if (genres.Count > 0)
+							{
+								_logger.Info("Genres records");
+								return true;
+							}
+						}
+					}
+				}
+			}
+			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

@@ -0,0 +1,326 @@
+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

@@ -0,0 +1,231 @@
+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

@@ -0,0 +1,381 @@
+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 gnr.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
+	}
+}