phoenix/icarus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 33 Wiki Activity

Removing repositories

Browse Source
This commit is contained in:
kdeng00
2021-12-22 20:28:20 -05:00
parent 46f0da4a5f
commit 922e527819
8 changed files with 0 additions and 2412 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Database/Repositories/AlbumRepository.cs
-385
View File
@@ -1,385 +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
-355
View File
@@ -1,355 +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
-23
View File
@@ -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/CoverArtRepository.cs
-282
View File
@@ -1,282 +0,0 @@
using System;
using System.Collections.Generic;
using MySql.Data.MySqlClient;
using Icarus.Models;
using Icarus.Types;
namespace Icarus.Database.Repositories
{
public class CoverArtRepository : BaseRepository
{
#region Constructors
public CoverArtRepository(string connectionString)
{
_connectionString = connectionString;
}
#endregion
#region Methods
public List<CoverArt> GetCoverArtRecords()
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Querying cover art records");
var query = "SELECT cv.*, sng.Id AS SongId FROM CoverArt " +
"cv LEFT JOIN Song sng ON cv.CoverArtId=sng.CoverArtId";
using (var cmd = new MySqlCommand(query, conn))
using (var reader = cmd.ExecuteReader())
return ParseData(reader);
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
return null;
}
public CoverArt GetCoverArt(CoverArt cover)
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Querying cover art record");
var query = "SELECT * FROM CoverArt WHERE " +
"CoverArtId=@CoverArtId";
using (var cmd = new MySqlCommand(query, conn))
{
cmd.Parameters
.AddWithValue("@CoverArtId", cover.CoverArtId);
using (var reader = cmd.ExecuteReader())
return ParseSingleData(reader);
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
return null;
}
public CoverArt GetCoverArt(Song song)
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Querying cover art record");
var query = "SELECT cov.* FROM CoverArt cov LEFT JOIN " +
"Song sng ON cov.CoverArtId=sng.CoverArtId WHERE " +
"sng.Id=@SongId";
using (var cmd = new MySqlCommand(query, conn))
{
cmd.Parameters.AddWithValue("@SongId", song.Id);
using (var reader = cmd.ExecuteReader())
return ParseSingleData(reader);
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
return null;
}
public CoverArt GetCoverArt(CoverArtField field, CoverArt cover)
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Querying cover art record");
using (var cmd = new MySqlCommand(BuildQuery(field), conn))
{
switch (field)
{
case CoverArtField.SongTitle:
cmd.Parameters.AddWithValue("@SongTitle",
cover.SongTitle);
break;
case CoverArtField.ImagePath:
cmd.Parameters.AddWithValue("@ImagePath",
cover.ImagePath);
break;
}
using (var reader = cmd.ExecuteReader())
return ParseSingleData(reader);
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
return null;
}
public bool DoesCoverArtExist(CoverArt cover)
{
return GetCoverArt(cover) != null ? true : false;
}
public bool DoesCoverArtExist(Song song)
{
return GetCoverArt(song) != null ? true : false;
}
public void SaveCoverArt(CoverArt coverArt)
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Saving cover art record");
var query = "INSERT INTO CoverArt(SongTitle, ImagePath) " +
"VALUES(@SongTitle, @ImagePath)";
using (var cmd = new MySqlCommand(query, conn))
{
cmd.Parameters
.AddWithValue("@SongTitle", coverArt.SongTitle);
cmd.Parameters
.AddWithValue("@ImagePath", coverArt.ImagePath);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
}
public void DeleteCoverArt(CoverArt cover)
{
try
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Deleting cover art record");
var query = "DELETE FROM CoverArt WHERE " +
"CoverArtId=@CoverArtId";
using (var cmd = new MySqlCommand(query, conn))
{
cmd.Parameters
.AddWithValue("@CoverArtId", cover.CoverArtId);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
var msg = ex.Message;
_logger.Error(msg, "An error occurred");
}
}
private List<CoverArt> ParseData(MySqlDataReader reader)
{
if (reader.HasRows)
{
var coverArtList = new List<CoverArt>();
_logger.Info("Parsing cover art records");
while (reader.Read())
coverArtList.Add(new CoverArt
{
CoverArtId = Convert.ToInt32(reader["CoverArtId"]),
SongTitle = reader["SongTitle"].ToString(),
ImagePath = reader["ImagePath"].ToString(),
SongId = Convert.ToInt32(reader["SongId"].ToString())
});
return coverArtList;
}
return null;
}
private CoverArt ParseSingleData(MySqlDataReader reader)
{
if (reader.HasRows)
{
_logger.Info("Parsing single cover art record");
reader.Read();
return new CoverArt
{
CoverArtId = Convert.ToInt32(reader["CoverArtId"]),
SongTitle = reader["SongTitle"].ToString(),
ImagePath = reader["ImagePath"].ToString()
};
}
return null;
}
private string BuildQuery(CoverArtField field)
{
switch (field)
{
case CoverArtField.SongTitle:
return "SELECT * FROM CoverArt WHERE SongTitle=@SongTitle";
case CoverArtField.ImagePath:
return "SELECT * FROM CoverArt WHERE ImagePath=" +
"@ImagePath";
}
return null;
}
private bool? AnyCoverArt()
{
using (var conn = GetConnection())
{
conn.Open();
_logger.Info("Checking to see if there are any cover art " +
"records");
var query = "SELECT * FROM CoverArt";
using (var cmd = new MySqlCommand(query, conn))
using (var reader = cmd.ExecuteReader())
return reader.HasRows;
}
}
#endregion
}
}
Database/Repositories/GenreRepository.cs
-447
View File
@@ -1,447 +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
-324
View File
@@ -1,324 +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, CoverArtId) VALUES(@Title," +
" @AlbumTitle, @Artist, @Year, @Genre, @Duration, " +
"@Filename, @SongPath, @AlbumId, @ArtistId, @GenreId," +
" @YearId, @CoverArtId)";
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.Parameters.AddWithValue("@CoverArtId", song.CoverArtId);
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()),
CoverArtId = Convert.ToInt32(reader["CoverArtId"].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());
song.CoverArtId = Convert.ToInt32(reader["CoverArtId"].ToString());
}
return song;
}
#endregion
}
}
Database/Repositories/UserRepository.cs
-229
View File
@@ -1,229 +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" +
", Phone, 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
-367
View File
@@ -1,367 +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
}
}