mirror of
https://github.com/YGGverse/YGGtracker.git
synced 2025-09-13 23:02:35 +00:00
1809 lines
49 KiB
PHP
1809 lines
49 KiB
PHP
<?php
|
|
|
|
class AppModelDatabase
|
|
{
|
|
private PDO $_db;
|
|
|
|
private object $_debug;
|
|
|
|
public function __construct(object $config)
|
|
{
|
|
$this->_db = new PDO(
|
|
'mysql:dbname=' . $config->name . ';host=' . $config->host . ';port=' . $config->port . ';charset=utf8',
|
|
$config->user,
|
|
$config->password,
|
|
[
|
|
PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8'
|
|
]
|
|
);
|
|
|
|
$this->_db->setAttribute(
|
|
PDO::ATTR_ERRMODE,
|
|
PDO::ERRMODE_EXCEPTION
|
|
);
|
|
|
|
$this->_db->setAttribute(
|
|
PDO::ATTR_DEFAULT_FETCH_MODE,
|
|
PDO::FETCH_OBJ
|
|
);
|
|
|
|
$this->_db->setAttribute(
|
|
PDO::ATTR_TIMEOUT,
|
|
600
|
|
);
|
|
|
|
$this->_debug = (object)
|
|
[
|
|
'query' => (object)
|
|
[
|
|
'select' => (object)
|
|
[
|
|
'total' => 0
|
|
],
|
|
'insert' => (object)
|
|
[
|
|
'total' => 0
|
|
],
|
|
'update' => (object)
|
|
[
|
|
'total' => 0
|
|
],
|
|
'delete' => (object)
|
|
[
|
|
'total' => 0
|
|
],
|
|
]
|
|
];
|
|
}
|
|
|
|
// Tools
|
|
public function beginTransaction() : void
|
|
{
|
|
$this->_db->beginTransaction();
|
|
}
|
|
|
|
public function commit() : void
|
|
{
|
|
$this->_db->commit();
|
|
}
|
|
|
|
public function rollBack() : void
|
|
{
|
|
$this->_db->rollBack();
|
|
}
|
|
|
|
public function getDebug() : object
|
|
{
|
|
return $this->_debug;
|
|
}
|
|
|
|
// Page
|
|
public function addPage(int $timeAdded) : int
|
|
{
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `page` SET `timeAdded` = ?');
|
|
|
|
$query->execute([$timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getPage(int $pageId)
|
|
{
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `page` WHERE `pageId` = ?');
|
|
|
|
$query->execute([$pageId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
// Scheme
|
|
public function addScheme(string $value) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `scheme` SET `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getScheme(int $schemeId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `scheme` WHERE `schemeId` = ?');
|
|
|
|
$query->execute([$schemeId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findScheme(string $value) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `scheme` WHERE `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initSchemeId(string $value) : int {
|
|
|
|
if ($result = $this->findScheme($value)) {
|
|
|
|
return $result->schemeId;
|
|
}
|
|
|
|
return $this->addScheme($value);
|
|
}
|
|
|
|
// Host
|
|
public function addHost(string $value) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `host` SET `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getHost(int $hostId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `host` WHERE `hostId` = ?');
|
|
|
|
$query->execute([$hostId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findHost(string $value) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `host` WHERE `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initHostId(string $value) : int {
|
|
|
|
if ($result = $this->findHost($value)) {
|
|
|
|
return $result->hostId;
|
|
}
|
|
|
|
return $this->addHost($value);
|
|
}
|
|
|
|
// Port
|
|
public function addPort(mixed $value) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `port` SET `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getPort(int $portId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `port` WHERE `portId` = ?');
|
|
|
|
$query->execute([$portId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findPort(mixed $value) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
if ($value) {
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `port` WHERE `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
} else {
|
|
|
|
$query = $this->_db->query('SELECT * FROM `port` WHERE `value` IS NULL');
|
|
}
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initPortId(mixed $value) : int {
|
|
|
|
if ($result = $this->findPort($value)) {
|
|
|
|
return $result->portId;
|
|
}
|
|
|
|
return $this->addPort($value);
|
|
}
|
|
|
|
// URI
|
|
public function addUri(mixed $value) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `uri` SET `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getUri(int $uriId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `uri` WHERE `uriId` = ?');
|
|
|
|
$query->execute([$uriId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findUri(mixed $value) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
if ($value) {
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `uri` WHERE `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
} else {
|
|
|
|
$query = $this->_db->query('SELECT * FROM `uri` WHERE `value` IS NULL');
|
|
}
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initUriId(mixed $value) : int {
|
|
|
|
if ($result = $this->findUri($value)) {
|
|
|
|
return $result->uriId;
|
|
}
|
|
|
|
return $this->addUri($value);
|
|
}
|
|
|
|
// Info Hash
|
|
public function addInfoHash(mixed $value, int $version) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `infoHash` SET `value` = ?, `version` = ?');
|
|
|
|
$query->execute([$value, $version]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getInfoHash(int $infoHashId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `infoHash` WHERE `infoHashId` = ?');
|
|
|
|
$query->execute([$infoHashId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findInfoHash(string $value, int $version) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `infoHash` WHERE `value` = ? AND `version` = ?');
|
|
|
|
$query->execute([$value, $version]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initInfoHashId(mixed $value, int $version) : int {
|
|
|
|
if ($result = $this->findInfoHash($value, $version)) {
|
|
|
|
return $result->infoHashId;
|
|
}
|
|
|
|
return $this->addInfoHash($value, $version);
|
|
}
|
|
|
|
// Address Tracker
|
|
public function addAddressTracker(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `addressTracker` SET `schemeId` = ?, `hostId` = ?, `portId` = ?, `uriId` = ?');
|
|
|
|
$query->execute([$schemeId, $hostId, $portId, $uriId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getAddressTracker(int $addressTrackerId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `addressTracker` WHERE `addressTrackerId` = ?');
|
|
|
|
$query->execute([$addressTrackerId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findAddressTracker(int $schemeId, int $hostId, mixed $portId, mixed $uriId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `addressTracker` WHERE `schemeId` = ' . (int) $schemeId . '
|
|
AND `hostId` = ' . (int) $hostId . '
|
|
AND `portId` ' . ($portId ? ' = ' . (int) $portId : ' IS NULL ') . '
|
|
AND `uriId` ' . ($uriId ? ' = ' . (int) $uriId : ' IS NULL '));
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initAddressTrackerId(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
if ($result = $this->findAddressTracker($schemeId, $hostId, $portId, $uriId)) {
|
|
|
|
return $result->addressTrackerId;
|
|
}
|
|
|
|
return $this->addAddressTracker($schemeId, $hostId, $portId, $uriId);
|
|
}
|
|
|
|
// Acceptable Source
|
|
public function addAcceptableSource(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `acceptableSource` SET `schemeId` = ?, `hostId` = ?, `portId` = ?, `uriId` = ?');
|
|
|
|
$query->execute([$schemeId, $hostId, $portId, $uriId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getAcceptableSource(int $acceptableSourceId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `acceptableSource` WHERE `acceptableSourceId` = ?');
|
|
|
|
$query->execute([$acceptableSourceId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findAcceptableSource(int $schemeId, int $hostId, mixed $portId, mixed $uriId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `acceptableSource` WHERE `schemeId` = ' . (int) $schemeId . '
|
|
AND `hostId` = ' . (int) $hostId . '
|
|
AND `portId` ' . ($portId ? ' = ' . (int) $portId : ' IS NULL ') . '
|
|
AND `uriId` ' . ($uriId ? ' = ' . (int) $uriId : ' IS NULL '));
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initAcceptableSourceId(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
if ($result = $this->findAcceptableSource($schemeId, $hostId, $portId, $uriId)) {
|
|
|
|
return $result->acceptableSourceId;
|
|
}
|
|
|
|
return $this->addAcceptableSource($schemeId, $hostId, $portId, $uriId);
|
|
}
|
|
|
|
// eXact Source
|
|
public function addExactSource(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `eXactSource` SET `schemeId` = ?, `hostId` = ?, `portId` = ?, `uriId` = ?');
|
|
|
|
$query->execute([$schemeId, $hostId, $portId, $uriId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getExactSource(int $eXactSourceId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `eXactSource` WHERE `eXactSourceId` = ?');
|
|
|
|
$query->execute([$eXactSourceId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findExactSource(int $schemeId, int $hostId, mixed $portId, mixed $uriId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `eXactSource` WHERE `schemeId` = ' . (int) $schemeId . '
|
|
AND `hostId` = ' . (int) $hostId . '
|
|
AND `portId` ' . ($portId ? ' = ' . (int) $portId : ' IS NULL ') . '
|
|
AND `uriId` ' . ($uriId ? ' = ' . (int) $uriId : ' IS NULL '));
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initExactSourceId(int $schemeId, int $hostId, mixed $portId, mixed $uriId) : int {
|
|
|
|
if ($result = $this->findExactSource($schemeId, $hostId, $portId, $uriId)) {
|
|
|
|
return $result->eXactSourceId;
|
|
}
|
|
|
|
return $this->addExactSource($schemeId, $hostId, $portId, $uriId);
|
|
}
|
|
|
|
// Keyword Topic
|
|
public function addKeywordTopic(string $value) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `keywordTopic` SET `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function findKeywordTopic(string $value) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `keywordTopic` WHERE `value` = ?');
|
|
|
|
$query->execute([$value]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getKeywordTopic(int $keywordTopicId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `keywordTopic` WHERE `keywordTopicId` = ?');
|
|
|
|
$query->execute([$keywordTopicId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initKeywordTopicId(string $value) : int {
|
|
|
|
if ($result = $this->findKeywordTopic($value)) {
|
|
|
|
return $result->keywordTopicId;
|
|
}
|
|
|
|
return $this->addKeywordTopic($value);
|
|
}
|
|
|
|
// User
|
|
public function addUser(string $address, bool $status, bool $approved, $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `user` SET `address` = ?, `status` = ?, `approved` = ?, `timeAdded` = ?');
|
|
|
|
$query->execute([$address, (int) $status, (int) $approved, $timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getUser(int $userId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `user` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getUsers() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `user`');
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getUsersTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `user`');
|
|
|
|
$query->execute();
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function getUsersTotalByPublic(mixed $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
if (is_null($public))
|
|
{
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `user` WHERE `public` IS NULL');
|
|
$query->execute();
|
|
}
|
|
else
|
|
{
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `user` WHERE `public` = ?');
|
|
$query->execute([(int) $public]);
|
|
}
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findUserByAddress(string $address) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `user` WHERE `address` = ?');
|
|
|
|
$query->execute([$address]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function initUserId(string $address, bool $status, bool $approved, int $timeAdded) : int {
|
|
|
|
if ($result = $this->findUserByAddress($address)) {
|
|
|
|
return $result->userId;
|
|
}
|
|
|
|
return $this->addUser($address, $status, $approved, $timeAdded);
|
|
}
|
|
|
|
public function updateUserApproved(int $userId, mixed $approved, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `user` SET `approved` = ?, `timeUpdated` = ? WHERE `userId` = ?');
|
|
|
|
$query->execute([(int) $approved, $timeUpdated, $userId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateUserPublic(int $userId, bool $public, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `user` SET `public` = ?, `timeUpdated` = ? WHERE `userId` = ?');
|
|
|
|
$query->execute([(int) $public, $timeUpdated, $userId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateUserTimeAdded(int $userId, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `user` SET `timeAdded` = ? WHERE `userId` = ?');
|
|
|
|
$query->execute([$timeAdded, $userId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateUserTimeUpdated(int $userId, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `user` SET `timeUpdated` = ? WHERE `userId` = ?');
|
|
|
|
$query->execute([$timeUpdated, $userId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function findUserPageStarsDistinctTotal(int $userId, bool $value) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `pageId`) AS `result` FROM `userPageStar` WHERE `userId` = ? AND `value` = ?');
|
|
|
|
$query->execute([$userId, (int) $value]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findUserPageViewsDistinctTotal(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `pageId`) AS `result` FROM `userPageView` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findUserPageDownloadsDistinctTotal(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `pageId`) AS `result` FROM `userPageDownload` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findUserPageCommentsDistinctTotal(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `pageId`) AS `result` FROM `userPageComment` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findUserPageEditionsDistinctTotal(int $userId) : int {
|
|
|
|
return 0;
|
|
|
|
/* @TODO
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `pageId`) AS `result` FROM `userPageEdition` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
*/
|
|
}
|
|
|
|
// Magnet
|
|
public function addMagnet(int $userId,
|
|
int $xl,
|
|
string $dn,
|
|
string $linkSource,
|
|
bool $public,
|
|
bool $comments,
|
|
bool $sensitive,
|
|
bool $approved,
|
|
int $timeAdded,
|
|
mixed $timeUpdated = null) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnet` SET `userId` = ?,
|
|
`xl` = ?,
|
|
`dn` = ?,
|
|
`linkSource` = ?,
|
|
`public` = ?,
|
|
`comments` = ?,
|
|
`sensitive` = ?,
|
|
`approved` = ?,
|
|
`timeAdded` = ?,
|
|
`timeUpdated` = ?');
|
|
|
|
$query->execute(
|
|
[
|
|
$userId,
|
|
$xl,
|
|
$dn,
|
|
$linkSource,
|
|
$public ? 1 : 0,
|
|
$comments ? 1 : 0,
|
|
$sensitive ? 1 : 0,
|
|
$approved ? 1 : 0,
|
|
$timeAdded,
|
|
$timeUpdated
|
|
]
|
|
);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getMagnet(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnet` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getMagnets() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnet`');
|
|
|
|
$query->execute();
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getMagnetsTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnet`');
|
|
|
|
$query->execute();
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnet(int $userId, int $timeAdded) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnet` WHERE `userId` = ? AND `timeAdded` = ?');
|
|
|
|
$query->execute([$userId, $timeAdded]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findMagnetsByUserId(int $userId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnet` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function findMagnetsTotalByUserId(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnet` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetsTotalByUsersPublic(bool $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnet`
|
|
JOIN `user` ON (`user`.`userId` = `magnet`.`userId`)
|
|
WHERE `user`.`public` = ?');
|
|
|
|
$query->execute([(int) $public]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function updateMagnetXl(int $magnetId, int $xl, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `xl` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$xl, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetDn(int $magnetId, string $dn, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `dn` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$dn, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetTitle(int $magnetId, string $title, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `title` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$title, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetPreview(int $magnetId, string $preview, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `preview` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$preview, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetDescription(int $magnetId, string $description, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `description` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$description, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetPublic(int $magnetId, bool $public, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `public` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([(int) $public, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetComments(int $magnetId, bool $comments, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `comments` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([(int) $comments, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetSensitive(int $magnetId, bool $sensitive, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `sensitive` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([(int) $sensitive, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetApproved(int $magnetId, bool $approved, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `approved` = ?, `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([(int) $approved, $timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetTimeUpdated(int $magnetId, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `timeUpdated` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$timeUpdated, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetTimeAdded(int $magnetId, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnet` SET `timeAdded` = ? WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$timeAdded, $magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
// Magnet to Info Hash
|
|
public function addMagnetToInfoHash(int $magnetId, int $infoHashId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetToInfoHash` SET `magnetId` = ?, `infoHashId` = ?');
|
|
|
|
$query->execute([$magnetId, $infoHashId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function findMagnetToInfoHashByMagnetId(int $magnetId)
|
|
{
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToInfoHash` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
// Magnet to AddressTracker
|
|
public function addMagnetToAddressTracker(int $magnetId, int $addressTrackerId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetToAddressTracker` SET `magnetId` = ?, `addressTrackerId` = ?');
|
|
|
|
$query->execute([$magnetId, $addressTrackerId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function updateMagnetToAddressTrackerSeeders(int $magnetToAddressTrackerId, int $seeders, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetToAddressTracker` SET `seeders` = ?, `timeUpdated` = ? WHERE `magnetToAddressTrackerId` = ?');
|
|
|
|
$query->execute([$seeders, $timeUpdated, $magnetToAddressTrackerId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetToAddressTrackerCompleted(int $magnetToAddressTrackerId, int $completed, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetToAddressTracker` SET `completed` = ?, `timeUpdated` = ? WHERE `magnetToAddressTrackerId` = ?');
|
|
|
|
$query->execute([$completed, $timeUpdated, $magnetToAddressTrackerId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetToAddressTrackerLeechers(int $magnetToAddressTrackerId, int $leechers, int $timeUpdated) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetToAddressTracker` SET `leechers` = ?, `timeUpdated` = ? WHERE `magnetToAddressTrackerId` = ?');
|
|
|
|
$query->execute([$leechers, $timeUpdated, $magnetToAddressTrackerId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetToAddressTrackerTimeOffline(int $magnetToAddressTrackerId, mixed $timeOffline) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetToAddressTracker` SET `timeOffline` = ? WHERE `magnetToAddressTrackerId` = ?');
|
|
|
|
$query->execute([$timeOffline, $magnetToAddressTrackerId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function deleteMagnetToAddressTrackerByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->delete->total++;
|
|
|
|
$query = $this->_db->prepare('DELETE FROM `magnetToAddressTracker` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function findMagnetToAddressTracker(int $magnetId, int $addressTrackerId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToAddressTracker` WHERE `magnetId` = ? AND `addressTrackerId` = ?');
|
|
|
|
$query->execute([$magnetId, $addressTrackerId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findAddressTrackerByMagnetId(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToAddressTracker` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerScrapeQueue(int $limit) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToAddressTracker`
|
|
|
|
WHERE `timeOffline` IS NULL
|
|
|
|
ORDER BY `timeUpdated` ASC, RAND()
|
|
|
|
LIMIT ' . (int) $limit);
|
|
|
|
$query->execute();
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function resetMagnetToAddressTrackerTimeOfflineByTimeout(int $timeOffline) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetToAddressTracker` SET `timeOffline` = NULL WHERE `timeOffline` < ?');
|
|
|
|
$query->execute(
|
|
[
|
|
time() - $timeOffline
|
|
]
|
|
);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function initMagnetToAddressTrackerId(int $magnetId, int $addressTrackerId) : int {
|
|
|
|
if ($result = $this->findMagnetToAddressTracker($magnetId, $addressTrackerId)) {
|
|
|
|
return $result->magnetToAddressTrackerId;
|
|
}
|
|
|
|
return $this->addMagnetToAddressTracker($magnetId, $addressTrackerId);
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerSeedersSumByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`seeders`) AS `result` FROM `magnetToAddressTracker` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerCompletedSumByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`completed`) AS `result` FROM `magnetToAddressTracker` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerLeechersSumByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`leechers`) AS `result` FROM `magnetToAddressTracker` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAcceptableSourceTotalByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetToAcceptableSource` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerSeedersSum() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`seeders`) AS `result` FROM `magnetToAddressTracker`');
|
|
|
|
$query->execute();
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerCompletedSum() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`completed`) AS `result` FROM `magnetToAddressTracker`');
|
|
|
|
$query->execute();
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetToAddressTrackerLeechersSum() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT SUM(`leechers`) AS `result` FROM `magnetToAddressTracker`');
|
|
|
|
$query->execute();
|
|
|
|
return (int) $query->fetch()->result;
|
|
}
|
|
|
|
// Magnet to AcceptableSource
|
|
public function addMagnetToAcceptableSource(int $magnetId, int $acceptableSourceId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetToAcceptableSource` SET `magnetId` = ?, `acceptableSourceId` = ?');
|
|
|
|
$query->execute([$magnetId, $acceptableSourceId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function deleteMagnetToAcceptableSourceByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->delete->total++;
|
|
|
|
$query = $this->_db->prepare('DELETE FROM `magnetToAcceptableSource` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function findMagnetToAcceptableSource(int $magnetId, int $acceptableSourceId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToAcceptableSource` WHERE `magnetId` = ? AND `acceptableSourceId` = ?');
|
|
|
|
$query->execute([$magnetId, $acceptableSourceId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findAcceptableSourceByMagnetId(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToAcceptableSource` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function initMagnetToAcceptableSourceId(int $magnetId, int $acceptableSourceId) : int {
|
|
|
|
if ($result = $this->findMagnetToAcceptableSource($magnetId, $acceptableSourceId)) {
|
|
|
|
return $result->magnetToAcceptableSourceId;
|
|
}
|
|
|
|
return $this->addMagnetToAcceptableSource($magnetId, $acceptableSourceId);
|
|
}
|
|
|
|
// Magnet to eXactSource
|
|
public function addMagnetToExactSource(int $magnetId, int $eXactSourceId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetToExactSource` SET `magnetId` = ?, `eXactSourceId` = ?');
|
|
|
|
$query->execute([$magnetId, $eXactSourceId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function deleteMagnetToExactSourceByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->delete->total++;
|
|
|
|
$query = $this->_db->prepare('DELETE FROM `magnetToExactSource` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function findMagnetToExactSource(int $magnetId, int $eXactSourceId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToExactSource` WHERE `magnetId` = ? AND `eXactSourceId` = ?');
|
|
|
|
$query->execute([$magnetId, $eXactSourceId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findExactSourceByMagnetId(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToExactSource` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function initMagnetToExactSourceId(int $magnetId, int $eXactSourceId) : int {
|
|
|
|
if ($result = $this->findMagnetToEXactSource($magnetId, $eXactSourceId)) {
|
|
|
|
return $result->magnetToExactSourceId;
|
|
}
|
|
|
|
return $this->addMagnetToEXactSource($magnetId, $eXactSourceId);
|
|
}
|
|
|
|
// Magnet to KeywordTopic
|
|
public function addMagnetToKeywordTopic(int $magnetId, int $keywordTopicId) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetToKeywordTopic` SET `magnetId` = ?, `keywordTopicId` = ?');
|
|
|
|
$query->execute([$magnetId, $keywordTopicId]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function deleteMagnetToKeywordTopicByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->delete->total++;
|
|
|
|
$query = $this->_db->prepare('DELETE FROM `magnetToKeywordTopic` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function findMagnetToKeywordTopic(int $magnetId, int $keywordTopicId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToKeywordTopic` WHERE `magnetId` = ? AND `keywordTopicId` = ?');
|
|
|
|
$query->execute([$magnetId, $keywordTopicId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findKeywordTopicByMagnetId(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetToKeywordTopic` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function initMagnetToKeywordTopicId(int $magnetId, int $keywordTopicId) : int {
|
|
|
|
if ($result = $this->findMagnetToKeywordTopic($magnetId, $keywordTopicId)) {
|
|
|
|
return $result->magnetToKeywordTopicId;
|
|
}
|
|
|
|
return $this->addMagnetToKeywordTopic($magnetId, $keywordTopicId);
|
|
}
|
|
|
|
// Magnet lock
|
|
public function addMagnetLock(int $magnetId, int $userId, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetLock` SET `magnetId` = ?, `userId` = ?, `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function flushMagnetLock(int $magnetId) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('DELETE FROM `magnetLock` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function findLastMagnetLock(int $magnetId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetLock` WHERE `magnetId` = ? ORDER BY `magnetLockId` DESC LIMIT 1');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
// Magnet comment
|
|
public function addMagnetComment( int $magnetId,
|
|
int $userId,
|
|
mixed $magnetCommentIdParent,
|
|
string $value,
|
|
bool $approved,
|
|
bool $public,
|
|
int $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetComment` SET `magnetId` = ?,
|
|
`userId` = ?,
|
|
`magnetCommentIdParent` = ?,
|
|
`value` = ?,
|
|
`approved` = ?,
|
|
`public` = ?,
|
|
`timeAdded` = ?');
|
|
|
|
$query->execute(
|
|
[
|
|
$magnetId,
|
|
$userId,
|
|
$magnetCommentIdParent,
|
|
$value,
|
|
$approved,
|
|
$public,
|
|
$timeAdded
|
|
]
|
|
);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function updateMagnetCommentPublic(int $magnetCommentId, mixed $public) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetComment` SET `public` = ? WHERE `magnetCommentId` = ?');
|
|
|
|
$query->execute([(int) $public, $magnetCommentId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function updateMagnetCommentApproved(int $magnetCommentId, mixed $approved) : int {
|
|
|
|
$this->_debug->query->update->total++;
|
|
|
|
$query = $this->_db->prepare('UPDATE `magnetComment` SET `approved` = ? WHERE `magnetCommentId` = ?');
|
|
|
|
$query->execute([(int) $approved, $magnetCommentId]);
|
|
|
|
return $query->rowCount();
|
|
}
|
|
|
|
public function getMagnetCommentsTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT COUNT(*) AS `result` FROM `magnetComment`');
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function getMagnetComments() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `magnetComment`');
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function findMagnetCommentsTotalByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `userId`) AS `result` FROM `magnetComment` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetCommentsTotalByUserId(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `magnetId`) AS `result` FROM `magnetComment` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetCommentsTotal(int $magnetId, int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetComment` WHERE `magnetId` = ? AND `userId` = ?');
|
|
|
|
$query->execute([$magnetId, $userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetCommentsTotalByUsersPublic(bool $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetComment`
|
|
JOIN `user` ON (`user`.`userId` = `magnetComment`.`userId`)
|
|
WHERE `user`.`public` = ?');
|
|
|
|
$query->execute([(int) $public]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetComments(int $magnetId, mixed $magnetCommentIdParent = null) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
if ($magnetCommentIdParent)
|
|
{
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetComment` WHERE `magnetId` = ? AND `magnetCommentIdParent` = ?');
|
|
|
|
$query->execute([$magnetId, $magnetCommentIdParent]);
|
|
}
|
|
else
|
|
{
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetComment` WHERE `magnetId` = ? AND `magnetCommentIdParent` IS NULL');
|
|
|
|
$query->execute([$magnetId]);
|
|
}
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function findMagnetComment(int $magnetId, int $userId, int $timeAdded) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetComment` WHERE `magnetId` = ? AND `userId` = ? AND `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getMagnetComment(int $magnetCommentId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetComment` WHERE `magnetCommentId` = ?');
|
|
|
|
$query->execute([$magnetCommentId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
// Magnet star
|
|
public function addMagnetStar(int $magnetId, int $userId, bool $value, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetStar` SET `magnetId` = ?, `userId` = ?, `value` = ?, `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, (int) $value, $timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getMagnetStar(int $magnetStarId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetStar` WHERE `magnetStarId` = ?');
|
|
|
|
$query->execute([$magnetStarId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getMagnetStars() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `magnetStar`');
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getMagnetStarsTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT COUNT(*) AS `result` FROM `magnetStar`');
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetStarsTotalByMagnetId(int $magnetId, bool $value) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$total = 0;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `userId`) AS `result` FROM `magnetStar` WHERE `magnetId` = ? AND `value` = ?');
|
|
|
|
$query->execute([$magnetId, (int) $value]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetStarsTotalByUserId(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `magnetId`) AS `result` FROM `magnetStar` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findLastMagnetStarValue(int $magnetId, int $userId) : bool {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetStar` WHERE `magnetId` = ? AND `userId` = ? ORDER BY `magnetStarId` DESC');
|
|
|
|
$query->execute([$magnetId, $userId]);
|
|
|
|
return $query->rowCount() ? (bool) $query->fetch()->value : false;
|
|
}
|
|
|
|
public function findMagnetStarsTotalByUsersPublic(bool $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetStar`
|
|
JOIN `user` ON (`user`.`userId` = `magnetStar`.`userId`)
|
|
WHERE `user`.`public` = ?');
|
|
|
|
$query->execute([(int) $public]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetStar(int $magnetId, int $userId, int $timeAdded) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetStar` WHERE `magnetId` = ? AND `userId` = ? AND `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
// Magnet download
|
|
public function addMagnetDownload(int $magnetId, int $userId, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetDownload` SET `magnetId` = ?, `userId` = ?, `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getMagnetDownload(int $magnetDownloadId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetDownload` WHERE `magnetDownloadId` = ?');
|
|
|
|
$query->execute([$magnetDownloadId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getMagnetDownloads() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `magnetDownload`');
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getMagnetDownloadsTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT COUNT(*) AS `result` FROM `magnetDownload`');
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetDownloadsTotal(int $magnetId, int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetDownload` WHERE `magnetId` = ? AND `userId` = ?');
|
|
|
|
$query->execute([$magnetId, $userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetDownload(int $magnetId, int $userId, int $timeAdded) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetDownload` WHERE `magnetId` = ? AND `userId` = ? AND `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function findMagnetDownloadsTotalByMagnetId(int $magnetId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `userId`) AS `result` FROM `magnetDownload` WHERE `magnetId` = ?');
|
|
|
|
$query->execute([$magnetId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetDownloadsTotalByUserId(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(DISTINCT `magnetId`) AS `result` FROM `magnetDownload` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetDownloadsTotalByUsersPublic(bool $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetDownload`
|
|
JOIN `user` ON (`user`.`userId` = `magnetDownload`.`userId`)
|
|
WHERE `user`.`public` = ?');
|
|
|
|
$query->execute([(int) $public]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
// Magnet view
|
|
public function addMagnetView(int $magnetId, int $userId, int $timeAdded) : int {
|
|
|
|
$this->_debug->query->insert->total++;
|
|
|
|
$query = $this->_db->prepare('INSERT INTO `magnetView` SET `magnetId` = ?, `userId` = ?, `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $this->_db->lastInsertId();
|
|
}
|
|
|
|
public function getMagnetViews() {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT * FROM `magnetView`');
|
|
|
|
return $query->fetchAll();
|
|
}
|
|
|
|
public function getMagnetView(int $magnetViewId) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetView` WHERE `magnetViewId` = ?');
|
|
|
|
$query->execute([$magnetViewId]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
|
|
public function getMagnetViewsTotal() : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->query('SELECT COUNT(*) AS `result` FROM `magnetView`');
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetViewsTotalByUserId(int $userId) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetView` WHERE `userId` = ?');
|
|
|
|
$query->execute([$userId]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetViewsTotalByUsersPublic(bool $public) : int {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT COUNT(*) AS `result` FROM `magnetView`
|
|
JOIN `user` ON (`user`.`userId` = `magnetView`.`userId`)
|
|
WHERE `user`.`public` = ?');
|
|
|
|
$query->execute([(int) $public]);
|
|
|
|
return $query->fetch()->result;
|
|
}
|
|
|
|
public function findMagnetView(int $magnetId, int $userId, int $timeAdded) {
|
|
|
|
$this->_debug->query->select->total++;
|
|
|
|
$query = $this->_db->prepare('SELECT * FROM `magnetView` WHERE `magnetId` = ? AND `userId` = ? AND `timeAdded` = ?');
|
|
|
|
$query->execute([$magnetId, $userId, $timeAdded]);
|
|
|
|
return $query->fetch();
|
|
}
|
|
} |