PHP static::messages方法代码示例

 /**
  * Rolls back the configured migrations.
  */
 public function rollback()
 {
     static::$messages = new DrushLogMigrateMessage();
     $query = \Drupal::entityQuery('migration');
     $names = $query->execute();
     // Order the migrations according to their dependencies.
     /** @var MigrationInterface[] $migrations */
     $migrations = \Drupal::entityManager()->getStorage('migration')->loadMultiple($names);
     // Assume we want all those tagged 'Drupal %'.
     foreach ($migrations as $migration_id => $migration) {
         $keep = FALSE;
         $tags = $migration->get('migration_tags');
         foreach ($tags as $tag) {
             if (strpos($tag, 'Drupal ') === 0) {
                 $keep = TRUE;
                 break;
             }
         }
         if (!$keep) {
             unset($migrations[$migration_id]);
         }
     }
     // Roll back in reverse order.
     $this->migrationList = array_reverse($migrations);
     foreach ($this->migrationList as $migration_id => $migration) {
         drush_print(dt('Rolling back @migration', ['@migration' => $migration_id]));
         $executable = new MigrateExecutable($migration, static::$messages);
         // drush_op() provides --simulate support.
         drush_op([$executable, 'rollback']);
         $migration->delete();
     }
 }

 /**
  * Resets the form model to its vanilla form. Mostly used for tests.
  */
 public static function reset()
 {
     static::$field_data = array();
     static::$rules = array();
     static::$messages = array();
     static::$validation = false;
     static::$loaded = null;
     static::$custom_validators_loaded = null;
 }

 public static function isValid()
 {
     $validation = Validator::make(Input::all(), static::$rules);
     if ($validation->passes()) {
         return true;
     }
     static::$messages = $validation->messages();
     return false;
 }

 public function validate($input)
 {
     Event::fire('validating', [$input]);
     static::$messages = static::$messages ? static::$messages : [];
     $validator = V::make($input, static::$rules, static::$messages);
     if ($validator->fails()) {
         $this->errors = $validator->messages();
         return false;
     }
     return true;
 }

 /**
  * Reset current message class' code to message mappings cache
  *
  * ```php
  *     MyMessage::setMappings([
  *         MyMessage::MSG_HELLO => 'Hello %s'
  *     ]);
  * ```
  *
  * @param  array $messages messages mapping array
  * @param  bool $manual manually, not auto load from $loader
  * @access public
  * @api
  */
 public static function setMappings(array $messages, $manual = true)
 {
     $class = get_called_class();
     if ($manual) {
         // set default
         static::$messages = $messages;
         // status changed
         self::setStatus();
     } else {
         // set cache
         self::$mappings[$class] = array_replace($class::getMappings(), $messages);
     }
 }

 /**
  * @dataProvider filters
  */
 public function testFilter($filter, $expected)
 {
     static::$messages = [];
     $logger = new Logger();
     $dispatcher = new Dispatcher(['logger' => $logger, 'targets' => [new TestTarget(array_merge($filter, ['logVars' => []]))], 'flushInterval' => 1]);
     $logger->log('testA', Logger::LEVEL_INFO);
     $logger->log('testB', Logger::LEVEL_ERROR);
     $logger->log('testC', Logger::LEVEL_WARNING);
     $logger->log('testD', Logger::LEVEL_TRACE);
     $logger->log('testE', Logger::LEVEL_INFO, 'application');
     $logger->log('testF', Logger::LEVEL_INFO, 'application.components.Test');
     $logger->log('testG', Logger::LEVEL_ERROR, 'yii.db.Command');
     $logger->log('testH', Logger::LEVEL_ERROR, 'yii.db.Command.whatever');
     $this->assertEquals(count($expected), count(static::$messages));
     $i = 0;
     foreach ($expected as $e) {
         $this->assertEquals('test' . $e, static::$messages[$i++][0]);
     }
 }

 public static function clearMessages()
 {
     static::$messages = array();
 }

 /**
  * @param bool $combined
  * @return array
  */
 public static function getMessages($combined = false)
 {
     if (!isset(static::$messages, static::$combinedMessages)) {
         $messages = [];
         $combinedMessages = [];
         foreach (static::getValues() as $key => $value) {
             if (substr($key, 0, 5) === 'MESSAGE_') {
                 $messages[$key] = $value;
                 $combinedMessages[$value] = $value;
             }
         }
         static::$messages = $messages;
         static::$combinedMessages = $combinedMessages;
     }
     return $combined ? static::$combinedMessages : static::$messages;
 }

 /**
  * Plugin Constructor
  *
  * Constructor performs...
  *  - Set $CI Reference
  *  - Load Plugins Model
  *  - Set the plugin directory
  *  - Get plugins from DB and include enabled plugins
  *  - Load the plugins by initializing the plugin Classes
  *
  * @access public
  */
 public function __construct()
 {
     // Codeigniter instance
     static::$CI =& get_instance();
     // Set a static handler for the instance (So it can be called outside of CI classes, IE: below)
     // No real need to setup a singleton with CI....
     static::$instance = $this;
     // Load the plugins model
     static::$CI->load->model('Plugins_model');
     // Load the plugins helper
     static::$CI->load->helper('plugin');
     // Set a shorter handle for the plugins model
     static::$PM = static::$CI->Plugins_model;
     static::$messages = array('error' => [], 'debug' => [], 'warn' => []);
     // Set plugin path
     $this->set_plugin_dir();
     // Get all activated plugins
     $this->get_plugins();
     // Include plugins
     $this->include_enabled_plugins();
     // Load them
     $this->load_enabled_plugins();
 }

 protected function printPassMessages()
 {
     foreach (static::$messages as $message) {
         $mark = $this->formatWithColor('fg-green', '    ✓ ');
         $this->write($mark);
         $this->writeWithColor('fg-white', $message);
     }
     static::$messages = [];
 }

 /**
  * Returns the array of messages
  * 
  * @return array
  */
 public function getMessages()
 {
     $messages = static::$messages;
     static::$messages = [];
     return $messages;
 }

 /**
  * flush the messages to browser by adding to HTML page
  *
  * @return void
  * @access public
  * @static
  * @api
  */
 public static function flush()
 {
     if (static::hasHttpHeader() && count(static::$messages)) {
         echo '<script>', static::generateScript(), '</script>';
     }
     static::$messages = [];
 }

 /**
  * flush the messages to browser by adding to HTML page
  *
  * @return void
  * @access public
  * @static
  * @api
  */
 public static function flush()
 {
     // Check content type
     $html = true;
     foreach (headers_list() as $header) {
         if (stripos($header, 'content-type:') === 0) {
             if (stripos($header, 'application/javascript') !== false || stripos($header, 'text/javascript') !== false) {
                 $html = false;
             } elseif (stripos($header, 'text/html') === false) {
                 return;
             }
             break;
         }
     }
     if (count(static::$messages)) {
         if ($html) {
             echo '<script>', static::generateScript(), '</script>';
         } else {
             echo static::generateScript();
         }
     }
     static::$messages = [];
 }

 /**
  * Run a single migration batch.
  *
  * @param array $initial_ids
  *   The full set of migration IDs to import.
  * @param string $operation
  *   'import' or 'rollback'.
  * @param $context
  *   The batch context.
  */
 public static function run($initial_ids, $operation, &$context)
 {
     if (!static::$listenersAdded) {
         if ($operation == 'import') {
             \Drupal::service('event_dispatcher')->addListener(MigrateEvents::POST_ROW_SAVE, [get_class(), 'onPostRowSave']);
             \Drupal::service('event_dispatcher')->addListener(MigrateEvents::MAP_SAVE, [get_class(), 'onMapSave']);
             \Drupal::service('event_dispatcher')->addListener(MigrateEvents::IDMAP_MESSAGE, [get_class(), 'onIdMapMessage']);
         } else {
             \Drupal::service('event_dispatcher')->addListener(MigrateEvents::POST_ROW_DELETE, [get_class(), 'onPostRowDelete']);
             \Drupal::service('event_dispatcher')->addListener(MigrateEvents::MAP_DELETE, [get_class(), 'onMapDelete']);
         }
         static::$maxExecTime = ini_get('max_execution_time');
         if (static::$maxExecTime <= 0) {
             static::$maxExecTime = 60;
         }
         // Set an arbitrary threshold of 3 seconds (e.g., if max_execution_time is
         // 45 seconds, we will quit at 42 seconds so a slow item or cleanup
         // overhead don't put us over 45).
         static::$maxExecTime -= 3;
         static::$listenersAdded = TRUE;
     }
     if (!isset($context['sandbox']['migration_ids'])) {
         $context['sandbox']['max'] = count($initial_ids);
         $context['sandbox']['current'] = 1;
         // Total number processed for this migration.
         $context['sandbox']['num_processed'] = 0;
         // migration_ids will be the list of IDs remaining to run.
         $context['sandbox']['migration_ids'] = $initial_ids;
         $context['sandbox']['messages'] = [];
         $context['results']['failures'] = 0;
         $context['results']['successes'] = 0;
         $context['results']['operation'] = $operation;
     }
     // Number processed in this batch.
     static::$numProcessed = 0;
     $migration_id = reset($context['sandbox']['migration_ids']);
     /** @var \Drupal\migrate\Entity\Migration $migration */
     $migration = Migration::load($migration_id);
     if ($migration) {
         static::$messages = new MigrateMessageCapture();
         $executable = new MigrateExecutable($migration, static::$messages);
         $migration_name = $migration->label() ? $migration->label() : $migration_id;
         try {
             if ($operation == 'import') {
                 $migration_status = $executable->import();
             } else {
                 $migration_status = $executable->rollback();
             }
         } catch (\Exception $e) {
             static::logger()->error($e->getMessage());
             $migration_status = MigrationInterface::RESULT_FAILED;
         }
         switch ($migration_status) {
             case MigrationInterface::RESULT_COMPLETED:
                 if ($operation == 'import') {
                     $singular_message = 'Upgraded @migration (processed 1 item total)';
                     $plural_message = 'Upgraded @migration (processed @num_processed items total)';
                 } else {
                     $singular_message = 'Rolled back @migration (processed 1 item total)';
                     $plural_message = 'Rolled back @migration (processed @num_processed items total)';
                     $migration->delete();
                 }
                 // Store the number processed in the sandbox.
                 $context['sandbox']['num_processed'] += static::$numProcessed;
                 $message = \Drupal::translation()->formatPlural($context['sandbox']['num_processed'], $singular_message, $plural_message, ['@migration' => $migration_name, '@num_processed' => $context['sandbox']['num_processed']]);
                 $context['sandbox']['messages'][] = $message;
                 static::logger()->notice($message);
                 $context['sandbox']['num_processed'] = 0;
                 $context['results']['successes']++;
                 break;
             case MigrationInterface::RESULT_INCOMPLETE:
                 $singular_message = 'Continuing with @migration (processed 1 item)';
                 $plural_message = 'Continuing with @migration (processed @num_processed items)';
                 $context['sandbox']['messages'][] = \Drupal::translation()->formatPlural(static::$numProcessed, $singular_message, $plural_message, ['@migration' => $migration_name, '@num_processed' => static::$numProcessed]);
                 $context['sandbox']['num_processed'] += static::$numProcessed;
                 break;
             case MigrationInterface::RESULT_STOPPED:
                 $context['sandbox']['messages'][] = t('Operation stopped by request');
                 break;
             case MigrationInterface::RESULT_FAILED:
                 $context['sandbox']['messages'][] = t('Operation on @migration failed', ['@migration' => $migration_name]);
                 $context['results']['failures']++;
                 static::logger()->error('Operation on @migration failed', ['@migration' => $migration_name]);
                 break;
             case MigrationInterface::RESULT_SKIPPED:
                 $context['sandbox']['messages'][] = t('Operation on @migration skipped due to unfulfilled dependencies', ['@migration' => $migration_name]);
                 static::logger()->error('Operation on @migration skipped due to unfulfilled dependencies', ['@migration' => $migration_name]);
                 break;
             case MigrationInterface::RESULT_DISABLED:
                 // Skip silently if disabled.
//.........这里部分代码省略.........

 /**
  * Collect messages retrieved from file processors.
  *
  * @param $messages
  * @param bool $error
  */
 protected function addMessageResponse($messages, $error = false)
 {
     if (is_string($messages)) {
         $messages = [$messages];
     } elseif ($messages instanceof MessageProviderInterface) {
         $messages = $messages->getMessageBag()->getMessages();
     } else {
         return null;
         // We don't have anything to add in this case.
     }
     if ($error) {
         static::$errors = array_merge(static::$errors, $messages);
     } else {
         static::$messages = array_merge(static::$messages, $messages);
     }
 }