934 lines
31 KiB
C++
934 lines
31 KiB
C++
#include <algorithm>
|
|
#include <array>
|
|
#include <cctype>
|
|
#include <iomanip>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <codecvt>
|
|
#include <shlobj.h>
|
|
|
|
#else // UNIX
|
|
|
|
#include <pwd.h>
|
|
#include <stdio.h>
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
|
|
#ifndef GUI
|
|
|
|
#include <iostream>
|
|
#include <stdlib.h>
|
|
#include <vector>
|
|
|
|
#endif // GUI
|
|
|
|
#endif // UNIX
|
|
|
|
#include "filesystem.hpp"
|
|
#include "functions.hpp"
|
|
#include "progress.hpp"
|
|
#include "sqlitepp.hpp"
|
|
#include "tv_rename.hpp"
|
|
|
|
#ifdef _WIN32
|
|
|
|
#define cout std::wcout
|
|
#define cerr std::wcerr
|
|
#define cin std::wcin
|
|
|
|
constexpr const char_t *dir_divider = L"\\";
|
|
|
|
#else // UNIX
|
|
|
|
#define TEXT( a ) a
|
|
|
|
#define cout std::cout
|
|
#define cerr std::cerr
|
|
#define cin std::cin
|
|
|
|
constexpr const char_t *dir_divider = "/";
|
|
|
|
#endif // UNIX
|
|
|
|
#ifndef GUI
|
|
|
|
constexpr std::array< const char_t *, 46 > languages{
|
|
TEXT( "en" ), TEXT( "English" ), TEXT( "sv" ), TEXT( "Svenska" ),
|
|
TEXT( "no" ), TEXT( "Norsk" ), TEXT( "da" ), TEXT( "Dansk" ),
|
|
TEXT( "fi" ), TEXT( "Suomeksi" ), TEXT( "nl" ), TEXT( "Nederlands" ),
|
|
TEXT( "de" ), TEXT( "Deutsch" ), TEXT( "it" ), TEXT( "Italiano" ),
|
|
TEXT( "es" ), TEXT( "Español" ), TEXT( "fr" ), TEXT( "Français" ),
|
|
TEXT( "pl" ), TEXT( "Polski" ), TEXT( "hu" ), TEXT( "Magyar" ),
|
|
TEXT( "el" ), TEXT( "Greek" ), TEXT( "tr" ), TEXT( "Turkish" ),
|
|
TEXT( "ru" ), TEXT( "Russian" ), TEXT( "he" ), TEXT( "Hebrew" ),
|
|
TEXT( "ja" ), TEXT( "Japanese" ), TEXT( "pt" ), TEXT( "Portuguese" ),
|
|
TEXT( "zh" ), TEXT( "Chinese" ), TEXT( "cs" ), TEXT( "Czech" ),
|
|
TEXT( "sl" ), TEXT( "Slovenian" ), TEXT( "hr" ), TEXT( "Croatian" ),
|
|
TEXT( "ko" ), TEXT( "Korea" )
|
|
};
|
|
|
|
#endif // not GUI
|
|
|
|
#ifdef _WIN32
|
|
|
|
// functions to convert between string and wstring
|
|
|
|
std::string wstring_to_utf8( const std::wstring &wstring ) {
|
|
std::wstring_convert< std::codecvt_utf8_utf16< wchar_t > > wconv;
|
|
return wconv.to_bytes( wstring );
|
|
}
|
|
|
|
std::wstring utf8_to_wstring( const std::string &utf8 ) {
|
|
std::wstring_convert< std::codecvt_utf8_utf16< wchar_t > > wconv;
|
|
return wconv.from_bytes( utf8 );
|
|
}
|
|
|
|
#endif // _WIN32
|
|
|
|
// encode url so it's valid even with UTF-8 characters
|
|
string encodeUrl( const string &url ) {
|
|
// stolen from here -
|
|
// https://stackoverflow.com/questions/154536/encode-decode-urls-in-c
|
|
#ifdef _WIN32
|
|
std::wstringstream encoded;
|
|
auto url_c = wstring_to_utf8( url );
|
|
#else
|
|
std::stringstream encoded;
|
|
const auto &url_c = url;
|
|
#endif
|
|
encoded.fill( '0' );
|
|
encoded << std::hex;
|
|
for ( const auto &x : url_c ) {
|
|
if ( isalnum( static_cast< unsigned char >( x ) ) || x == '-' ||
|
|
x == '_' || x == '.' || x == '~' || x == '+' ) {
|
|
encoded << x;
|
|
continue;
|
|
}
|
|
encoded << std::uppercase << '%' << std::setw( 2 );
|
|
encoded << int( static_cast< unsigned char >( x ) ) << std::nouppercase;
|
|
}
|
|
return encoded.str();
|
|
}
|
|
|
|
// return true if filename has specified season
|
|
// set ep_pos to position where episode number starts
|
|
bool searchSpecificSeason( const char_t *const path, size_t &ep_pos,
|
|
const string &number ) {
|
|
size_t cur_pos{};
|
|
#ifdef _WIN32
|
|
auto ncompare = wcsncmp;
|
|
#else
|
|
auto ncompare = strncmp;
|
|
#endif
|
|
// search for S[0-9]+E[0-9]+
|
|
while ( path[cur_pos] != '\0' ) {
|
|
if ( ( path[cur_pos] == 's' || path[cur_pos] == 'S' ) &&
|
|
iswdigit( path[cur_pos + 1] ) ) {
|
|
cur_pos++;
|
|
while ( path[cur_pos] == '0' )
|
|
cur_pos++;
|
|
// if season number is 0, move back because previous loop skipped it
|
|
if ( number == TEXT( "0" ) )
|
|
cur_pos--;
|
|
// make sure season's number is the same as provided in argument
|
|
// `number`
|
|
if ( !ncompare( path + cur_pos, number.c_str(), number.size() ) ) {
|
|
cur_pos += number.size();
|
|
if ( ( path[cur_pos] == 'e' || path[cur_pos] == 'E' ) &&
|
|
iswdigit( path[cur_pos + 1] ) ) {
|
|
ep_pos = cur_pos + 1;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
cur_pos++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool searchSpecificSeason( const char_t *const p, const string &number ) {
|
|
size_t tmp;
|
|
return searchSpecificSeason( p, tmp, number );
|
|
}
|
|
|
|
// return true if file contains S[0-9]+E[0-9]+ nad set
|
|
// season_pos to start of season number
|
|
bool searchSeason( const char_t *const path, size_t &season_pos ) {
|
|
size_t cur_pos{};
|
|
while ( path[cur_pos] != '\0' ) {
|
|
if ( ( path[cur_pos] == 's' || path[cur_pos] == 'S' ) &&
|
|
iswdigit( path[cur_pos + 1] ) ) {
|
|
cur_pos++;
|
|
season_pos = cur_pos; // after ++ because we want the first pos to
|
|
// point to season's number
|
|
while ( iswdigit( path[cur_pos] ) )
|
|
cur_pos++;
|
|
if ( ( path[cur_pos] == 'e' || path[cur_pos] == 'E' ) &&
|
|
iswdigit( path[cur_pos + 1] ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
cur_pos++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool searchSeason( const char_t *const path ) {
|
|
size_t tmp{};
|
|
return searchSeason( path, tmp );
|
|
}
|
|
|
|
void iterateFS( std::map< int, std::set< string > > &seasons,
|
|
const string &path ) {
|
|
// season_pos - position of first digit of the season
|
|
size_t season_pos{ string::npos };
|
|
for ( const auto p : FSLib::Directory( path ) ) {
|
|
// if p is directory, iterate through it
|
|
if ( FSLib::isDirectory( path + dir_divider + p ) ) {
|
|
iterateFS( seasons, path + dir_divider + p );
|
|
continue;
|
|
}
|
|
|
|
// if file is a correct format, add it to file list
|
|
// for its season
|
|
if ( searchSeason( p, season_pos ) )
|
|
seasons[std::stoi( p + season_pos )].insert( path + dir_divider +
|
|
p );
|
|
}
|
|
}
|
|
|
|
#ifndef GUI
|
|
// following functions are only needed for CLI version
|
|
|
|
// find all files for provided season in `path` and store it in `files`
|
|
void findSeason( std::set< string > &files, int season, const string &path ) {
|
|
#ifdef _WIN32
|
|
auto number = std::to_wstring( season );
|
|
#else
|
|
auto number = std::to_string( season );
|
|
#endif
|
|
|
|
for ( const auto p : FSLib::Directory( path ) ) {
|
|
// if p is directory, iterate through it
|
|
if ( FSLib::isDirectory( path + dir_divider + p ) ) {
|
|
findSeason( files, season, path + dir_divider + p );
|
|
continue;
|
|
}
|
|
|
|
if ( searchSpecificSeason( p, number ) )
|
|
files.insert( path + dir_divider + p );
|
|
}
|
|
}
|
|
|
|
// find all files that comply with the S[0-9]+E[0-9]+ pattern
|
|
// and their season is in season_numbers and store tem in `seasons`
|
|
void findSeasons( std::map< int, std::set< string > > &seasons,
|
|
const string &path, const std::set< int > &season_numbers ) {
|
|
// season_pos - position of first digit of the season
|
|
size_t season_pos{ string::npos };
|
|
for ( const auto p : FSLib::Directory( path ) ) {
|
|
// if p is directory, iterate through it
|
|
if ( FSLib::isDirectory( path + dir_divider + p ) ) {
|
|
findSeasons( seasons, path + dir_divider + p, season_numbers );
|
|
continue;
|
|
}
|
|
|
|
if ( searchSeason( p, season_pos ) ) {
|
|
auto num = std::stoi( p + season_pos );
|
|
if ( season_numbers.find( num ) != season_numbers.end() )
|
|
seasons[num].insert( path + dir_divider + p );
|
|
}
|
|
}
|
|
}
|
|
|
|
string getDefUrl( string &show, const string &language, Curl &c ) {
|
|
std::replace( show.begin(), show.end(), ' ', '+' );
|
|
|
|
string base_url = TEXT( "https://www.thetvdb.com" );
|
|
|
|
#ifdef _WIN32
|
|
string source_code = utf8_to_wstring(
|
|
c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) +
|
|
encodeUrl( show ) + TEXT( "&l=" ) + language ) );
|
|
#else
|
|
string source_code =
|
|
c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) +
|
|
encodeUrl( show ) + TEXT( "&l=" ) + language );
|
|
#endif
|
|
|
|
size_t order{}, pos{};
|
|
std::vector< std::pair< string, string > > urls;
|
|
|
|
// find all possible shows
|
|
while ( true ) {
|
|
pos = source_code.find( TEXT( "/ser" ), pos );
|
|
if ( pos != string::npos ) {
|
|
auto end = source_code.find( TEXT( ">" ), pos );
|
|
end--;
|
|
auto end2 = source_code.find( TEXT( "<" ), end + 2 );
|
|
// store shows in urls, first is name, second is url
|
|
urls.emplace_back( source_code.substr( end + 2, end2 - end - 2 ),
|
|
source_code.substr( pos, end - pos ) );
|
|
cout << ++order << ". " << urls.back().first << std::endl;
|
|
pos = end2;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
cout << "Which TV Show is the right one? ";
|
|
cin >> pos;
|
|
cin.clear();
|
|
cin.ignore( 1, '\n' );
|
|
show = urls[pos - 1].first;
|
|
return base_url + urls[pos - 1].second;
|
|
}
|
|
|
|
void printHelp() {
|
|
cout << "Usage:" << std::endl;
|
|
cout << " tv_rename [options] [path]" << std::endl << std::endl;
|
|
cout << " -h, --help show this help message and exit"
|
|
<< std::endl
|
|
<< std::endl;
|
|
cout << " path can be either a file or a directory, if it's a directory"
|
|
<< std::endl;
|
|
cout << " all files in it and its subdirectories will be renamed"
|
|
<< std::endl
|
|
<< std::endl;
|
|
cout << "OPTIONS" << std::endl;
|
|
cout << " -s, --show <string> TV show from which you want the";
|
|
cout << " episode names" << std::endl;
|
|
cout << " -n, --season <numbers> Season number/s (if multiple seasons,"
|
|
<< std::endl;
|
|
cout << " must be seperated by one space)"
|
|
<< " or 'all'" << std::endl;
|
|
cout << " for all seasons in selected directory"
|
|
<< std::endl;
|
|
cout << " --name-pattern <string> Pattern to which change the file name."
|
|
<< std::endl;
|
|
cout << " Possible sequences are:" << std::endl;
|
|
cout << " %filename - original filename"
|
|
<< std::endl;
|
|
cout << " (without filetype"
|
|
<< " extension)" << std::endl;
|
|
cout << " %show - show name from thetvdb"
|
|
<< std::endl;
|
|
cout << " %epname - episode name from thetvdb"
|
|
<< std::endl;
|
|
cout << " %season - season number"
|
|
<< std::endl;
|
|
cout << " it's possible to specify leading"
|
|
<< " 0 like this:" << std::endl;
|
|
cout << " %2season (number means how many"
|
|
<< " zeros)" << std::endl;
|
|
cout << " %episode - episode number"
|
|
<< std::endl;
|
|
cout << " it's possible to specify leading"
|
|
<< " 0 like this:" << std::endl;
|
|
cout << " %2episode (number means how many"
|
|
<< " zeros)" << std::endl;
|
|
cout << " Default pattern is \"$filename -"
|
|
<< " $epname\"" << std::endl;
|
|
cout << " -c, --correct-path This is the correct path,"
|
|
<< " stop asking me!" << std::endl;
|
|
cout << " -t, --trust Don't ask whether the names are correct"
|
|
<< std::endl;
|
|
cout << " -x, --linux Don't replace characters characters"
|
|
<< " that are" << std::endl;
|
|
cout << " illegal in Windows" << std::endl;
|
|
cout << " -l, --lang <string> Select which language the episode"
|
|
<< " names shoud be in" << std::endl;
|
|
cout << " --print-langs Pring available languages" << std::endl;
|
|
cout << std::endl;
|
|
cout << "DATABASE OPTIONS" << std::endl;
|
|
cout << " --db-add Add path to the database"
|
|
<< std::endl;
|
|
cout << " --db-refresh Refresh episode names for all paths"
|
|
<< " in the database" << std::endl;
|
|
cout << " --db-update Check all paths in the database,"
|
|
<< std::endl;
|
|
cout << " if they contain new files,"
|
|
<< " rename them" << std::endl;
|
|
cout << " --db-name-pattern <string> Change name pattern used for files"
|
|
<< std::endl
|
|
<< " managed by database" << std::endl;
|
|
cout << " --db-clean Remove deleted files from the"
|
|
<< " database" << std::endl;
|
|
cout << " --db-remove Remove path from the database"
|
|
<< std::endl;
|
|
}
|
|
|
|
// parse command line argument --seasons (e.g. '1 2 3 4 5')
|
|
// and store season numbers as integers in seasons_num
|
|
void parseSeasonNumbers( std::set< int > &seasons_num,
|
|
const char_t *argument ) {
|
|
size_t pos{ 0 };
|
|
|
|
while ( !iswdigit( argument[pos] ) && argument[pos] != '\0' )
|
|
pos++;
|
|
|
|
if ( argument[pos] == '\0' ) {
|
|
seasons_num.clear();
|
|
return;
|
|
}
|
|
|
|
int temp;
|
|
|
|
#ifdef _WIN32
|
|
std::wstringstream iss( argument + pos );
|
|
#else
|
|
std::stringstream iss( argument + pos );
|
|
#endif
|
|
|
|
while ( iss >> temp ) {
|
|
seasons_num.insert( temp );
|
|
}
|
|
}
|
|
|
|
// print possible language codes and their corresponding language
|
|
void printLangs() {
|
|
for ( size_t i = 0; i < languages.size(); i += 2 ) {
|
|
cout << languages[i] << " - " << languages[i + 1] << std::endl;
|
|
}
|
|
}
|
|
|
|
// make sure language is a valide language code
|
|
bool findLanguage( const char_t *language ) {
|
|
for ( size_t i = 0; i < languages.size(); i += 2 ) {
|
|
#ifdef _WIN32
|
|
if ( !wcscmp( language, languages[i] ) )
|
|
#else
|
|
if ( !strcmp( language, languages[i] ) )
|
|
#endif
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#else // GUI
|
|
// functions that are needed for GUI but not for CLI
|
|
|
|
// get possible shows for search query in `show`
|
|
std::vector< std::pair< string, string > >
|
|
getPossibleShows( string show, const string &language, Curl &c ) {
|
|
// encode show name so it can be resolved as url
|
|
std::replace( show.begin(), show.end(), ' ', '+' );
|
|
show = encodeUrl( show );
|
|
#ifdef _WIN32
|
|
auto source_code = utf8_to_wstring(
|
|
c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) + show +
|
|
TEXT( "&l=" ) + language ) );
|
|
#else
|
|
auto source_code = c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) +
|
|
show + TEXT( "&l=" ) + language );
|
|
#endif
|
|
size_t pos{};
|
|
std::vector< std::pair< string, string > > urls;
|
|
while ( true ) {
|
|
pos = source_code.find( TEXT( "/ser" ), pos );
|
|
if ( pos != string::npos ) {
|
|
auto end = source_code.find( TEXT( ">" ), pos );
|
|
auto end2 = source_code.find( TEXT( "<" ), end + 1 );
|
|
end--;
|
|
urls.emplace_back(
|
|
source_code.substr( end + 2, end2 - ( end + 2 ) ),
|
|
source_code.substr( pos, end - pos ) );
|
|
pos = end + 2;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return urls;
|
|
}
|
|
|
|
#endif // ndef GUI
|
|
|
|
#ifndef _WIN32
|
|
|
|
// get user's home directory
|
|
string userHome() {
|
|
uid_t user_uid; // current user's uid
|
|
{
|
|
uid_t eid;
|
|
uid_t sid;
|
|
getresuid( &user_uid, &eid, &sid ); // don't need eid and sid
|
|
}
|
|
// password file entry
|
|
auto user_passwd = getpwuid( user_uid );
|
|
|
|
if ( user_passwd == nullptr )
|
|
throw std::runtime_error(
|
|
"User with uid " + std::to_string( user_uid ) + " doesn't exist!" );
|
|
return user_passwd->pw_dir;
|
|
}
|
|
|
|
#else // UNIX
|
|
|
|
// get user's %APPDATA% folder location
|
|
string userHome() {
|
|
wchar_t *dir = static_cast< wchar_t * >( CoTaskMemAlloc( MAX_PATH ) );
|
|
auto res = SHGetKnownFolderPath( FOLDERID_RoamingAppData, 0, NULL, &dir );
|
|
if ( res == S_OK ) {
|
|
string dir_s = dir;
|
|
CoTaskMemFree( dir );
|
|
return dir_s;
|
|
}
|
|
return L"";
|
|
}
|
|
|
|
#endif // UNIX
|
|
|
|
// create file name based on given pattern
|
|
string compilePattern( const string &pattern, int season, int episode,
|
|
const string &filename, const string &episodeName,
|
|
const string &showName ) {
|
|
string output;
|
|
|
|
#ifdef _WIN32
|
|
auto season_num = std::to_wstring( season );
|
|
auto ep_num = std::to_wstring( episode );
|
|
#else
|
|
auto season_num = std::to_string( season );
|
|
auto ep_num = std::to_string( episode );
|
|
#endif
|
|
|
|
for ( size_t i = 0; i < pattern.size(); i++ ) {
|
|
// if current character is % check if a pattern follows, otherwise
|
|
// put %
|
|
if ( pattern[i] == '%' ) {
|
|
// check for numbers right after % indicating size of zero
|
|
// padding for numbers
|
|
auto pos = pattern.find_first_not_of( TEXT( "0123456789" ), i + 1 );
|
|
|
|
if ( pattern.find( TEXT( "season" ), pos - 1 ) == pos &&
|
|
pos != i + 1 ) {
|
|
// if season is AFTER numbers, put season number padded
|
|
// with zeros
|
|
|
|
// get number of leading zeros
|
|
auto leading = std::stoi( pattern.c_str() + i + 1 );
|
|
// move i to the last char of 'season'
|
|
i = pos + 5;
|
|
|
|
// get number of zeros to be put before the season number
|
|
leading -= season_num.size();
|
|
if ( leading < 0 )
|
|
leading = 0;
|
|
|
|
// add padded season to output
|
|
output += string( leading, '0' ) + season_num;
|
|
} else if ( pattern.find( TEXT( "season" ), i ) == i + 1 ) {
|
|
// if season isn't after numbers, just put season number to
|
|
// output
|
|
i += 6;
|
|
output += season_num;
|
|
} else if ( pattern.find( TEXT( "episode" ), pos - 1 ) == pos &&
|
|
pos != i + 1 ) {
|
|
// same principle as with season after number
|
|
auto leading = std::stoi( pattern.c_str() + i + 1 );
|
|
|
|
i = pos + 6;
|
|
|
|
leading -= ep_num.size();
|
|
if ( leading < 0 )
|
|
leading = 0;
|
|
|
|
output += string( leading, '0' ) + ep_num;
|
|
} else if ( pattern.find( TEXT( "episode" ), i ) == i + 1 ) {
|
|
// if episode isn't after number, just put the episode number to
|
|
// output
|
|
i += 7;
|
|
output += ep_num;
|
|
} else if ( pattern.find( TEXT( "epname" ), i ) == i + 1 ) {
|
|
// episode name from thetvdb
|
|
i += 6;
|
|
output += episodeName;
|
|
} else if ( pattern.find( TEXT( "show" ), i ) == i + 1 ) {
|
|
// show name from thetvdb
|
|
i += 4;
|
|
output += showName;
|
|
} else if ( pattern.find( TEXT( "filename" ), i ) == i + 1 ) {
|
|
// original file name
|
|
i += 8;
|
|
output += filename;
|
|
} else {
|
|
// output % if no escape sequence was found
|
|
output += '%';
|
|
}
|
|
} else if ( pattern[i] == '\\' ) {
|
|
// possibility to escape %
|
|
if ( pattern[i + 1] == '%' ) {
|
|
output += '%';
|
|
i++;
|
|
} else if ( pattern[i + 1] == '\\' ) {
|
|
output += '\\';
|
|
i++;
|
|
} else {
|
|
output += '\\';
|
|
}
|
|
} else {
|
|
// if char isn't % or / just add it to the output string
|
|
output += pattern[i];
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
#ifndef GUI
|
|
|
|
#ifdef WIN32
|
|
|
|
std::wstring getDBName() {
|
|
return userHome() + L"\\tv_rename\\database.db";
|
|
}
|
|
|
|
#else
|
|
|
|
std::string getDBName() {
|
|
return userHome() + "/.cache/tv_rename.db";
|
|
}
|
|
|
|
#endif
|
|
|
|
string sanitize( const string &str ) {
|
|
string ret;
|
|
size_t prev_pos{};
|
|
size_t pos = str.find_first_of( '\'' );
|
|
while ( pos != string::npos ) {
|
|
ret += str.substr( prev_pos, pos - prev_pos );
|
|
prev_pos = pos + 1;
|
|
pos = str.find_first_of( '\'', prev_pos );
|
|
ret += TEXT( "\'\'" );
|
|
}
|
|
ret += str.substr( prev_pos, pos );
|
|
return ret;
|
|
}
|
|
|
|
void prepareDB() {
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Couldn't create database, make sure you have"
|
|
<< " write permission for " << getDBName() << std::endl;
|
|
throw e;
|
|
}
|
|
db.exec( "CREATE TABLE IF NOT EXISTS SHOWS (ID INTEGER NOT NULL "
|
|
"PRIMARY KEY AUTOINCREMENT, URL TEXT NOT NULL, SHOW TEXT NOT NULL,"
|
|
"PATH TEXT NOT NULL UNIQUE, LANGUAGE TEXT NOT NULL);" );
|
|
db.exec( "CREATE TABLE IF NOT EXISTS EPISODES (SHOWID INTEGER NOT NULL,"
|
|
"PATH TEXT NOT NULL UNIQUE, FOREIGN KEY(SHOWID) "
|
|
"REFERENCES SHOWS(ID));" );
|
|
cout << "Insert name pattern for database:" << std::endl;
|
|
string pattern;
|
|
std::getline( cin, pattern );
|
|
db.exec( TEXT( "INSERT INTO SHOWS ( URL, SHOW, PATH, LANGUAGE ) "
|
|
"VALUES ( 'pattern', 'pattern', '" ) +
|
|
sanitize( pattern ) + TEXT( "', 'pattern' );" ) );
|
|
}
|
|
|
|
void addToDB( string &show, const string &path, const string &language,
|
|
bool linux, Curl &c ) {
|
|
if ( !FSLib::exists( getDBName() ) )
|
|
prepareDB();
|
|
SQLite::Database db{};
|
|
auto absolute = FSLib::canonical( path );
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
auto url = getDefUrl( show, language, c );
|
|
string show_id{};
|
|
string pattern{};
|
|
db.exec( TEXT( "INSERT OR IGNORE INTO SHOWS ( URL, SHOW, PATH, LANGUAGE ) "
|
|
"VALUES ( '" ) +
|
|
sanitize( url ) + TEXT( "', '" ) + sanitize( show ) +
|
|
TEXT( "', '" ) + sanitize( absolute ) + TEXT( "', '" ) +
|
|
sanitize( language ) + TEXT( "' );" ) );
|
|
show_id = std::to_string( db.lastRowID() );
|
|
db.exec( TEXT( "SELECT PATH FROM SHOWS WHERE URL == 'pattern';" ),
|
|
pattern );
|
|
|
|
std::map< int, std::set< string > > seasons;
|
|
// get all seasons and episodes
|
|
iterateFS( seasons, absolute );
|
|
auto size = seasons.size();
|
|
size_t i = 0;
|
|
cout << "Renaming" << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
ProgressBar::print( 0 );
|
|
for ( const auto &x : seasons ) {
|
|
singleSeason( absolute, show, x.first, url, language, pattern, linux,
|
|
true, c, &x.second, false );
|
|
i++;
|
|
ProgressBar::print( ( i * 100 ) / size );
|
|
}
|
|
cout << std::endl;
|
|
seasons.clear();
|
|
iterateFS( seasons, absolute );
|
|
size = seasons.size();
|
|
i = 0;
|
|
|
|
cout << "Adding to database" << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
ProgressBar::print( 0 );
|
|
for ( auto &season : seasons ) {
|
|
for ( auto &episode : season.second ) {
|
|
db.exec( TEXT( "INSERT OR IGNORE INTO EPISODES ( SHOWID, PATH ) "
|
|
"VALUES ( " ) +
|
|
show_id + TEXT( ", '" ) + sanitize( episode ) +
|
|
TEXT( "' );" ) );
|
|
}
|
|
i++;
|
|
ProgressBar::print( ( i * 100 ) / size );
|
|
}
|
|
cout << std::endl;
|
|
}
|
|
|
|
void cleanUpLine() {
|
|
#ifdef WIN32
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
int width;
|
|
|
|
GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &csbi );
|
|
width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
|
|
|
|
static HANDLE h = NULL;
|
|
if ( !h )
|
|
h = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
CONSOLE_SCREEN_BUFFER_INFO info;
|
|
GetConsoleScreenBufferInfo( h, &info );
|
|
COORD c = { 0, info.dwCursorPosition.Y - 3 };
|
|
SetConsoleCursorPosition( h, c );
|
|
#else
|
|
struct winsize w;
|
|
ioctl( 0, TIOCGWINSZ, &w );
|
|
|
|
auto width = w.ws_col;
|
|
|
|
cout << "\x1b[2A";
|
|
#endif
|
|
cout << string( width, ' ' ) << std::endl << std::endl;
|
|
#ifdef WIN32
|
|
SetConsoleCursorPosition( h, c );
|
|
#else
|
|
cout << "\x1b[2A";
|
|
#endif
|
|
}
|
|
|
|
void refreshDB( bool linux, Curl &c ) {
|
|
std::vector< std::unordered_map< string, string > > shows;
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
db.exec( "DELETE FROM EPISODES;" );
|
|
db.exec( TEXT( "SELECT ID, URL, SHOW, PATH, LANGUAGE FROM SHOWS WHERE URL "
|
|
"!= 'pattern';" ),
|
|
shows );
|
|
|
|
string pattern{};
|
|
db.exec( TEXT( "SELECT PATH FROM SHOWS WHERE URL == 'pattern';" ),
|
|
pattern );
|
|
|
|
cout << "Refreshing database" << std::endl << std::endl << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
for ( auto &show : shows ) {
|
|
if ( FSLib::exists( show[TEXT( "PATH" )] ) ) {
|
|
cleanUpLine();
|
|
cout << "Refreshing " << show[TEXT( "SHOW" )] << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
ProgressBar::print( 0 );
|
|
std::map< int, std::set< string > > seasons;
|
|
// get all season number from this directory and subdirectories
|
|
iterateFS( seasons, show[TEXT( "PATH" )] );
|
|
auto size = seasons.size();
|
|
size_t i{};
|
|
for ( const auto &x : seasons ) {
|
|
singleSeason( show[TEXT( "PATH" )], show[TEXT( "SHOW" )],
|
|
x.first, show[TEXT( "URL" )],
|
|
show[TEXT( "LANGUAGE" )], pattern, linux, true, c,
|
|
&x.second, false );
|
|
i++;
|
|
ProgressBar::print( ( i * 100 ) / size );
|
|
}
|
|
ProgressBar::print( 100 );
|
|
cout << std::endl;
|
|
seasons.clear();
|
|
iterateFS( seasons, show[TEXT( "PATH" )] );
|
|
for ( auto &season : seasons ) {
|
|
for ( auto &episode : season.second ) {
|
|
db.exec( TEXT( "INSERT INTO EPISODES ( SHOWID, PATH ) "
|
|
"VALUES ( " ) +
|
|
show[TEXT( "ID" )] + TEXT( ", '" ) +
|
|
sanitize( episode ) + TEXT( "' );" ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateDB( bool linux, Curl &c ) {
|
|
std::vector< std::unordered_map< string, string > > shows;
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
db.exec( TEXT( "SELECT ID, URL, SHOW, PATH, LANGUAGE FROM SHOWS WHERE URL "
|
|
"!= 'pattern';" ),
|
|
shows );
|
|
|
|
string pattern{};
|
|
db.exec( TEXT( "SELECT PATH FROM SHOWS WHERE URL == 'pattern';" ),
|
|
pattern );
|
|
|
|
cout << "Updating database" << std::endl << std::endl << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
for ( auto &show : shows ) {
|
|
if ( !FSLib::exists( show[TEXT( "PATH" )] ) ) {
|
|
continue;
|
|
}
|
|
cleanUpLine();
|
|
cout << "Updating " << show[TEXT( "SHOW" )] << std::endl;
|
|
#ifdef WIN32
|
|
cout << std::endl;
|
|
#endif
|
|
std::unordered_set< string > episodes;
|
|
db.exec( TEXT( "SELECT PATH FROM EPISODES WHERE SHOWID == " ) +
|
|
show[TEXT( "ID" )] + TEXT( ";" ),
|
|
episodes );
|
|
std::map< int, std::set< string > > seasons;
|
|
std::map< int, std::set< string > > new_eps;
|
|
// get all season number from this directory and subdirectories
|
|
iterateFS( seasons, show[TEXT( "PATH" )] );
|
|
for ( const auto &x : seasons ) {
|
|
for ( const auto &episode : x.second ) {
|
|
if ( episodes.find( episode ) == episodes.end() ) {
|
|
new_eps[x.first].insert( episode );
|
|
}
|
|
}
|
|
}
|
|
ProgressBar::print( 0 );
|
|
if ( !new_eps.empty() ) {
|
|
auto size = new_eps.size();
|
|
size_t i{};
|
|
for ( const auto &x : new_eps ) {
|
|
singleSeason( show[TEXT( "PATH" )], show[TEXT( "SHOW" )],
|
|
x.first, show[TEXT( "URL" )],
|
|
show[TEXT( "LANGUAGE" )], pattern, linux, true, c,
|
|
&x.second, false );
|
|
i++;
|
|
ProgressBar::print( ( i * 100 ) / size );
|
|
}
|
|
seasons.clear();
|
|
iterateFS( seasons, show[TEXT( "PATH" )] );
|
|
for ( auto &season : seasons ) {
|
|
for ( auto &episode : season.second ) {
|
|
db.exec( TEXT( "INSERT OR IGNORE INTO EPISODES ( SHOWID, "
|
|
"PATH ) VALUES ( " ) +
|
|
show[TEXT( "ID" )] + TEXT( ", '" ) +
|
|
sanitize( episode ) + TEXT( "' );" ) );
|
|
}
|
|
}
|
|
}
|
|
ProgressBar::print( 100 );
|
|
cout << std::endl;
|
|
}
|
|
}
|
|
|
|
void changeDBPattern( const string &pattern ) {
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
db.exec( TEXT( "UPDATE SHOWS SET PATH = '" ) + pattern +
|
|
TEXT( "' WHERE URL == 'pattern';" ) );
|
|
}
|
|
|
|
void cleanDB() {
|
|
std::vector< std::unordered_map< string, string > > shows;
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
db.exec( TEXT( "SELECT ID, URL, SHOW, PATH, LANGUAGE FROM SHOWS WHERE URL "
|
|
"!= 'pattern';" ),
|
|
shows );
|
|
|
|
string pattern{};
|
|
db.exec( TEXT( "SELECT PATH FROM SHOWS WHERE URL == 'pattern';" ),
|
|
pattern );
|
|
|
|
for ( auto &show : shows ) {
|
|
if ( !FSLib::exists( show[TEXT( "PATH" )] ) ) {
|
|
continue;
|
|
}
|
|
std::unordered_set< string > episodes;
|
|
db.exec( TEXT( "SELECT PATH FROM EPISODES WHERE SHOWID == " ) +
|
|
show[TEXT( "ID" )] + TEXT( ";" ),
|
|
episodes );
|
|
for ( const auto &episode : episodes ) {
|
|
if ( !FSLib::exists( episode ) ) {
|
|
db.exec( TEXT( "DELETE FROM EPISODES WHERE PATH == '" ) +
|
|
sanitize( episode ) + TEXT( "';" ) );
|
|
}
|
|
}
|
|
episodes.clear();
|
|
db.exec( TEXT( "SELECT PATH FROM EPISODES WHERE SHOWID == " ) +
|
|
show[TEXT( "ID" )] + TEXT( ";" ),
|
|
episodes );
|
|
if ( episodes.empty() ) {
|
|
db.exec( TEXT( "DELETE FROM SHOWS WHERE ID == " ) +
|
|
show[TEXT( "ID" )] + TEXT( ";" ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void removeFromDB( const string &path ) {
|
|
SQLite::Database db{};
|
|
try {
|
|
db.open( getDBName(), SQLite::OPEN_READWRITE );
|
|
} catch ( std::exception &e ) {
|
|
cerr << "Can't open database, make sure it exists" << std::endl;
|
|
throw e;
|
|
}
|
|
string show_id{};
|
|
db.exec( TEXT( "SELECT ID FROM SHOWS WHERE PATH == '" ) + sanitize( path ) +
|
|
TEXT( "';" ),
|
|
show_id );
|
|
db.exec( TEXT( "DELETE FROM EPISODES WHERE SHOWID == " ) + show_id +
|
|
TEXT( ";" ) );
|
|
db.exec( TEXT( "DELETE FROM SHOWS WHERE ID == " ) + show_id + TEXT( ";" ) );
|
|
}
|
|
|
|
#endif
|