EmailUser.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Mail;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MainConfigNames;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Preferences\MultiUsernameFilter;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\User\CentralId\CentralIdLookup;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserFactory;
use StatusValue;
use UnexpectedValueException;
use Wikimedia\Message\IMessageFormatterFactory;
use Wikimedia\Message\ITextFormatter;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\Message\MessageValue;
 
class EmailUser {
    public const array CONSTRUCTOR_OPTIONS = [
        MainConfigNames::EnableEmail,
        MainConfigNames::EnableUserEmail,
        MainConfigNames::PasswordSender,
        MainConfigNames::UserEmailUseReplyTo,
    ];
 
    private readonly HookRunner $hookRunner;
 
    private string $editToken = '';
 
    public function __construct(
        private readonly ServiceOptions $options,
        HookContainer $hookContainer,
        private readonly UserOptionsLookup $userOptionsLookup,
        private readonly CentralIdLookup $centralIdLookup,
        private readonly UserFactory $userFactory,
        private readonly IEmailer $emailer,
        private readonly IMessageFormatterFactory $messageFormatterFactory,
        private readonly ITextFormatter $contLangMsgFormatter,
        private readonly Authority $sender,
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    public function validateTarget( UserEmailContact $target ): StatusValue {
        $targetIdentity = $target->getUser();
 
        if ( !$targetIdentity->getId() ) {
            return StatusValue::newFatal( 'emailnotarget' );
        }
 
        if ( !$target->isEmailConfirmed() ) {
            return StatusValue::newFatal( 'noemailtext' );
        }
 
        $targetUser = $this->userFactory->newFromUserIdentity( $targetIdentity );
        if ( !$targetUser->canReceiveEmail() ) {
            return StatusValue::newFatal( 'nowikiemailtext' );
        }
 
        $senderUser = $this->userFactory->newFromAuthority( $this->sender );
        if (
            !$this->userOptionsLookup->getOption( $targetIdentity, 'email-allow-new-users' ) &&
            $senderUser->isNewbie()
        ) {
            return StatusValue::newFatal( 'nowikiemailtext' );
        }
 
        $muteList = $this->userOptionsLookup->getOption(
            $targetIdentity,
            'email-blacklist',
            ''
        );
        if ( $muteList ) {
            $muteList = MultiUsernameFilter::splitIds( $muteList );
            $senderId = $this->centralIdLookup->centralIdFromLocalUser( $this->sender->getUser() );
            if ( $senderId !== 0 && in_array( $senderId, $muteList ) ) {
                return StatusValue::newFatal( 'nowikiemailtext' );
            }
        }
 
        return StatusValue::newGood();
    }
 
    public function canSend(): StatusValue {
        if (
            !$this->options->get( MainConfigNames::EnableEmail ) ||
            !$this->options->get( MainConfigNames::EnableUserEmail )
        ) {
            return StatusValue::newFatal( 'usermaildisabled' );
        }
 
        $user = $this->userFactory->newFromAuthority( $this->sender );
 
        // Run this before checking 'sendemail' permission
        // to show appropriate message to anons (T160309)
        if ( !$user->isEmailConfirmed() ) {
            return StatusValue::newFatal( 'mailnologin' );
        }
 
        $status = PermissionStatus::newGood();
        if ( !$this->sender->isDefinitelyAllowed( 'sendemail', $status ) ) {
            return $status;
        }
 
        $hookErr = false;
 
        // TODO Remove deprecated hooks
        $this->hookRunner->onUserCanSendEmail( $user, $hookErr );
        $this->hookRunner->onEmailUserPermissionsErrors( $user, $this->editToken, $hookErr );
        if ( is_array( $hookErr ) ) {
            // SpamBlacklist uses null for the third element, and there might be more handlers not using an array.
            $msgParamsArray = is_array( $hookErr[2] ) ? $hookErr[2] : [];
            $ret = StatusValue::newFatal( $hookErr[1], ...$msgParamsArray );
            $ret->value = $hookErr[0];
            return $ret;
        }
 
        return StatusValue::newGood();
    }
 
    public function authorizeSend(): StatusValue {
        $status = $this->canSend();
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $status = PermissionStatus::newGood();
        if ( !$this->sender->authorizeAction( 'sendemail', $status ) ) {
            return $status;
        }
 
        $hookRes = $this->hookRunner->onEmailUserAuthorizeSend( $this->sender, $status );
        if ( !$hookRes && !$status->isGood() ) {
            return $status;
        }
 
        return StatusValue::newGood();
    }
 
    public function sendEmailUnsafe(
        UserEmailContact $target,
        string $subject,
        string $text,
        bool $CCMe,
        string $langCode
    ): StatusValue {
        $senderIdentity = $this->sender->getUser();
        $targetStatus = $this->validateTarget( $target );
        if ( !$targetStatus->isGood() ) {
            return $targetStatus;
        }
 
        $senderUser = $this->userFactory->newFromAuthority( $this->sender );
 
        $toAddress = MailAddress::newFromUser( $target );
        $fromAddress = MailAddress::newFromUser( $senderUser );
 
        // Add a standard footer and trim up trailing newlines
        $text = rtrim( $text ) . "\n\n-- \n";
        $text .= $this->contLangMsgFormatter->format(
            MessageValue::new( 'emailuserfooter', [ $fromAddress->name, $toAddress->name ] )
        );
 
        $text .= "\n" . $this->contLangMsgFormatter->format(
            MessageValue::new(
                'specialmute-email-footer',
                [
                    $this->getSpecialMuteCanonicalURL( $senderIdentity->getName() ),
                    $senderIdentity->getName()
                ]
            )
        );
 
        $error = false;
        // TODO Remove deprecated ugly hook
        if ( !$this->hookRunner->onEmailUser( $toAddress, $fromAddress, $subject, $text, $error ) ) {
            if ( $error instanceof StatusValue ) {
                return $error;
            } elseif ( $error === false || $error === '' || $error === [] ) {
                // Possibly to tell HTMLForm to pretend there was no submission?
                return StatusValue::newFatal( 'hookaborted' );
            } elseif ( $error === true ) {
                // Hook sent the mail itself and indicates success?
                return StatusValue::newGood();
            } elseif ( is_array( $error ) ) {
                $status = StatusValue::newGood();
                foreach ( $error as $e ) {
                    $status->fatal( $e );
                }
                return $status;
            } elseif ( $error instanceof MessageSpecifier ) {
                return StatusValue::newFatal( $error );
            } else {
                // Setting $error to something else was deprecated in 1.29 and
                // removed in 1.36, and so an exception is now thrown
                $type = get_debug_type( $error );
                throw new UnexpectedValueException(
                    'EmailUser hook set $error to unsupported type ' . $type
                );
            }
        }
 
        $hookStatus = StatusValue::newGood();
        $hookRes = $this->hookRunner->onEmailUserSendEmail(
            $this->sender,
            $fromAddress,
            $target,
            $toAddress,
            $subject,
            $text,
            $hookStatus
        );
        if ( !$hookRes && !$hookStatus->isGood() ) {
            return $hookStatus;
        }
 
        [ $mailFrom, $replyTo ] = $this->getFromAndReplyTo( $fromAddress );
 
        $status = $this->emailer->send(
            $toAddress,
            $mailFrom,
            $subject,
            $text,
            null,
            [ 'replyTo' => $replyTo ]
        );
 
        if ( !$status->isGood() ) {
            return $status;
        }
 
        // if the user requested a copy of this mail, do this now,
        // unless they are emailing themselves, in which case one
        // copy of the message is sufficient.
        if ( $CCMe && !$toAddress->equals( $fromAddress ) ) {
            $userMsgFormatter = $this->messageFormatterFactory->getTextFormatter( $langCode );
            $ccTo = $fromAddress;
            $ccFrom = $fromAddress;
            $ccSubject = $userMsgFormatter->format(
                MessageValue::new( 'emailccsubject' )->plaintextParams(
                    $target->getUser()->getName(),
                    $subject
                )
            );
            $ccText = $text;
 
            $this->hookRunner->onEmailUserCC( $ccTo, $ccFrom, $ccSubject, $ccText );
 
            [ $mailFrom, $replyTo ] = $this->getFromAndReplyTo( $ccFrom );
 
            $ccStatus = $this->emailer->send(
                $ccTo,
                $mailFrom,
                $ccSubject,
                $ccText,
                null,
                [ 'replyTo' => $replyTo ]
            );
            $status->merge( $ccStatus );
        }
 
        $this->hookRunner->onEmailUserComplete( $toAddress, $fromAddress, $subject, $text );
 
        return $status;
    }
 
    private function getFromAndReplyTo( MailAddress $fromAddress ): array {
        if ( $this->options->get( MainConfigNames::UserEmailUseReplyTo ) ) {
            $mailFrom = new MailAddress(
                $this->options->get( MainConfigNames::PasswordSender ),
                $this->contLangMsgFormatter->format( MessageValue::new( 'emailsender' ) )
            );
            $replyTo = $fromAddress;
        } else {
            $mailFrom = $fromAddress;
            $replyTo = null;
        }
        return [ $mailFrom, $replyTo ];
    }
 
    private function getSpecialMuteCanonicalURL( string $targetName ): string {
        if ( defined( 'MW_PHPUNIT_TEST' ) ) {
            return "Ceci n'est pas une URL";
        }
        return SpecialPage::getTitleFor( 'Mute', $targetName )->getCanonicalURL();
    }
 
    public function setEditToken( string $token ): void {
        $this->editToken = $token;
    }
 
}