thredded 0.1.0 → 0.2.2

data/app/commands/thredded/notify_private_topic_users.rb

@@ -0,0 +1,51 @@
+module Thredded
+  class NotifyPrivateTopicUsers
+    DELIVER_METHOD = Rails.version < '4.2.0' ? :deliver : :deliver_later
+
+    def initialize(private_topic)
+      @post = private_topic.posts.first || Post.new
+      @private_topic = private_topic
+    end
+
+    def run
+      members = private_topic_recipients
+
+      return unless members.present?
+      user_emails = members.map(&:email)
+      PrivateTopicMailer
+        .message_notification(private_topic.id, user_emails)
+        .send(DELIVER_METHOD)
+      mark_notified(members)
+    end
+
+    def private_topic_recipients
+      members = private_topic.users - [private_topic.user]
+      members = exclude_those_opting_out_of_message_notifications(members)
+      members = exclude_previously_notified(members)
+      members
+    end
+
+    private
+
+    attr_reader :post, :private_topic
+
+    def mark_notified(members)
+      members.each do |member|
+        post.post_notifications.create(email: member.email)
+      end
+    end
+
+    def exclude_those_opting_out_of_message_notifications(members)
+      # TODO: implement global notification preferences for private topics.
+      members
+    end
+
+    def exclude_previously_notified(members)
+      emails_notified = post.post_notifications.map(&:email)
+
+      members.reject do |member|
+        emails_notified.include? member.email
+      end
+    end
+  end
+end

data/app/commands/thredded/user_reads_private_topic.rb

@@ -0,0 +1,22 @@
+module Thredded
+  class UserReadsPrivateTopic
+    def initialize(private_topic, user)
+      @private_topic = private_topic
+      @user = user
+    end
+
+    def run
+      private_user = Thredded::PrivateUser
+        .find_by(private_topic_id: private_topic.id, user_id: user.id)
+      private_user.update_attributes(read: true)
+    end
+
+    private
+
+    attr_reader :private_topic, :user
+
+    def messageboard
+      private_topic.messageboard
+    end
+  end
+end

data/app/commands/thredded/user_resets_private_topic_to_unread.rb

@@ -0,0 +1,23 @@
+module Thredded
+  class UserResetsPrivateTopicToUnread
+    def initialize(private_topic, user)
+      @private_topic = private_topic
+      @user = user
+    end
+
+    def run
+      other_users = Thredded::PrivateUser
+        .where(private_topic: private_topic)
+        .where.not(user_id: user.id)
+      other_users.update_all(read: false)
+    end
+
+    private
+
+    attr_reader :private_topic, :user
+
+    def messageboard
+      private_topic.messageboard
+    end
+  end
+end

data/app/controllers/thredded/application_controller.rb

@@ -0,0 +1,105 @@
+module Thredded
+  class ApplicationController < ::ApplicationController
+    layout Thredded.layout
+
+    helper Thredded::Engine.helpers
+    helper_method \
+      :active_users,
+      :messageboard,
+      :preferences,
+      :unread_private_topics_count,
+      :signed_in?
+
+    rescue_from \
+      CanCan::AccessDenied,
+      Thredded::Errors::MessageboardNotFound,
+      Thredded::Errors::MessageboardReadDenied,
+      Thredded::Errors::TopicCreateDenied,
+      Thredded::Errors::MessageboardCreateDenied,
+      Thredded::Errors::PrivateTopicCreateDenied do |exception|
+        redirect_to root_path,
+          flash: { alert: exception.message }
+      end
+
+    rescue_from \
+      Thredded::Errors::EmptySearchResults,
+      Thredded::Errors::TopicNotFound do |exception|
+        redirect_to messageboard_topics_path(messageboard),
+          flash: { error: exception.message }
+      end
+
+    def signed_in?
+      !thredded_current_user.thredded_anonymous?
+    end
+
+    private
+
+    def unread_private_topics_count
+      @unread_private_topics_count ||= Thredded::PrivateTopic
+        .joins(:private_users)
+        .where(
+          thredded_private_users: {
+            user_id: thredded_current_user.id,
+            read: false
+          })
+        .count
+    end
+
+    def authorize_reading(obj)
+      return if current_ability.can? :read, obj
+
+      class_name = obj.class.to_s
+      error = class_name
+        .gsub(/Thredded::/, 'Thredded::Errors::') + 'ReadDenied'
+
+      fail error.constantize
+    end
+
+    def authorize_creating(obj)
+      obj = obj.new if obj.class == Class
+
+      return if current_ability.can? :create, obj
+
+      class_name = obj.class.to_s
+      error = class_name
+        .gsub(/Thredded::/, 'Thredded::Errors::') + 'CreateDenied'
+
+      fail error.constantize
+    end
+
+    def update_user_activity
+      return if messageboard.nil?
+
+      Thredded::ActivityUpdaterJob.perform_later(
+        thredded_current_user.id,
+        messageboard.id
+      )
+    end
+
+    def current_ability
+      @current_ability ||= Ability.new(thredded_current_user)
+    end
+
+    def messageboard
+      @messageboard ||= params[:messageboard_id].presence && Messageboard.find_by_slug!(params[:messageboard_id])
+    end
+
+    def preferences
+      @preferences ||= thredded_current_user.thredded_user_preference
+    end
+
+    def thredded_current_user
+      current_user || NullUser.new
+    end
+
+    def active_users
+      users = if messageboard
+                messageboard.recently_active_users
+              else
+                Thredded.user_class.joins(:thredded_user_detail).merge(Thredded::UserDetail.recently_active).to_a
+              end.to_a
+      users.push(thredded_current_user) unless thredded_current_user.is_a?(NullUser)
+      users.uniq
+    end
+  end
+end

data/app/controllers/thredded/messageboards_controller.rb

@@ -0,0 +1,58 @@
+module Thredded
+  class MessageboardsController < Thredded::ApplicationController
+    def index
+      @messageboards = Messageboard.where(closed: false).decorate
+    end
+
+    def new
+      authorize_creating Messageboard
+
+      @messageboard = Messageboard.new
+    end
+
+    def create
+      @messageboard = Messageboard.new(messageboard_params)
+
+      if signed_in? && @messageboard.save
+        @topic = Topic.create!(topic_params)
+        @post = Post.create!(post_params)
+
+        redirect_to root_path
+      else
+        show_sign_in_error unless signed_in?
+        render action: :new
+      end
+    end
+
+    private
+
+    def show_sign_in_error
+      flash.now[:error] = 'You are not signed in. Sign in or create an account before creating your messageboard.'
+    end
+
+    def messageboard_params
+      params
+        .require(:messageboard)
+        .permit(:description, :name, :posting_permission, :security)
+    end
+
+    def topic_params
+      {
+        messageboard: @messageboard,
+        user: thredded_current_user,
+        last_user: thredded_current_user,
+        title: "Welcome to your messageboard's very first thread",
+      }
+    end
+
+    def post_params
+      {
+        messageboard: @messageboard,
+        postable: @topic,
+        content: "There's not a whole lot here for now.",
+        ip: request.ip,
+        user: thredded_current_user,
+      }
+    end
+  end
+end

data/app/controllers/thredded/posts_controller.rb

@@ -0,0 +1,78 @@
+module Thredded
+  class PostsController < Thredded::ApplicationController
+    include ActionView::RecordIdentifier
+
+    load_and_authorize_resource only: [:index, :show]
+    helper_method :messageboard, :topic
+    before_filter :update_user_activity
+
+    def create
+      post = parent_topic.posts.create!(post_params)
+
+      reset_read_status if for_a_private_topic?
+      redirect_to post_path(post)
+    end
+
+    def edit
+      authorize! :edit, post
+    end
+
+    def update
+      post.update_attributes(post_params.except(:user, :ip))
+
+      redirect_to post_path(post)
+    end
+
+    def topic
+      post.postable
+    end
+
+    private
+
+    def post_path(post)
+      if for_a_private_topic?
+        private_topic_path(post.postable, anchor: dom_id(post))
+      else
+        messageboard_topic_path(messageboard, post.postable, anchor: dom_id(post))
+      end
+    end
+
+    def reset_read_status
+      Thredded::UserResetsPrivateTopicToUnread.new(parent_topic, thredded_current_user).run
+    end
+
+    def post_params
+      params
+        .require(:post)
+        .permit(:content)
+        .merge!(user: thredded_current_user, ip: request.remote_ip)
+        .tap { |p| p.merge!(messageboard: messageboard) unless for_a_private_topic? }
+    end
+
+    def parent_topic
+      if for_a_private_topic?
+        PrivateTopic
+          .includes(:private_users)
+          .friendly
+          .find(params[:private_topic_id])
+      else
+        Topic
+          .where(messageboard: messageboard)
+          .friendly
+          .find(params[:topic_id])
+      end
+    end
+
+    def for_a_private_topic?
+      params[:private_topic_id].present?
+    end
+
+    def post
+      @post ||= (for_a_private_topic? ? Thredded::PrivatePost : Thredded::Post).find(params[:id])
+    end
+
+    def current_page
+      params[:page].nil? ? 1 : params[:page].to_i
+    end
+  end
+end

data/app/controllers/thredded/preferences_controller.rb

@@ -0,0 +1,28 @@
+module Thredded
+  class PreferencesController < Thredded::ApplicationController
+    helper_method :preference
+
+    def edit
+    end
+
+    def update
+      preference.update_attributes(preference_params)
+
+      redirect_to :back, flash: { notice: 'Your settings have been updated.' }
+    end
+
+    def preference
+      @preference ||= NotificationPreference
+        .where(messageboard_id: messageboard.id, user_id: thredded_current_user.id)
+        .first_or_create!
+    end
+
+    private
+
+    def preference_params
+      params
+        .require(:notification_preference)
+        .permit(:notify_on_mention, :notify_on_message, :filter)
+    end
+  end
+end

data/app/controllers/thredded/private_topics_controller.rb

@@ -0,0 +1,65 @@
+module Thredded
+  class PrivateTopicsController < Thredded::ApplicationController
+    helper_method :private_topic
+
+    def index
+      @new_private_topic = PrivateTopicForm.new(user: thredded_current_user)
+      @private_topics = PrivateTopic
+                          .uniq
+                          .for_user(thredded_current_user)
+                          .order('updated_at DESC')
+                          .on_page(params[:page])
+                          .load
+      @decorated_private_topics = Thredded::UserPrivateTopicDecorator
+        .decorate_all(thredded_current_user, @private_topics)
+    end
+
+    def show
+      authorize! :read, private_topic
+      UserReadsPrivateTopic.new(private_topic, thredded_current_user).run
+
+      @posts = private_topic
+        .posts
+        .includes(:user)
+        .order('id ASC')
+
+      @post = private_topic.posts.build
+    end
+
+    def new
+      @private_topic = PrivateTopicForm.new(user: thredded_current_user)
+      authorize_creating @private_topic.private_topic
+    end
+
+    def create
+      @private_topic = PrivateTopicForm.new(new_private_topic_params)
+      if @private_topic.save
+        NotifyPrivateTopicUsersJob
+          .perform_later(@private_topic.private_topic.id)
+
+        UserResetsPrivateTopicToUnread
+          .new(@private_topic.private_topic, thredded_current_user)
+          .run
+
+        redirect_to @private_topic.private_topic
+      else
+        render :new
+      end
+    end
+
+    private
+
+    def private_topic
+      @private_topic ||= Thredded::PrivateTopic.find_by_slug(params[:id])
+    end
+
+    def new_private_topic_params
+      params
+        .require(:private_topic)
+        .permit(:title, :locked, :sticky, :content, user_ids: [], category_ids: [])
+        .merge(
+          user: thredded_current_user,
+          ip: request.remote_ip)
+    end
+  end
+end

data/app/controllers/thredded/setups_controller.rb

@@ -0,0 +1,53 @@
+module Thredded
+  class SetupsController < Thredded::ApplicationController
+    def new
+      show_sign_in_error unless signed_in?
+      @messageboard = Messageboard.new
+    end
+
+    def create
+      @messageboard = Messageboard.new(messageboard_params)
+
+      if signed_in? && @messageboard.save
+        @topic = Topic.create!(topic_params)
+        @post = Post.create!(post_params)
+
+        redirect_to root_path
+      else
+        show_sign_in_error unless signed_in?
+        render action: :new
+      end
+    end
+
+    private
+
+    def show_sign_in_error
+      flash.now[:error] = 'You are not signed in. Sign in or create an account before creating your messageboard.'
+    end
+
+    def messageboard_params
+      params
+        .require(:messageboard)
+        .permit(:description, :name, :posting_permission, :security)
+    end
+
+    def topic_params
+      {
+        messageboard: @messageboard,
+        user: thredded_current_user,
+        last_user: thredded_current_user,
+        title: "Welcome to your messageboard's very first thread",
+      }
+    end
+
+    def post_params
+      {
+        messageboard: @messageboard,
+        postable: @topic,
+        content: "There's not a whole lot here for now.",
+        ip: request.ip,
+        user: thredded_current_user,
+      }
+    end
+  end
+end

data/app/controllers/thredded/theme_previews_controller.rb

@@ -0,0 +1,59 @@
+module Thredded
+  class ThemePreviewsController < Thredded::ApplicationController
+    before_filter :fail_on_empty_database, if: :no_messageboard?
+
+    def show
+      @messageboard = messageboard
+      @messageboards = Messageboard.where(closed: false).decorate
+      @topics = messageboard.topics.on_page(current_page).limit(3)
+      @decorated_topics = UserTopicDecorator.decorate_all(user, @topics)
+      @decorated_private_topics = Thredded::UserPrivateTopicDecorator
+        .decorate_all(thredded_current_user, user.thredded_private_topics)
+      @topic = @topics.find { |t| t.posts.present? } || @topics.first ||
+        @messageboard.topics.build(title: 'Hello', slug: 'hello', user: user)
+      @user_topic = UserTopicDecorator.new(user, @topic)
+      @posts = @topic.posts.first(3)
+      @post = @posts.first || @messageboard.posts.build(id: 1337, postable: @topic, content: 'Hello world', user: user)
+      @new_post = @messageboard.posts.build(postable: @topic)
+      @new_topic = TopicForm.new(messageboard: messageboard, user: Thredded::NullUser.new)
+      @new_private_topic = PrivateTopicForm.new(user: user)
+      @private_topic = PrivateTopic.all.first || PrivateTopic.new(id: 1337, title: 'Hello', user: user, last_user: user,
+                                                                  users: [user])
+      @private_post = PrivatePost.first ||
+        @private_topic.posts.build(id: 1337, postable: @private_topic, content: 'A private hello world', user: user)
+      @preference = preference
+    end
+
+    def messageboard
+      @messageboard ||= Messageboard.first
+    end
+
+    def preference
+      @preference ||= NotificationPreference
+        .where(messageboard_id: messageboard.id, user_id: user.id)
+        .first_or_create!
+    end
+
+    def current_page
+      1
+    end
+
+    private
+
+    def fail_on_empty_database
+      fail Thredded::Errors::DatabaseEmpty
+    end
+
+    def no_messageboard?
+      !Thredded::Messageboard.any?
+    end
+
+    def user
+      @user ||= if thredded_current_user.thredded_anonymous?
+                  Thredded.user_class.first_or_create!(slug: 'joe', name: 'joe', email: 'joe@example.com')
+                else
+                  thredded_current_user
+                end
+    end
+  end
+end

data/app/controllers/thredded/topics_controller.rb

@@ -0,0 +1,153 @@
+module Thredded
+  class TopicsController < Thredded::ApplicationController
+    helper_method :current_page, :topic, :user_topic
+    before_filter :update_user_activity
+
+    def index
+      authorize_reading messageboard
+
+      @topics = topics
+      @decorated_topics = Thredded::UserTopicDecorator
+        .decorate_all(thredded_current_user, @topics)
+      initialize_new_topic.tap do |new_topic|
+        @new_topic = new_topic if current_ability.can?(:create, new_topic.topic)
+      end
+    end
+
+    def show
+      authorize! :read, topic
+
+      @posts = topic.posts
+        .includes(:user, :messageboard, :postable)
+        .order('id ASC')
+        .page(current_page)
+
+      @new_post = messageboard.posts.build(
+        postable: topic,
+        filter: messageboard.filter
+      )
+
+      update_read_status
+    end
+
+    def search
+      @topics = Topic.search(params[:q], messageboard)
+      @decorated_topics = Thredded::UserTopicDecorator
+        .decorate_all(thredded_current_user, @topics)
+      flash.now[:notice] = "Search Results for '#{params[:q]}'"
+    end
+
+    def new
+      @new_topic = TopicForm.new(messageboard: messageboard, user: thredded_current_user)
+      authorize_creating @new_topic.topic
+    end
+
+    def category
+      @category = messageboard.categories.friendly.find(params[:category_id])
+      @topics = @category
+        .topics
+        .unstuck
+        .order_by_updated_time
+        .on_page(current_page)
+        .load
+      @decorated_topics = Thredded::UserTopicDecorator
+        .decorate_all(thredded_current_user, @topics)
+
+      render :index
+    end
+
+    def create
+      @new_topic = TopicForm.new(new_topic_params)
+      authorize_creating @new_topic.topic
+      if @new_topic.save
+        redirect_to messageboard_topics_path(messageboard)
+      else
+        render :new
+      end
+    end
+
+    def edit
+      authorize! :update, topic
+    end
+
+    def update
+      topic.update_attributes!(topic_params.merge(last_user_id: thredded_current_user.id))
+      redirect_to messageboard_topic_posts_url(messageboard, topic), flash: { notice: 'Topic updated' }
+    end
+
+    def destroy
+      authorize! :destroy, topic
+      topic.destroy!
+      redirect_to messageboard_topics_path(messageboard), flash: { notice: 'Topic deleted' }
+    end
+
+    private
+
+    def initialize_new_topic
+      TopicForm.new(messageboard: messageboard, user: thredded_current_user)
+    end
+
+    def topic
+      @topic ||= messageboard.topics.find_by_slug_with_user_topic_reads!(params[:id])
+    end
+
+    def topics
+      messageboard
+        .topics
+        .includes(:user_topic_reads, :categories, :last_user, :user)
+        .order_by_stuck_and_updated_time
+        .on_page(current_page)
+        .load
+    end
+
+    def topic_params
+      params
+        .require(:topic)
+        .permit(:title, :locked, :sticky, category_ids: [])
+        .merge(user: thredded_current_user)
+    end
+
+    def new_topic_params
+      params
+        .require(:topic)
+        .permit(:title, :locked, :sticky, :content, category_ids: [])
+        .merge(
+          messageboard: messageboard,
+          user: thredded_current_user,
+          ip: request.remote_ip,
+        )
+    end
+
+    def topics_by_category(category_id)
+      messageboard.categories.friendly.find(category_id)
+        .topics
+        .unstuck
+        .order_by_updated
+        .on_page(current_page)
+        .load
+    end
+
+    def current_page
+      params[:page] || 1
+    end
+
+    def user_topic
+      @user_topic ||= UserTopicDecorator.new(thredded_current_user, topic)
+    end
+
+    def update_read_status
+      return if thredded_current_user.thredded_anonymous?
+
+      read_history = UserTopicRead.where(
+        user_id: thredded_current_user,
+        topic: topic,
+      ).first_or_initialize
+
+      read_history.update_attributes(
+        farthest_post: @posts.last,
+        posts_count: topic.posts_count,
+        page: current_page,
+      )
+    end
+  end
+end