help_center 0.0.1

data/app/controllers/help_center/notifications_controller.rb

@@ -0,0 +1,19 @@
+class HelpCenter::NotificationsController < HelpCenter::ApplicationController
+  before_action :authenticate_user!
+  before_action :set_support_thread
+
+  def create
+    @support_thread.toggle_subscription(current_user)
+    redirect_to help_center.support_thread_path(@support_thread)
+  end
+
+  def show
+    redirect_to help_center.support_thread_path(@support_thread)
+  end
+
+  private
+
+    def set_support_thread
+      @support_thread = SupportThread.friendly.find(params[:support_thread_id])
+    end
+end

data/app/controllers/help_center/support_categories_controller.rb

@@ -0,0 +1,17 @@
+class HelpCenter::SupportCategoriesController < HelpCenter::ApplicationController
+  before_action :set_category
+
+  def index
+    @support_threads = SupportThread.where(support_category: @category) if @category.present?
+    @support_threads = @support_threads.pinned_first.sorted.includes(:user, :support_category).paginate(per_page: 10, page: page_number)
+    render "help_center/support_threads/index"
+  end
+
+  private
+
+    def set_category
+      @category = SupportCategory.friendly.find(params[:id])
+    rescue ActiveRecord::RecordNotFound
+      redirect_to help_center.support_threads_path
+    end
+end

data/app/controllers/help_center/support_posts_controller.rb

@@ -0,0 +1,72 @@
+class HelpCenter::SupportPostsController < HelpCenter::ApplicationController
+  before_action :authenticate_user!
+  before_action :set_support_thread
+  before_action :set_support_post, only: [:edit, :update, :destroy]
+  before_action :require_mod_or_author_for_post!, only: [:edit, :update, :destroy]
+  before_action :require_mod_or_author_for_thread!, only: [:solved, :unsolved]
+
+  def create
+    @support_post = @support_thread.support_posts.new(support_post_params)
+    @support_post.user_id = current_user.id
+
+    if @support_post.save
+      HelpCenter::SupportPostNotificationJob.perform_later(@support_post)
+      redirect_to help_center.support_thread_path(@support_thread, anchor: "support_post_#{@support_post.id}")
+    else
+      render template: "help_center/support_threads/show"
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @support_post.update(support_post_params)
+      redirect_to help_center.support_thread_path(@support_thread)
+    else
+      render action: :edit
+    end
+  end
+
+  def destroy
+    @support_post.destroy!
+    redirect_to help_center.support_thread_path(@support_thread)
+  end
+
+  def solved
+    @support_post = @support_thread.support_posts.find(params[:id])
+
+    @support_thread.support_posts.update_all(solved: false)
+    @support_post.update_column(:solved, true)
+    @support_thread.update_column(:solved, true)
+
+    redirect_to help_center.support_thread_path(@support_thread, anchor: ActionView::RecordIdentifier.dom_id(@support_post))
+  end
+
+  def unsolved
+    @support_post = @support_thread.support_posts.find(params[:id])
+
+    @support_thread.support_posts.update_all(solved: false)
+    @support_thread.update_column(:solved, false)
+
+    redirect_to help_center.support_thread_path(@support_thread, anchor: ActionView::RecordIdentifier.dom_id(@support_post))
+  end
+
+  private
+
+    def set_support_thread
+      @support_thread = SupportThread.friendly.find(params[:support_thread_id])
+    end
+
+    def set_support_post
+      if is_moderator?
+        @support_post = @support_thread.support_posts.find(params[:id])
+      else
+        @support_post = current_user.support_posts.find(params[:id])
+      end
+    end
+
+    def support_post_params
+      params.require(:support_post).permit(:body)
+    end
+end

data/app/controllers/help_center/support_threads_controller.rb

@@ -0,0 +1,72 @@
+class HelpCenter::SupportThreadsController < HelpCenter::ApplicationController
+  before_action :authenticate_user!, only: [:mine, :participating, :new, :create]
+  before_action :set_support_thread, only: [:show, :edit, :update]
+  before_action :require_mod_or_author_for_thread!, only: [:edit, :update]
+
+  def index
+    @support_threads = SupportThread.pinned_first.sorted.includes(:user, :support_category).paginate(page: page_number)
+  end
+
+  def answered
+    @support_threads = SupportThread.solved.sorted.includes(:user, :support_category).paginate(page: page_number)
+    render action: :index
+  end
+
+  def unanswered
+    @support_threads = SupportThread.unsolved.sorted.includes(:user, :support_category).paginate(page: page_number)
+    render action: :index
+  end
+
+  def mine
+    @support_threads = SupportThread.where(user: current_user).sorted.includes(:user, :support_category).paginate(page: page_number)
+    render action: :index
+  end
+
+  def participating
+    @support_threads = SupportThread.includes(:user, :support_category).joins(:support_posts).where(support_posts: { user_id: current_user.id }).distinct(support_posts: :id).sorted.paginate(page: page_number)
+    render action: :index
+  end
+
+  def show
+    @support_post = SupportPost.new
+    @support_post.user = current_user
+  end
+
+  def new
+    @support_thread = SupportThread.new
+    @support_thread.support_posts.new
+  end
+
+  def create
+    @support_thread = current_user.support_threads.new(support_thread_params)
+    @support_thread.support_posts.each{ |post| post.user_id = current_user.id }
+
+    if @support_thread.save
+      HelpCenter::SupportThreadNotificationJob.perform_later(@support_thread)
+      redirect_to help_center.support_thread_path(@support_thread)
+    else
+      render action: :new
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if @support_thread.update(support_thread_params)
+      redirect_to help_center.support_thread_path(@support_thread), notice: I18n.t('your_changes_were_saved')
+    else
+      render action: :edit
+    end
+  end
+
+  private
+
+    def set_support_thread
+      @support_thread = SupportThread.friendly.find(params[:id])
+    end
+
+    def support_thread_params
+      params.require(:support_thread).permit(:title, :content, :support_category_id, support_posts_attributes: [:body])
+    end
+end

data/app/helpers/help_center/support_posts_helper.rb

@@ -0,0 +1,29 @@
+module HelpCenter::SupportPostsHelper
+  # Override this to use avatars from other places than Gravatar
+  def avatar_tag(email)
+    gravatar_image_tag(email, gravatar: { size: 40 }, class: "rounded avatar")
+  end
+
+  def support_category_link(category)
+    link_to category.name, help_center.support_category_support_threads_path(category),
+      style: "color: #{category.color}"
+  end
+
+  # Override this method to provide your own content formatting like Markdown
+  def formatted_content(text)
+    simple_format(text)
+  end
+
+  def support_post_classes(support_post)
+    klasses = ["support-post", "card", "mb-3"]
+    klasses << "solved" if support_post.solved?
+    klasses << "original-poster" if support_post.user == @support_thread.user
+    klasses
+  end
+
+  def support_user_badge(user)
+    if user.respond_to?(:moderator) && user.moderator?
+      content_tag :span, "Mod", class: "badge badge-default"
+    end
+  end
+end

data/app/helpers/help_center/support_threads_helper.rb

@@ -0,0 +1,28 @@
+module HelpCenter::SupportThreadsHelper
+  # Used for flagging links in the navbar as active
+  def support_link_to(path, opts={}, &block)
+    link_to path, class: support_link_class(path, opts), &block
+  end
+
+  def support_link_class(matches, opts={})
+    case matches
+    when Array
+      "active" if matches.any?{ |m| request.path.starts_with?(m) }
+    when String
+      "active" if opts.fetch(:exact, false) ? request.path == matches : request.path.starts_with?(matches)
+    end
+  end
+
+  # A nice hack to manipulate the layout so we can have sub-layouts
+  # without any changes in the user's application.
+  #
+  # We use this for rendering the sidebar layout for all the support pages
+  #
+  # https://mattbrictson.com/easier-nested-layouts-in-rails
+  #
+  def parent_layout(layout)
+    @view_flow.set(:layout, output_buffer)
+    output = render(file: "layouts/#{layout}")
+    self.output_buffer = ActionView::OutputBuffer.new(output)
+  end
+end

data/app/jobs/help_center/support_post_notification_job.rb

@@ -0,0 +1,42 @@
+class HelpCenter::SupportPostNotificationJob < ApplicationJob
+  include HelpCenter::Engine.routes.url_helpers
+
+  def perform(support_post)
+    send_emails(support_post) if HelpCenter.send_email_notifications
+    send_webhook(support_post) if HelpCenter.send_slack_notifications
+  end
+
+  def send_emails(support_post)
+    support_thread = support_post.support_thread
+    users        = support_thread.subscribed_users - [support_post.user]
+    users.each do |user|
+      HelpCenter::UserMailer.new_post(support_post, user).deliver_later
+    end
+  end
+
+  def send_webhook(support_post)
+    slack_webhook_url = Rails.application.secrets.help_center_slack_url
+    return if slack_webhook_url.blank?
+
+    support_thread = support_post.support_thread
+    payload = {
+      fallback: "#{support_post.user.name} replied to <#{support_thread_url(support_thread, anchor: ActionView::RecordIdentifier.dom_id(support_post))}|#{support_thread.title}>",
+      pretext: "#{support_post.user.name} replied to <#{support_thread_url(support_thread, anchor: ActionView::RecordIdentifier.dom_id(support_post))}|#{support_thread.title}>",
+      fields: [
+        {
+          title: "Thread",
+          value: support_thread.title,
+          short: true
+        },
+        {
+          title: "Posted By",
+          value: support_post.user.name,
+          short: true,
+        },
+      ],
+      ts: support_post.created_at.to_i
+    }
+
+    HelpCenter::Slack.new(slack_webhook_url).post(payload)
+  end
+end

data/app/jobs/help_center/support_thread_notification_job.rb

@@ -0,0 +1,40 @@
+class HelpCenter::SupportThreadNotificationJob < ApplicationJob
+  include HelpCenter::Engine.routes.url_helpers
+
+  def perform(support_thread)
+    send_emails(support_thread) if HelpCenter.send_email_notifications
+    send_webhook(support_thread) if HelpCenter.send_slack_notifications
+  end
+
+  def send_emails(support_thread)
+    support_thread.notify_users.each do |user|
+      HelpCenter::UserMailer.new_thread(support_thread, user).deliver_later
+    end
+  end
+
+  def send_webhook(support_thread)
+    slack_webhook_url = Rails.application.secrets.simple_discussion_slack_url
+    return if slack_webhook_url.blank?
+
+    support_post = support_thread.support_posts.first
+    payload = {
+      fallback: "A new discussion was started: <#{support_thread_url(support_thread, anchor: ActionView::RecordIdentifier.dom_id(support_posts))}|#{support_thread.title}>",
+      pretext: "A new discussion was started: <#{support_thread_url(support_thread, anchor: ActionView::RecordIdentifier.dom_id(support_posts))}|#{support_thread.title}>",
+      fields: [
+        {
+          title: "Thread",
+          value: support_thread.title,
+          short: true
+        },
+        {
+          title: "Posted By",
+          value: support_post.user.name,
+          short: true,
+        },
+      ],
+      ts: support_post.created_at.to_i
+    }
+
+    HelpCenter::Slack.new(slack_webhook_url).post(payload)
+  end
+end

data/app/mailers/help_center/user_mailer.rb

@@ -0,0 +1,28 @@
+class HelpCenter::UserMailer < ApplicationMailer
+  # You can set the default `from` address in ApplicationMailer
+
+  helper HelpCenter::ForumPostsHelper
+  helper HelpCenter::Engine.routes.url_helpers
+
+  def new_thread(support_thread, recipient)
+    @support_thread = support_thread
+    @support_post   = support_thread.support_posts.first
+    @recipient    = recipient
+
+    mail(
+      to: "#{@recipient.name} <#{@recipient.email}>",
+      subject: @support_thread.title
+    )
+  end
+
+  def new_post(support_post, recipient)
+    @support_post   = support_post
+    @support_thread = support_post.support_thread
+    @recipient    = recipient
+
+    mail(
+      to: "#{@recipient.name} <#{@recipient.email}>",
+      subject: "New post in #{@support_thread.title}"
+    )
+  end
+end

data/app/models/support_category.rb

@@ -0,0 +1,13 @@
+class SupportCategory < ApplicationRecord
+  extend FriendlyId
+  friendly_id :name, use: :slugged
+
+  scope :sorted, ->{ order(position: :asc) }
+
+  validates :name, :slug, :color, presence: true
+
+  def color
+    colour = super
+    colour.start_with?("#") ? colour : "##{colour}"
+  end
+end

data/app/models/support_post.rb

@@ -0,0 +1,15 @@
+class SupportPost < ApplicationRecord
+  belongs_to :support_thread, counter_cache: true, touch: true
+  belongs_to :user
+  has_many :reactions, as: :reactable
+
+  validates :user_id, :body, presence: true
+
+  scope :sorted, ->{ order(:created_at) }
+
+  after_update :solve_support_thread, if: :solved?
+
+  def solve_support_thread
+    support_thread.update(solved: true)
+  end
+end

data/app/models/support_subscription.rb

@@ -0,0 +1,19 @@
+class SupportSubscription < ApplicationRecord
+  belongs_to :support_thread
+  belongs_to :user
+
+  scope :optin, ->{ where(subscription_type: :optin) }
+  scope :optout, ->{ where(subscription_type: :optout) }
+
+  validates :subscription_type, presence: true, inclusion: { in: %w{ optin optout } }
+  validates :user_id, uniqueness: { scope: :support_thread_id }
+
+  def toggle!
+    case subscription_type
+    when "optin"
+      update(subscription_type: "optout")
+    when "optout"
+      update(subscription_type: "optin")
+    end
+  end
+end

data/app/models/support_thread.rb

@@ -0,0 +1,85 @@
+class SupportThread < ApplicationRecord
+  extend FriendlyId
+  friendly_id :title, use: :slugged
+
+  belongs_to :support_category
+  belongs_to :user
+  has_many :support_posts
+  has_many :support_subscriptions
+  has_many :optin_subscribers,  ->{ where(support_subscriptions: { subscription_type: :optin }) },  through: :support_subscriptions, source: :user
+  has_many :optout_subscribers, ->{ where(support_subscriptions: { subscription_type: :optout }) }, through: :support_subscriptions, source: :user
+  has_many :users, through: :support_posts
+
+  has_rich_text :content
+
+  accepts_nested_attributes_for :support_posts
+
+  validates :support_category, presence: true
+  validates :user_id, :title, presence: true
+  validates_associated :support_posts
+
+  scope :pinned_first, ->{ order(pinned: :desc) }
+  scope :solved,       ->{ where(solved: true) }
+  scope :sorted,       ->{ order(position: :asc) }
+  scope :unpinned,     ->{ where.not(pinned: true) }
+  scope :unsolved,     ->{ where.not(solved: true) }
+
+  def subscribed_users
+    (users + optin_subscribers).uniq - optout_subscribers
+  end
+
+  def subscription_for(user)
+    return nil if user.nil?
+    support_subscriptions.find_by(user_id: user.id)
+  end
+
+  def subscribed?(user)
+    return false if user.nil?
+
+    subscription = subscription_for(user)
+
+    if subscription.present?
+      subscription.subscription_type == "optin"
+    else
+      support_posts.where(user_id: user.id).any?
+    end
+  end
+
+  def toggle_subscription(user)
+    subscription = subscription_for(user)
+
+    if subscription.present?
+      subscription.toggle!
+    elsif support_posts.where(user_id: user.id).any?
+      support_subscriptions.create(user: user, subscription_type: "optout")
+    else
+      support_subscriptions.create(user: user, subscription_type: "optin")
+    end
+  end
+
+  def subscribed_reason(user)
+    return I18n.t('.not_receiving_notifications') if user.nil?
+
+    subscription = subscription_for(user)
+
+    if subscription.present?
+      if subscription.subscription_type == "optout"
+        I18n.t('.ignoring_thread')
+      elsif subscription.subscription_type == "optin"
+        I18n.t('.receiving_notifications_because_subscribed')
+      end
+    elsif support_posts.where(user_id: user.id).any?
+      I18n.t('.receiving_notifications_because_posted')
+    else
+      I18n.t('.not_receiving_notifications')
+    end
+  end
+
+  # These are the users to notify on a new thread. Currently this does nothing,
+  # but you can override this to provide whatever functionality you like here.
+  #
+  # For example: You might use this to send all moderators an email of new threads.
+  def notify_users
+    []
+  end
+end