class ActivityWorkerLogger in Open Social 10.1.x

A report worker.

@QueueWorker( id = "activity_creator_logger", title = @Translation("Process activity loggers."), cron = {"time" = 60} )

This QueueWorker is responsible for processing ActivityLog items and will retrieve recipients batched and then create new queue items for processing in QueueWorker ActivityWorkerActivities.

Hierarchy

• class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
  • class \Drupal\Core\Queue\QueueWorkerBase implements QueueWorkerInterface
    • class \Drupal\activity_creator\Plugin\QueueWorker\ActivityWorkerBase uses StringTranslationTrait
      • class \Drupal\activity_creator\Plugin\QueueWorker\ActivityWorkerLogger

File

modules/custom/activity_creator/src/Plugin/QueueWorker/ActivityWorkerLogger.php, line 18

Namespace

Drupal\activity_creator\Plugin\QueueWorker

class ActivityWorkerLogger extends ActivityWorkerBase {

  /**
   * The ActivityContext manager.
   *
   * @var \Drupal\activity_creator\Plugin\ActivityContextManager
   */
  protected $contextPluginManager;

  /**
   * The state.
   *
   * @var \Drupal\Core\State\
   */
  protected $state;

  /**
   * {@inheritdoc}
   */
  public function processItem($data) {

    // Get 100 Recipients at a time.
    $limit = 0;

    // @todo Move all this logic to a service.
    $context_plugin_manager = \Drupal::service('plugin.manager.activity_context.processor');

    /** @var \Drupal\activity_creator\Plugin\ActivityContextBase $plugin */

    // @todo Do we need multiple context plugins? If so should we call Manager?
    $plugin = $context_plugin_manager
      ->createInstance($data['context']);
    $recipients = $plugin
      ->getRecipients($data, $data['last_uid'], $limit);
    if (!empty($recipients)) {

      // Default activity creator template.
      $activity_creator_data = [
        'mid' => $data['mid'],
        'message_template' => $data['message_template'],
        'actor' => $data['actor'],
        'context' => $data['context'],
        'destination' => $data['destination'],
        'related_object' => $data['related_object'],
      ];

      // Get all the activity recipient types. Maintain target IDs as key.
      $activity_by_type = array_column($recipients, 'target_type');
      foreach ($activity_by_type as $recipients_key => $target_type) {

        // For all one to one target entity types we create an activity.
        if ($target_type !== 'user') {
          $activity_creator_data['recipient'] = $recipients[$recipients_key];
          $this
            ->createQueueItem('activity_creator_activities', $activity_creator_data);
        }
        if ($target_type === 'user') {
          $user_recipients[] = $recipients[$recipients_key];
        }
        $last_uid = $recipients[$recipients_key];
      }

      // When the activity should be created for a one to many user entity
      // we like to group these.
      if (!empty($user_recipients)) {
        $activity_creator_data['recipient'] = $user_recipients;
        $this
          ->createQueueItem('activity_creator_activities', $activity_creator_data);
      }

      // Now create new queue item for activity_creator_logger if necessary.
      if ($limit !== 0 && isset($last_uid) && count($recipients) >= $limit) {
        $data['last_uid'] = $last_uid;
        $data['status'] = 'processing';
        $this
          ->createQueueItem('activity_creator_logger', $data);
      }
    }
    else {
      $activity_creator_data = [
        'mid' => $data['mid'],
        'message_template' => $data['message_template'],
        'actor' => $data['actor'],
        // Not necessary?
        'context' => $data['context'],
        'destination' => $data['destination'],
        'related_object' => $data['related_object'],
      ];
      $this
        ->createQueueItem('activity_creator_activities', $activity_creator_data);
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ActivityWorkerBase::createQueueItem	protected	function	Simple reporter log and display information about the queue.
ActivityWorkerLogger::$contextPluginManager	protected	property	The ActivityContext manager.
ActivityWorkerLogger::$state	protected	property	The state.
ActivityWorkerLogger::processItem	public	function	Works on a single queue item. Overrides QueueWorkerInterface::processItem
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition	2
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
PluginBase::__construct	public	function	Constructs a \Drupal\Component\Plugin\PluginBase object.	98
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	4
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.