Adding filterbyhashtag method for HeartbeatStreamServices

new HeartbeatHashtag block

config/schema/heartbeat.schema.yml

@@ -92,3 +92,11 @@ heartbeat_friendship.config:
     data:
       type: blob
       label: 'Data structure comprising all of the friendship states for all users'
+
+heartbeat_hashtag.config:
+  type: config_object
+  label: 'Hashtag selections'
+  mapping:
+    tid:
+      type: integer
+      label: 'The Taxonomy term to be used when filtering a Heartbeat Stream'

heartbeat.routing.yml

@@ -112,3 +112,11 @@ heartbeat.heartbeat_update_feed_form:
   requirements:
     _access: 'TRUE'
 
+heartbeat.heartbeat_filter_feed:
+  path: '/heartbeat/filter-feed/{tid}'
+  defaults:
+    _controller: '\Drupal\heartbeat\Controller\HeartbeatController::filterFeed'
+    _title: 'Heartbeat Filter Feed'
+  requirements:
+    _access: 'TRUE'
+

heartbeat.services.yml

@@ -5,7 +5,7 @@ services:
 
   heartbeatstream:
     class: Drupal\heartbeat\HeartbeatStreamServices
-    arguments: ["@entity_type.manager", "@entity_type.repository", '@entity.query', '@config.factory']
+    arguments: ["@entity_type.manager", "@entity_type.repository", '@entity.query', '@config.factory', '@database']
 
   heartbeatstreamalt:
     class: Drupal\heartbeat\HeartbeatAltServices

js/heartbeat.js

@@ -10,7 +10,6 @@
             // console.log(divs);
             divs.forEach(function (anchor) {
               var userId = anchor.href.substring(anchor.href.indexOf('friendship') + 11, anchor.href.indexOf('?destination'));
-              console.log(userId);
               JSON.parse(drupalSettings.friendData).forEach(function (friendship) {
                 if (friendship.uid_target === userId && friendship.uid == drupalSettings.user.uid && friendship.status == 0) {
                   anchor.innerHTML = 'Friendship Pending';

src/Controller/HeartbeatController.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\heartbeat\Controller;
 
+use Drupal\block\BlockViewBuilder;
 use Drupal\Component\Utility\Xss;
 use Drupal\Core\Controller\ControllerBase;
 use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
@@ -167,12 +168,19 @@ class HeartbeatController extends ControllerBase implements ContainerInjectionIn
     $myConfig->set('message', $arg)->save();
     \Drupal::logger('HeartbeatController')->debug('My argument is %arg', ['%arg' => $arg]);
 
-    return \Drupal\block\BlockViewBuilder::lazyBuilder('heartbeatblock', 'teaser');
+    return BlockViewBuilder::lazyBuilder('heartbeatblock', 'teaser');
   }
 
 
   public function updateFeed($arg) {
     \Drupal::logger('HeartbeatController::updater')->debug('Jigga what is %arg', ['%arg' => $arg]);
+  }
+
+  public function filterFeed($tid) {
+    $myConfig = \Drupal::service('config.factory')->getEditable('heartbeat_hashtag.settings');
+    $myConfig->set('tid', $tid)->save();
+
+    return BlockViewBuilder::lazyBuilder('heartbeathashblock', 'teaser');
 
   }
 

src/HeartbeatStreamServices.php

@@ -5,6 +5,8 @@ namespace Drupal\heartbeat;
 use Drupal\Core\Entity\EntityTypeManager;
 use Drupal\Core\Entity\EntityTypeRepository;
 use Drupal\Core\Entity\Query\QueryFactory;
+use Drupal\Core\Database\Connection;
+//use Drupal\Core\Database\Driver\pgsql\Connection;
 use Drupal\Core\Config\ConfigFactoryInterface;
 
 /**
@@ -48,17 +50,27 @@ class HeartbeatStreamServices {
    */
   protected $configFactory;
 
+
+  /**
+   * @var \Drupal\Core\Database\Database
+   */
+
+  protected $database;
+
   /**
    * Constructor.
    * @param EntityTypeManager $entityTypeManager
    * @param EntityTypeRepository $entityTypeRepository
    * @param QueryFactory $entityQuery
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $configFactory
+   * @param \Drupal\Core\Database\Database $database
    */
-  public function __construct(EntityTypeManager $entityTypeManager, EntityTypeRepository $entityTypeRepository, QueryFactory $entityQuery, ConfigFactoryInterface $configFactory) {
+  public function __construct(EntityTypeManager $entityTypeManager, EntityTypeRepository $entityTypeRepository, QueryFactory $entityQuery, ConfigFactoryInterface $configFactory, Connection $database) {
     $this->entityTypeManager = $entityTypeManager;
     $this->entityTypeRepository = $entityTypeRepository;
     $this->entityQuery = $entityQuery;
     $this->configFactory = $configFactory;
+    $this->database = $database;
   }
 
   /**
@@ -170,6 +182,62 @@ class HeartbeatStreamServices {
     return null;
   }
 
+
+  public function createHashStreamForUidsByType($uids, $type, $tid) {
+    $currentUid = \Drupal::currentUser()->id();
+//    $nids = $this->entityQuery->get('node')
+    $query = $this->database->query('
+      SELECT id
+      FROM heartbeat_field_revision hr
+      INNER JOIN node n ON n.nid = hr.nid
+      INNER JOIN node__field_tags fu ON fu.entity_id = n.nid 
+      WHERE fu.field_tags_target_id = :tid', array(
+        ':tid' => $tid
+      )
+    );
+    $hids = array();
+    foreach ($query->fetchAllKeyed() as $id => $row) {
+      $hids[] = $id;
+    }
+
+
+//    $stream = $this->entityTypeManager->getStorage('heartbeat_stream')->load(array_values($this->loadStream($type))[0]);
+//    if ($stream !== null) {
+//      $types = array();
+//      foreach ($stream->getTypes() as $heartbeatType) {
+//        $value = $heartbeatType->getValue()['target_id'];
+//        if ($value !== "0") {
+//          $types[] = $value;
+//        }
+//      }
+//      $uids[] = $currentUid;
+
+
+    if (!empty($hids)) {
+      $beats = $this->entityTypeManager->getStorage('heartbeat')
+        ->loadMultiple($this->entityQuery->get('heartbeat')
+          ->condition('status', 1)
+          ->condition('uid', $uids, 'IN')
+          ->condition('id', $hids, 'IN')
+          ->sort('created', 'DESC')
+          ->execute());
+
+      if (count($beats) > 0) {
+        $this->lastId = call_user_func('end', array_keys($beats));
+
+        $this->configFactory->getEditable('heartbeat_update_feed.settings')
+          ->set('lastId', $this->lastId)
+          ->set('update', FALSE)
+          ->set('timestamp', array_values($beats)[0]->getRevisionCreationTime())
+          ->save();
+
+        return $beats;
+      }
+    }
+    return null;
+  }
+
+
   public function updateStreamForUidsByType($uids, $type) {
     $currentUid = \Drupal::currentUser()->id();
     $stream = $this->entityTypeManager->getStorage('heartbeat_stream')->load(array_values($this->loadStream($type))[0]);

src/Plugin/Block/HeartbeatHashBlock.php

@@ -0,0 +1,208 @@
+<?php
+
+namespace Drupal\heartbeat\Plugin\Block;
+
+use Drupal\Core\Block\BlockBase;
+use Drupal\Core\Entity\EntityTypeManager;
+use Drupal\Core\Form\FormBuilder;
+use Drupal\flag\FlagService;
+use Drupal\User\Entity\User;
+use Drupal\Flag\Entity\Flag;
+use Drupal\Core\Datetime\DateFormatter;
+use Drupal\file\Entity\File;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\Core\Database\Database;
+use Drupal\heartbeat\HeartbeatTypeServices;
+use Drupal\heartbeat\HeartbeatStreamServices;
+use Drupal\heartbeat\HeartbeatService;
+
+
+/**
+ * Provides a 'HeartbeatBlock' block.
+ *
+ * @Block(
+ *  id = "heartbeat_hash_block",
+ *  admin_label = @Translation("Heartbeat Hash block"),
+ * )
+ */
+class HeartbeatHashBlock extends BlockBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * Drupal\heartbeat\HeartbeatTypeServices definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatTypeServices
+   */
+  protected $heartbeatTypeServices;
+  /**
+   * Drupal\heartbeat\HeartbeatStreamServices definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatStreamServices
+   */
+  protected $heartbeatStreamServices;
+  /**
+   * Drupal\heartbeat\HeartbeatService definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatService
+   */
+  protected $heartbeatService;
+
+  protected $entityTypeManager;
+
+  protected $dateFormatter;
+
+  protected $flagService;
+
+  protected $formBuilder;
+  /**
+   * Construct.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param string $plugin_definition
+   *   The plugin implementation definition.
+   */
+  public function __construct(
+        array $configuration,
+        $plugin_id,
+        $plugin_definition,
+        HeartbeatTypeServices $heartbeat_heartbeattype,
+	HeartbeatStreamServices $heartbeatstream,
+	HeartbeatService $heartbeat, EntityTypeManager $entity_type_manager, DateFormatter $date_formatter, FlagService $flag_service, FormBuilder $form_builder
+  ) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->heartbeatTypeServices = $heartbeat_heartbeattype;
+    $this->heartbeatStreamServices = $heartbeatstream;
+    $this->heartbeatService = $heartbeat;
+    $this->entityTypeManager = $entity_type_manager;
+    $this->dateFormatter = $date_formatter;
+    $this->flagService = $flag_service;
+    $this->formBuilder = $form_builder;
+  }
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('heartbeat.heartbeattype'),
+      $container->get('heartbeatstream'),
+      $container->get('heartbeat'),
+      $container->get('entity_type.manager'),
+      $container->get('date.formatter'),
+      $container->get('flag'),
+      $container->get('form_builder')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   * @throws \Drupal\Core\Database\InvalidQueryException
+   */
+  public function build() {
+
+    $myConfig = \Drupal::service('config.factory')->getEditable('heartbeat_feed.settings');
+    $tagConfig = \Drupal::config('heartbeat_hashtag.settings');
+    $tid = $tagConfig->get('tid');
+    $friendData = \Drupal::config('heartbeat_friendship.settings')->get('data');
+
+    $feed = $myConfig->get('message');
+    $uids = null;
+    $messages = array();
+
+    $query = Database::getConnection()->select('heartbeat_friendship', 'hf')
+      ->fields('hf',['uid', 'uid_target']);
+    $conditionOr = $query->orConditionGroup()
+      ->condition('hf.uid', \Drupal::currentUser()->id())
+      ->condition('hf.uid_target', \Drupal::currentUser()->id());
+
+    $results = $query->condition($conditionOr)->execute();
+    if ($result = $results->fetchAll()) {
+      $uids = array();
+      foreach ($result as $uid) {
+        $uids[] = $uid->uid_target;
+        $uids[] = $uid->uid;
+      }
+    }
+      if ($feed !== null) {
+      $uids = count($uids) > 1 ? array_unique($uids) : $uids;
+        if (!empty($uids)) {
+          foreach ($this->heartbeatStreamServices->createHashStreamForUidsByType($uids, $feed, $tid) as $heartbeat) {
+            $this->renderMessage($messages, $heartbeat);
+          }
+        } else {
+          foreach ($this->heartbeatStreamServices->createStreamByType($feed) as $heartbeat) {
+            $this->renderMessage($messages, $heartbeat);
+          }
+        }
+      } else {
+//        foreach ($this->heartbeatStreamServices->createStreamForUids($uids) as $heartbeat) {
+        foreach ($this->heartbeatStreamServices->loadAllStreams() as $heartbeat) {
+          \Drupal::logger('HeartbeatHashBlock')->error('Could not load Heartbeats for Hashtag');
+          $this->renderMessage($messages, $heartbeat);
+        }
+      }
+
+      return [
+        '#theme' => 'heartbeat_stream',
+        '#messages' => $messages,
+        '#attached' => array(
+          'library' => 'heartbeat/heartbeat',
+          'drupalSettings' => [
+            'activeFeed' => 'jigga',
+            'friendData' => $friendData,
+          ]
+        ),
+        '#cache' => array('max-age' => 0)
+      ];
+
+    }
+
+    private function renderMessage(array &$messages, $heartbeat) {
+
+      $timeago = $this->dateFormatter->formatInterval(REQUEST_TIME - $heartbeat->getCreatedTime());
+      $user = $heartbeat->getOwner();
+//      $rendered = $this->entityTypeManager->getViewBuilder('user')->view($user, 'full');
+      $userView = user_view($user, 'compact');
+//      $flag = $this->flagService->getFlagById("friendship");
+//      $flagLink = $flag->getLinkTypePlugin()->getAsLink($flag, $user);
+//      $flagUrl = $flagLink->getUrl()->toString();
+//      $flagText = $flagLink->getText();
+      $profilePic = $user->get('user_picture')->getValue()[0]['target_id'];
+
+//      $commentForm = $this->formBuilder->getForm('Drupal\comment\CommentForm', $heartbeat);
+
+//      $flagRenderable = $flagLink->toRenderable();
+
+      if ($profilePic === null) {
+        $profilePic = 86;
+      }
+
+      $pic = File::load($profilePic);
+
+      if ($pic !== null) {
+        $style = $this->entityTypeManager->getStorage('image_style')->load('thumbnail');
+
+        $rendered = $style->buildUrl($pic->getFileUri());
+      }
+
+
+//TODO GET ACTION AND APPEND TO CLASSES IN FLAG WRAPPER
+
+      $messages[] = array('heartbeat' => $heartbeat->getMessage()->getValue()[0]['value'],
+        'userPicture' => $rendered,
+        'userId' => $user->id(),
+        'timeAgo' => $timeago,
+        'id' => $heartbeat->id(),
+//        'friendFlag' => $flagUrl,
+//        'friendFlagText' => $flagText,
+//        'flagId' => $flag->id(),
+        'user' => $userView,
+//        'commentForm' => $commentForm
+        );
+    }
+}