Merge pull request #1756 from codidact/0valt/1351/subscriptions

Email subscription improvements

Author: Oaphi

app/assets/javascripts/categories.js

@@ -43,7 +43,7 @@ $(() => {
     $topic.val(union).trigger('change');
   });
 
-  $('.js-category-change-select').each((_i, el) => {
+  $('.js-category-select').each((_i, el) => {
     const $tgt = $(el);
     $tgt.select2({
       ajax: {

app/assets/javascripts/posts.js

@@ -114,10 +114,6 @@ $(() => {
     $postField.val($postField.val()?.toString().replace(placeholder, ''));
   });
 
-  $('.js-category-select').select2({
-    tags: true
-  });
-
   /**
    * @typedef {{
    *  body: string

app/assets/javascripts/subscriptions.js

@@ -1,4 +1,79 @@
-$(() => {
+document.addEventListener('DOMContentLoaded', () => {
+  /**
+   * Extracts qualifier type from the field's dataset
+   * @returns {string | null}
+   */
+  const getQualifierType = () => {
+    const field = document.querySelector('.js-sub-type-select');
+    return field instanceof HTMLSelectElement ? field.value : null;
+  };
+
+  /**
+   * Is a given subscription type qualifiable?
+   * @param {string} type subscription type
+   * @returns {boolean}
+   */
+  const isQualifiable = (type) => {
+    return ['category', 'tag', 'user'].includes(type);
+  };
+
+  /**
+   * Synchronizes qualifier field with the given type
+   * @param {string} type subscription type
+   * @param {boolean} [clear] whether to clear qualifier value
+   */
+  const syncQualifier = (type, clear = true) => {
+    const field = document.querySelector('.js-sub-qualifier-select');
+    const label = document.querySelector('.js-sub-qualifier-label');
+
+    if (field instanceof HTMLElement) {
+      if (clear) {
+        $(field).val(null).trigger('change');
+      }
+
+      field.closest('.form-group')?.classList.toggle('hide', !isQualifiable(type));
+    }
+
+    if (label instanceof HTMLElement) {
+      label.textContent = type.slice(0, 1).toUpperCase() + type.slice(1).toLowerCase();
+    }
+  };
+
+  /**
+   * Is a given element a subscription type select?
+   * @param {Element} element
+   * @returns {element is HTMLSelectElement}
+   */
+  const isTypeSelect = (element) => {
+    return element.matches('.js-sub-type-select');
+  };
+
+  document.querySelectorAll('.js-sub-type-select, .js-sub-frequency-select').forEach((el) => {
+    $(el).select2().on('change', ($event) => {
+      if (isTypeSelect($event.target)) {
+        syncQualifier($event.target.value);
+      }
+    });
+
+    if (isTypeSelect(el)) {
+      syncQualifier(el.value, false);
+    }
+  });
+
+  $('.js-sub-qualifier-select').select2({
+    ajax: {
+      url: () => {
+        const type = getQualifierType();
+        return `/subscriptions/qualifiers?type=${type}`
+      },
+      headers: { 'Accept': 'application/json' },
+      delay: 100,
+      processResults: (results) => {
+        return { results }
+      },
+    }
+  });
+
   $('.js-enable-subscription').on('change', async (evt) => {
     const $tgt = $(evt.target);
     const $sub = $tgt.parents('details');

app/assets/javascripts/users.js

@@ -77,4 +77,16 @@ $(() => {
       location.reload();
     }
   });
+
+  $('.js-user-select').each((_i, el) => {
+    const $tgt = $(el);
+    $tgt.select2({
+      ajax: {
+        url: '/users',
+        headers: { 'Accept': 'application/json' },
+        delay: 100,
+        processResults: (data) => ({results: data.map((u) => ({id: u.id, text: u.username}))}),
+      }
+    });
+  });
 });

app/assets/stylesheets/subscriptions.scss

@@ -1,3 +1,23 @@
-// Place all the styles related to the Subscriptions controller here.
-// They will automatically be included in application.css.
-// You can use Sass (SCSS) here: http://sass-lang.com/
+@import 'variables';
+
+.new_subscription {
+  .select2-container {
+    height: 37px;
+    margin: 4px 0px;
+  }
+
+  .select2-container {
+    .selection {
+      .select2-selection {
+        border-color: $muted-graphic;
+        height: 100%;
+        padding: 4px 0;
+      }
+
+      .select2-selection__arrow {
+        top: 50%;
+        translate: 0 -50%;
+      }
+    }
+  }
+}

app/controllers/subscriptions_controller.rb

@@ -1,11 +1,9 @@
 class SubscriptionsController < ApplicationController
   before_action :authenticate_user!
   before_action :stop_the_awful_troll
-  helper_method :phrase_for
 
   def new
-    @phrasing = phrase_for params[:type]
-    @subscription = Subscription.new
+    @subscription = Subscription.new(new_sub_params)
   end
 
   def create
@@ -14,14 +12,41 @@ def create
       flash[:success] = 'Your subscription was saved successfully.'
       redirect_to params[:return_to].presence || root_path
     else
-      render :error, status: :internal_server_error
+      render :new, status: :bad_request
     end
   end
 
   def index
     @subscriptions = current_user.subscriptions
   end
 
+  def qualifiers
+    per_page = 20
+
+    @items = case params[:type]
+             when 'category'
+               Category.accessible_to(current_user)
+                       .order(sequence: :asc, id: :asc)
+             when 'tag'
+               Tag.order(name: :asc)
+             when 'user'
+               User.accessible_to(current_user)
+                   .joins(:community_user)
+                   .undeleted
+                   .where.not(community_users: { deleted: true })
+                   .order(username: :asc)
+             end
+
+    @items = params[:q].present? ? @items&.search(params[:q]) : @items
+    @items = @items&.paginate(page: params[:page], per_page: per_page).to_a
+
+    @items = @items.map do |item|
+      { id: item.is_a?(Tag) ? item.name : item.id, text: item.name }
+    end
+
+    render json: @items
+  end
+
   def enable
     @subscription = Subscription.find params[:id]
     if current_user.admin? || current_user.id == @subscription.user_id
@@ -56,29 +81,12 @@ def destroy
     end
   end
 
-  protected
+  private
 
-  def phrase_for(type, qualifier = nil)
-    case type
-    when 'all'
-      'all new questions'
-    when 'tag'
-      "new questions in the tag '#{Tag.find_by(name: qualifier || params[:qualifier])&.name}'"
-    when 'user'
-      "new questions by the user '#{User.find_by(id: qualifier || params[:qualifier])&.username}'"
-    when 'interesting'
-      'new questions classed as interesting'
-    when 'category'
-      "new questions in the category '#{Category.find_by(id: qualifier || params[:qualifier])&.name}'"
-    when 'moderators'
-      'announcements and newsletters for moderators'
-    else
-      'nothing, apparently. How did you get here, again?'
-    end
+  def new_sub_params
+    params.permit(:type, :qualifier, :frequency, :name)
   end
 
-  private
-
   def sub_params
     params.require(:subscription).permit(:type, :qualifier, :frequency, :name)
   end

app/controllers/users_controller.rb

@@ -29,6 +29,13 @@ def index
                    .paginate(page: params[:page], per_page: 48)
 
     @post_counts = Post.where(user_id: @users.pluck(:id).uniq).group(:user_id).count
+
+    respond_to do |format|
+      format.html
+      format.json do
+        render json: @users
+      end
+    end
   end
 
   def show
@@ -682,11 +689,9 @@ def set_user
   end
 
   def user_scope
-    if current_user&.at_least_moderator?
-      User.all
-    else
-      User.undeleted
-    end.joins(:community_user).includes(:community_user, :avatar_attachment)
+    User.accessible_to(current_user)
+        .joins(:community_user)
+        .includes(:community_user, :avatar_attachment)
   end
 
   def check_deleted

app/helpers/subscriptions_helper.rb

@@ -1,2 +1,36 @@
 module SubscriptionsHelper
+  # Generates <select> options for available subscription frequences
+  # @return [Array(String, Integer)]
+  def frequency_choice
+    [
+      ['Every day', 1],
+      ['Every week', 7],
+      ['Every month', 30],
+      ['Every quarter', 90]
+    ]
+  end
+
+  # Gets human-readable representation of a given subscription type
+  # @param type [String] subscription type
+  # @return [String]
+  def phrase_for(type)
+    phrase_map = {
+      all: 'all new questions',
+      tag: 'new questions with the tag',
+      user: 'new questions by the user',
+      interesting: 'new questions classed as interesting',
+      category: 'new questions in the category',
+      moderators:  'announcements and newsletters for moderators'
+    }
+
+    phrase_map[type.to_sym] || 'nothing, apparently. How did you get here, again?'
+  end
+
+  # Generates <select> options for available subscription types for a given user
+  # @param user [User] user to perform access control checks for
+  # @return [Array(String, String)]
+  def type_choice_for(user)
+    Subscription.types_accessible_to(user)
+                .map { |type| [phrase_for(type).capitalize, type] }
+  end
 end

app/models/category.rb

@@ -67,4 +67,8 @@ def self.by_id(id)
     end
     categories[id]
   end
+
+  def self.search(term)
+    where('name LIKE ?', "%#{sanitize_sql_like(term)}%")
+  end
 end

app/models/subscription.rb

@@ -1,16 +1,28 @@
 class Subscription < ApplicationRecord
-  self.inheritance_column = 'sti_type'
-
   include CommunityRelated
   include Timestamped
 
+  self.inheritance_column = 'sti_type'
+
+  BASE_TYPES = ['all', 'tag', 'user', 'interesting', 'category'].freeze
+  MOD_ONLY_TYPES = ['moderators'].freeze
+  TYPES = (BASE_TYPES + MOD_ONLY_TYPES).freeze
+  QUALIFIED_TYPES = ['category', 'tag', 'user'].freeze
+
   belongs_to :user
 
-  validates :type, presence: true, inclusion: ['all', 'tag', 'user', 'interesting', 'category', 'moderators']
+  validates :type, presence: true, inclusion: TYPES
   validates :frequency, numericality: { minimum: 1, maximum: 90 }
 
   validate :qualifier_presence
 
+  # Gets a list of subscription types available to a given user
+  # @param user [User] user to check type access for
+  # @return [Array<String>] list of available types
+  def self.types_accessible_to(user)
+    user.at_least_moderator? ? TYPES : BASE_TYPES
+  end
+
   def questions
     case type
     when 'all'
@@ -36,10 +48,39 @@ def questions
     end&.order(created_at: :desc)&.limit(25)
   end
 
+  # Is the subscription's type qualified (bound to an entity)?
+  # @param type [String] type to check
+  # @return [Boolean] check result
+  def qualified?
+    QUALIFIED_TYPES.include?(type)
+  end
+
+  # Gets entity bound to the subscription through qualifier, if any
+  # @return [Category, Tag, User, nil]
+  def qualifier_entity
+    if qualified? && qualifier.present?
+      model = type.singularize.classify.constantize
+      tag? ? model.find_by(name: qualifier) : model.find(qualifier)
+    end
+  end
+
+  # Gets name of the entity bound to the subscription through qualifier, if any
+  # @return [String]
+  def qualifier_name
+    qualifier_entity&.name || qualifier
+  end
+
+  # Predicates for each of the available type (f.e., user?)
+  TYPES.each do |type_name|
+    define_method "#{type_name}?" do
+      type == type_name
+    end
+  end
+
   private
 
   def qualifier_presence
-    return unless ['tag', 'user', 'category'].include? type
+    return unless qualified?
 
     if type == 'tag' && (qualifier.blank? || Tag.find_by(name: qualifier).nil?)
       errors.add(:qualifier, 'must provide a valid tag name for tag subscriptions')