mirror of
https://github.com/YGGverse/YGGtracker.git
synced 2026-04-01 01:25:39 +00:00
1327 lines
No EOL
26 KiB
PHP
1327 lines
No EOL
26 KiB
PHP
<?php
|
|
|
|
class Valid
|
|
{
|
|
// Common
|
|
public static function host(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid host data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!filter_var(str_replace(['[',']'], false, $value), FILTER_VALIDATE_IP, FILTER_FLAG_IPV6))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Host of "%s" not supported'),
|
|
$value
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(YGGDRASIL_HOST_REGEX, str_replace(['[',']'], false, $value)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Host "%s" not match condition "%s"'),
|
|
$value,
|
|
YGGDRASIL_HOST_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function url(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid URL data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!filter_var($value, FILTER_VALIDATE_URL))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('URL "%s" invalid'),
|
|
$value
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!$host = parse_url($value, PHP_URL_HOST))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Could not init host for URL "%s"'),
|
|
$value
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!self::host($host, $error))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('URL "%s" has not supported host "%s"'),
|
|
$value,
|
|
$host,
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// User
|
|
public static function user(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Validate required fields
|
|
if (!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
!isset($value->address) || !self::userAddress($value->address, $error) ||
|
|
!isset($value->timeAdded) || !self::userTimeAdded($value->timeAdded, $error) ||
|
|
!isset($value->timeUpdated) || !self::userTimeUpdated($value->timeUpdated, $error) ||
|
|
!isset($value->approved) || !self::userApproved($value->approved, $error) ||
|
|
|
|
(isset($value->public) && !self::userPublic($value->public, $error)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid userId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userAddress(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user address data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!self::host($value, $error))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('User address "%s" not supported'),
|
|
$value
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('User timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userTimeUpdated(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!(is_int($value) || is_bool($value)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user timeUpdated data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (is_int($value) && ($value > time() || $value < 0))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('User timeUpdated out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userApproved(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user approved data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function userPublic(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid user public data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Magnet
|
|
public static function magnet(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Validate required fields by protocol
|
|
if (!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
|
|
!isset($value->magnetId) || !self::magnetId($value->magnetId, $error) ||
|
|
|
|
|
|
!isset($value->title) || !self::magnetTitle($value->title, $error) ||
|
|
!isset($value->preview) || !self::magnetPreview($value->preview, $error) ||
|
|
!isset($value->description) || !self::magnetDescription($value->description, $error) ||
|
|
|
|
!isset($value->comments) || !self::magnetComments($value->comments, $error) ||
|
|
!isset($value->sensitive) || !self::magnetSensitive($value->sensitive, $error) ||
|
|
!isset($value->approved) || !self::magnetApproved($value->approved, $error) ||
|
|
|
|
!isset($value->timeAdded) || !self::magnetTimeAdded($value->timeAdded, $error) ||
|
|
!isset($value->timeUpdated) || !self::magnetTimeUpdated($value->timeUpdated, $error) ||
|
|
|
|
!isset($value->dn) || !self::magnetDn($value->dn, $error) ||
|
|
!isset($value->xt) || !self::magnetXt($value->xt, $error) ||
|
|
|
|
!isset($value->xl) || !self::magnetXl($value->xl, $error) ||
|
|
|
|
!isset($value->kt) || !self::magnetKt($value->kt, $error) ||
|
|
!isset($value->tr) || !self::magnetTr($value->tr, $error) ||
|
|
!isset($value->as) || !self::magnetAs($value->as, $error) ||
|
|
!isset($value->xs) || !self::magnetWs($value->xs, $error) ||
|
|
|
|
(isset($value->public) && !self::magnetPublic($value->public, $error)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnetId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetTitle(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet title data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(MAGNET_TITLE_REGEX, $value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet title format does not match condition "%s"'),
|
|
MAGNET_TITLE_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($value) < MAGNET_TITLE_MIN_LENGTH ||
|
|
mb_strlen($value) > MAGNET_TITLE_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet title out of %s-%s chars range'),
|
|
MAGNET_TITLE_MIN_LENGTH,
|
|
MAGNET_TITLE_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetPreview(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet preview data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(MAGNET_PREVIEW_REGEX, $value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet preview format does not match condition "%s"'),
|
|
MAGNET_PREVIEW_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($value) < MAGNET_PREVIEW_MIN_LENGTH ||
|
|
mb_strlen($value) > MAGNET_PREVIEW_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet preview out of %s-%s chars range'),
|
|
MAGNET_PREVIEW_MIN_LENGTH,
|
|
MAGNET_PREVIEW_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetDescription(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet description data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(MAGNET_DESCRIPTION_REGEX, $value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet description format does not match condition "%s"'),
|
|
MAGNET_DESCRIPTION_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($value) < MAGNET_DESCRIPTION_MIN_LENGTH ||
|
|
mb_strlen($value) > MAGNET_DESCRIPTION_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet description out of %s-%s chars range'),
|
|
MAGNET_DESCRIPTION_MIN_LENGTH,
|
|
MAGNET_DESCRIPTION_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetComments(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comments data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetPublic(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet public data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetApproved(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet approved data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetSensitive(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet sensitive data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetTimeUpdated(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!(is_int($value) || is_bool($value)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet timeUpdated data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (is_int($value) && ($value > time() || $value < 0))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet timeUpdated out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetDn(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet display name data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(MAGNET_DN_REGEX, $value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet display name format does not match condition "%s"'),
|
|
MAGNET_DN_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($value) < MAGNET_DN_MIN_LENGTH ||
|
|
mb_strlen($value) > MAGNET_DN_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet display name out of %s-%s chars range'),
|
|
MAGNET_DN_MIN_LENGTH,
|
|
MAGNET_DN_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetXl(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!(is_int($value) || is_float($value)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet exact length data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetKt(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet keyword data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total = 0;
|
|
|
|
foreach ($value as $kt)
|
|
{
|
|
if (!is_string($kt))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet keyword value data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!preg_match(MAGNET_KT_REGEX, $kt))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet keyword format does not match condition "%s"'),
|
|
MAGNET_KT_REGEX
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($kt) < MAGNET_KT_MIN_LENGTH ||
|
|
mb_strlen($kt) > MAGNET_KT_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet keyword out of %s-%s chars range'),
|
|
MAGNET_KT_MIN_LENGTH,
|
|
MAGNET_KT_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total++;
|
|
}
|
|
|
|
if ($total < MAGNET_KT_MIN_QUANTITY ||
|
|
$total > MAGNET_KT_MAX_QUANTITY)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet keywords quantity out of %s-%s range'),
|
|
MAGNET_KT_MIN_QUANTITY,
|
|
MAGNET_KT_MAX_QUANTITY
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetXt(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet info hash data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
foreach ($value as $xt)
|
|
{
|
|
if (empty($xt->version))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet info hash version required')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!(is_int($xt->version) || is_float($xt->version)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet info hash version data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (empty($xt->value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet info hash value required')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!is_string($xt->value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet info hash value data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
switch ($xt->version)
|
|
{
|
|
case 1:
|
|
|
|
if (!preg_match('/^([A-z0-9]{40})$/i', $xt->value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet info hash v1 value')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (!preg_match('/^([A-z0-9]{64})$/i', $xt->value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet info hash v2 value')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
array_push(
|
|
$error,
|
|
_('Magnet info hash version not supported')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetTr(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet address tracker data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total = 0;
|
|
|
|
foreach ($value as $tr)
|
|
{
|
|
if (!self::url($tr, $error))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Invalid magnet address tracker URL "%s"'),
|
|
$tr
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total++;
|
|
}
|
|
|
|
if ($total < MAGNET_TR_MIN_QUANTITY ||
|
|
$total > MAGNET_TR_MAX_QUANTITY)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet address trackers quantity out of %s-%s range'),
|
|
MAGNET_TR_MIN_QUANTITY,
|
|
MAGNET_TR_MAX_QUANTITY
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetAs(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet acceptable source data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total = 0;
|
|
|
|
foreach ($value as $as)
|
|
{
|
|
if (!self::url($as, $error))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Invalid magnet acceptable source URL "%s"'),
|
|
$as
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total++;
|
|
}
|
|
|
|
if ($total < MAGNET_AS_MIN_QUANTITY ||
|
|
$total > MAGNET_AS_MAX_QUANTITY)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet acceptable sources quantity out of %s-%s range'),
|
|
MAGNET_AS_MIN_QUANTITY,
|
|
MAGNET_AS_MAX_QUANTITY
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetWs(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet web seed data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total = 0;
|
|
|
|
foreach ($value as $ws)
|
|
{
|
|
if (!self::url($ws, $error))
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Invalid magnet web seed URL "%s"'),
|
|
$ws
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
$total++;
|
|
}
|
|
|
|
if ($total < MAGNET_WS_MIN_QUANTITY ||
|
|
$total > MAGNET_WS_MAX_QUANTITY)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet web seeds quantity out of %s-%s range'),
|
|
MAGNET_WS_MIN_QUANTITY,
|
|
MAGNET_WS_MAX_QUANTITY
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Magnet comment
|
|
public static function magnetComment(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!isset($value->magnetCommentId) || !self::magnetCommentId($value->magnetCommentId, $error) ||
|
|
!isset($value->magnetId) || !self::magnetId($value->magnetId, $error) ||
|
|
!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
!isset($value->timeAdded) || !self::magnetCommentTimeAdded($value->timeAdded, $error) ||
|
|
!isset($value->approved) || !self::magnetCommentApproved($value->approved, $error) ||
|
|
!isset($value->value) || !self::magnetCommentValue($value->value, $error) ||
|
|
|
|
(isset($value->magnetCommentIdParent) && !self::magnetCommentIdParent($value->magnetCommentIdParent, $error)) ||
|
|
|
|
(isset($value->public) && !self::magnetCommentPublic($value->public, $error)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnetCommentId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentIdParent(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!(is_null($value) || is_int($value)))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet magnetCommentIdParent data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (is_int($value) && !self::magnetCommentId($value, $error))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet comment timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentApproved(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment approved data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentPublic(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment public data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetCommentValue(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_string($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet comment value data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mb_strlen($value) < MAGNET_COMMENT_MIN_LENGTH ||
|
|
mb_strlen($value) > MAGNET_COMMENT_MAX_LENGTH)
|
|
{
|
|
array_push(
|
|
$error,
|
|
sprintf(
|
|
_('Magnet comment value out of %s-%s chars range'),
|
|
MAGNET_COMMENT_MIN_LENGTH,
|
|
MAGNET_COMMENT_MAX_LENGTH
|
|
)
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Magnet download
|
|
public static function magnetDownload(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet download data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!isset($value->magnetDownloadId) || !self::magnetDownloadId($value->magnetDownloadId, $error) ||
|
|
!isset($value->magnetId) || !self::magnetId($value->magnetId, $error) ||
|
|
!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
!isset($value->timeAdded) || !self::magnetDownloadTimeAdded($value->timeAdded, $error)
|
|
)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet download data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetDownloadId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnetDownloadId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetDownloadTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet download timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet download timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Magnet star
|
|
public static function magnetStar(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet star data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!isset($value->magnetStarId) || !self::magnetViewId($value->magnetStarId, $error) ||
|
|
!isset($value->magnetId) || !self::magnetId($value->magnetId, $error) ||
|
|
!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
!isset($value->timeAdded) || !self::magnetStarTimeAdded($value->timeAdded, $error) ||
|
|
!isset($value->value) || !self::magnetStarValue($value->value, $error)
|
|
)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet star data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetStarId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnetStarId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetStarValue(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_bool($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet star value data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetStarTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet star timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet star timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Magnet view
|
|
public static function magnetView(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_object($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet view data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!isset($value->magnetViewId) || !self::magnetViewId($value->magnetViewId, $error) ||
|
|
!isset($value->magnetId) || !self::magnetId($value->magnetId, $error) ||
|
|
!isset($value->userId) || !self::userId($value->userId, $error) ||
|
|
!isset($value->timeAdded) || !self::magnetViewTimeAdded($value->timeAdded, $error)
|
|
)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet view data protocol')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetViewId(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnetViewId data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function magnetViewTimeAdded(mixed $value, array &$error = []) : bool
|
|
{
|
|
if (!is_int($value))
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Invalid magnet view timeAdded data type')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
if ($value > time() || $value < 0)
|
|
{
|
|
array_push(
|
|
$error,
|
|
_('Magnet view timeAdded out of range')
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} |