diff --git a/database.json b/database.json index 661decf..ed03ff2 100644 --- a/database.json +++ b/database.json @@ -1,7 +1,7 @@ { - "server": "server", - "database": "database", - "username": "username", - "password": "password" + "server": "localhost", + "database": "Icarus", + "username": "icarus-admin", + "password": "dreamofpeace" } diff --git a/include/controller/songController.hpp b/include/controller/songController.hpp index 54b6ee7..ca36000 100644 --- a/include/controller/songController.hpp +++ b/include/controller/songController.hpp @@ -117,6 +117,9 @@ namespace Controller Model::Song songDb; songDb.id = id; + OATPP_ASSERT_HTTP(songRepo.doesSongExist(songDb, Type::songFilter::id) , Status::CODE_403, "song does not exist"); + + std::cout << "song exists" << std::endl; songDb = songRepo.retrieveRecord(songDb, Type::songFilter::id); auto song = Dto::songDto::createShared(); diff --git a/include/database/albumRepository.h b/include/database/albumRepository.h index e9e9dfe..59e0ada 100644 --- a/include/database/albumRepository.h +++ b/include/database/albumRepository.h @@ -23,7 +23,11 @@ namespace Database void saveAlbum(const Model::Album&); private: std::vector parseRecords(MYSQL_RES*); + + // TODO: after parseRecord(MYSQL_STMT*) is implemented remove + // parseRecord(MYSQL_RES*) Model::Album parseRecord(MYSQL_RES*); + Model::Album parseRecord(MYSQL_STMT*); }; } diff --git a/include/database/artistRepository.h b/include/database/artistRepository.h index f47a69d..83b897b 100644 --- a/include/database/artistRepository.h +++ b/include/database/artistRepository.h @@ -14,9 +14,14 @@ namespace Database Model::Artist retrieveRecord(Model::Artist&, Type::artistFilter); + bool doesArtistExist(const Model::Artist&, Type::artistFilter); + void saveRecord(const Model::Artist&); private: + // TODO: After parseRecord(MYSQL_STMT*) is implemented + // remove parseRecord(MYSQL_RES*) Model::Artist parseRecord(MYSQL_RES*); + Model::Artist parseRecord(MYSQL_STMT*); }; } diff --git a/include/database/coverArtRepository.h b/include/database/coverArtRepository.h index 115c320..c664d8f 100644 --- a/include/database/coverArtRepository.h +++ b/include/database/coverArtRepository.h @@ -16,11 +16,16 @@ namespace Database coverArtRepository(const Model::BinaryPath&); Model::Cover retrieveRecord(Model::Cover&, Type::coverFilter); + + bool doesCoverArtExist(const Model::Cover&, Type::coverFilter); void deleteRecord(const Model::Cover&); void saveRecord(const Model::Cover&); private: + // TODO: After parseRecord(MYSQL_STMT*) is implemented + // remove parseRecord(MYSQL_RES*) Model::Cover parseRecord(MYSQL_RES*); + Model::Cover parseRecord(MYSQL_STMT*); }; } diff --git a/include/database/genreRepository.h b/include/database/genreRepository.h index 927eb3a..e495105 100644 --- a/include/database/genreRepository.h +++ b/include/database/genreRepository.h @@ -14,9 +14,14 @@ namespace Database Model::Genre retrieveRecord(Model::Genre&, Type::genreFilter); + bool doesGenreExist(const Model::Genre&, Type::genreFilter); + void saveRecord(const Model::Genre&); private: + // TODO: After parseRecord(MYSQL_STMT*) is implemented + // remove parseRecord(MYSQL_RES*) Model::Genre parseRecord(MYSQL_RES*); + Model::Genre parseRecord(MYSQL_STMT*); }; } diff --git a/include/database/songRepository.h b/include/database/songRepository.h index 0bc05f6..a32922b 100644 --- a/include/database/songRepository.h +++ b/include/database/songRepository.h @@ -20,14 +20,18 @@ namespace Database std::vector retrieveRecords(); + bool doesSongExist(const Model::Song&, Type::songFilter); + Model::Song retrieveRecord(Model::Song&, Type::songFilter); void deleteRecord(const Model::Song&); void saveRecord(const Model::Song&); private: - std::vector parseRecords(MYSQL_RES*); + std::vector parseRecords(MYSQL_RES*); // TODO: to be removed + std::vector parseRecords(MYSQL_STMT*); - Model::Song parseRecord(MYSQL_RES*); + Model::Song parseRecord(MYSQL_RES*); // TODO: to be removed + Model::Song parseRecord(MYSQL_STMT*); }; } diff --git a/include/database/yearRepository.h b/include/database/yearRepository.h index da61784..135b98f 100644 --- a/include/database/yearRepository.h +++ b/include/database/yearRepository.h @@ -14,9 +14,14 @@ namespace Database Model::Year retrieveRecord(Model::Year&, Type::yearFilter); + bool doesYearExist(const Model::Year&, Type::yearFilter); + void saveRecord(const Model::Year&); private: + // TODO: After parseRecord(MYSQL_STMT*) is implemented + // remove parseRecord(MYSQL_RES*) Model::Year parseRecord(MYSQL_RES*); + Model::Year parseRecord(MYSQL_STMT*); }; } diff --git a/src/database/albumRepository.cpp b/src/database/albumRepository.cpp index 57b7190..80d9f74 100644 --- a/src/database/albumRepository.cpp +++ b/src/database/albumRepository.cpp @@ -63,7 +63,53 @@ bool Database::albumRepository::doesAlbumExists(const Model::Album& album, Type: // record for songs on the same album. After fixing this, do the // same for Artist, Genre, and Year records - return false; + auto conn = setup_mysql_connection(); + auto stmt = mysql_stmt_init(conn); + + MYSQL_BIND params[1]; + memset(params, 0, sizeof(params)); + + std::stringstream qry; + qry << "SELECT * FROM Album WHERE "; + + auto titleLength = album.title.size(); + switch (filter) { + case Type::albumFilter::id: + qry << "AlbumId = ?"; + + params[0].buffer_type = MYSQL_TYPE_LONG; + params[0].buffer = (char*)&album.id; + params[0].length = 0; + params[0].is_null = 0; + break; + case Type::albumFilter::title: + qry << "Title = ?"; + + params[0].buffer_type = MYSQL_TYPE_STRING; + params[0].buffer = (char*)album.title.c_str(); + params[0].length = &titleLength; + params[0].is_null = 0; + break; + default: + break; + } + + qry << " LIMIT 1"; + + const auto query = qry.str(); + auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size()); + status = mysql_stmt_bind_param(stmt, params); + status = mysql_stmt_execute(stmt); + + std::cout << "the query has been performed" << std::endl; + + ::mysql_stmt_store_result(stmt); + auto rowCount = ::mysql_stmt_num_rows(stmt); + + ::mysql_stmt_close(stmt); + ::mysql_close(conn); + + return (rowCount > 0) ? true : false; } void Database::albumRepository::saveAlbum(const Model::Album& album) @@ -133,3 +179,11 @@ Model::Album Database::albumRepository::parseRecord(MYSQL_RES* results) return album; } + +Model::Album Database::albumRepository::parseRecord(MYSQL_STMT *stmt) +{ + // TODO: implement this + Model::Album album; + + return album; +} diff --git a/src/database/artistRepository.cpp b/src/database/artistRepository.cpp index 7aa145e..3eec442 100644 --- a/src/database/artistRepository.cpp +++ b/src/database/artistRepository.cpp @@ -47,6 +47,13 @@ Model::Artist Database::artistRepository::retrieveRecord(Model::Artist& artist, return artist; } +bool Database::artistRepository::doesArtistExist(const Model::Artist& artist, Type::artistFilter filter) +{ + // TODO: implement this + + return false; +} + void Database::artistRepository::saveRecord(const Model::Artist& artist) { std::cout << "inserting artist record" << std::endl; @@ -100,3 +107,11 @@ Model::Artist Database::artistRepository::parseRecord(MYSQL_RES* results) return artist; } + +Model::Artist Database::artistRepository::parseRecord(MYSQL_STMT *stmt) +{ + // TODO: implement this + Model::Artist art; + + return art; +} diff --git a/src/database/coverArtRepository.cpp b/src/database/coverArtRepository.cpp index f559902..a2edc9c 100644 --- a/src/database/coverArtRepository.cpp +++ b/src/database/coverArtRepository.cpp @@ -46,6 +46,12 @@ Model::Cover Database::coverArtRepository::retrieveRecord(Model::Cover& cov, Typ return covDb; } +bool Database::coverArtRepository::doesCoverArtExist(const Model::Cover& cover, Type::coverFilter filter) +{ + // TODO: implement this + return false; +} + void Database::coverArtRepository::deleteRecord(const Model::Cover& cov) { auto conn = setup_mysql_connection(); @@ -119,3 +125,12 @@ Model::Cover Database::coverArtRepository::parseRecord(MYSQL_RES *results) return cov; } + +Model::Cover Database::coverArtRepository::parseRecord(MYSQL_STMT *stmt) +{ + // TODO: implement this + + Model::Cover cover; + + return cover; +} diff --git a/src/database/genreRepository.cpp b/src/database/genreRepository.cpp index b25e2cf..dde767d 100644 --- a/src/database/genreRepository.cpp +++ b/src/database/genreRepository.cpp @@ -45,6 +45,13 @@ Model::Genre Database::genreRepository::retrieveRecord(Model::Genre& genre, Type return genre; } +bool Database::genreRepository::doesGenreExist(const Model::Genre& genre, Type::genreFilter filter) +{ + // TODO: implement this + + return false; +} + void Database::genreRepository::saveRecord(const Model::Genre& genre) { std::cout << "inserting genre record" << std::endl; @@ -97,3 +104,11 @@ Model::Genre Database::genreRepository::parseRecord(MYSQL_RES* results) return genre; } +Model::Genre Database::genreRepository::parseRecord(MYSQL_STMT *stmt) +{ + // TODO: implement this + + Model::Genre genre; + + return genre; +} diff --git a/src/database/songRepository.cpp b/src/database/songRepository.cpp index 1536fae..7a702bc 100644 --- a/src/database/songRepository.cpp +++ b/src/database/songRepository.cpp @@ -16,14 +16,17 @@ Database::songRepository::songRepository(const Model::BinaryPath& bConf) : base_ std::vector Database::songRepository::retrieveRecords() { auto conn = setup_mysql_connection(); + auto stmt = mysql_stmt_init(conn); const std::string query = "SELECT * FROM Song"; - auto results = perform_mysql_query(conn, query); - auto songs = parseRecords(results); + ::mysql_stmt_prepare(stmt, query.c_str(), query.size()); + ::mysql_stmt_execute(stmt); + auto songs = parseRecords(stmt); + + mysql_stmt_close(stmt); mysql_close(conn); - return songs; } @@ -31,34 +34,106 @@ Model::Song Database::songRepository::retrieveRecord(Model::Song& song, Type::so { std::stringstream qry; auto conn = setup_mysql_connection(); + auto stmt = mysql_stmt_init(conn); + + MYSQL_BIND params[1]; + memset(params, 0, sizeof(params)); + qry << "SELECT * FROM Song WHERE "; - std::unique_ptr param; + auto titleLength = song.title.size(); switch (filter) { case Type::songFilter::id: - qry << "SongId = " << song.id; + qry << "SongId = ?"; + + params[0].buffer_type = MYSQL_TYPE_LONG; + params[0].buffer = (char*)&song.id; + params[0].length = 0; + params[0].is_null = 0;; break; case Type::songFilter::title: - param = std::make_unique(new char[song.title.size()]); - mysql_real_escape_string(conn, *param, song.title.c_str(), song.title.size()); - qry << "Title = '" << *param << "'"; + qry << "Title = ?"; + + params[0].buffer_type = MYSQL_TYPE_STRING; + params[0].buffer = (char*)song.title.c_str(); + params[0].length = &titleLength; + params[0].is_null = 0; break; default: break; } + qry << " LIMIT 1"; + const std::string query = qry.str(); - auto results = perform_mysql_query(conn, query); + auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size()); + status = mysql_stmt_bind_param(stmt, params); + status = mysql_stmt_execute(stmt); + std::cout << "the query has been performed" << std::endl; - song = parseRecord(results); + song = parseRecord(stmt); + mysql_stmt_close(stmt); mysql_close(conn); std::cout << "done" << std::endl; return song; } +bool Database::songRepository::doesSongExist(const Model::Song& song, Type::songFilter filter) +{ + std::cout << "checking to see if song exists" << std::endl; + std::stringstream qry; + auto conn = setup_mysql_connection(); + auto stmt = mysql_stmt_init(conn); + + MYSQL_BIND params[1]; + memset(params, 0, sizeof(params)); + + qry << "SELECT * FROM Song WHERE "; + + auto titleLength = song.title.size(); + switch (filter) { + case Type::songFilter::id: + qry << "SongId = ?"; + + params[0].buffer_type = MYSQL_TYPE_LONG; + params[0].buffer = (char*)&song.id; + params[0].length = 0; + params[0].is_null = 0; + break; + case Type::songFilter::title: + qry << "Title = ?"; + + params[0].buffer_type = MYSQL_TYPE_STRING; + params[0].buffer = (char*)song.title.c_str(); + params[0].length = &titleLength; + params[0].is_null = 0; + break; + default: + break; + } + + qry << " LIMIT 1"; + + const std::string query = qry.str(); + auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size()); + status = mysql_stmt_bind_param(stmt, params); + status = mysql_stmt_execute(stmt); + + std::cout << "the query has been performed" << std::endl; + + ::mysql_stmt_store_result(stmt); + auto rowCount = ::mysql_stmt_num_rows(stmt); + + mysql_stmt_close(stmt); + mysql_close(conn); + std::cout << "done" << std::endl; + + return (rowCount > 0) ? true : false; +} + void Database::songRepository::deleteRecord(const Model::Song& song) { auto conn = setup_mysql_connection(); @@ -172,6 +247,7 @@ void Database::songRepository::saveRecord(const Model::Song& song) std::cout << "done inserting song record" << std::endl; } +// TODO: delete this, not being used std::vector Database::songRepository::parseRecords(MYSQL_RES* results) { auto fieldNum = mysql_num_fields(results); @@ -184,6 +260,59 @@ std::vector Database::songRepository::parseRecords(MYSQL_RES* resul Model::Song song; for (auto i = 0; i != fieldNum; ++i) { + /** + auto field = mysql_fetch_field(results); + if (field->name == NULL) { + std::cout << "null field" << std::endl; + break; + } + */ + /** + std::string field; + if ((i + 0) == fieldNum) { + std::cout << "goodbye" << std::endl; + break; + } else { + std::cout << "still good" << std::endl; + field.assign(mysql_fetch_field(results)->name); + } + //const std::string field(row[i].field); + std::cout << field << std::endl; + + if (field.compare("SongId") == 0) { + song.id = std::stoi(row[i]); + } + if (field.compare("Title") == 0) { + song.title = row[i]; + } + if (field.compare("Artist") == 0) { + song.artist = row[i]; + } + if (field.compare("Album") == 0) { + song.album = row[i]; + } + if (field.compare("Genre") == 0) { + song.genre = row[i]; + } + if (field.compare("Year") == 0) { + song.year = std::stoi(row[i]); + } + if (field.compare("Duration") == 0) { + song.duration = std::stoi(row[i]); + } + if (field.compare("Track") == 0) { + song.track = std::stoi(row[i]); + } + if (field.compare("Disc") == 0) { + song.disc = std::stoi(row[i]); + } + if (field.compare("SongPath") == 0) { + song.songPath = row[i]; + } + if (field.compare("CoverArtId") == 0) { + song.coverArtId = std::stoi(row[i]); + } + */ switch (i) { case 0: song.id = std::stoi(row[i]); @@ -222,19 +351,163 @@ std::vector Database::songRepository::parseRecords(MYSQL_RES* resul } songs.push_back(song); + //std::cout << "added" << std::endl; + } + //std::cout << "completely" << std::endl; + + return songs; +} + +std::vector Database::songRepository::parseRecords(MYSQL_STMT *stmt) +{ + ::mysql_stmt_store_result(stmt); + auto c = ::mysql_stmt_num_rows(stmt); + std::cout << "number of results " << c << std::endl; + std::vector songs; + songs.reserve(c); + + auto status = 0; + auto time = 0; + auto valAmt = 15; + unsigned long len[valAmt]; + my_bool nullRes[valAmt]; + + while (status == 0) { + std::cout << time++ << " time" << std::endl; + std::cout << "field count " << ::mysql_stmt_field_count(stmt) << std::endl; + + if (::mysql_stmt_field_count(stmt) > 0) { + + Model::Song song; + auto res = ::mysql_stmt_result_metadata(stmt); + auto fields = ::mysql_fetch_fields(res); + auto strLen = 1024; + MYSQL_BIND val[valAmt]; + memset(val, 0, sizeof(val)); + + char title[strLen]; + char album[strLen]; + char artist[strLen]; + char genre[strLen]; + char path[strLen]; + + val[0].buffer_type = MYSQL_TYPE_LONG; + val[0].buffer = (char*)&song.id; + val[0].length = &len[0]; + val[0].is_null = &nullRes[0]; + + val[1].buffer_type = MYSQL_TYPE_STRING; + val[1].buffer = (char*)title; + val[1].buffer_length = strLen; + val[1].length = &len[1]; + val[1].is_null = &nullRes[1]; + + val[2].buffer_type = MYSQL_TYPE_STRING; + val[2].buffer = (char*)artist; + val[2].buffer_length = strLen; + val[2].length = &len[2]; + val[2].is_null = &nullRes[2]; + + val[3].buffer_type = MYSQL_TYPE_STRING; + val[3].buffer = (char*)album; + val[3].buffer_length = strLen; + val[3].length = &len[3]; + val[3].is_null = &nullRes[3]; + + val[4].buffer_type = MYSQL_TYPE_STRING; + val[4].buffer = (char*)genre; + val[4].buffer_length = strLen; + val[4].length = &len[4]; + val[4].is_null = &nullRes[4]; + + val[5].buffer_type = MYSQL_TYPE_LONG; + val[5].buffer = (char*)&song.year; + val[5].length = &len[5]; + val[5].is_null = &nullRes[5]; + + val[6].buffer_type = MYSQL_TYPE_LONG; + val[6].buffer = (char*)&song.duration; + val[6].length = &len[6]; + val[6].is_null = &nullRes[6]; + + val[7].buffer_type = MYSQL_TYPE_LONG; + val[7].buffer = (char*)&song.track; + val[7].length = &len[7]; + val[7].is_null = &nullRes[7]; + + val[8].buffer_type = MYSQL_TYPE_LONG; + val[8].buffer = (char*)&song.disc; + val[8].length = &len[8]; + val[8].is_null = &nullRes[8]; + + val[9].buffer_type = MYSQL_TYPE_STRING; + val[9].buffer = (char*)path; + val[9].buffer_length = strLen; + val[9].length = &len[9]; + val[9].is_null = &nullRes[9]; + + val[10].buffer_type = MYSQL_TYPE_LONG; + val[10].buffer = (char*)&song.coverArtId; + val[10].length = &len[10]; + val[10].is_null = &nullRes[10]; + + val[11].buffer_type = MYSQL_TYPE_LONG; + val[11].buffer = (char*)&song.artistId; + val[11].length = &len[11]; + val[11].is_null = &nullRes[11]; + + val[12].buffer_type = MYSQL_TYPE_LONG; + val[12].buffer = (char*)&song.albumId;; + val[12].length = &len[12]; + val[12].is_null = &nullRes[12]; + + val[13].buffer_type = MYSQL_TYPE_LONG; + val[13].buffer = (char*)&song.genreId; + val[13].length = &len[13]; + val[13].is_null = &nullRes[13]; + + val[14].buffer_type = MYSQL_TYPE_LONG; + val[14].buffer = (char*)&song.yearId; + val[14].length = &len[14]; + val[14].is_null = &nullRes[14]; + + status = ::mysql_stmt_bind_result(stmt, val); + + while (1) { + std::cout << "fetching statement result" << std::endl; + status = ::mysql_stmt_fetch(stmt); + + if (status == 1 || status == MYSQL_NO_DATA) { + break; + } + song.title = title; + song.album = album; + song.artist = artist; + song.genre = genre; + song.songPath = path; + + songs.push_back(song); + } + } + std::cout << "fetching next result" << std::endl; + status = ::mysql_stmt_next_result(stmt); } return songs; } + +// TODO: delete this, not being used anymore Model::Song Database::songRepository::parseRecord(MYSQL_RES* results) { Model::Song song; - auto fieldNum = mysql_num_fields(results); - MYSQL_ROW row = mysql_fetch_row(results); + auto fieldNum = mysql_num_fields(results); + auto row = mysql_fetch_row(results); for (auto i = 0; i != fieldNum; ++i) { + const std::string field(mysql_fetch_field(results)->name); + switch (i) { case 0: song.id = std::stoi(row[i]); @@ -275,3 +548,127 @@ Model::Song Database::songRepository::parseRecord(MYSQL_RES* results) return song; } + +Model::Song Database::songRepository::parseRecord(MYSQL_STMT *stmt) +{ + Model::Song song; + auto status = 0; + auto time = 0; + auto valAmt = 15; + unsigned long len[valAmt]; + my_bool nullRes[valAmt]; + + while (status == 0) { + if (::mysql_stmt_field_count(stmt) > 0) { + auto res = ::mysql_stmt_result_metadata(stmt); + auto fields = ::mysql_fetch_fields(res); + auto strLen = 1024; + MYSQL_BIND val[valAmt]; + memset(val, 0, sizeof(val)); + + char title[strLen]; + char album[strLen]; + char artist[strLen]; + char genre[strLen]; + char path[strLen]; + + val[0].buffer_type = MYSQL_TYPE_LONG; + val[0].buffer = (char*)&song.id; + val[0].length = &len[0]; + val[0].is_null = &nullRes[0]; + + val[1].buffer_type = MYSQL_TYPE_STRING; + val[1].buffer = (char*)title; + val[1].buffer_length = strLen; + val[1].length = &len[1]; + val[1].is_null = &nullRes[1]; + + val[2].buffer_type = MYSQL_TYPE_STRING; + val[2].buffer = (char*)artist; + val[2].buffer_length = strLen; + val[2].length = &len[2]; + val[2].is_null = &nullRes[2]; + + val[3].buffer_type = MYSQL_TYPE_STRING; + val[3].buffer = (char*)album; + val[3].buffer_length = strLen; + val[3].length = &len[3]; + val[3].is_null = &nullRes[3]; + + val[4].buffer_type = MYSQL_TYPE_STRING; + val[4].buffer = (char*)genre; + val[4].buffer_length = strLen; + val[4].length = &len[4]; + val[4].is_null = &nullRes[4]; + + val[5].buffer_type = MYSQL_TYPE_LONG; + val[5].buffer = (char*)&song.year; + val[5].length = &len[5]; + val[5].is_null = &nullRes[5]; + + val[6].buffer_type = MYSQL_TYPE_LONG; + val[6].buffer = (char*)&song.duration; + val[6].length = &len[6]; + val[6].is_null = &nullRes[6]; + + val[7].buffer_type = MYSQL_TYPE_LONG; + val[7].buffer = (char*)&song.track; + val[7].length = &len[7]; + val[7].is_null = &nullRes[7]; + + val[8].buffer_type = MYSQL_TYPE_LONG; + val[8].buffer = (char*)&song.disc; + val[8].length = &len[8]; + val[8].is_null = &nullRes[8]; + + val[9].buffer_type = MYSQL_TYPE_STRING; + val[9].buffer = (char*)path; + val[9].buffer_length = strLen; + val[9].length = &len[9]; + val[9].is_null = &nullRes[9]; + + val[10].buffer_type = MYSQL_TYPE_LONG; + val[10].buffer = (char*)&song.coverArtId; + val[10].length = &len[10]; + val[10].is_null = &nullRes[10]; + + val[11].buffer_type = MYSQL_TYPE_LONG; + val[11].buffer = (char*)&song.artistId; + val[11].length = &len[11]; + val[11].is_null = &nullRes[11]; + + val[12].buffer_type = MYSQL_TYPE_LONG; + val[12].buffer = (char*)&song.albumId;; + val[12].length = &len[12]; + val[12].is_null = &nullRes[12]; + + val[13].buffer_type = MYSQL_TYPE_LONG; + val[13].buffer = (char*)&song.genreId; + val[13].length = &len[13]; + val[13].is_null = &nullRes[13]; + + val[14].buffer_type = MYSQL_TYPE_LONG; + val[14].buffer = (char*)&song.yearId; + val[14].length = &len[14]; + val[14].is_null = &nullRes[14]; + + status = ::mysql_stmt_bind_result(stmt, val); + ::mysql_stmt_store_result(stmt); + + status = ::mysql_stmt_fetch(stmt); + + song.title = title; + song.album = album; + song.artist = artist; + song.genre = genre; + song.songPath = path; + + } + status = ::mysql_stmt_next_result(stmt); + } + + std::cout << "okay!!!!" << std::endl; + std::cout << "done parsing record" << std::endl; + + return song; +} diff --git a/src/database/yearRepository.cpp b/src/database/yearRepository.cpp index 1d900c6..818f0de 100644 --- a/src/database/yearRepository.cpp +++ b/src/database/yearRepository.cpp @@ -44,6 +44,13 @@ Model::Year Database::yearRepository::retrieveRecord(Model::Year& year, Type::ye return year; } +bool Database::yearRepository::doesYearExist(const Model::Year& year, Type::yearFilter filter) +{ + // TODO: implement this + + return false; +} + void Database::yearRepository::saveRecord(const Model::Year& year) { std::cout << "saving year record" << std::endl; @@ -95,3 +102,11 @@ Model::Year Database::yearRepository::parseRecord(MYSQL_RES *results) return year; } +Model::Year Database::yearRepository::parseRecord(MYSQL_STMT *stmt) +{ + // TODO: imeplement this + + Model::Year year; + + return year; +} diff --git a/src/managers/albumManager.cpp b/src/managers/albumManager.cpp index 872204c..08d1121 100644 --- a/src/managers/albumManager.cpp +++ b/src/managers/albumManager.cpp @@ -26,7 +26,12 @@ Model::Album Manager::albumManager::saveAlbum(const Model::Song& song) album.year = song.year; Database::albumRepository albRepo(m_bConf); - albRepo.saveAlbum(album); + if (!albRepo.doesAlbumExists(album, Type::albumFilter::title)) { + albRepo.saveAlbum(album); + } else { + std::cout << "album record already exists in the database" << std::endl; + } + return album; } diff --git a/src/managers/artistManager.cpp b/src/managers/artistManager.cpp index 41069a2..2cf8857 100644 --- a/src/managers/artistManager.cpp +++ b/src/managers/artistManager.cpp @@ -24,8 +24,11 @@ Model::Artist Manager::artistManager::saveArtist(const Model::Song& song) artist.artist = song.artist; Database::artistRepository artRepo(m_bConf); - artRepo.saveRecord(artist); - + if (!artRepo.doesArtistExist(artist, Type::artistFilter::artist)) { + artRepo.saveRecord(artist); + } else { + std::cout << "artist already exists" << std::endl; + } return artist; } diff --git a/src/managers/coverArtManager.cpp b/src/managers/coverArtManager.cpp index c9f8a62..3f79f64 100644 --- a/src/managers/coverArtManager.cpp +++ b/src/managers/coverArtManager.cpp @@ -20,8 +20,13 @@ Model::Cover Manager::coverArtManager::saveCover(const Model::Song& song, std::s cov.songTitle = song.title; Database::coverArtRepository covRepo(m_bConf); - std::cout << "saving image record to the database" << std::endl; - covRepo.saveRecord(cov); + if (!covRepo.doesCoverArtExist(cov, Type::coverFilter::songTitle)) { + std::cout << "saving image record to the database" << std::endl; + covRepo.saveRecord(cov); + } else { + std::cout << "cover art record already exists" << std::endl; + } + std::cout << "retrieving image record from database" << std::endl; cov = covRepo.retrieveRecord(cov, Type::coverFilter::songTitle); diff --git a/src/managers/genreManager.cpp b/src/managers/genreManager.cpp index 08cbc19..868efd7 100644 --- a/src/managers/genreManager.cpp +++ b/src/managers/genreManager.cpp @@ -24,7 +24,11 @@ Model::Genre Manager::genreManager::saveGenre(const Model::Song& song) genre.category = song.genre; Database::genreRepository gnrRepo(m_bConf); - gnrRepo.saveRecord(genre); + if (!gnrRepo.doesGenreExist(genre, Type::genreFilter::category)) { + gnrRepo.saveRecord(genre); + } else { + std::cout << "genre record already exists" << std::endl; + } return genre; } diff --git a/src/managers/yearManager.cpp b/src/managers/yearManager.cpp index 5aa3f77..f008198 100644 --- a/src/managers/yearManager.cpp +++ b/src/managers/yearManager.cpp @@ -24,7 +24,11 @@ Model::Year Manager::yearManager::saveYear(const Model::Song& song) year.year = song.year; Database::yearRepository yearRepo(m_bConf); - yearRepo.saveRecord(year); + if (!yearRepo.doesYearExist(year, Type::yearFilter::year)) { + yearRepo.saveRecord(year); + } else { + std::cout << "year record already exists in the database" << std::endl; + } return year; }