PHP GeneralUtility::validEmail方法代码示例

 /**
  * @param Address $address
  * @return bool
  */
 protected function isValid($address)
 {
     $result = true;
     $settings = $this->configurationManager->getConfiguration(ConfigurationManagerInterface::CONFIGURATION_TYPE_SETTINGS, 'H2dmailsub', 'Pidmailsubscribe');
     $validationSettings = $settings['validation'];
     foreach ($validationSettings as $field => $validations) {
         $value = $address->{'get' . ucfirst($field)}();
         foreach ($validations as $validation => $validationSetting) {
             switch ($validation) {
                 case 'required':
                     if ($validationSetting === '1' && empty($value)) {
                         $error = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Validation\\Error', \TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('validation.required', 'h2dmailsub'), time());
                         $this->result->forProperty($field)->addError($error);
                         $result = false;
                     }
                     break;
                 case 'email':
                     if (!empty($value) && $validationSetting === '1' && !\TYPO3\CMS\Core\Utility\GeneralUtility::validEmail($value)) {
                         $error = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Validation\\Error', \TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('validation.email', 'h2dmailsub'), time());
                         $this->result->forProperty($field)->addError($error);
                         $result = false;
                     }
                     break;
             }
         }
     }
     return $result;
 }

 /**
  * This is the main-function for sending Mails
  *
  * @param array $mailTo
  * @param array $mailFrom
  * @param string $subject
  * @param string $emailBody
  *
  * @return integer the number of recipients who were accepted for delivery
  */
 public function send($mailTo, $mailFrom, $subject, $emailBody)
 {
     if (!($mailTo && is_array($mailTo) && GeneralUtility::validEmail(key($mailTo)))) {
         $this->log->error('Given mailto email address is invalid.', $mailTo);
         return FALSE;
     }
     if (!($mailFrom && is_array($mailFrom) && GeneralUtility::validEmail(key($mailFrom)))) {
         $mailFrom = MailUtility::getSystemFrom();
     }
     /* @var $message \TYPO3\CMS\Core\Mail\MailMessage */
     $message = $this->objectManager->get('TYPO3\\CMS\\Core\\Mail\\MailMessage');
     $message->setTo($mailTo)->setFrom($mailFrom)->setSubject($subject)->setCharset(\TYPO3\T3extblog\Utility\GeneralUtility::getTsFe()->metaCharset);
     // send text or html emails
     if (strip_tags($emailBody) === $emailBody) {
         $message->setBody($emailBody, 'text/plain');
     } else {
         $message->setBody($emailBody, 'text/html');
     }
     if (!$this->settings['debug']['disableEmailTransmission']) {
         $message->send();
     }
     $logData = array('mailTo' => $mailTo, 'mailFrom' => $mailFrom, 'subject' => $subject, 'emailBody' => $emailBody, 'isSent' => $message->isSent());
     $this->log->dev('Email sent.', $logData);
     return $logData['isSent'];
 }

 /**
  * return true if the element is valide
  *
  * @param	string $value value to test
  * @return	bool true if the element is valide
  */
 public function isValid($value)
 {
     if ($value == '') {
         return true;
     }
     return GeneralUtility::validEmail($value);
 }

 /**
  * Validates the additional fields' values
  *
  * @param array $submittedData An array containing the data submitted by the add/edit task form
  * @param \TYPO3\CMS\Scheduler\Controller\SchedulerModuleController $schedulerModule Reference to the scheduler backend module
  * @return boolean TRUE if validation was ok (or selected class is not relevant), FALSE otherwise
  */
 public function validateAdditionalFields(array &$submittedData, SchedulerModuleController $schedulerModule)
 {
     $validInput = true;
     if (empty($submittedData[$this->fieldNames['time']])) {
         $schedulerModule->addMessage($GLOBALS['LANG']->sL($this->languageFile . 'error.empty'), FlashMessage::ERROR);
         $validInput = false;
     }
     try {
         $date = new \DateTime($submittedData[$this->fieldNames['time']]);
     } catch (\Exception $e) {
         $schedulerModule->addMessage($GLOBALS['LANG']->sL($this->languageFile . 'error.wrongFormat'), FlashMessage::ERROR);
         $validInput = false;
     }
     if (!empty($submittedData[$this->fieldNames['email']])) {
         $emails = GeneralUtility::trimExplode(';', $submittedData[$this->fieldNames['email']], true);
         foreach ($emails as $key => $email) {
             if (!GeneralUtility::validEmail($email)) {
                 $schedulerModule->addMessage($GLOBALS['LANG']->sL($this->languageFile . 'error.wrongEmail'), FlashMessage::ERROR);
                 $validInput = false;
                 break;
             }
         }
     }
     $validInput = $this->validateTestRunner($submittedData);
     return $validInput;
 }

 /**
  * Check if $value is valid. If it is not valid, needs to add an error
  * to result.
  *
  * @param mixed $value
  * @return void
  */
 public function isValid($value)
 {
     if (empty($value) || !is_string($value)) {
         return;
     }
     if (!GeneralUtility::validEmail($value)) {
         $this->addError($this->renderMessage($this->options['errorMessage'][0], $this->options['errorMessage'][1], 'error'), 1442000235);
     }
 }

 /**
  * Spam-Validation of given Params
  * 		see powermail/doc/SpamDetection for formula
  *
  * @param \In2code\Powermail\Domain\Model\Mail $mail
  * @return bool
  */
 public function isValid($mail)
 {
     if (!$this->settings['spamshield.']['_enable']) {
         return $this->getIsValid();
     }
     $spamFactor = $this->settings['spamshield.']['factor'] / 100;
     // Different checks to increase spam indicator
     $this->honeypodCheck($this->settings['spamshield.']['indicator.']['honeypod']);
     $this->linkCheck($mail, $this->settings['spamshield.']['indicator.']['link'], $this->settings['spamshield.']['indicator.']['linkLimit']);
     $this->nameCheck($mail, $this->settings['spamshield.']['indicator.']['name']);
     $this->sessionCheck($mail, $this->settings['spamshield.']['indicator.']['session']);
     $this->uniqueCheck($mail, $this->settings['spamshield.']['indicator.']['unique']);
     $this->blacklistStringCheck($mail, $this->settings['spamshield.']['indicator.']['blacklistString']);
     $this->blacklistIpCheck($this->settings['spamshield.']['indicator.']['blacklistIp']);
     // spam formula with asymptote 1 (100%)
     if ($this->spamIndicator > 0) {
         $thisSpamFactor = -1 / $this->spamIndicator + 1;
     } else {
         $thisSpamFactor = 0;
     }
     // Save Spam Factor in session for db storage
     $GLOBALS['TSFE']->fe_user->setKey('ses', 'powermail_spamfactor', $this->formatSpamFactor($thisSpamFactor));
     $GLOBALS['TSFE']->storeSessionData();
     // Spam debugging
     if ($this->settings['debug.']['spamshield']) {
         GeneralUtility::devLog('Spamshield (Spamfactor ' . $this->formatSpamFactor($thisSpamFactor) . ')', 'powermail', 0, $this->getMessages());
     }
     // if spam
     if ($thisSpamFactor >= $spamFactor) {
         $this->addError('spam_details', $this->formatSpamFactor($thisSpamFactor));
         $this->setIsValid(FALSE);
         // Send notification email to admin
         if (GeneralUtility::validEmail($this->settings['spamshield.']['email'])) {
             $subject = 'Spam in powermail form recognized';
             $message = 'Possible spam in powermail form on page with PID ' . $GLOBALS['TSFE']->id;
             $message .= "\n\n";
             $message .= 'Spamfactor of this mail: ' . $this->formatSpamFactor($thisSpamFactor) . "\n";
             $message .= "\n\n";
             $message .= 'Failed Spamchecks:' . "\n";
             $message .= Div::viewPlainArray($this->getMessages());
             $message .= "\n\n";
             $message .= 'Given Form variables:' . "\n";
             foreach ($mail->getAnswers() as $answer) {
                 $message .= $answer->getField()->getTitle();
                 $message .= ': ';
                 $message .= $answer->getValue();
                 $message .= "\n";
             }
             $header = 'MIME-Version: 1.0' . "\r\n";
             $header .= 'Content-type: text/html; charset=utf-8' . "\r\n";
             $header .= 'From: powermail@' . GeneralUtility::getIndpEnv('TYPO3_HOST_ONLY') . "\r\n";
             GeneralUtility::plainMailEncoded($this->settings['spamshield.']['email'], $subject, $message, $header);
         }
     }
     return $this->getIsValid();
 }

 /**
  * Server valuation
  *
  * @param \string $value The field value to be evaluated.
  * @param \string $isIn The "isIn" value of the field configuration from TCA
  * @param \bool $set defining if the value is written to the database or not.
  * @return \string
  */
 public function evaluateFieldValue($value, $isIn, &$set)
 {
     if (GeneralUtility::validEmail($value)) {
         $set = 1;
     } else {
         $set = 0;
         $value = 'errorinemail@tryagain.com';
     }
     return $value;
 }

 /**
  * Returns TRUE if submitted value validates according to rule
  *
  * @return bool
  * @see \TYPO3\CMS\Form\Validation\ValidatorInterface::isValid()
  */
 public function isValid()
 {
     if ($this->requestHandler->has($this->fieldName)) {
         $value = $this->requestHandler->getByMethod($this->fieldName);
         if (!\TYPO3\CMS\Core\Utility\GeneralUtility::validEmail($value)) {
             return FALSE;
         }
     }
     return TRUE;
 }

 public function check()
 {
     $checkFailed = '';
     if (isset($this->gp[$this->formFieldName]) && strlen(trim($this->gp[$this->formFieldName])) > 0) {
         $valid = \TYPO3\CMS\Core\Utility\GeneralUtility::validEmail($this->gp[$this->formFieldName]);
         if (!$valid) {
             $checkFailed = $this->getCheckFailed();
         }
     }
     return $checkFailed;
 }

 /**
  * Sends an e-mail, if sender and recipient is an valid e-mail address
  *
  * @param string $sender The sender
  * @param string $recipient The recipient
  * @param string $subject The subject
  * @param string $body E-Mail body
  * @param string $name Optional sendername
  *
  * @return bool true/false if message is sent
  */
 public function sendEmailMessage($sender, $recipient, $subject, $body, $name)
 {
     if (GeneralUtility::validEmail($sender) && GeneralUtility::validEmail($recipient)) {
         $this->mail->setFrom($sender, $name);
         $this->mail->setSubject($subject);
         $this->mail->setBody($body, 'text/html');
         $this->mail->setTo($recipient);
         $this->mail->send();
         return $this->mail->isSent();
     } else {
         return false;
     }
 }

 /**
  * Read Emails from String
  *
  * @param int $uid fe_groups Uid
  * @return array Array with emails
  */
 protected static function getEmailsFromFeGroup($uid)
 {
     /** @var UserRepository $userRepository */
     $userRepository = GeneralUtility::makeInstance(ObjectManager::class)->get(UserRepository::class);
     $users = $userRepository->findByUsergroup($uid);
     $array = [];
     foreach ($users as $user) {
         if (GeneralUtility::validEmail($user->getEmail())) {
             $array[] = $user->getEmail();
         }
     }
     return $array;
 }

 /**
  * Read Emails from String
  *
  * @param int $uid fe_groups Uid
  * @return array Array with emails
  */
 protected static function getEmailsFromFeGroup($uid)
 {
     /** @var UserRepository $userRepository */
     $userRepository = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager')->get('In2code\\Powermail\\Domain\\Repository\\UserRepository');
     $users = $userRepository->findByUsergroup($uid);
     $array = array();
     foreach ($users as $user) {
         if (GeneralUtility::validEmail($user->getEmail())) {
             $array[] = $user->getEmail();
         }
     }
     return $array;
 }

 function process(&$event, $email, $userId)
 {
     if ($email != '' && GeneralUtility::validEmail($email)) {
         $template = $this->conf['view.']['event.']['remind.'][$userId . '.']['template'];
         if (!$template) {
             $template = $this->conf['view.']['event.']['remind.']['all.']['template'];
         }
         $titleText = $this->conf['view.']['event.']['remind.'][$userId . '.']['emailTitle'];
         if (!$titleText) {
             $titleText = $this->conf['view.']['event.']['remind.']['all.']['emailTitle'];
         }
         $this->sendNotification($event, $email, $template, $titleText, '');
     }
 }

 /**
  * Sends an e-mail, if sender and recipient is an valid e-mail address
  *
  * @param string $sender The sender
  * @param string $recipient The recipient
  * @param string $subject The subject
  * @param string $body E-Mail body
  * @param string $name Optional sendername
  * @param array $attachments Array of files (e.g. ['/absolute/path/doc.pdf'])
  *
  * @return bool TRUE/FALSE if message is sent
  */
 public function sendEmailMessage($sender, $recipient, $subject, $body, $name = null, $attachments = [])
 {
     if (GeneralUtility::validEmail($sender) && GeneralUtility::validEmail($recipient)) {
         $this->initialize();
         $this->mailer->setFrom($sender, $name);
         $this->mailer->setSubject($subject);
         $this->mailer->setBody($body, 'text/html');
         $this->mailer->setTo($recipient);
         $this->addAttachments($attachments);
         $this->mailer->send();
         return $this->mailer->isSent();
     } else {
         return false;
     }
 }

 /**
  * Validates the additional fields' values
  *
  * @param array $submittedData An array containing the data submitted by the add/edit task form
  * @param \TYPO3\CMS\Scheduler\Controller\SchedulerModuleController $schedulerModule Reference to the scheduler backend module
  * @return bool TRUE if validation was ok (or selected class is not relevant), FALSE otherwise
  */
 public function validateAdditionalFields(array &$submittedData, SchedulerModuleController $schedulerModule)
 {
     $validInput = true;
     $notificationEmails = GeneralUtility::trimExplode(LF, $submittedData[$this->fieldPrefix . 'NotificationEmail'], true);
     foreach ($notificationEmails as $notificationEmail) {
         if (!GeneralUtility::validEmail($notificationEmail)) {
             $validInput = false;
             break;
         }
     }
     if (empty($submittedData[$this->fieldPrefix . 'NotificationEmail']) || !$validInput) {
         $schedulerModule->addMessage($this->getLanguageService()->sL('LLL:EXT:reports/Resources/Private/Language/locallang_reports.xlf:status_updateTaskField_notificationEmails_invalid'), FlashMessage::ERROR);
         $validInput = false;
     }
     return $validInput;
 }