threddedDANIEL 0.14.5

data/app/forms/thredded/edit_topic_form.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Thredded
+  class EditTopicForm
+    include ActiveModel::Model
+
+    delegate :id, :title, :category_ids, :locked, :sticky, :messageboard, :messageboard_id, :valid?,
+             to: :@topic
+
+    # @param user [Thredded.user_class]
+    # @param topic [Thredded::Topic]
+    def initialize(user:, topic:)
+      @user = user
+      @topic = topic
+    end
+
+    def self.model_name
+      Thredded::Topic.model_name
+    end
+
+    def category_options
+      @topic.messageboard.categories.map { |cat| [cat.name, cat.id] }
+    end
+
+    def messageboard_options
+      @user.thredded_can_write_messageboards.map { |messageboard| [messageboard.name, messageboard.id] }
+    end
+
+    def save
+      return false unless valid?
+      @topic.save!
+      true
+    end
+
+    def persisted?
+      true
+    end
+
+    def path
+      Thredded::UrlsHelper.messageboard_topic_path(@topic.messageboard, @topic)
+    end
+
+    def edit_path
+      Thredded::UrlsHelper.edit_messageboard_topic_path(@topic.messageboard, @topic)
+    end
+
+    def messageboard_path
+      Thredded::UrlsHelper.messageboard_topics_path(@topic.messageboard)
+    end
+  end
+end

data/app/forms/thredded/post_form.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PostForm
+    attr_reader :post, :topic
+    delegate :id,
+             :persisted?,
+             :content,
+             :content=,
+             to: :@post
+
+    # @param user [Thredded.user_class]
+    # @param topic [Topic]
+    # @param post [PrivatePost]
+    # @param post_params [Hash]
+    def initialize(user:, topic:, post: nil, post_params: {})
+      @messageboard = topic.messageboard
+      @topic = topic
+      @post = post ? post : topic.posts.build
+      user ||= Thredded::NullUser.new
+
+      if post_params.include?(:quote_post)
+        post_params[:content] =
+          Thredded::ContentFormatter.quote_content(post_params.delete(:quote_post).content)
+      end
+      @post.attributes = post_params.merge(
+        user: (user unless user.thredded_anonymous?),
+        messageboard: topic.messageboard
+      )
+    end
+
+    def self.for_persisted(post)
+      new(user: post.user, topic: post.postable, post: post)
+    end
+
+    def submit_path
+      Thredded::UrlsHelper.url_for([@messageboard, @topic, @post, only_path: true])
+    end
+
+    def preview_path
+      if @post.persisted?
+        Thredded::UrlsHelper.messageboard_topic_post_preview_path(@messageboard, @topic, @post)
+      else
+        Thredded::UrlsHelper.preview_new_messageboard_topic_post_path(@messageboard, @topic)
+      end
+    end
+
+    def save
+      return false unless @post.valid?
+      @post.save!
+      true
+    end
+  end
+end

data/app/forms/thredded/private_post_form.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivatePostForm
+    attr_reader :post, :topic
+    delegate :id,
+             :persisted?,
+             :content,
+             :content=,
+             to: :@post
+
+    # @param user [Thredded.user_class]
+    # @param topic [PrivateTopic]
+    # @param post [Post]
+    # @param post_params [Hash]
+    def initialize(user:, topic:, post: nil, post_params: {})
+      @topic = topic
+      @post = post ? post : topic.posts.build
+      user ||= Thredded::NullUser.new
+
+      if post_params.include?(:quote_post)
+        post_params[:content] =
+          Thredded::ContentFormatter.quote_content(post_params.delete(:quote_post).content)
+      end
+      @post.attributes = post_params.merge(user: (user unless user.thredded_anonymous?))
+    end
+
+    def self.for_persisted(post)
+      new(user: post.user, topic: post.postable, post: post)
+    end
+
+    def submit_path
+      Thredded::UrlsHelper.url_for([@topic, @post, only_path: true])
+    end
+
+    def preview_path
+      if @post.persisted?
+        Thredded::UrlsHelper.private_topic_private_post_preview_path(@topic, @post)
+      else
+        Thredded::UrlsHelper.preview_new_private_topic_private_post_path(@topic)
+      end
+    end
+
+    def save
+      return false unless @post.valid?
+      @post.save!
+      true
+    end
+  end
+end

data/app/forms/thredded/private_topic_form.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivateTopicForm # rubocop:disable Metrics/ClassLength
+    include ActiveModel::Model
+
+    delegate :id,
+             to: :private_topic
+
+    attr_accessor \
+      :title,
+      :category_ids,
+      :user_ids,
+      :locked,
+      :sticky,
+      :content,
+      :private_topic
+
+    attr_reader :user, :params
+    attr_writer :user_names
+
+    validate :validate_children
+
+    def initialize(params = {})
+      @params = params
+      @title = params[:title]
+      @category_ids = params[:category_ids] || []
+      @user_ids = params[:user_ids] || []
+      @user = params[:user] || fail('user is required')
+      @locked = params[:locked]
+      @sticky = params[:sticky]
+      @content = params[:content]
+      @user_names = params[:user_names]
+    end
+
+    def self.model_name
+      Thredded::PrivateTopic.model_name
+    end
+
+    def save
+      @user_ids ||= []
+      @user_ids += Thredded.user_class.where(Thredded.user_name_column => parse_names(user_names)).pluck(:id)
+
+      return false unless valid?
+
+      ActiveRecord::Base.transaction do
+        private_topic.save!
+        post.save!
+      end
+      true
+    end
+
+    def private_topic
+      @private_topic ||= Thredded::PrivateTopic.new(
+        title: title,
+        users: private_users,
+        user: non_null_user,
+        last_user: non_null_user
+      )
+    end
+
+    def post
+      @post ||= private_topic.posts.build(
+        content: content,
+        user: non_null_user
+      )
+    end
+
+    def submit_path
+      Thredded::UrlsHelper.url_for([private_topic, only_path: true])
+    end
+
+    def preview_path
+      Thredded::UrlsHelper.preview_new_private_topic_path
+    end
+
+    def user_names
+      @user_names ||= Thredded.user_class.where(id: user_ids).pluck(Thredded.user_name_column).map do |name|
+        if name.include?(',')
+          "\"#{name}\""
+        else
+          name
+        end
+      end.join(', ')
+    end
+
+    private
+
+    def topic_categories
+      if category_ids
+        ids = category_ids.reject(&:empty?)
+        Thredded::Category.where(id: ids)
+      else
+        []
+      end
+    end
+
+    def private_users
+      Thredded.user_class.where(id: normalized_user_ids)
+    end
+
+    def private_user_ids
+      private_users.map(&:id)
+    end
+
+    def normalized_user_ids
+      user_ids
+        .map(&:to_s)
+        .reject(&:empty?)
+        .push(user.id.to_s)
+        .uniq
+    end
+
+    # @return [Thredded.user_class, nil] return a user or nil if the user is a NullUser
+    # This is necessary because assigning a NullUser to an ActiveRecord association results in an exception.
+    def non_null_user
+      @user unless @user.thredded_anonymous?
+    end
+
+    def validate_children
+      promote_errors(private_topic.errors) if private_topic.invalid?
+      promote_errors(post.errors) if post.invalid?
+    end
+
+    def promote_errors(child_errors)
+      child_errors.each do |attribute, message|
+        errors.add(attribute, message)
+      end
+    end
+
+    def parse_names(text) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      result = []
+      current = String.new
+      in_name = in_quoted = false
+      text.each_char do |char|
+        case char
+        when '"'
+          in_quoted = !in_quoted
+        when ' '
+          current << char if in_name
+        when ','
+          if in_quoted
+            current << char
+          else
+            in_name = false
+            unless current.empty?
+              result << current.dup
+              current.clear
+            end
+          end
+        else
+          in_name = true
+          current << char
+        end
+      end
+      result << current unless current.empty?
+      result
+    end
+  end
+end

data/app/forms/thredded/topic_form.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Thredded
+  class TopicForm
+    include ActiveModel::Model
+
+    attr_accessor :title, :category_ids, :locked, :sticky, :content, :topic
+    attr_reader :user, :messageboard
+
+    validate :validate_children
+
+    def initialize(params = {})
+      @title = params[:title]
+      @category_ids = params[:category_ids]
+      @locked = params[:locked] || false
+      @sticky = params[:sticky] || false
+      @content = params[:content]
+      @user = params[:user] || fail('user is required')
+      @messageboard = params[:messageboard]
+    end
+
+    def self.model_name
+      Thredded::Topic.model_name
+    end
+
+    def category_options
+      messageboard.categories.map { |cat| [cat.name, cat.id] }
+    end
+
+    def save
+      return false unless valid?
+
+      ActiveRecord::Base.transaction do
+        topic.save!
+        post.save!
+        Thredded::UserTopicReadState.read_on_first_post!(user, topic) if topic.previous_changes.include?(:id)
+      end
+      true
+    end
+
+    def topic
+      @topic ||= messageboard.topics.build(
+        title: title,
+        locked: locked,
+        sticky: sticky,
+        user: non_null_user,
+        categories: topic_categories,
+      )
+    end
+
+    def post
+      @post ||= topic.posts.build(
+        content: content,
+        user: non_null_user,
+        messageboard: messageboard
+      )
+    end
+
+    def submit_path
+      Thredded::UrlsHelper.url_for([messageboard, topic, only_path: true])
+    end
+
+    def preview_path
+      Thredded::UrlsHelper.preview_new_messageboard_topic_path(messageboard)
+    end
+
+    private
+
+    # @return [Thredded.user_class, nil] return a user or nil if the user is a NullUser
+    # This is necessary because assigning a NullUser to an ActiveRecord association results in an exception.
+    def non_null_user
+      @user unless @user.thredded_anonymous?
+    end
+
+    def topic_categories
+      if category_ids
+        ids = category_ids.reject(&:empty?)
+        Thredded::Category.where(id: ids)
+      else
+        []
+      end
+    end
+
+    def validate_children
+      promote_errors(topic.errors) if topic.invalid?
+      promote_errors(post.errors) if post.invalid?
+    end
+
+    def promote_errors(child_errors)
+      child_errors.each do |attribute, message|
+        errors.add(attribute, message)
+      end
+    end
+  end
+end

data/app/forms/thredded/user_preferences_form.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserPreferencesForm
+    include ActiveModel::Model
+
+    # @return [Thredded::Messageboard, nil]
+    attr_reader :messageboard
+
+    validate :validate_children
+
+    delegate :follow_topics_on_mention, :follow_topics_on_mention=,
+             :auto_follow_topics, :auto_follow_topics=,
+             :messageboard_notifications_for_followed_topics_attributes=,
+             :notifications_for_followed_topics_attributes=,
+             :notifications_for_private_topics_attributes=,
+             to: :user_preference
+
+    delegate :follow_topics_on_mention, :follow_topics_on_mention=,
+             :auto_follow_topics, :auto_follow_topics=,
+             to: :user_messageboard_preference,
+             prefix: :messageboard
+
+    # @param user [Thredded.user_class]
+    # @param messageboard [Thredded::Messageboard, nil]
+    # @param messageboards [ActiveRecord::Relation<Thredded::Messageboard>]
+    def initialize(user:, messageboard: nil, messageboards: nil, params: {})
+      @user = user
+      @messageboard = messageboard
+      @messageboards = messageboards
+      super(params)
+    end
+
+    # @return [Boolean]
+    def save
+      return false unless valid?
+      Thredded::UserPreference.transaction do
+        user_preference.save!
+
+        # Update all of the messageboards' auto_follow_topics if the global preference has changed.
+        if user_preference.previous_changes.include?('auto_follow_topics')
+          Thredded::UserMessageboardPreference.where(user: @user)
+            .update_all(auto_follow_topics: user_preference.auto_follow_topics)
+          user_messageboard_preference.auto_follow_topics_will_change! if messageboard
+        end
+
+        user_messageboard_preference.save! if messageboard
+      end
+      true
+    end
+
+    def messageboard_groups
+      @messageboard_groups ||= Thredded::MessageboardGroupView.grouped(@messageboards)
+    end
+
+    def notifications_for_private_topics
+      for_every_notifier(user_preference.notifications_for_private_topics)
+    end
+
+    def notifications_for_followed_topics
+      for_every_notifier(user_preference.notifications_for_followed_topics)
+    end
+
+    def messageboard_notifications_for_followed_topics
+      return nil unless messageboard
+      for_every_notifier(user_preference.messageboard_notifications_for_followed_topics.for_messageboard(messageboard))
+    end
+
+    def for_every_notifier(prefs)
+      Thredded.notifiers.map do |notifier|
+        prefs.find { |n| n.notifier_key == notifier.key } || prefs.build(notifier_key: notifier.key)
+      end
+    end
+
+    def update_path
+      if @messageboard
+        Thredded::UrlsHelper.messageboard_preferences_path(@messageboard)
+      else
+        Thredded::UrlsHelper.global_preferences_path
+      end
+    end
+
+    private
+
+    # @return [Thredded::UserPreference]
+    def user_preference
+      @user_preference ||= @user.thredded_user_preference
+    end
+
+    # @return [Thredded::UserMessageboardPreference, nil]
+    def user_messageboard_preference
+      return nil unless @messageboard
+      @user_messageboard_preference ||=
+        user_preference.messageboard_preferences.find_or_initialize_by(messageboard_id: @messageboard.id)
+    end
+
+    def validate_children
+      promote_errors(user_preference.errors) if user_preference.invalid?
+      if messageboard && user_messageboard_preference.invalid? # rubocop:disable Style/GuardClause
+        promote_errors(user_messageboard_preference.errors, :messageboard)
+      end
+    end
+
+    def promote_errors(child_errors, prefix = nil)
+      child_errors.each do |attribute, message|
+        errors.add([prefix, attribute].compact.join('_'), message)
+      end
+    end
+  end
+end