tv_rename/functions.cpp

558 lines
18 KiB
C++
Raw Normal View History

2019-01-07 22:24:28 +00:00
#include <algorithm>
2019-02-04 16:39:48 +00:00
#include <array>
#include <cctype>
2019-01-21 19:30:14 +00:00
#include <iomanip>
2019-01-23 19:46:03 +00:00
#include <sstream>
2019-02-04 16:39:48 +00:00
#include <vector>
2019-01-23 19:46:03 +00:00
2019-02-04 16:39:48 +00:00
#ifdef _WIN32
2019-01-23 19:46:03 +00:00
2019-02-04 16:39:48 +00:00
#include <codecvt>
2018-09-22 22:50:42 +00:00
#include <iostream>
2019-02-04 16:39:48 +00:00
#include <shlobj.h>
#else // UNIX
2019-02-04 16:39:48 +00:00
#ifndef GUI
#include <iostream>
2018-09-22 22:50:42 +00:00
#include <stdlib.h>
2019-01-07 22:24:28 +00:00
#include <vector>
2018-09-22 22:50:42 +00:00
#else // UNIX and GUI
2019-01-23 19:46:03 +00:00
#include <pwd.h>
2019-02-04 16:39:48 +00:00
#include <unistd.h>
2019-01-23 19:46:03 +00:00
2019-02-04 16:39:48 +00:00
#endif // GUI
#endif // UNIX
2019-02-04 16:39:48 +00:00
#include "filesystem.hpp"
#include "functions.hpp"
#ifdef _WIN32
#define cout std::wcout
#define cerr std::wcerr
#define cin std::wcin
constexpr const char_t *dir_divider = L"\\";
#else // UNIX
2019-02-04 16:39:48 +00:00
#define TEXT( a ) a
#define cout std::cout
#define cerr std::cerr
#define cin std::cin
constexpr const char_t *dir_divider = "/";
#endif // UNIX
2019-01-23 19:46:03 +00:00
#ifndef GUI
2019-02-04 16:39:48 +00:00
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" )
2019-01-19 12:40:10 +00:00
};
2018-09-22 22:50:42 +00:00
2019-02-04 16:39:48 +00:00
#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
2019-01-23 19:46:03 +00:00
// encode url so it's valid even with UTF-8 characters
2019-02-04 16:39:48 +00:00
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' );
2019-01-23 19:46:03 +00:00
encoded << std::hex;
2019-02-04 16:39:48 +00:00
for ( const auto &x : url_c ) {
if ( isalnum( static_cast< unsigned char >( x ) ) || x == '-' ||
x == '_' || x == '.' || x == '~' ) {
2019-01-23 19:46:03 +00:00
encoded << x;
continue;
}
2019-02-04 16:39:48 +00:00
encoded << std::uppercase << '%' << std::setw( 2 );
encoded << int( static_cast< unsigned char >( x ) ) << std::nouppercase;
2019-01-23 19:46:03 +00:00
}
return encoded.str();
}
// return true if filename has specified season
// set ep_pos to position where episode number starts
2019-02-04 16:39:48 +00:00
bool searchSpecificSeason( const char_t *const path, size_t &ep_pos,
const string &number ) {
size_t cur_pos{};
2019-02-07 18:36:36 +00:00
#ifdef _WIN32
auto ncompare = wcsncmp;
#else
auto ncompare = strncmp;
#endif
2019-02-04 16:39:48 +00:00
// 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++;
2019-02-04 16:39:48 +00:00
while ( path[cur_pos] == '0' )
cur_pos++;
2019-02-07 18:36:36 +00:00
// if season number is 0, move back because previous while skipped it
if( number == TEXT("0") )
cur_pos--;
2019-02-04 16:39:48 +00:00
// make sure season's number is the same as provided in argument
// `number`
2019-02-07 18:36:36 +00:00
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++;
}
2019-02-04 16:39:48 +00:00
return false;
}
2019-02-04 16:39:48 +00:00
bool searchSpecificSeason( const char_t *const p, const string &number ) {
size_t tmp;
2019-02-04 16:39:48 +00:00
return searchSpecificSeason( p, tmp, number );
}
2019-02-04 16:39:48 +00:00
// 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{};
2019-02-04 16:39:48 +00:00
while ( path[cur_pos] != '\0' ) {
if ( ( path[cur_pos] == 's' || path[cur_pos] == 'S' ) &&
iswdigit( path[cur_pos + 1] ) ) {
cur_pos++;
2019-02-04 16:39:48 +00:00
season_pos = cur_pos; // after ++ because we want the first pos to
// point to season's number
while ( iswdigit( path[cur_pos] ) )
cur_pos++;
2019-02-04 16:39:48 +00:00
if ( ( path[cur_pos] == 'e' || path[cur_pos] == 'E' ) &&
iswdigit( path[cur_pos + 1] ) ) {
return true;
}
}
cur_pos++;
}
2019-02-04 16:39:48 +00:00
return false;
}
2019-02-04 16:39:48 +00:00
bool searchSeason( const char_t *const path ) {
size_t tmp{};
2019-02-04 16:39:48 +00:00
return searchSeason( path, tmp );
}
2019-02-04 16:39:48 +00:00
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 );
2019-01-23 19:46:03 +00:00
continue;
}
2019-02-04 16:39:48 +00:00
// 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 );
2019-01-23 19:46:03 +00:00
}
}
#ifndef GUI
2019-02-04 16:39:48 +00:00
// following functions are only needed for CLI version
2019-01-23 19:46:03 +00:00
2019-02-04 16:39:48 +00:00
// 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
2019-02-04 16:39:48 +00:00
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 );
2019-01-04 19:19:08 +00:00
continue;
}
2019-01-03 18:01:43 +00:00
2019-02-04 16:39:48 +00:00
if ( searchSpecificSeason( p, number ) )
files.insert( path + dir_divider + p );
2019-01-04 19:19:08 +00:00
}
2018-09-22 22:50:42 +00:00
}
2019-02-04 16:39:48 +00:00
// 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;
}
2019-02-04 16:39:48 +00:00
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 );
}
}
}
2019-02-04 16:39:48 +00:00
string getDefUrl( string &show, const string &language, Curl &c ) {
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
2019-01-07 22:24:28 +00:00
size_t order{}, pos{};
2019-02-04 16:39:48 +00:00
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 );
2019-01-07 22:24:28 +00:00
end--;
2019-02-04 16:39:48 +00:00
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;
2019-01-25 23:50:26 +00:00
pos = end2;
2019-01-07 22:24:28 +00:00
} else {
break;
}
2019-01-04 19:19:08 +00:00
}
2019-02-04 16:39:48 +00:00
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;
2018-09-22 22:50:42 +00:00
}
void printHelp() {
2019-02-04 16:39:48 +00:00
cout << "usage: tv_rename [--help] [--show show name] [--season season "
"number]"
<< std::endl;
cout
<< " [--correct-path] [--show-path show path] [--trust]"
<< std::endl;
cout << " [--linux] [--lang language] [--print-langs]"
<< std::endl;
cout << std::endl
<< "Rename TV episodes" << std::endl
<< std::endl
<< "optional arguments:" << std::endl;
cout << " -h, --help\t\tshow this help message and exit" << std::endl;
cout << " --show show name, -s show name" << std::endl;
cout << "\t\t\tTV show from which you want episode names (needs to be"
<< std::endl;
cout << "\t\t\tin quotation marks if it has more than one word)"
<< std::endl;
cout << " --season season number, -n season number" << std::endl;
cout << "\t\t\tSeason number/s (if multiple seasons, put them in"
<< std::endl;
cout << "\t\t\tquotation marks and seperate by one space)" << std::endl;
cout << "\t\t\tor 'all' for all seasons in selected subdirectory"
<< std::endl;
cout << " --show-path show path, -p show path" << std::endl;
cout << "\t\t\tPath of the directory with episodes" << std::endl;
cout << " --correct-path, -c\tThis is the correct path, stop asking me!"
<< std::endl;
cout << " --name-pattern pattern" << std::endl;
cout << "\t\t\tPattern to which change the file name. Possible sequences "
"are:"
<< std::endl;
cout << "\t\t\t\t%filename - original filename (without filetype extension)"
<< std::endl;
cout << "\t\t\t\t%show - show name from thetvdb" << std::endl;
cout << "\t\t\t\t%epname - episode name from thetvdb" << std::endl;
cout << "\t\t\t\t%season - season number" << std::endl;
cout << "\t\t\t\ttpossible to specify leading 0 like this: %2season "
"(number means how many leading zeros)"
<< std::endl;
cout << "\t\t\t\t%episode - episode number" << std::endl;
cout << "\t\t\t\t\tpossible to specify leading 0 like this: %2episode "
"(number means how many leading zeros)"
<< std::endl;
cout << "\t\t\tDefault pattern is \"$filename - $epname\"" << std::endl;
cout << " --trust, -t\t\tDon't ask whether the names are correct"
<< std::endl;
cout << " --linux, -x\t\tDon't replace characters characters that are "
"illegal in Windows"
<< std::endl;
cout << " --lang language, -l language" << std::endl;
cout << "\t\t\tSelect which language the episode names shoud be in"
<< std::endl;
cout << " --print-langs\t\tPring available language" << std::endl;
2018-09-22 22:50:42 +00:00
}
2019-02-04 16:39:48 +00:00
// 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 };
2019-01-19 12:40:10 +00:00
2019-02-04 16:39:48 +00:00
while ( !iswdigit( argument[pos] ) && argument[pos] != '\0' )
2019-01-19 12:40:10 +00:00
pos++;
2019-02-04 16:39:48 +00:00
if ( argument[pos] == '\0' ) {
2019-01-19 12:40:10 +00:00
seasons_num.clear();
return;
}
int temp;
2019-02-04 16:39:48 +00:00
#ifdef _WIN32
std::wstringstream iss( argument + pos );
#else
std::stringstream iss( argument + pos );
#endif
while ( iss >> temp ) {
seasons_num.insert( temp );
2019-01-19 12:40:10 +00:00
}
}
2019-02-04 16:39:48 +00:00
// print possible language codes and their corresponding language
2019-01-19 12:40:10 +00:00
void printLangs() {
2019-02-04 16:39:48 +00:00
for ( size_t i = 0; i < languages.size(); i += 2 ) {
cout << languages[i] << " - " << languages[i + 1] << std::endl;
2019-01-19 12:40:10 +00:00
}
}
2019-02-04 16:39:48 +00:00
// 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
2019-01-19 12:40:10 +00:00
return true;
}
return false;
}
#else // GUI
2019-02-04 16:39:48 +00:00
// 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
show = encodeUrl( show );
2019-02-04 16:39:48 +00:00
#ifdef _WIN32
auto source_code = utf8_to_wstring(
c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) +
show + TEXT( "&l=" ) + language ) );
2019-02-04 16:39:48 +00:00
#else
auto source_code =
c.execute( TEXT( "https://www.thetvdb.com/search?q=" ) +
show + TEXT( "&l=" ) + language );
2019-02-04 16:39:48 +00:00
#endif
2019-01-23 19:46:03 +00:00
size_t pos{};
2019-02-04 16:39:48 +00:00
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 );
2019-01-23 19:46:03 +00:00
end--;
2019-02-04 16:39:48 +00:00
urls.emplace_back(
source_code.substr( end + 2, end2 - ( end + 2 ) ),
source_code.substr( pos, end - pos ) );
2019-01-23 19:46:03 +00:00
pos = end + 2;
} else {
break;
2019-01-21 19:30:14 +00:00
}
}
2019-01-23 19:46:03 +00:00
return urls;
2019-01-21 19:30:14 +00:00
}
2019-02-04 16:39:48 +00:00
#ifndef _WIN32
// get user's home directory
string userHome() {
uid_t user_uid; // current user's uid
2019-01-23 19:46:03 +00:00
{
uid_t eid;
uid_t sid;
getresuid( &user_uid, &eid, &sid ); // don't need eid and sid
}
2019-02-04 16:39:48 +00:00
// password file entry
2019-01-23 19:46:03 +00:00
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
2019-02-04 16:39:48 +00:00
// 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
2019-01-23 19:46:03 +00:00
2019-02-04 16:39:48 +00:00
#endif // ndef GUI
// 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;
2019-01-23 13:08:40 +00:00
2019-02-04 16:39:48 +00:00
#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
2019-01-23 13:08:40 +00:00
2019-02-04 16:39:48 +00:00
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 ) {
2019-01-23 13:08:40 +00:00
// if season is AFTER numbers, put season number padded
// with zeros
// get number of leading zeros
2019-02-04 16:39:48 +00:00
auto leading = std::stoi( pattern.c_str() + i + 1 );
2019-01-23 13:08:40 +00:00
// 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();
2019-02-04 16:39:48 +00:00
if ( leading < 0 )
2019-01-23 13:08:40 +00:00
leading = 0;
// add padded season to output
2019-02-04 16:39:48 +00:00
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
2019-01-23 13:08:40 +00:00
i += 6;
2019-02-04 16:39:48 +00:00
output += season_num;
} else if ( pattern.find( TEXT( "episode" ), pos - 1 ) == pos &&
pos != i + 1 ) {
2019-01-23 13:08:40 +00:00
// same principle as with season after number
2019-02-04 16:39:48 +00:00
auto leading = std::stoi( pattern.c_str() + i + 1 );
2019-01-23 13:08:40 +00:00
i = pos + 6;
leading -= ep_num.size();
2019-02-04 16:39:48 +00:00
if ( leading < 0 )
2019-01-23 13:08:40 +00:00
leading = 0;
2019-02-04 16:39:48 +00:00
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
2019-01-23 13:08:40 +00:00
i += 7;
2019-02-04 16:39:48 +00:00
output += ep_num;
} else if ( pattern.find( TEXT( "epname" ), i ) == i + 1 ) {
2019-01-23 13:08:40 +00:00
// episode name from thetvdb
i += 6;
output += episodeName;
2019-02-04 16:39:48 +00:00
} else if ( pattern.find( TEXT( "show" ), i ) == i + 1 ) {
2019-01-23 13:08:40 +00:00
// show name from thetvdb
i += 4;
output += showName;
2019-02-04 16:39:48 +00:00
} else if ( pattern.find( TEXT( "filename" ), i ) == i + 1 ) {
2019-01-23 13:08:40 +00:00
// original file name
i += 8;
output += filename;
} else {
// output % if no escape sequence was found
output += '%';
}
} else if ( pattern[i] == '\\' ) {
// possibility to escape %
2019-02-04 16:39:48 +00:00
if ( pattern[i + 1] == '%' ) {
2019-01-23 13:08:40 +00:00
output += '%';
i++;
2019-02-04 16:39:48 +00:00
} else if ( pattern[i + 1] == '\\' ) {
2019-01-23 13:08:40 +00:00
output += '\\';
i++;
} else {
output += '\\';
}
} else {
// if char isn't % or / just add it to the output string
output += pattern[i];
}
}
return output;
}