ExpiryDef.php

Go to the documentation of this file.

<?php
 
namespace Wikimedia\ParamValidator\TypeDef;
 
use InvalidArgumentException;
use Wikimedia\Message\DataMessageValue;
use Wikimedia\Message\MessageValue;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\ParamValidator\TypeDef;
use Wikimedia\Timestamp\ConvertibleTimestamp;
 
class ExpiryDef extends TypeDef {
 
    public const INFINITY_VALS = [ 'infinite', 'indefinite', 'infinity', 'never' ];
 
    public const PARAM_USE_MAX = 'param-use-max';
 
    public const PARAM_MAX = 'param-max';
 
    public function validate( $name, $value, array $settings, array $options ) {
        $this->failIfNotString( $name, $value, $settings, $options );
 
        try {
            $expiry = self::normalizeExpiry( $value, TS_ISO_8601 );
        } catch ( InvalidArgumentException $e ) {
            $this->failure( 'badexpiry', $name, $value, $settings, $options );
        }
 
        if ( $expiry !== 'infinity' && $expiry < ConvertibleTimestamp::now( TS_ISO_8601 ) ) {
            $this->failure( 'badexpiry-past', $name, $value, $settings, $options );
        }
 
        $max = $settings[self::PARAM_MAX] ?? null;
 
        if ( self::expiryExceedsMax( $expiry, $max ) ) {
            $dontUseMax = empty( $settings[self::PARAM_USE_MAX] );
            // Show warning that expiry exceeds the max, and that the max is being used instead.
            $msg = DataMessageValue::new(
                $dontUseMax
                    ? 'paramvalidator-badexpiry-duration'
                    : 'paramvalidator-badexpiry-duration-max',
                [ $max ]
            );
            $this->failure( $msg, $name, $value, $settings, $options, $dontUseMax );
 
            return self::normalizeExpiry( $max, TS_ISO_8601 );
        }
 
        return $expiry;
    }
 
    public function getHelpInfo( $name, array $settings, array $options ) {
        $info = parent::getHelpInfo( $name, $settings, $options );
 
        $info[ParamValidator::PARAM_TYPE] = MessageValue::new( 'paramvalidator-help-type-expiry' )
            ->params( empty( $settings[ParamValidator::PARAM_ISMULTI] ) ? 1 : 2 )
            ->textListParams(
                // Should be quoted or monospace for presentation purposes,
                //   but textListParams() doesn't do this.
                array_map( static function ( $val ) {
                    return "\"$val\"";
                }, self::INFINITY_VALS )
            );
 
        return $info;
    }
 
    public static function normalizeExpiry( ?string $expiry = null, ?int $style = null ) {
        if ( $expiry === null ) {
            return null;
        }
        if ( in_array( $expiry, self::INFINITY_VALS, true ) ) {
            return 'infinity';
        }
 
        // ConvertibleTimestamp::time() used so we can fake the current time in ExpiryDefTest.
        $unix = strtotime( $expiry, ConvertibleTimestamp::time() );
        if ( $unix === false || !self::isInMwRange( $unix ) ) {
            // Invalid expiry.
            throw new InvalidArgumentException( "Invalid expiry value: {$expiry}" );
        }
 
        // Don't pass 0, since ConvertibleTimestamp interprets that to mean the current timestamp.
        // '00' does the right thing. Without this check, calling normalizeExpiry()
        // with 1970-01-01T00:00:00Z incorrectly returns the current time.
        $expiryConvertibleTimestamp = new ConvertibleTimestamp( $unix === 0 ? '00' : $unix );
 
        if ( $style !== null ) {
            return $expiryConvertibleTimestamp->getTimestamp( $style );
        }
 
        return $expiryConvertibleTimestamp;
    }
 
    private static function isInMwRange( int $unix ): bool {
        return $unix > strtotime( '0000-01-01T00:00:00Z' )
            && $unix < strtotime( '9999-12-31T00:00:00Z' );
    }
 
    public static function normalizeUsingMaxExpiry( ?string $expiry, ?string $maxExpiryDuration, ?int $style ) {
        if ( self::expiryExceedsMax( $expiry, $maxExpiryDuration ) ) {
            return self::normalizeExpiry( $maxExpiryDuration, $style );
        }
        return self::normalizeExpiry( $expiry, $style );
    }
 
    public function checkSettings( string $name, $settings, array $options, array $ret ): array {
        $ret = parent::checkSettings( $name, $settings, $options, $ret );
 
        $ret['allowedKeys'][] = self::PARAM_USE_MAX;
        $ret['allowedKeys'][] = self::PARAM_MAX;
 
        return $ret;
    }
 
    private static function expiryExceedsMax( ?string $expiry, ?string $max = null ): bool {
        $expiry = self::normalizeExpiry( $expiry );
        $max = self::normalizeExpiry( $max );
 
        if ( !$max || !$expiry || $expiry === 'infinity' ) {
            // Either there is no max or given expiry was invalid.
            return false;
        }
 
        return $expiry > $max;
    }
 
}