Major work

Dynamic feed uses two way Ajax callbacks and custom re-rendering of block with feed argument to provide user with an asynchronously loaded feed as per their choice and filtered by friendships

config/install/heartbeat.heartbeatfeed.yml

@@ -0,0 +1 @@
+heartbeat:

config/schema/heartbeat.schema.yml

@@ -65,3 +65,11 @@ heartbeat.friendship.*:
     created:
       type: integer
       label: 'Created timestamp'
+
+heartbeat_feed.config:
+  type: config_object
+  label: 'Active Feed Choice'
+  mapping:
+    message:
+      type: text
+      label: 'Feed Choice'

css/heartbeat.css

@@ -14,3 +14,69 @@
   display: block;
 }
 
+
+/*Main Feed Form*/
+#heartbeat-feed-form input[type="radio"] {
+    -webkit-appearance: none;
+    display: inline-block;
+}
+
+#heartbeat-feed-form .form-type-radio {
+    display: inline-block;
+    position: relative;
+    border-right: 1px solid white;
+
+}
+#heartbeat-feed-form input.form-radio {
+    background: #12ff00;
+    min-width: 100%;
+    margin-bottom:0;
+    padding: 0em 22em 2.5em 0em;
+    font-weight: 700;
+    display: inline-block;
+}
+
+#heartbeat-feed-form input.form-radio:hover {
+   background: #1E6100;
+ }
+
+
+#heartbeat-feed-form input[type="radio"]:checked {
+   background: #003b00;
+ }
+
+#heartbeat-feed-form label {
+    font-size:1rem;
+    color: white;
+    position:absolute;
+    top:50%;;
+    left:50%;
+    display:inline-block;
+    width:auto;
+    transform:translate(-50%, -50%);
+}
+
+#heartbeat-feed-form .form-item-feedtabs {
+    display: inline-block;
+}
+
+/*Heartbeat feed re-render block
+Temporarily hiding all irrelevant content */
+
+.heartbeat-stream a.visually-hidden,
+.heartbeat-stream #toolbar-administration,
+.heartbeat-stream header,
+.heartbeat-stream footer,
+.heartbeat-stream .highlighted,
+.heartbeat-stream .region-breadcrumb,
+.heartbeat-stream #sidebar-first,
+.heartbeat-stream .block-page-title-block { display: none}
+
+.heartbeat-stream #content {
+  margin-left: 0;
+}
+
+heartbeat-stream section.section {
+  padding: 0;
+ }
+

heartbeat.libraries.yml

@@ -8,3 +8,10 @@ heartbeat:
   css:
     theme:
       css/heartbeat.css: {}
+  js:
+    js/heartbeat.js: {}
+  dependencies:
+    - core/jquery
+    - core/jquery.once
+    - core/drupal
+    - core/drupalSettings

heartbeat.module

@@ -274,3 +274,8 @@ function heartbeat_ajax_render_alter(array &$data) {
 //TODO Add heartbeat language to Javascript
 //TODO Determine necessity of polling
 //Add
+
+//TODO implement polling in JS using Drupal Settings
+//$variables['#attached']['drupalSettings']['heartbeatData'] = $mydata;
+//^ will become available in JS as:
+//settings.heartbeatData, data

heartbeat.routing.yml

@@ -58,3 +58,19 @@ route_callbacks:
 #    _title: 'getRoutes'
 #  requirements:
 #    _permission: 'access content'
+
+heartbeat.heartbeat_feed_form:
+  path: '/heartbeat/form/heartbeat_feed'
+  defaults:
+    _form: '\Drupal\heartbeat\Form\HeartbeatFeedForm'
+    _title: 'HeartbeatFeedForm'
+  requirements:
+    _access: 'TRUE'
+
+heartbeat.render_feed:
+  path: '/heartbeat/render_feed/{arg}'
+  defaults:
+    _controller: '\Drupal\heartbeat\Controller\HeartbeatController::renderFeed'
+    _title: 'Render Feed'
+  requirements:
+    _permission: 'access content'

js/heartbeat.js

@@ -0,0 +1,30 @@
+/**
+ * Created by logicp on 5/28/17.
+ */
+(function($, Drupal, drupalSettings) {
+    Drupal.behaviors.heartbeat = {
+        attach: function (context, settings) {
+
+
+            Drupal.AjaxCommands.prototype.selectFeed = function(ajax, response, status) {
+                console.log(response.feed);
+                console.dir(drupalSettings);
+                console.dir(context);
+                console.dir(settings);
+
+              $.ajax({
+                type:'POST',
+                url:'/heartbeat/render_feed/' + response.feed,
+                success: function(response) {
+                  // feedElement = document.getElementById('block-heartbeatblock');
+                  feedElement = document.querySelector('.heartbeat-stream');
+                  feedElement.innerHTML = response;
+                  console.dir(feedElement);
+                  console.dir(response);
+                }
+              });
+              // #block-heartbeatblock
+            }
+        }
+    }
+})(jQuery, Drupal, drupalSettings);

src/Ajax/SelectFeedCommand.php

@@ -0,0 +1,26 @@
+<?php
+namespace Drupal\heartbeat\Ajax;
+/**
+ * Created by IntelliJ IDEA.
+ * User: logicp
+ * Date: 5/28/17
+ * Time: 11:38 PM
+ */
+
+use Drupal\Core\Ajax\CommandInterface;
+
+class SelectFeedCommand implements CommandInterface {
+    protected $message;
+
+    public function __construct($message) {
+        $this->message = $message;
+    }
+
+    public function render() {
+
+        return array(
+            'command' => 'selectFeed',
+            'feed' => $this->message
+        );
+    }
+}

src/Ajax/oldcommand.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\heartbeat;
+
+use Drupal\Core\Ajax\CommandInterface;
+
+class SelectFeedCommandss implements CommandInterface {
+    protected $message;
+    // Constructs a ReadMessageCommand object.
+    public function __construct($message) {
+        $this->message = $message;
+    }
+    // Implements Drupal\Core\Ajax\CommandInterface:render().
+    public function render() {
+        return array(
+            'command' => 'selectFeed',
+            'feed' => $this->message
+        );
+    }
+
+    public static function hello() {
+        return 'jigga';
+}
+}

src/Controller/HeartbeatController.php

@@ -162,4 +162,12 @@ class HeartbeatController extends ControllerBase implements ContainerInjectionIn
     return $build;
   }
 
+  public function renderFeed($arg) {
+    $myConfig = \Drupal::service('config.factory')->getEditable('heartbeat_feed.settings');
+    $myConfig->set('message', $arg)->save();
+    \Drupal::logger('HeartbeatController')->debug('My argument is %arg', ['%arg' => $arg]);
+
+    return \Drupal\block\BlockViewBuilder::lazyBuilder('heartbeatblock', 'teaser');
+  }
+
 }

src/Form/HeartbeatFeedForm.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace Drupal\heartbeat\Form;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Render\Element\Ajax;
+use Drupal\heartbeat\Ajax\SelectFeedCommand;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\heartbeat\HeartbeatService;
+use Drupal\heartbeat\HeartbeatTypeServices;
+use Drupal\heartbeat\HeartbeatStreamServices;
+use Drupal\Core\Ajax\AjaxResponse;
+
+
+/**
+ * Class HeartbeatFeedForm.
+ *
+ * @package Drupal\heartbeat\Form
+ */
+class HeartbeatFeedForm extends FormBase {
+
+  /**
+   * Drupal\heartbeat\HeartbeatService definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatService
+   */
+  protected $heartbeatService;
+  /**
+   * Drupal\heartbeat\HeartbeatTypeServices definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatTypeServices
+   */
+  protected $typeService;
+  /**
+   * Drupal\heartbeat\HeartbeatStreamServices definition.
+   *
+   * @var \Drupal\heartbeat\HeartbeatStreamServices
+   */
+  protected $streamService;
+
+    /**
+     * The currently selected stream
+     * @var
+     */
+  private $stream;
+
+  private $streams;
+
+
+  public function __construct(
+    HeartbeatService $heartbeat,
+    HeartbeatTypeServices $heartbeat_heartbeattype,
+    HeartbeatStreamServices $heartbeatstream
+  ) {
+    $this->heartbeatService = $heartbeat;
+    $this->typeService = $heartbeat_heartbeattype;
+    $this->streamService = $heartbeatstream;
+  }
+
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('heartbeat'),
+      $container->get('heartbeat.heartbeattype'),
+      $container->get('heartbeatstream')
+    );
+  }
+
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'heartbeat_feed_form';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+
+      if ($this->stream === null) {
+          $this->stream = $form_state->getValue('feedtabs');
+      }
+      if ($this->streams === null) {
+          foreach ($this->streamService->getAllStreams() as $heartbeatStream) {
+              $this->streams[$heartbeatStream->getName()] = t($heartbeatStream->getName());
+          }
+      }
+
+    $form['feedtabs'] = [
+      '#type' => 'radios',
+      '#title' => $this->t('Choose a feed'),
+//      '#description' => $this->t('User selectable feeds'),
+      '#options' => $this->streams,
+      '#ajax' => [
+        'callback' => '::updateFeed',
+//        'event' => 'onclick',
+        'progress' => array(
+        'type' => 'none',
+//        'message' => t('Fetching feed'),
+        ),
+      ]
+    ];
+
+    $form['feedsearch'] = [
+      '#type' => 'search',
+    ];
+
+    $form['hidden-data'] = [
+        '#type' => 'textfield',
+        '#value' => $form_state->get('hidden-data')
+    ];
+
+
+    $form['submit'] = [
+        '#type' => 'submit',
+        '#value' => $this->t('Search'),
+    ];
+
+    $form['#attached']['library'][] = 'heartbeat/heartbeat';
+
+      return $form;
+  }
+
+
+    /**
+     * @param array $form
+     * @param FormStateInterface $form_state
+     * @return AjaxResponse
+     */
+    public function updateFeed(array &$form, FormStateInterface $form_state) {
+
+      $response = new AjaxResponse();
+      $response->addCommand(new SelectFeedCommand($form_state->getValue('feedtabs')));
+
+      return $response;
+
+  }
+  /**
+    * {@inheritdoc}
+    */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    parent::validateForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Display result.
+    foreach ($form_state->getValues() as $key => $value) {
+        drupal_set_message($key . ': ' . $value);
+    }
+  }
+
+}

src/Form/HeartbeatTypeForm.php

@@ -4,7 +4,6 @@ namespace Drupal\heartbeat\Form;
 
 use Drupal\Core\Entity\EntityTypeManager;
 use Drupal\Core\Render\Renderer;
-use Drupal\heartbeat;
 use Drupal\heartbeat\Entity;
 use Drupal\Core\Ajax\AjaxResponse;
 use Drupal\Core\Ajax\HtmlCommand;

src/HeartbeatEntityQuery.php

@@ -0,0 +1,405 @@
+<?php
+
+
+use Drupal\Core\Entity\Query\QueryInterface;
+/**
+ * Created by IntelliJ IDEA.
+ * User: logicp
+ * Date: 5/28/17
+ * Time: 1:37 PM
+ */
+
+class HeartbeatEntityQuery implements QueryInterface {
+
+  /**
+   * Adds a tag to a query.
+   *
+   * Tags are strings that identify a query. A query may have any number of
+   * tags. Tags are used to mark a query so that alter hooks may decide if they
+   * wish to take action. Tags should be all lower-case and contain only
+   * letters, numbers, and underscore, and start with a letter. That is, they
+   * should follow the same rules as PHP identifiers in general.
+   *
+   * @param $tag
+   *   The tag to add.
+   *
+   * @return \Drupal\Core\Database\Query\AlterableInterface
+   *   The called object.
+   */
+  public function addTag($tag)
+  {
+    // TODO: Implement addTag() method.
+  }
+
+  /**
+   * Determines if a given query has a given tag.
+   *
+   * @param $tag
+   *   The tag to check.
+   *
+   * @return
+   *   TRUE if this query has been marked with this tag, FALSE otherwise.
+   */
+  public function hasTag($tag)
+  {
+    // TODO: Implement hasTag() method.
+  }
+
+  /**
+   * Determines if a given query has all specified tags.
+   *
+   * @param $tags
+   *   A variable number of arguments, one for each tag to check.
+   *
+   * @return
+   *   TRUE if this query has been marked with all specified tags, FALSE
+   *   otherwise.
+   */
+  public function hasAllTags()
+  {
+    // TODO: Implement hasAllTags() method.
+  }
+
+  /**
+   * Determines if a given query has any specified tag.
+   *
+   * @param $tags
+   *   A variable number of arguments, one for each tag to check.
+   *
+   * @return
+   *   TRUE if this query has been marked with at least one of the specified
+   *   tags, FALSE otherwise.
+   */
+  public function hasAnyTag()
+  {
+    // TODO: Implement hasAnyTag() method.
+  }
+
+  /**
+   * Adds additional metadata to the query.
+   *
+   * Often, a query may need to provide additional contextual data to alter
+   * hooks. Alter hooks may then use that information to decide if and how
+   * to take action.
+   *
+   * @param $key
+   *   The unique identifier for this piece of metadata. Must be a string that
+   *   follows the same rules as any other PHP identifier.
+   * @param $object
+   *   The additional data to add to the query. May be any valid PHP variable.
+   *
+   * @return \Drupal\Core\Database\Query\AlterableInterface
+   *   The called object.
+   */
+  public function addMetaData($key, $object)
+  {
+    // TODO: Implement addMetaData() method.
+  }
+
+  /**
+   * Retrieves a given piece of metadata.
+   *
+   * @param $key
+   *   The unique identifier for the piece of metadata to retrieve.
+   *
+   * @return
+   *   The previously attached metadata object, or NULL if one doesn't exist.
+   */
+  public function getMetaData($key)
+  {
+    // TODO: Implement getMetaData() method.
+  }
+
+  /**
+   * Gets the ID of the entity type for this query.
+   *
+   * @return string
+   */
+  public function getEntityTypeId()
+  {
+    // TODO: Implement getEntityTypeId() method.
+  }
+
+  /**
+   * Add a condition to the query or a condition group.
+   *
+   * For example, to find all entities containing both the Turkish 'merhaba'
+   * and the Polish 'siema' within a 'greetings' text field:
+   * @code
+   *   $entity_ids = \Drupal::entityQuery($entity_type)
+   *     ->condition('greetings', 'merhaba', '=', 'tr')
+   *     ->condition('greetings.value', 'siema', '=', 'pl')
+   *     ->execute();
+   * @endcode
+   *
+   * @param $field
+   *   Name of the field being queried. It must contain a field name, optionally
+   *   followed by a column name. The column can be the reference property,
+   *   usually "entity", for reference fields and that can be followed
+   *   similarly by a field name and so on. Additionally, the target entity type
+   *   can be specified by appending the ":target_entity_type_id" to "entity".
+   *   Some examples:
+   *   - nid
+   *   - tags.value
+   *   - tags
+   *   - tags.entity.name
+   *   - tags.entity:taxonomy_term.name
+   *   - uid.entity.name
+   *   - uid.entity:user.name
+   *   "tags" "is the same as "tags.value" as value is the default column.
+   *   If two or more conditions have the same field names they apply to the
+   *   same delta within that field. In order to limit the condition to a
+   *   specific item a numeric delta should be added between the field name and
+   *   the column name.
+   * @code
+   *   ->condition('tags.5.value', 'news')
+   * @endcode
+   *   This will require condition to be satisfied on a specific delta of the
+   *   field. The condition above will require the 6th value of the field to
+   *   match the provided value. Further, it's possible to create a condition on
+   *   the delta itself by using '%delta'. For example,
+   * @code
+   *   ->condition('tags.%delta', 5)
+   * @endcode
+   *   will find only entities which have at least six tags. Finally, the
+   *   condition on the delta itself accompanied with a condition on the value
+   *   will require the value to appear in the specific delta range. For
+   *   example,
+   * @code
+   *   ->condition('tags.%delta', 0, '>'))
+   *   ->condition('tags.%delta.value', 'news'))
+   * @endcode
+   *   will only find the "news" tag if it is not the first value. It should be
+   *   noted that conditions on specific deltas and delta ranges are only
+   *   supported when querying content entities.
+   * @param $value
+   *   The value for $field. In most cases, this is a scalar and it's treated as
+   *   case-insensitive. For more complex operators, it is an array. The meaning
+   *   of each element in the array is dependent on $operator.
+   * @param $operator
+   *   Possible values:
+   *   - '=', '<>', '>', '>=', '<', '<=', 'STARTS_WITH', 'CONTAINS',
+   *     'ENDS_WITH': These operators expect $value to be a literal of the
+   *     same type as the column.
+   *   - 'IN', 'NOT IN': These operators expect $value to be an array of
+   *     literals of the same type as the column.
+   *   - 'BETWEEN': This operator expects $value to be an array of two literals
+   *     of the same type as the column.
+   * @param $langcode
+   *   Language code (optional). If omitted, any translation satisfies the
+   *   condition. However, if two or more conditions omit the langcode within
+   *   one condition group then they are presumed to apply to the same
+   *   translation. If within one condition group one condition has a langcode
+   *   and another does not they are not presumed to apply to the same
+   *   translation.
+   *
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   * @see \Drupal\Core\Entity\Query\andConditionGroup
+   * @see \Drupal\Core\Entity\Query\orConditionGroup
+   */
+  public function condition($field, $value = NULL, $operator = NULL, $langcode = NULL)
+  {
+    // TODO: Implement condition() method.
+  }
+
+  /**
+   * Queries for a non-empty value on a field.
+   *
+   * @param $field
+   *   Name of a field.
+   * @param $langcode
+   *   Language code (optional).
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   */
+  public function exists($field, $langcode = NULL)
+  {
+    // TODO: Implement exists() method.
+  }
+
+  /**
+   * Queries for an empty field.
+   *
+   * @param $field
+   *   Name of a field.
+   * @param $langcode
+   *   Language code (optional).
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   */
+  public function notExists($field, $langcode = NULL)
+  {
+    // TODO: Implement notExists() method.
+  }
+
+  /**
+   * Enables a pager for the query.
+   *
+   * @param $limit
+   *   An integer specifying the number of elements per page.  If passed a false
+   *   value (FALSE, 0, NULL), the pager is disabled.
+   * @param $element
+   *   An optional integer to distinguish between multiple pagers on one page.
+   *   If not provided, one is automatically calculated.
+   *
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function pager($limit = 10, $element = NULL)
+  {
+    // TODO: Implement pager() method.
+  }
+
+  /**
+   * @param null $start
+   * @param null $length
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function range($start = NULL, $length = NULL)
+  {
+    // TODO: Implement range() method.
+  }
+
+  /**
+   * @param $field
+   *   Name of a field.
+   * @param string $direction
+   * @param $langcode
+   *   Language code (optional).
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function sort($field, $direction = 'ASC', $langcode = NULL)
+  {
+    // TODO: Implement sort() method.
+  }
+
+  /**
+   * Makes this a count query.
+   *
+   * For count queries, execute() returns the number entities found.
+   *
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function count()
+  {
+    // TODO: Implement count() method.
+  }
+
+  /**
+   * Enables sortable tables for this query.
+   *
+   * @param $headers
+   *   An array of headers of the same structure as described in
+   *   template_preprocess_table(). Use a 'specifier' in place of a 'field' to
+   *   specify what to sort on. This can be an entity or a field as described
+   *   in condition().
+   *
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function tableSort(&$headers)
+  {
+    // TODO: Implement tableSort() method.
+  }
+
+  /**
+   * @return \Drupal\Core\Entity\Query\QueryInterface
+   *   The called object.
+   */
+  public function accessCheck($access_check = TRUE)
+  {
+    // TODO: Implement accessCheck() method.
+  }
+
+  /**
+   * Execute the query.
+   *
+   * @return int|array
+   *   Returns an integer for count queries or an array of ids. The values of
+   *   the array are always entity ids. The keys will be revision ids if the
+   *   entity supports revision and entity ids if not.
+   */
+  public function execute()
+  {
+    // TODO: Implement execute() method.
+  }
+
+  /**
+   * Creates a new group of conditions ANDed together.
+   *
+   * For example, consider a drawing entity type with a 'figures' multi-value
+   * field containing 'shape' and 'color' columns. To find all drawings
+   * containing both a red triangle and a blue circle:
+   * @code
+   *   $query = \Drupal::entityQuery('drawing');
+   *   $group = $query->andConditionGroup()
+   *     ->condition('figures.color', 'red')
+   *     ->condition('figures.shape', 'triangle');
+   *   $query->condition($group);
+   *   $group = $query->andConditionGroup()
+   *     ->condition('figures.color', 'blue')
+   *     ->condition('figures.shape', 'circle');
+   *   $query->condition($group);
+   *   $entity_ids = $query->execute();
+   * @endcode
+   *
+   * @return \Drupal\Core\Entity\Query\ConditionInterface
+   */
+  public function andConditionGroup()
+  {
+    // TODO: Implement andConditionGroup() method.
+  }
+
+  /**
+   * Creates a new group of conditions ORed together.
+   *
+   * For example, consider a map entity with an 'attributes' field
+   * containing 'building_type' and 'color' columns.  To find all green and
+   * red bikesheds:
+   * @code
+   *   $query = \Drupal::entityQuery('map');
+   *   $group = $query->orConditionGroup()
+   *     ->condition('attributes.color', 'red')
+   *     ->condition('attributes.color', 'green');
+   *   $entity_ids = $query
+   *     ->condition('attributes.building_type', 'bikeshed')
+   *     ->condition($group)
+   *     ->execute();
+   * @endcode
+   * Note that this particular example can be simplified:
+   * @code
+   *   $entity_ids = $query
+   *     ->condition('attributes.color', array('red', 'green'))
+   *     ->condition('attributes.building_type', 'bikeshed')
+   *     ->execute();
+   * @endcode
+   *
+   * @return \Drupal\Core\Entity\Query\ConditionInterface
+   */
+  public function orConditionGroup()
+  {
+    // TODO: Implement orConditionGroup() method.
+  }
+
+  /**
+   * Queries the current revision.
+   *
+   * @return $this
+   */
+  public function currentRevision()
+  {
+    // TODO: Implement currentRevision() method.
+  }
+
+  /**
+   * Queries all the revisions.
+   *
+   * @return $this
+   */
+  public function allRevisions()
+  {
+    // TODO: Implement allRevisions() method.
+  }
+}
+

src/HeartbeatSelectExtender.php

@@ -0,0 +1,37 @@
+<?php
+
+use Drupal\Core\Database\Query\SelectExtender;
+/**
+ * Created by IntelliJ IDEA.
+ * User: logicp
+ * Date: 5/28/17
+ * Time: 1:41 PM
+ */
+
+class HeartbeatSelectExtender extends SelectExtender {
+
+
+  public $lastActivityId = 0;
+
+
+  /**
+   * Sets the last id
+   */
+  public function setLastActivityId($lastActivityId) {
+    $this->lastActivityId = $lastActivityId;
+    $this->query->condition('h.id', $this->lastActivityId, '>');
+  }
+
+  /**
+   * Sets the offset timestamps.
+   */
+  public function setOffsetTime($before, $after = 0) {
+    $this->query->condition('ha.timestamp', $before, '<');
+
+    if ($after > 0) {
+      $this->query->condition('ha.timestamp', $_SERVER['REQUEST_TIME'] - $after, '>');
+    }
+  }
+
+
+}

src/HeartbeatStreamServices.php

@@ -79,6 +79,11 @@ class HeartbeatStreamServices {
   }
 
 
+  public function loadStream($type) {
+    return $this->entityQuery->get('heartbeat_stream')->condition('name', $type)->execute();
+  }
+
+
   /*
    * Load all available HeartbeatStream entities
    */
@@ -87,7 +92,14 @@ class HeartbeatStreamServices {
   }
 
   public function createStreamForUids($uids) {
-    return $this->entityTypeManager->getStorage('heartbeat')->loadMultiple($this->entityQuery->get('heartbeat')->condition('uid', $uids, 'IN')->sort('created', 'DESC')->execute());
+    return $this->entityTypeManager->getStorage('heartbeat')->loadMultiple($this->entityQuery->get('heartbeat')->condition('status', 1)->condition('uid', $uids, 'IN')->sort('created', 'DESC')->execute());
+  }
+
+
+  public function createStreamForUidsByType($uids, $type) {
+    $stream = $this->entityTypeManager->getStorage('heartbeat_stream')->load(array_values($this->loadStream($type))[0]);
+
+    return $this->entityTypeManager->getStorage('heartbeat')->loadMultiple($this->entityQuery->get('heartbeat')->condition('status', 1)->condition('type', array_column($stream->getTypes(), 'target_id'), 'IN')->condition('uid', $uids, 'IN')->sort('created', 'DESC')->execute());
   }
 
 }

src/Plugin/Block/HeartbeatBlock.php

@@ -3,6 +3,7 @@
 namespace Drupal\heartbeat\Plugin\Block;
 
 use Drupal\Core\Block\BlockBase;
+//use Drupal\Core\Asset\AssetResolver;
 use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Drupal\Core\Database\Database;
@@ -81,7 +82,12 @@ class HeartbeatBlock extends BlockBase implements ContainerFactoryPluginInterfac
    */
   public function build() {
 
+    $myConfig = \Drupal::service('config.factory')->getEditable('heartbeat_feed.settings');
+
+    $feed = $myConfig->get('message');
+
     $messages = array();
+
     $query = Database::getConnection()->select('heartbeat_friendship', 'hf')
       ->fields('hf',['uid_target'])
       ->condition('hf.uid', \Drupal::currentUser()->id())->execute();
@@ -91,14 +97,24 @@ class HeartbeatBlock extends BlockBase implements ContainerFactoryPluginInterfac
       foreach ($result as $uid) {
         $uids[] = $uid->uid_target;
       }
-      foreach($this->heartbeatStreamServices->createStreamForUids($uids) as $heartbeat) {
-        $messages[] = $heartbeat->getMessage()->getValue()[0]['value'];
+      if ($feed !== null) {
+        foreach ($this->heartbeatStreamServices->createStreamForUidsByType($uids, $feed) as $heartbeat) {
+          $messages[] = $heartbeat->getMessage()->getValue()[0]['value'];
+        }
+      } else {
+        foreach ($this->heartbeatStreamServices->createStreamForUids($uids) as $heartbeat) {
+          $messages[] = $heartbeat->getMessage()->getValue()[0]['value'];
+        }
       }
 
       return [
         '#theme' => 'heartbeat_stream',
         '#messages' => $messages,
-        '#attached' => array('library' => 'heartbeat/heartbeat')
+        '#attached' => array(
+          'library' => 'heartbeat/heartbeat',
+          'drupalSettings' => ['activeFeed' => 'jigga']
+        ),
+        '#cache' => array('max-age' => 0)
       ];
 
     }

src/Plugin/Block/HeartbeatFeedBlock.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Drupal\heartbeat\Plugin\Block;
+
+use Drupal\Core\Block\BlockBase;
+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 'HeartbeatFeedBlock' block.
+ *
+ * @Block(
+ *  id = "heartbeat_feed_block",
+ *  admin_label = @Translation("Heartbeat feed block"),
+ * )
+ */
+class HeartbeatFeedBlock 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;
+    /**
+     * 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
+    ) {
+
+        parent::__construct($configuration, $plugin_id, $plugin_definition);
+//        $this->heartbeatTypeServices = $heartbeat_heartbeattype;
+//        $this->heartbeatStreamServices = $heartbeatstream;
+//        $this->heartbeatService = $heartbeat;
+    }
+    /**
+     * {@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')
+        );
+    }
+  /**
+   * {@inheritdoc}
+   */
+  public function build() {
+
+      return \Drupal::formBuilder()->getForm('Drupal\heartbeat\Form\HeartbeatFeedForm');
+
+//      $messages = array();
+//      $query = Database::getConnection()->select('heartbeat_friendship', 'hf')
+//          ->fields('hf', ['uid_target'])
+//          ->condition('hf.uid', \Drupal::currentUser()->id())->execute();
+//
+//      if ($result = $query->fetchAll()) {
+//          $uids = array();
+//          foreach ($result as $uid) {
+//              $uids[] = $uid->uid_target;
+//          }
+//          foreach ($this->heartbeatStreamServices->createStreamForUids($uids) as $heartbeat) {
+//              $messages[] = $heartbeat->getMessage()->getValue()[0]['value'];
+//          }
+//
+//      }
+//
+//      return [
+//          '#theme' => 'heartbeat_stream',
+//          '#messages' => $messages,
+//          '#heartbeat-form' => $form,
+//          '#attached' => array('library' => 'heartbeat/heartbeat')
+//      ];
+
+  }
+}