SetFields('type', '1', 'inarray', 'Please select a valid type.', array('inarray' => array_keys($Categories)));
switch ($Type) {
case 'Movies':
case 'Anime':
$Validate->SetFields('codec',
'1','inarray','Please select a valid codec.', array('inarray'=>$Codecs));
$Validate->SetFields('resolution',
'1','regex','Please set a valid resolution.', array('regex'=>'/^(SD)|([0-9]+(p|i))|([0-9]K)|([0-9]+x[0-9]+)$/'));
$Validate->SetFields('audioformat',
'1','inarray','Please select a valid audio format.', array('inarray'=>$AudioFormats));
$Validate->SetFields('sub',
'1','inarray','Please select a valid sub format.', array('inarray'=>$Subbing));
$Validate->SetFields('censored', '1', 'inarray', 'Set valid censoring', array('inarray'=>array(0, 1)));
case 'Games':
$Validate->SetFields('container',
'1','inarray','Please select a valid container.', array('inarray'=>array_merge($Containers, $ContainersGames)));
case 'Manga':
if (!isset($_POST['groupid']) || !$_POST['groupid']) {
$Validate->SetFields('year',
'1','number','The year of the original release must be entered.', array('maxlength'=>3000, 'minlength'=>1800));
if ($Type == 'Manga') {
$Validate->SetFields('pages',
'1', 'number', 'That is not a valid page count', array('minlength'=>1));
}
}
$Validate->SetFields('media',
'1','inarray','Please select a valid media/platform.', array('inarray'=>array_merge($Media, $MediaManga, $Platform)));
$Validate->SetFields('lang',
'1','inarray','Please select a valid language.', array('inarray'=>$Languages));
$Validate->SetFields('release_desc',
'0','string','The release description has a minimum length of 10 characters.', array('maxlength'=>1000000, 'minlength'=>10));
default:
if (!isset($_POST['groupid']) || !$_POST['groupid']) {
$Validate->SetFields('title',
'1','string','Title must be between 1 and 200 characters.', array('maxlength'=>200, 'minlength'=>1));
if (isset($_POST['title_jp'])) {
$Validate->SetFields('title_jp',
'1','string','Japanese Title must be between 1 and 512 bytes.', array('maxlength'=>512, 'minlength'=>1));
}
$Validate->SetFields('tags',
'1','string','You must enter at least five tag. Maximum length is 1500 characters.', array('maxlength'=>1500, 'minlength'=>2));
$Validate->SetFields('image',
'0','link','The image URL you entered was invalid.', array('maxlength'=>255, 'minlength'=>12));
}
$Validate->SetFields('album_desc',
'1','string','The description has a minimum length of 10 characters.', array('maxlength'=>1000000, 'minlength'=>10));
$Validate->SetFields('groupid', '0', 'number', 'Group ID was not numeric');
}
$Validate->SetFields('rules',
'1','require','Your torrent must abide by the rules.');
$Err = $Validate->ValidateForm($_POST); // Validate the form
if (count(explode(',', $Properties['TagList'])) < 5) {
$Err = 'You must enter at least 5 tags.';
}
$File = $_FILES['file_input']; // This is our torrent file
$TorrentName = $File['tmp_name'];
if (!is_uploaded_file($TorrentName) || !filesize($TorrentName)) {
$Err = 'No torrent file uploaded, or file is empty.';
} elseif (substr(strtolower($File['name']), strlen($File['name']) - strlen('.torrent')) !== '.torrent') {
$Err = "You seem to have put something other than a torrent file into the upload field. (".$File['name'].").";
}
/*if ($Type == 'Music') {
include(SERVER_ROOT.'/sections/upload/get_extra_torrents.php');
}*/
//Multiple artists!
$LogName = '';
if (empty($Properties['GroupID']) && empty($ArtistForm) && ($Type == 'Movies' || $Type == 'Anime' || $Type == 'Manga' || $Type == 'Games')) {
$ArtistNames = array();
$ArtistForm = array();
for ($i = 0; $i < count($Artists); $i++) {
if (trim($Artists[$i]) != '') {
if (!in_array($Artists[$i], $ArtistNames)) {
$ArtistForm[$i] = array('name' => Artists::normalise_artist_name($Artists[$i]));
array_push($ArtistNames, $ArtistForm[$i]['name']);
}
}
}
$LogName .= Artists::display_artists($ArtistForm, false, true, false);
} elseif (($Type == 'Movies' || $Type == 'Anime' || $Type == 'Manga' || $Type == 'Games') && empty($ArtistForm)) {
$DB->query("
SELECT ta.ArtistID, ag.Name
FROM torrents_artists AS ta
JOIN artists_group AS ag ON ta.ArtistID = ag.ArtistID
WHERE ta.GroupID = ".$Properties['GroupID']."
ORDER BY ag.Name ASC;");
$ArtistForm = array();
while (list($ArtistID, $ArtistName) = $DB->next_record(MYSQLI_BOTH, false)) {
array_push($ArtistForm, array('id' => $ArtistID, 'name' => display_str($ArtistName)));
array_push($ArtistsUnescaped, array('name' => $ArtistName));
}
$LogName .= Artists::display_artists($ArtistsUnescaped, false, true, false);
}
if ($Err) { // Show the upload form, with the data the user entered
$UploadForm = $Type;
include(SERVER_ROOT.'/sections/upload/upload.php');
die();
}
// Strip out Amazon's padding
$AmazonReg = '/(http:\/\/ecx.images-amazon.com\/images\/.+)(\._.*_\.jpg)/i';
$Matches = array();
//What the fuck is $RegX what.cd devs?
//if (preg_match($RegX, $Properties['Image'], $Matches)) {
if (preg_match($AmazonReg, $Properties['Image'], $Matches)) {
$Properties['Image'] = $Matches[1].'.jpg';
}
ImageTools::blacklisted($Properties['Image']);
//******************************************************************************//
//--------------- Make variables ready for database input ----------------------//
// Shorten and escape $Properties for database input
$T = array();
foreach ($Properties as $Key => $Value) {
$T[$Key] = "'".db_string(trim($Value))."'";
if (!$T[$Key]) {
$T[$Key] = null;
}
}
$T['Censored'] = $Properties['Censored'];
//******************************************************************************//
//--------------- Generate torrent file ----------------------------------------//
$Tor = new BencodeTorrent($TorrentName, true);
$PublicTorrent = $Tor->make_private(); // The torrent is now private.
$TorEnc = $Tor->encode();
$InfoHash = pack('H*', $Tor->info_hash());
$DB->query("
SELECT ID
FROM torrents
WHERE info_hash = '".db_string($InfoHash)."'");
if ($DB->has_results()) {
list($ID) = $DB->next_record();
if (file_exists(TORRENT_STORE.$ID.'.torrent')) {
$Err = 'The exact same torrent file already exists on the site!';
} else {
// A lost torrent
file_put_contents(TORRENT_STORE.$ID.'.torrent', $TorEnc);
$Err = 'Thank you for fixing this torrent';
}
}
if (isset($Tor->Dec['encrypted_files'])) {
$Err = 'This torrent contains an encrypted file list which is not supported here.';
}
// File list and size
list($TotalSize, $FileList) = $Tor->file_list();
$NumFiles = count($FileList);
$TmpFileList = array();
$TooLongPaths = array();
$DirName = (isset($Tor->Dec['info']['files']) ? Format::make_utf8($Tor->get_name()) : '');
$IgnoredLogFileNames = array('audiochecker.log', 'sox.log');
check_name($DirName); // check the folder name against the blacklist
foreach ($FileList as $File) {
list($Size, $Name) = $File;
// Check file name and extension against blacklist/whitelist
check_file($Type, $Name);
// Make sure the filename is not too long
if (mb_strlen($Name, 'UTF-8') + mb_strlen($DirName, 'UTF-8') + 1 > MAX_FILENAME_LENGTH) {
$TooLongPaths[] = "$DirName/$Name";
}
// Add file info to array
$TmpFileList[] = Torrents::filelist_format_file($File);
}
if (count($TooLongPaths) > 0) {
$Names = implode('
', $TooLongPaths);
$Err = "The torrent contained one or more files with too long a name:
$Names";
}
$FilePath = db_string($DirName);
$FileString = db_string(implode("\n", $TmpFileList));
$Debug->set_flag('upload: torrent decoded');
/*if ($Type == 'Music') {
include(SERVER_ROOT.'/sections/upload/generate_extra_torrents.php');
}*/
if (!empty($Err)) { // Show the upload form, with the data the user entered
$UploadForm = $Type;
include(SERVER_ROOT.'/sections/upload/upload.php');
die();
}
//******************************************************************************//
//--------------- Start database stuff -----------------------------------------//
$Body = $Properties['GroupDescription'];
// Trickery
if (!preg_match('/^'.IMAGE_REGEX.'$/i', $Properties['Image'])) {
$Properties['Image'] = '';
$T['Image'] = "''";
}
if ($Type == 'Movies' || $Type == 'Anime' || $Type == 'Manga' || $Type == 'Games') {
// Does it belong in a group?
if ($Properties['GroupID']) {
$DB->query("
SELECT
ID,
WikiImage,
WikiBody,
RevisionID,
Name,
Year,
TagList
FROM torrents_group
WHERE id = ".$Properties['GroupID']);
if ($DB->has_results()) {
// Don't escape tg.Name. It's written directly to the log table
list($GroupID, $WikiImage, $WikiBody, $RevisionID, $Properties['Title'], $Properties['Year'], $Properties['TagList']) = $DB->next_record(MYSQLI_NUM, array(4));
$Properties['TagList'] = str_replace(array(' ', '.', '_'), array(', ', '.', '.'), $Properties['TagList']);
if (!$Properties['Image'] && $WikiImage) {
$Properties['Image'] = $WikiImage;
$T['Image'] = "'".db_string($WikiImage)."'";
}
if (strlen($WikiBody) > strlen($Body)) {
$Body = $WikiBody;
if (!$Properties['Image'] || $Properties['Image'] == $WikiImage) {
$NoRevision = true;
}
}
$Properties['Artist'] = Artists::display_artists(Artists::get_artist($GroupID), false, false);
}
}
if (!isset($GroupID) || !$GroupID) {
foreach ($ArtistForm as $Num => $Artist) {
$DB->query("
SELECT
tg.id,
tg.WikiImage,
tg.WikiBody,
tg.RevisionID
FROM torrents_group AS tg
LEFT JOIN torrents_artists AS ta ON ta.GroupID = tg.ID
LEFT JOIN artists_group AS ag ON ta.ArtistID = ag.ArtistID
WHERE ag.Name = '".db_string($Artist['name'])."'
AND tg.Name = ".$T['Title']."
AND tg.Year = ".$T['Year']);
if ($DB->has_results()) {
list($GroupID, $WikiImage, $WikiBody, $RevisionID) = $DB->next_record();
if (!$Properties['Image'] && $WikiImage) {
$Properties['Image'] = $WikiImage;
$T['Image'] = "'".db_string($WikiImage)."'";
}
if (strlen($WikiBody) > strlen($Body)) {
$Body = $WikiBody;
if (!$Properties['Image'] || $Properties['Image'] == $WikiImage) {
$NoRevision = true;
}
}
$ArtistForm = Artists::get_artist($GroupID);
//This torrent belongs in a group
break;
} else {
// The album hasn't been uploaded. Try to get the artist IDs
$DB->query("
SELECT
ArtistID,
Name
FROM artists_group
WHERE Name = '".db_string($Artist['name'])."'");
if ($DB->has_results()) {
while (list($ArtistID, $Name) = $DB->next_record(MYSQLI_NUM, false)) {
if (!strcasecmp($Artist['name'], $Name)) {
$ArtistForm[$Num] = array('id' => $ArtistID, 'name' => $Name);
break;
}
}
}
}
}
}
}
//Needs to be here as it isn't set for add format until now
$LogName .= $Properties['Title'];
//For notifications--take note now whether it's a new group
$IsNewGroup = !isset($GroupID) || !$GroupID;
//----- Start inserts
if ((!isset($GroupID) || !$GroupID) && ($Type != 'Other')) {
//array to store which artists we have added already, to prevent adding an artist twice
$ArtistsAdded = array();
foreach ($ArtistForm as $Num => $Artist) {
if (!isset($Artist['id']) || !$Artist['id']) {
if (isset($ArtistsAdded[strtolower($Artist['name'])])) {
$ArtistForm[$Num] = $ArtistsAdded[strtolower($Artist['name'])];
} else {
// Create artist
$DB->query("
INSERT INTO artists_group (Name)
VALUES ('".db_string($Artist['name'])."')");
$ArtistID = $DB->inserted_id();
$Cache->increment('stats_artist_count');
/*$DB->query("
INSERT INTO artists_alias (ArtistID, Name)
VALUES ($ArtistID, '".db_string($Artist['name'])."')");
$AliasID = $DB->inserted_id();*/
$ArtistForm[$Num] = array('id' => $ArtistID, 'name' => $Artist['name']);
$ArtistsAdded[strtolower($Artist['name'])] = $ArtistForm[$Num];
}
}
}
unset($ArtistsAdded);
}
if (!isset($GroupID) || !$GroupID) {
// Create torrent group
$DB->query("
INSERT INTO torrents_group
(CategoryID, Name, NameJP, Year, Series, Studio, CatalogueNumber, Pages, Time, WikiBody, WikiImage, DLsiteID)
VALUES
($TypeID, ".$T['Title'].", ".$T['TitleJP'].", ".$T['Year'].", ".$T['Series'].", ".$T['Studio'].", ".$T['CatalogueNumber'].", " . $T['Pages'] . ", '".sqltime()."', '".db_string($Body)."', ".$T['Image'].", ".$T['DLsiteID'].")");
$GroupID = $DB->inserted_id();
if ($Type == 'Movies' || $Type == 'Anime' || $Type == 'Manga' || $Type == 'Games') {
foreach ($ArtistForm as $Num => $Artist) {
$DB->query("
INSERT IGNORE INTO torrents_artists (GroupID, ArtistID, UserID)
VALUES ($GroupID, ".$Artist['id'].', '.$LoggedUser['ID'].")");
$Cache->increment('stats_album_count');
$Cache->delete_value('artist_groups_'.$Artist['id']);
}
}
$Cache->increment('stats_group_count');
// Add screenshots
$Screenshots = array_slice(array_filter(array_map("db_string", array_map("trim", array_unique(explode("\n", $Properties['Screenshots'])))), function ($s) { return preg_match('/^'.IMAGE_REGEX.'$/i', $s); }), 0, 10);
$values = array();
foreach ($Screenshots as $s) {
$values[] = "(" . $GroupID . ", " . $LoggedUser['ID'] . ", NOW(), '" . $s . "')";
}
if (!empty($values)) {
$DB->query("
INSERT INTO torrents_screenshots
(GroupID, UserID, Time, Image)
VALUES " . implode(", ", $values));
}
} else {
$DB->query("
UPDATE torrents_group
SET Time = '".sqltime()."'
WHERE ID = $GroupID");
$Cache->delete_value("torrent_group_$GroupID");
$Cache->delete_value("torrents_details_$GroupID");
$Cache->delete_value("detail_files_$GroupID");
}
// Description
if (!isset($NoRevision) || !$NoRevision) {
$DB->query("
INSERT INTO wiki_torrents
(PageID, Body, UserID, Summary, Time, Image)
VALUES
($GroupID, $T[GroupDescription], $LoggedUser[ID], 'Uploaded new torrent', '".sqltime()."', $T[Image])");
$RevisionID = $DB->inserted_id();
// Revision ID
$DB->query("
UPDATE torrents_group
SET RevisionID = '$RevisionID'
WHERE ID = $GroupID");
}
// Tags
$Tags = explode(',', $Properties['TagList']);
if (!$Properties['GroupID']) {
foreach ($Tags as $Tag) {
$Tag = Misc::sanitize_tag($Tag);
if (!empty($Tag)) {
$Tag = Misc::get_alias_tag($Tag);
$DB->query("
INSERT INTO tags
(Name, UserID)
VALUES
('$Tag', $LoggedUser[ID])
ON DUPLICATE KEY UPDATE
Uses = Uses + 1;
");
$TagID = $DB->inserted_id();
$DB->query("
INSERT INTO torrents_tags
(TagID, GroupID, UserID, PositiveVotes)
VALUES
($TagID, $GroupID, $LoggedUser[ID], 10)
ON DUPLICATE KEY UPDATE
PositiveVotes = PositiveVotes + 1;
");
}
}
}
// Use this section to control freeleeches
$DB->query("
SELECT Name, First, Second
FROM misc
WHERE Second = 'freeleech'");
if ($DB->has_results()) {
$FreeLeechTags = $DB->to_array('Name');
foreach ($FreeLeechTags as $Tag => $Exp) {
if ($Tag == 'global' || in_array($Tag, $Tags)) {
$T['FreeTorrent'] = 1;
$T['FreeLeechType'] = 3;
break;
}
}
} else {
$T['FreeTorrent'] = 0;
$T['FreeLeechType'] = 0;
}
// movie and anime ISOs are neutral leech, and receive a BP bounty
if (($Type == "Movies" || $Type == "Anime") && $T['Container'] == "'ISO'") {
$T['FreeTorrent'] = 2;
$T['FreeLeechType'] = 2;
}
// Torrent
$DB->query("
INSERT INTO torrents
(GroupID, UserID, Media, Container, Codec, Resolution, AudioFormat,
Subbing, Language, Subber, Censored, Archive, info_hash, FileCount, FileList,
FilePath, Size, Time, Description, MediaInfo, FreeTorrent, FreeLeechType)
VALUES
($GroupID, $LoggedUser[ID], $T[Media], $T[Container], $T[Codec], $T[Resolution], $T[AudioFormat],
$T[Subbing], $T[Language], $T[Subber], $T[Censored], $T[Archive],'".db_string($InfoHash)."', $NumFiles, '$FileString',
'$FilePath', $TotalSize, '".sqltime()."', $T[TorrentDescription], $T[MediaInfo], '$T[FreeTorrent]', '$T[FreeLeechType]')");
$Cache->increment('stats_torrent_count');
$TorrentID = $DB->inserted_id();
Tracker::update_tracker('add_torrent', array('id' => $TorrentID, 'info_hash' => rawurlencode($InfoHash), 'freetorrent' => $T['FreeTorrent']));
$Debug->set_flag('upload: ocelot updated');
// Prevent deletion of this torrent until the rest of the upload process is done
// (expire the key after 10 minutes to prevent locking it for too long in case there's a fatal error below)
$Cache->cache_value("torrent_{$TorrentID}_lock", true, 600);
//give BP if necessary
if (($Type == "Movies" || $Type == "Anime") && $T['Container'] == "'ISO'") {
$BPAmt = 2*($TotalSize / (1024*1024*1024))*1000;
$DB->query("
UPDATE users_main
SET BonusPoints = BonusPoints + $BPAmt
WHERE ID = $LoggedUser[ID]");
$DB->query("
UPDATE users_info
SET AdminComment = CONCAT('".sqltime()." - Received $BPAmt ".BONUS_POINTS." for uploading a torrent $TorrentID\n\n', AdminComment)
WHERE UserID = $LoggedUser[ID]");
$Cache->delete_value('user_info_heavy_'.$LoggedUser['ID']);
$Cache->delete_value('user_stats_'.$LoggedUser['ID']);
}
// Add to shop freeleeches if necessary
if ($T['FreeLeechType'] == 3) {
// Figure out which duration to use
$Expiry = 0;
foreach ($FreeLeechTags as $Tag => $Exp) {
if ($Tag == 'global' || in_array($Tag, $Tags)) {
if (((int) $FreeLeechTags[$Tag]['First']) > $Expiry)
$Expiry = (int) $FreeLeechTags[$Tag]['First'];
}
}
if ($Expiry > 0) {
$DB->query("
INSERT INTO shop_freeleeches
(TorrentID, ExpiryTime)
VALUES
(" . $TorrentID . ", FROM_UNIXTIME(" . $Expiry . "))
ON DUPLICATE KEY UPDATE
ExpiryTime = FROM_UNIXTIME(UNIX_TIMESTAMP(ExpiryTime) + ($Expiry - FROM_UNIXTIME(NOW())))");
} else {
Torrents::freeleech_torrents($TorrentID, 0, 0);
}
}
//******************************************************************************//
//--------------- Write torrent file -------------------------------------------//
file_put_contents(TORRENT_STORE.$TorrentID.'.torrent', $TorEnc);
Misc::write_log("Torrent $TorrentID ($LogName) (".number_format($TotalSize / (1024 * 1024), 2).' MB) was uploaded by ' . $LoggedUser['Username']);
Torrents::write_group_log($GroupID, $TorrentID, $LoggedUser['ID'], 'uploaded ('.number_format($TotalSize / (1024 * 1024), 2).' MB)', 0);
Torrents::update_hash($GroupID);
$Debug->set_flag('upload: sphinx updated');
/*if ($Type == 'Music') {
include(SERVER_ROOT.'/sections/upload/insert_extra_torrents.php');
}*/
//******************************************************************************//
//---------------------- Recent Uploads ----------------------------------------//
if (trim($Properties['Image']) != '') {
$RecentUploads = $Cache->get_value("recent_uploads_$UserID");
if (is_array($RecentUploads)) {
do {
foreach ($RecentUploads as $Item) {
if ($Item['ID'] == $GroupID) {
break 2;
}
}
// Only reached if no matching GroupIDs in the cache already.
if (count($RecentUploads) === 5) {
array_pop($RecentUploads);
}
array_unshift($RecentUploads, array(
'ID' => $GroupID,
'Name' => trim($Properties['Title']),
'Artist' => Artists::display_artists($ArtistForm, false, true),
'WikiImage' => trim($Properties['Image'])));
$Cache->cache_value("recent_uploads_$UserID", $RecentUploads, 0);
} while (0);
}
}
//******************************************************************************//
//------------------------------- Post-processing ------------------------------//
/* Because tracker updates and notifications can be slow, we're
* redirecting the user to the destination page and flushing the buffers
* to make it seem like the PHP process is working in the background.
*/
if ($PublicTorrent) {
View::show_header('Warning');
?>
Warning
Your torrent has been uploaded; however, you must download your torrent from here because you didn't make your torrent using the "private" option.
set_flag('upload: announced on irc');
// Manage notifications
/*
$UsedFormatBitrates = array();
if (!$IsNewGroup) {
// maybe there are torrents in the same release as the new torrent. Let's find out (for notifications)
$GroupInfo = get_group_info($GroupID, true, 0, false);
$ThisMedia = display_str($Properties['Media']);
$ThisRemastered = display_str($Properties['Remastered']);
$ThisRemasterYear = display_str($Properties['RemasterYear']);
$ThisRemasterTitle = display_str($Properties['RemasterTitle']);
$ThisRemasterRecordLabel = display_str($Properties['RemasterRecordLabel']);
$ThisRemasterCatalogueNumber = display_str($Properties['RemasterCatalogueNumber']);
foreach ($GroupInfo[1] as $TorrentInfo) {
if (($TorrentInfo['Media'] == $ThisMedia)
&& ($TorrentInfo['Remastered'] == $ThisRemastered)
&& ($TorrentInfo['RemasterYear'] == (int)$ThisRemasterYear)
&& ($TorrentInfo['RemasterTitle'] == $ThisRemasterTitle)
&& ($TorrentInfo['RemasterRecordLabel'] == $ThisRemasterRecordLabel)
&& ($TorrentInfo['RemasterCatalogueNumber'] == $ThisRemasterCatalogueNumber)
&& ($TorrentInfo['ID'] != $TorrentID)) {
$UsedFormatBitrates[] = array('format' => $TorrentInfo['Format'], 'bitrate' => $TorrentInfo['Encoding']);
}
}
}
*/
// For RSS
$Item = $Feed->item($Title, Text::strip_bbcode($Body), 'torrents.php?action=download&authkey=[[AUTHKEY]]&torrent_pass=[[PASSKEY]]&id='.$TorrentID, $LoggedUser['Username'], 'torrents.php?id='.$GroupID, trim($Properties['TagList']));
//Notifications
$SQL = "
SELECT unf.ID, unf.UserID, torrent_pass
FROM users_notify_filters AS unf
JOIN users_main AS um ON um.ID = unf.UserID
WHERE um.Enabled = '1'";
if (empty($ArtistsUnescaped)) {
$ArtistsUnescaped = $ArtistForm;
}
if (!empty($ArtistsUnescaped)) {
$ArtistNameList = array();
$GuestArtistNameList = array();
foreach ($ArtistsUnescaped as $Importance => $Artists) {
foreach ($Artists as $Artist) {
if ($Importance == 1 || $Importance == 4 || $Importance == 5 || $Importance == 6) {
$ArtistNameList[] = "Artists LIKE '%|".db_string(str_replace('\\', '\\\\', $Artist['name']), true)."|%'";
} else {
$GuestArtistNameList[] = "Artists LIKE '%|".db_string(str_replace('\\', '\\\\', $Artist['name']), true)."|%'";
}
}
}
// Don't add notification if >2 main artists or if tracked artist isn't a main artist
if (count($ArtistNameList) > 2 || $Artist['name'] == 'Various Artists') {
$SQL .= " AND (ExcludeVA = '0' AND (";
$SQL .= implode(' OR ', array_merge($ArtistNameList, $GuestArtistNameList));
$SQL .= " OR Artists = '')) AND (";
} else {
$SQL .= " AND (";
if (!empty($GuestArtistNameList)) {
$SQL .= "(ExcludeVA = '0' AND (";
$SQL .= implode(' OR ', $GuestArtistNameList);
$SQL .= ')) OR ';
}
if (count($ArtistNameList) > 0) {
$SQL .= implode(' OR ', $ArtistNameList);
$SQL .= " OR ";
}
$SQL .= "Artists = '') AND (";
}
} else {
$SQL .= "AND (Artists = '') AND (";
}
reset($Tags);
$TagSQL = array();
$NotTagSQL = array();
foreach ($Tags as $Tag) {
$TagSQL[] = " Tags LIKE '%|".db_string(trim($Tag))."|%' ";
$NotTagSQL[] = " NotTags LIKE '%|".db_string(trim($Tag))."|%' ";
}
$TagSQL[] = "Tags = ''";
$SQL .= implode(' OR ', $TagSQL);
$SQL .= ") AND !(".implode(' OR ', $NotTagSQL).')';
$SQL .= " AND (Categories LIKE '%|".db_string(trim($Type))."|%' OR Categories = '') ";
if ($Properties['ReleaseType']) {
$SQL .= " AND (ReleaseTypes LIKE '%|".db_string(trim($ReleaseTypes[$Properties['ReleaseType']]))."|%' OR ReleaseTypes = '') ";
} else {
$SQL .= " AND (ReleaseTypes = '') ";
}
/*
Notify based on the following:
1. The torrent must match the formatbitrate filter on the notification
2. If they set NewGroupsOnly to 1, it must also be the first torrent in the group to match the formatbitrate filter on the notification
*/
if ($Properties['Format']) {
$SQL .= " AND (Formats LIKE '%|".db_string(trim($Properties['Format']))."|%' OR Formats = '') ";
} else {
$SQL .= " AND (Formats = '') ";
}
if ($_POST['bitrate']) {
$SQL .= " AND (Encodings LIKE '%|".db_string(trim($_POST['bitrate']))."|%' OR Encodings = '') ";
} else {
$SQL .= " AND (Encodings = '') ";
}
if ($Properties['Media']) {
$SQL .= " AND (Media LIKE '%|".db_string(trim($Properties['Media']))."|%' OR Media = '') ";
} else {
$SQL .= " AND (Media = '') ";
}
// Either they aren't using NewGroupsOnly
$SQL .= "AND ((NewGroupsOnly = '0' ";
// Or this is the first torrent in the group to match the formatbitrate filter
$SQL .= ") OR ( NewGroupsOnly = '1' ";
// Test the filter doesn't match any previous formatbitrate in the group
/*
foreach ($UsedFormatBitrates as $UsedFormatBitrate) {
$FormatReq = "(Formats LIKE '%|".db_string($UsedFormatBitrate['format'])."|%' OR Formats = '') ";
$BitrateReq = "(Encodings LIKE '%|".db_string($UsedFormatBitrate['bitrate'])."|%' OR Encodings = '') ";
$SQL .= "AND (NOT($FormatReq AND $BitrateReq)) ";
}
*/
$SQL .= '))';
/*if ($Properties['Year'] && $Properties['RemasterYear']) {
$SQL .= " AND (('".db_string(trim($Properties['Year']))."' BETWEEN FromYear AND ToYear)
OR ('".db_string(trim($Properties['RemasterYear']))."' BETWEEN FromYear AND ToYear)
OR (FromYear = 0 AND ToYear = 0)) ";
} else*/
if ($Properties['Year'] || $Properties['RemasterYear']) {
//$SQL .= " AND (('".db_string(trim(Max($Properties['Year'],$Properties['RemasterYear'])))."' BETWEEN FromYear AND ToYear)
$SQL .= " AND (('".db_string(trim($Properties['Year']))."' BETWEEN FromYear AND ToYear)
OR (FromYear = 0 AND ToYear = 0)) ";
} else {
$SQL .= " AND (FromYear = 0 AND ToYear = 0) ";
}
$SQL .= " AND UserID != '".$LoggedUser['ID']."' ";
$DB->query("
SELECT Paranoia
FROM users_main
WHERE ID = $LoggedUser[ID]");
list($Paranoia) = $DB->next_record();
$Paranoia = unserialize($Paranoia);
if (!is_array($Paranoia)) {
$Paranoia = array();
}
if (!in_array('notifications', $Paranoia)) {
$SQL .= " AND (Users LIKE '%|".$LoggedUser['ID']."|%' OR Users = '') ";
}
$SQL .= " AND UserID != '".$LoggedUser['ID']."' ";
$DB->query($SQL);
$Debug->set_flag('upload: notification query finished');
if ($DB->has_results()) {
$UserArray = $DB->to_array('UserID');
$FilterArray = $DB->to_array('ID');
$InsertSQL = '
INSERT IGNORE INTO users_notify_torrents (UserID, GroupID, TorrentID, FilterID)
VALUES ';
$Rows = array();
foreach ($UserArray as $User) {
list($FilterID, $UserID, $Passkey) = $User;
$Rows[] = "('$UserID', '$GroupID', '$TorrentID', '$FilterID')";
$Feed->populate("torrents_notify_$Passkey", $Item);
$Cache->delete_value("notifications_new_$UserID");
}
$InsertSQL .= implode(',', $Rows);
$DB->query($InsertSQL);
$Debug->set_flag('upload: notification inserts finished');
foreach ($FilterArray as $Filter) {
list($FilterID, $UserID, $Passkey) = $Filter;
$Feed->populate("torrents_notify_{$FilterID}_$Passkey", $Item);
}
}
// RSS for bookmarks
$DB->query("
SELECT u.ID, u.torrent_pass
FROM users_main AS u
JOIN bookmarks_torrents AS b ON b.UserID = u.ID
WHERE b.GroupID = $GroupID");
while (list($UserID, $Passkey) = $DB->next_record()) {
$Feed->populate("torrents_bookmarks_t_$Passkey", $Item);
}
$Feed->populate('torrents_all', $Item);
$Debug->set_flag('upload: notifications handled');
if ($Type == 'Music') {
$Feed->populate('torrents_music', $Item);
if ($Properties['Media'] == 'Vinyl') {
$Feed->populate('torrents_vinyl', $Item);
}
if ($Properties['Bitrate'] == 'Lossless') {
$Feed->populate('torrents_lossless', $Item);
}
if ($Properties['Bitrate'] == '24bit Lossless') {
$Feed->populate('torrents_lossless24', $Item);
}
if ($Properties['Format'] == 'MP3') {
$Feed->populate('torrents_mp3', $Item);
}
if ($Properties['Format'] == 'FLAC') {
$Feed->populate('torrents_flac', $Item);
}
}
if ($Type == 'Applications') {
$Feed->populate('torrents_apps', $Item);
}
if ($Type == 'E-Books') {
$Feed->populate('torrents_ebooks', $Item);
}
if ($Type == 'Audiobooks') {
$Feed->populate('torrents_abooks', $Item);
}
if ($Type == 'E-Learning Videos') {
$Feed->populate('torrents_evids', $Item);
}
if ($Type == 'Comedy') {
$Feed->populate('torrents_comedy', $Item);
}
if ($Type == 'Comics') {
$Feed->populate('torrents_comics', $Item);
}
// Clear cache
$Cache->delete_value("torrents_details_$GroupID");
$Cache->delete_value("contest_scores");
// Allow deletion of this torrent now
$Cache->delete_value("torrent_{$TorrentID}_lock");