After_create following relationship after Project Creation not working
<p>I'm trying to allow users to create projects...and as soon as a user creates a project...they will automatically be following that project. (I have my app setup to allow a user to follow a project from a 'follow' button on the project profile).  I would like the project creator to automatically be following the new project without having to click the 'follow' button.  I rearranged my code as per Bilal's answer...but now clicking 'create project' simply refreshes the 'new' view (no project gets posted).  I assumed this has to do with the Pundit authorizations but perhaps someone can clarify why the 'create' action is no longer working...</p>

<p>My  Projects Model:</p>

<pre><code>class Project &lt; ActiveRecord::Base
  belongs_to :owner, :foreign_key=&gt;'user_id', :class_name=&gt;'User'

  has_many :reverse_relationships, foreign_key: "followed_id",
                                   class_name: "Relationship",
                                   dependent: :destroy
  has_many :followers, through: :reverse_relationships, source: :follower

  validates :title, presence: true
  validates :background, presence: true
  validates :projectimage, presence: true

  mount_uploader :projectimage, ProjectimageUploader
  attr_accessor :crop_x, :crop_y, :crop_w, :crop_h
  after_update :crop_projectimage

  def crop_projectimage
    projectimage.recreate_versions! if crop_x.present?
  end

  def private?
    self.is_private == true
  end

  def public?
    self.is_private == false
  end
end
</code></pre>

<p>Relationships Model:</p>

<pre><code>class Relationship &lt; ActiveRecord::Base
  belongs_to :follower, class_name: "User"
  belongs_to :followed, class_name: "Project"
  validates :follower_id, presence: true
  validates :followed_id, presence: true

  enum role: [:admin, :collaborator, :visitor]
  after_initialize :set_default_role, :if =&gt; :new_record?

  def set_default_role
    self.role ||= :visitor
  end
end
</code></pre>

<p>My Projects Controller:</p>

<pre><code>class ProjectsController &lt; ApplicationController
  before_filter :authenticate_user!, only: [:create, :new, :edit, :update, :delete, :followers]

  # CREATES REDIRECT &amp; ALERT MESSAGE WHEN PUNDIT SEES SOMEONE IS NOT AUTHORIZED (via :not_authorized_in_project below)
  rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

  def new
    @project = Project.new
  end

  def show
    @project = Project.find(params[:id])
    authorize @project, :visit? 
    # @user = User.where(:id =&gt; @project.user_id).first
  rescue Pundit::NotAuthorizedError
    flash[:warning] = "You are not authorized to access this page."
    redirect_to project_path || root_path
  end

  def index
    @projects = policy_scope(Project).all
  end

  def create
    @project = current_user.own_projects.build(project_params)
    @project.followers &lt;&lt; current_user
    if @project.save
      if params[:project][:projectimage].present?
        render :crop
      else
        flash[:success] = "You've successfully created a Project..."
        redirect_to @project
      end
    else
      render 'new'
    end
  end

  def update
    @project = Project.find(params[:id])
    if @project.update_attributes(project_params)
      if params[:project][:projectimage].present?
        render :crop
      else
        flash[:success] = "Project Created"
        redirect_to @project
      end
    else
      render 'edit'
    end
  end

  def destroy
    User.find(params[:id]).destroy
    flash[:success] = "Project destroyed"
    redirect_to users_path
  end

  def followers
    @title = "Following this Project"
    @project = Project.find(params[:id])
    @project = @project.followers.paginate(page: params[:page])
    render 'show_follow_project'
  end

  private

  def project_params
    params.require(:project).permit(:title, :background, :is_private, :projectimage, :user_id, :crop_x, :crop_y, :crop_w, :crop_h)
  end

  def user_not_authorized
    flash[:warning] = "You are not authorized to access this page."
    redirect_to project_path(@project) || root_path
  end
end
</code></pre>

<p>My User Model:</p>

<pre><code>class User &lt; ActiveRecord::Base
  has_many :own_projects, :class_name=&gt;'Project'

  has_many :projects
  has_many :relationships, foreign_key: "follower_id", dependent: :destroy

  has_many :followed_projects, through: :relationships, source: :followed
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable

  def following?(some_project)
   relationships.find_by_followed_id(some_project.id)
  end

  def follow!(some_project)
   self.relationships.create!(followed_id: some_project.id)
  end

  def unfollow!(some_project)
   relationships.find_by_followed_id(some_project.id).destroy
  end
</code></pre>

<p>Pundit Project Policy:</p>

<pre><code>class ProjectPolicy &lt; Struct.new(:user, :project)
  class Scope &lt; Struct.new(:user, :scope)
    # SCOPE &amp; RESOLVE METHOD USED TO RESTRICT PROJECTS INDEX TO PUBLIC &amp; THOSE YOU'RE AN ADMIN/COLLAB ON
    def resolve
      followed_project_ids = user.followed_projects.map(&amp;:id)
      public_project_ids = Project.where(:is_private=&gt;false).map(&amp;:id)
      Project.where(:id=&gt;followed_project_ids + public_project_ids)
    end
  end

    def update?
      user.project_admin? || user.project_collaborator?
    end


    # METHOD USED IN PROJECTS_CONTROLLER (SHOW) TO RESTRICT VISITING PRIVATE PROJECT PROFILES TO ADMINS &amp; COLLABS
    def visit?
      user.project_admin?(project) || user.project_collaborator?(project)
    end

end
</code></pre>