Display posts of users you follow? - ruby-on-rails

Question

I would like to display posts by users that I follow on a stream page.
I have a post controller which displays ALL posts from any users. Again I only want posts from users I follow to be displayed on the stream page. I created a new controller called 'Stream'. I am having a difficult time trying to get the users posts who I follow to display on my stream index.
Thank you in advance.
Stream Controller
class StreamController < ApplicationController
before_action :set_post, only: [:show, :edit, :update, :destroy]
before_action :correct_user, only: [:edit, :update, :destroy]
before_action :authenticate_user!, except: [:index, :show]
def index
#posts = Post.where(follower_id: current_user.id, followed_id: current_user.id)
end
end
Stream Index
<div class="page-header">
<center><strong><h1> Stream Page </h1></strong></center>
</div>
Post Controller
class PostsController < ApplicationController
before_action :set_post, only: [:show, :edit, :update, :destroy]
before_action :correct_user, only: [:edit, :update, :destroy]
before_action :authenticate_user!, except: [:index, :show]
def index
#posts = Post.all.order("created_at DESC").paginate(:page => params[:page], :per_page => 40)
end
def show
end
def new
#post = current_user.posts.build
end
def edit
end
def create
#post = current_user.posts.build(post_params)
respond_to do |format|
if #post.save
format.html { redirect_to #post, notice: 'Post was successfully created.' }
format.json { render action: 'show', status: :created, location: #post }
else
format.html { render action: 'new' }
format.json { render json: #post.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if #post.update(post_params)
format.html { redirect_to #post, notice: 'Post was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: 'edit' }
format.json { render json: #post.errors, status: :unprocessable_entity }
end
end
end
def destroy
#post.destroy
respond_to do |format|
format.html { redirect_to posts_url }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_post
#post = Post.find(params[:id])
end
def correct_user
#post = current_user.posts.find_by(id: params[:id])
redirect_to posts_path, notice: "Not authorized to edit this post" if #post.nil?
end
# Never trust parameters from the scary internet, only allow the white list through.
def post_params
params.require(:post).permit(:description, :image)
end
end
Users Controller
class UsersController < ApplicationController
before_action :correct_user, only: [:edit, :update, :destroy]
before_action :authenticate_user!, except: [:index, :show]
before_action :admin_user, only: :destroy
def following
#title = "Following"
#user = User.find(params[:id])
#users = #user.followed_users.paginate(page: params[:page])
render 'show_follow'
end
def followers
#title = "Followers"
#user = User.find(params[:id])
#users = #user.followers.paginate(page: params[:page])
render 'show_follow'
end
def index
#users = User.paginate(page: params[:page], :per_page => 20)
end
def show
#user = User.find(params[:id])
if #user
#posts = #user.posts.order("updated_at DESC")
render actions: :show
else
render file: 'public/404', status: 404, formats: [:html]
end
end
def destroy
User.find(params[:id]).destroy
flash[:success] = "Your account has been deleted."
redirect_to root_path
end
def correct_user
#user = User.find(params[:id])
redirect_to root_path
end
def admin_user
redirect_to root_path unless current_user.admin?
end
end
Relationships Controller
class RelationshipsController < ApplicationController
before_action :authenticate_user!, except: [:index, :show]
def create
#user = User.find(params[:relationship][:followed_id])
current_user.follow!(#user)
respond_to do |format|
format.html { redirect_to #user }
format.js
end
end
def destroy
#user = Relationship.find(params[:id]).followed
current_user.unfollow!(#user)
respond_to do |format|
format.html { redirect_to #user }
format.js
end
end
end
Migration
class CreateRelationships < ActiveRecord::Migration
def change
create_table :relationships do |t|
t.integer :follower_id
t.integer :followed_id
t.timestamps
end
add_index :relationships, :follower_id
add_index :relationships, :followed_id
add_index :relationships, [:follower_id, :followed_id], unique: true
end
end

Answer 1

Relationship
I'd personally use a scope with an association:
#app/models/user.rb
Class User < ActiveRecord::Base
has_many :posts
has_many :subscribed, class_name: "Relationship", foreign_key: "followed_id"
has_many :followers, class_name: "Relationship", foreign_key: "follower_id"
end
#app/models/post.rb
Class Post < ActiveRecord::Base
belongs_to :user
scope :subscribed, ->(followers) { where user_id: followers }
end
#app/models/relationship.rb
Class Relationship < ActiveRecord::Base
#fields id | user_id | follower_id | created_at | updated_at
belongs_to :user
end
This will give you the ability to call the following:
#app/controllers/stream_controller.rb
Class StreamController < ApplicationController
def index
#posts = Post.subscribed current_user.followers
end
end
--
Alternative
An alternative would be as follows:
#app/views/stream/index.html.erb
<% current_user.subscribed.each do |followed| %>
<% followed.posts.each do |post| %>
<%= post.title %>
<% end %>
<% end %>
--
Whilst I'm not sure if this will work out of the gate, it's the way I'd create the functionality you're seeking. Essentially, you have to be able to pass the "related" users to your query call, which will then return the objects belonging to the followed relation

Answer 2

The post variable in the stream controller needs to be an instance variable #posts to be available in the view, and to match the #posts instance variable you have in the view.

Answer 3

I guess it should look #posts = Post.subscribed #user.following instead of "current_user.followers". This should solve you problem of displaying people who are following you instead of showing users you follow.