2019-05-03 06:17:27 +08:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
class CategoriesController < ApplicationController
|
2022-11-08 00:24:55 +08:00
|
|
|
include TopicQueryParams
|
2013-02-06 03:16:51 +08:00
|
|
|
|
2022-04-08 11:14:06 +08:00
|
|
|
requires_login except: %i[
|
|
|
|
index
|
|
|
|
categories_and_latest
|
|
|
|
categories_and_top
|
|
|
|
show
|
|
|
|
redirect
|
|
|
|
find_by_slug
|
|
|
|
visible_groups
|
2023-11-28 23:58:47 +08:00
|
|
|
find
|
2023-10-18 00:46:54 +08:00
|
|
|
search
|
2022-04-08 11:14:06 +08:00
|
|
|
]
|
2023-01-09 20:20:10 +08:00
|
|
|
|
2022-04-08 11:14:06 +08:00
|
|
|
before_action :fetch_category, only: %i[show update destroy visible_groups]
|
2017-08-31 12:06:56 +08:00
|
|
|
before_action :initialize_staff_action_logger, only: %i[create update destroy]
|
2018-03-03 10:53:29 +08:00
|
|
|
skip_before_action :check_xhr, only: %i[index categories_and_latest categories_and_top redirect]
|
2014-10-17 00:15:31 +08:00
|
|
|
|
2020-01-30 02:30:48 +08:00
|
|
|
SYMMETRICAL_CATEGORIES_TO_TOPICS_FACTOR = 1.5
|
|
|
|
MIN_CATEGORIES_TOPICS = 5
|
2023-10-18 00:46:54 +08:00
|
|
|
MAX_CATEGORIES_LIMIT = 25
|
2020-01-30 02:30:48 +08:00
|
|
|
|
2014-10-17 00:15:31 +08:00
|
|
|
def redirect
|
2019-03-18 22:24:46 +08:00
|
|
|
return if handle_permalink("/category/#{params[:path]}")
|
2015-03-09 08:45:36 +08:00
|
|
|
redirect_to path("/c/#{params[:path]}")
|
2014-10-17 00:15:31 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
def index
|
2016-08-18 05:23:16 +08:00
|
|
|
discourse_expires_in 1.minute
|
|
|
|
|
2013-09-12 03:33:05 +08:00
|
|
|
@description = SiteSetting.site_description
|
|
|
|
|
2019-10-17 04:08:43 +08:00
|
|
|
parent_category =
|
|
|
|
Category.find_by_slug(params[:parent_category_id]) ||
|
|
|
|
Category.find_by(id: params[:parent_category_id].to_i)
|
2017-03-09 00:31:30 +08:00
|
|
|
|
2022-03-05 05:11:59 +08:00
|
|
|
include_subcategories =
|
|
|
|
SiteSetting.desktop_category_page_style == "subcategories_with_featured_topics" ||
|
|
|
|
params[:include_subcategories] == "true"
|
|
|
|
|
2016-08-19 07:47:00 +08:00
|
|
|
category_options = {
|
2020-04-30 14:48:34 +08:00
|
|
|
is_homepage: current_homepage == "categories",
|
2016-08-23 05:01:43 +08:00
|
|
|
parent_category_id: params[:parent_category_id],
|
2021-10-06 02:12:31 +08:00
|
|
|
include_topics: include_topics(parent_category),
|
2022-08-18 00:51:02 +08:00
|
|
|
include_subcategories: include_subcategories,
|
|
|
|
tag: params[:tag],
|
2023-12-11 23:58:45 +08:00
|
|
|
page: params[:page],
|
2016-08-19 07:47:00 +08:00
|
|
|
}
|
2013-10-17 14:44:56 +08:00
|
|
|
|
2016-08-18 05:23:16 +08:00
|
|
|
@category_list = CategoryList.new(guardian, category_options)
|
2013-05-29 09:15:30 +08:00
|
|
|
|
2018-12-12 18:46:14 +08:00
|
|
|
if category_options[:is_homepage] && SiteSetting.short_site_description.present?
|
|
|
|
@title = "#{SiteSetting.title} - #{SiteSetting.short_site_description}"
|
|
|
|
elsif !category_options[:is_homepage]
|
|
|
|
@title = "#{I18n.t("js.filters.categories.title")} - #{SiteSetting.title}"
|
|
|
|
end
|
2015-06-09 00:07:35 +08:00
|
|
|
|
2013-04-27 01:10:41 +08:00
|
|
|
respond_to do |format|
|
2016-08-18 05:23:16 +08:00
|
|
|
format.html do
|
|
|
|
store_preloaded(
|
|
|
|
@category_list.preload_key,
|
|
|
|
MultiJson.dump(CategoryListSerializer.new(@category_list, scope: guardian)),
|
|
|
|
)
|
2016-08-23 05:01:43 +08:00
|
|
|
|
2018-03-03 10:53:29 +08:00
|
|
|
style = SiteSetting.desktop_category_page_style
|
2020-01-30 02:30:48 +08:00
|
|
|
topic_options = { per_page: CategoriesController.topics_per_page, no_definitions: true }
|
2018-03-03 10:53:29 +08:00
|
|
|
|
2022-07-25 21:41:43 +08:00
|
|
|
if style == "categories_and_latest_topics_created_date"
|
|
|
|
topic_options[:order] = "created"
|
|
|
|
@topic_list = TopicQuery.new(current_user, topic_options).list_latest
|
|
|
|
@topic_list.more_topics_url = url_for(public_send("latest_path", sort: :created))
|
|
|
|
elsif style == "categories_and_latest_topics"
|
2018-03-03 10:53:29 +08:00
|
|
|
@topic_list = TopicQuery.new(current_user, topic_options).list_latest
|
2018-08-15 07:22:03 +08:00
|
|
|
@topic_list.more_topics_url = url_for(public_send("latest_path"))
|
2020-04-30 14:48:34 +08:00
|
|
|
elsif style == "categories_and_top_topics"
|
2020-05-27 08:05:06 +08:00
|
|
|
@topic_list =
|
|
|
|
TopicQuery.new(current_user, topic_options).list_top_for(
|
|
|
|
SiteSetting.top_page_default_timeframe.to_sym,
|
|
|
|
)
|
2018-08-15 07:22:03 +08:00
|
|
|
@topic_list.more_topics_url = url_for(public_send("top_path"))
|
2018-03-03 10:53:29 +08:00
|
|
|
end
|
|
|
|
|
2018-08-15 07:22:03 +08:00
|
|
|
if @topic_list.present? && @topic_list.topics.present?
|
2018-03-03 10:53:29 +08:00
|
|
|
store_preloaded(
|
|
|
|
@topic_list.preload_key,
|
|
|
|
MultiJson.dump(TopicListSerializer.new(@topic_list, scope: guardian)),
|
|
|
|
)
|
2016-08-23 05:01:43 +08:00
|
|
|
end
|
|
|
|
|
2016-08-18 05:23:16 +08:00
|
|
|
render
|
|
|
|
end
|
|
|
|
|
|
|
|
format.json { render_serialized(@category_list, CategoryListSerializer) }
|
2013-04-27 01:10:41 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2013-02-07 23:45:24 +08:00
|
|
|
|
2016-08-30 04:47:44 +08:00
|
|
|
def categories_and_latest
|
2018-03-03 10:53:29 +08:00
|
|
|
categories_and_topics(:latest)
|
|
|
|
end
|
2016-08-30 04:47:44 +08:00
|
|
|
|
2018-03-03 10:53:29 +08:00
|
|
|
def categories_and_top
|
|
|
|
categories_and_topics(:top)
|
2016-08-30 04:47:44 +08:00
|
|
|
end
|
|
|
|
|
2013-10-21 12:24:37 +08:00
|
|
|
def move
|
2015-08-28 01:14:59 +08:00
|
|
|
guardian.ensure_can_create_category!
|
2013-10-21 12:33:42 +08:00
|
|
|
|
2013-10-21 12:24:37 +08:00
|
|
|
params.require("category_id")
|
|
|
|
params.require("position")
|
|
|
|
|
|
|
|
if category = Category.find(params["category_id"])
|
|
|
|
category.move_to(params["position"].to_i)
|
|
|
|
render json: success_json
|
|
|
|
else
|
|
|
|
render status: 500, json: failed_json
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-08-28 01:14:59 +08:00
|
|
|
def reorder
|
|
|
|
guardian.ensure_can_create_category!
|
|
|
|
|
|
|
|
params.require(:mapping)
|
|
|
|
change_requests = MultiJson.load(params[:mapping])
|
|
|
|
by_category = Hash[change_requests.map { |cat, pos| [Category.find(cat.to_i), pos] }]
|
|
|
|
|
|
|
|
unless guardian.is_admin?
|
|
|
|
unless by_category.keys.all? { |c| guardian.can_see_category? c }
|
|
|
|
raise Discourse::InvalidAccess
|
2023-01-09 20:20:10 +08:00
|
|
|
end
|
2015-08-28 01:14:59 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
by_category.each do |cat, pos|
|
|
|
|
cat.position = pos
|
2017-08-31 12:06:56 +08:00
|
|
|
cat.save! if cat.will_save_change_to_position?
|
2015-08-28 01:14:59 +08:00
|
|
|
end
|
2017-08-31 12:06:56 +08:00
|
|
|
|
2015-08-28 01:14:59 +08:00
|
|
|
render json: success_json
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
def show
|
2019-08-19 15:08:28 +08:00
|
|
|
guardian.ensure_can_see!(@category)
|
|
|
|
|
2014-03-06 06:21:55 +08:00
|
|
|
if Category.topic_create_allowed(guardian).where(id: @category.id).exists?
|
|
|
|
@category.permission = CategoryGroup.permission_types[:full]
|
|
|
|
end
|
2022-04-08 11:14:06 +08:00
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
render_serialized(@category, CategorySerializer)
|
|
|
|
end
|
|
|
|
|
|
|
|
def create
|
|
|
|
guardian.ensure_can_create!(Category)
|
2014-05-16 23:33:44 +08:00
|
|
|
position = category_params.delete(:position)
|
|
|
|
|
2018-09-03 11:04:58 +08:00
|
|
|
@category =
|
|
|
|
begin
|
2020-08-13 02:28:29 +08:00
|
|
|
Category.new(required_create_params.merge(user: current_user))
|
2018-09-03 11:04:58 +08:00
|
|
|
rescue ArgumentError => e
|
|
|
|
return render json: { errors: [e.message] }, status: 422
|
|
|
|
end
|
2013-02-07 23:45:24 +08:00
|
|
|
|
2015-09-17 15:51:32 +08:00
|
|
|
if @category.save
|
|
|
|
@category.move_to(position.to_i) if position
|
|
|
|
|
|
|
|
Scheduler::Defer.later "Log staff action create category" do
|
|
|
|
@staff_action_logger.log_category_creation(@category)
|
|
|
|
end
|
|
|
|
|
|
|
|
render_serialized(@category, CategorySerializer)
|
|
|
|
else
|
2019-12-10 08:48:27 +08:00
|
|
|
render_json_error(@category)
|
2015-09-17 15:51:32 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
def update
|
|
|
|
guardian.ensure_can_edit!(@category)
|
2014-10-11 00:21:44 +08:00
|
|
|
|
|
|
|
json_result(@category, serializer: CategorySerializer) do |cat|
|
2021-09-17 18:37:56 +08:00
|
|
|
old_category_params = category_params.dup
|
2014-10-11 00:21:44 +08:00
|
|
|
|
2014-05-16 23:33:44 +08:00
|
|
|
cat.move_to(category_params[:position].to_i) if category_params[:position]
|
2016-03-09 03:52:04 +08:00
|
|
|
category_params.delete(:position)
|
2014-10-11 00:21:44 +08:00
|
|
|
|
2021-09-17 18:37:56 +08:00
|
|
|
old_custom_fields = cat.custom_fields.dup
|
|
|
|
if category_params[:custom_fields]
|
|
|
|
category_params[:custom_fields].each do |key, value|
|
|
|
|
if value.present?
|
|
|
|
cat.custom_fields[key] = value
|
|
|
|
else
|
|
|
|
cat.custom_fields.delete(key)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
category_params.delete(:custom_fields)
|
|
|
|
|
2016-03-09 03:52:04 +08:00
|
|
|
# properly null the value so the database constraint doesn't catch us
|
2023-12-21 10:15:10 +08:00
|
|
|
category_params[:email_in] = nil if category_params[:email_in].blank?
|
|
|
|
category_params[:minimum_required_tags] = 0 if category_params[:minimum_required_tags].blank?
|
2014-10-11 00:21:44 +08:00
|
|
|
|
2016-03-09 03:52:04 +08:00
|
|
|
old_permissions = cat.permissions_params
|
2023-01-31 21:15:17 +08:00
|
|
|
old_permissions = { "everyone" => 1 } if old_permissions.empty?
|
2014-10-11 00:21:44 +08:00
|
|
|
|
2017-08-31 12:06:56 +08:00
|
|
|
if result = cat.update(category_params)
|
2015-09-17 15:51:32 +08:00
|
|
|
Scheduler::Defer.later "Log staff action change category settings" do
|
2021-09-17 18:37:56 +08:00
|
|
|
@staff_action_logger.log_category_settings_change(
|
|
|
|
@category,
|
|
|
|
old_category_params,
|
|
|
|
old_permissions: old_permissions,
|
|
|
|
old_custom_fields: old_custom_fields,
|
|
|
|
)
|
2015-09-17 15:51:32 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-07-13 03:23:07 +08:00
|
|
|
DiscourseEvent.trigger(:category_updated, cat) if result
|
|
|
|
|
2015-09-17 15:51:32 +08:00
|
|
|
result
|
2014-10-11 00:21:44 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-12-20 22:07:29 +08:00
|
|
|
def update_slug
|
|
|
|
@category = Category.find(params[:category_id].to_i)
|
|
|
|
guardian.ensure_can_edit!(@category)
|
|
|
|
|
|
|
|
custom_slug = params[:slug].to_s
|
|
|
|
|
2020-04-21 09:50:20 +08:00
|
|
|
if custom_slug.blank?
|
|
|
|
error = @category.errors.full_message(:slug, I18n.t("errors.messages.blank"))
|
|
|
|
render_json_error(error)
|
|
|
|
elsif @category.update(slug: custom_slug)
|
2014-12-20 22:07:29 +08:00
|
|
|
render json: success_json
|
|
|
|
else
|
|
|
|
render_json_error(@category)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-04-17 17:17:39 +08:00
|
|
|
def set_notifications
|
|
|
|
category_id = params[:category_id].to_i
|
|
|
|
notification_level = params[:notification_level].to_i
|
|
|
|
|
2014-11-03 23:57:50 +08:00
|
|
|
CategoryUser.set_notification_level_for_category(current_user, notification_level, category_id)
|
2022-02-17 07:42:02 +08:00
|
|
|
render json:
|
|
|
|
success_json.merge(
|
|
|
|
{
|
|
|
|
indirectly_muted_category_ids:
|
|
|
|
CategoryUser.indirectly_muted_category_ids(current_user),
|
|
|
|
},
|
|
|
|
)
|
2014-04-17 17:17:39 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
def destroy
|
2013-04-19 05:07:06 +08:00
|
|
|
guardian.ensure_can_delete!(@category)
|
|
|
|
@category.destroy
|
2013-10-21 12:24:37 +08:00
|
|
|
|
2015-09-17 15:51:32 +08:00
|
|
|
Scheduler::Defer.later "Log staff action delete category" do
|
|
|
|
@staff_action_logger.log_category_deletion(@category)
|
|
|
|
end
|
|
|
|
|
2013-10-21 12:24:37 +08:00
|
|
|
render json: success_json
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2016-03-15 00:38:29 +08:00
|
|
|
def find_by_slug
|
|
|
|
params.require(:category_slug)
|
2023-03-10 13:45:01 +08:00
|
|
|
@category =
|
|
|
|
Category.includes(:category_setting).find_by_slug_path(params[:category_slug].split("/"))
|
2019-10-15 23:39:09 +08:00
|
|
|
|
|
|
|
raise Discourse::NotFound unless @category.present?
|
|
|
|
|
2019-10-08 19:15:08 +08:00
|
|
|
if !guardian.can_see?(@category)
|
|
|
|
if SiteSetting.detailed_404 && group = @category.access_category_via_group
|
|
|
|
raise Discourse::InvalidAccess.new(
|
|
|
|
"not in group",
|
|
|
|
@category,
|
|
|
|
custom_message: "not_in_group.title_category",
|
2021-06-15 05:42:09 +08:00
|
|
|
custom_message_params: {
|
|
|
|
group: group.name,
|
|
|
|
},
|
2019-10-08 19:15:08 +08:00
|
|
|
group: group,
|
|
|
|
)
|
|
|
|
else
|
|
|
|
raise Discourse::NotFound
|
|
|
|
end
|
|
|
|
end
|
2016-03-15 00:38:29 +08:00
|
|
|
|
|
|
|
@category.permission = CategoryGroup.permission_types[:full] if Category
|
|
|
|
.topic_create_allowed(guardian)
|
|
|
|
.where(id: @category.id)
|
|
|
|
.exists?
|
|
|
|
render_serialized(@category, CategorySerializer)
|
|
|
|
end
|
|
|
|
|
2022-04-08 11:14:06 +08:00
|
|
|
def visible_groups
|
|
|
|
@guardian.ensure_can_see!(@category)
|
2022-04-18 16:16:30 +08:00
|
|
|
|
|
|
|
groups =
|
|
|
|
if !@category.groups.exists?(id: Group::AUTO_GROUPS[:everyone])
|
|
|
|
@category.groups.merge(Group.visible_groups(current_user)).pluck("name")
|
|
|
|
end
|
|
|
|
|
|
|
|
render json: success_json.merge(groups: groups || [])
|
2022-04-08 11:14:06 +08:00
|
|
|
end
|
|
|
|
|
2023-11-28 23:58:47 +08:00
|
|
|
def find
|
2023-12-08 18:01:08 +08:00
|
|
|
categories = []
|
2024-02-29 19:48:20 +08:00
|
|
|
serializer = params[:include_permissions] ? CategorySerializer : SiteCategorySerializer
|
2023-12-08 18:01:08 +08:00
|
|
|
|
|
|
|
if params[:ids].present?
|
|
|
|
categories = Category.secured(guardian).where(id: params[:ids])
|
2024-02-29 19:48:20 +08:00
|
|
|
elsif params[:slug_path].present?
|
|
|
|
category = Category.find_by_slug_path(params[:slug_path].split("/"))
|
|
|
|
raise Discourse::NotFound if category.blank?
|
|
|
|
guardian.ensure_can_see!(category)
|
|
|
|
|
|
|
|
ancestors = Category.secured(guardian).with_ancestors(category.id).where.not(id: category.id)
|
|
|
|
categories = [*ancestors, category]
|
2023-12-08 18:01:08 +08:00
|
|
|
elsif params[:slug_path_with_id].present?
|
|
|
|
category = Category.find_by_slug_path_with_id(params[:slug_path_with_id])
|
|
|
|
raise Discourse::NotFound if category.blank?
|
|
|
|
guardian.ensure_can_see!(category)
|
|
|
|
|
|
|
|
ancestors = Category.secured(guardian).with_ancestors(category.id).where.not(id: category.id)
|
|
|
|
categories = [*ancestors, category]
|
|
|
|
end
|
|
|
|
|
|
|
|
raise Discourse::NotFound if categories.blank?
|
|
|
|
|
|
|
|
Category.preload_user_fields!(guardian, categories)
|
|
|
|
|
2024-02-29 19:48:20 +08:00
|
|
|
render_serialized(categories, serializer, root: :categories, scope: guardian)
|
2023-11-28 23:58:47 +08:00
|
|
|
end
|
|
|
|
|
2023-10-18 00:46:54 +08:00
|
|
|
def search
|
|
|
|
term = params[:term].to_s.strip
|
|
|
|
parent_category_id = params[:parent_category_id].to_i if params[:parent_category_id].present?
|
|
|
|
include_uncategorized =
|
|
|
|
(
|
|
|
|
if params[:include_uncategorized].present?
|
|
|
|
ActiveModel::Type::Boolean.new.cast(params[:include_uncategorized])
|
|
|
|
else
|
|
|
|
true
|
|
|
|
end
|
|
|
|
)
|
2024-02-29 19:48:20 +08:00
|
|
|
if params[:select_category_ids].is_a?(Array)
|
|
|
|
select_category_ids = params[:select_category_ids].map(&:presence)
|
|
|
|
end
|
|
|
|
if params[:reject_category_ids].is_a?(Array)
|
|
|
|
reject_category_ids = params[:reject_category_ids].map(&:presence)
|
|
|
|
end
|
2023-10-18 00:46:54 +08:00
|
|
|
include_subcategories =
|
|
|
|
if params[:include_subcategories].present?
|
|
|
|
ActiveModel::Type::Boolean.new.cast(params[:include_subcategories])
|
|
|
|
else
|
|
|
|
true
|
|
|
|
end
|
2024-02-21 01:24:30 +08:00
|
|
|
include_ancestors =
|
|
|
|
if params[:include_ancestors].present?
|
|
|
|
ActiveModel::Type::Boolean.new.cast(params[:include_ancestors])
|
|
|
|
else
|
|
|
|
false
|
|
|
|
end
|
2023-10-18 00:46:54 +08:00
|
|
|
prioritized_category_id = params[:prioritized_category_id].to_i if params[
|
|
|
|
:prioritized_category_id
|
|
|
|
].present?
|
2024-04-25 21:47:45 +08:00
|
|
|
limit =
|
|
|
|
(
|
|
|
|
if params[:limit].present?
|
|
|
|
params[:limit].to_i.clamp(1, MAX_CATEGORIES_LIMIT)
|
|
|
|
else
|
|
|
|
MAX_CATEGORIES_LIMIT
|
|
|
|
end
|
|
|
|
)
|
|
|
|
page = [1, params[:page].to_i].max
|
2023-10-18 00:46:54 +08:00
|
|
|
|
|
|
|
categories = Category.secured(guardian)
|
|
|
|
|
2024-04-17 22:20:25 +08:00
|
|
|
if term.present? && words = term.split
|
|
|
|
words.each { |word| categories = categories.where("name ILIKE ?", "%#{word}%") }
|
|
|
|
end
|
2023-10-18 00:46:54 +08:00
|
|
|
|
|
|
|
categories =
|
2023-11-29 15:41:25 +08:00
|
|
|
(
|
|
|
|
if parent_category_id != -1
|
|
|
|
categories.where(parent_category_id: parent_category_id)
|
|
|
|
else
|
|
|
|
categories.where(parent_category_id: nil)
|
|
|
|
end
|
|
|
|
) if parent_category_id.present?
|
2023-10-18 00:46:54 +08:00
|
|
|
|
|
|
|
categories =
|
|
|
|
categories.where.not(id: SiteSetting.uncategorized_category_id) if !include_uncategorized
|
|
|
|
|
|
|
|
categories = categories.where(id: select_category_ids) if select_category_ids
|
|
|
|
|
|
|
|
categories = categories.where.not(id: reject_category_ids) if reject_category_ids
|
|
|
|
|
|
|
|
categories = categories.where(parent_category_id: nil) if !include_subcategories
|
|
|
|
|
2024-03-07 22:14:50 +08:00
|
|
|
categories_count = categories.count
|
|
|
|
|
2024-03-19 01:01:17 +08:00
|
|
|
categories =
|
|
|
|
categories
|
|
|
|
.includes(
|
|
|
|
:uploaded_logo,
|
|
|
|
:uploaded_logo_dark,
|
|
|
|
:uploaded_background,
|
|
|
|
:uploaded_background_dark,
|
|
|
|
:tags,
|
|
|
|
:tag_groups,
|
|
|
|
:form_templates,
|
|
|
|
category_required_tag_groups: :tag_group,
|
|
|
|
)
|
|
|
|
.joins("LEFT JOIN topics t on t.id = categories.topic_id")
|
|
|
|
.select("categories.*, t.slug topic_slug")
|
2024-04-25 21:47:45 +08:00
|
|
|
.limit(limit)
|
|
|
|
.offset((page - 1) * limit)
|
2023-10-18 00:46:54 +08:00
|
|
|
|
2024-03-19 20:11:19 +08:00
|
|
|
if Site.preloaded_category_custom_fields.present?
|
|
|
|
Category.preload_custom_fields(categories, Site.preloaded_category_custom_fields)
|
|
|
|
end
|
|
|
|
|
2023-12-08 18:01:08 +08:00
|
|
|
Category.preload_user_fields!(guardian, categories)
|
|
|
|
|
2024-02-21 22:32:58 +08:00
|
|
|
# Prioritize categories that start with the term, then top-level
|
|
|
|
# categories, then subcategories
|
|
|
|
categories =
|
|
|
|
categories.to_a.sort_by do |category|
|
|
|
|
[
|
|
|
|
category.name.downcase.starts_with?(term) ? 0 : 1,
|
|
|
|
category.parent_category_id.blank? ? 0 : 1,
|
2024-02-22 02:20:40 +08:00
|
|
|
category.id == prioritized_category_id ? 0 : 1,
|
|
|
|
category.parent_category_id == prioritized_category_id ? 0 : 1,
|
|
|
|
category.id,
|
2024-02-21 22:32:58 +08:00
|
|
|
]
|
|
|
|
end
|
|
|
|
|
2024-03-07 22:14:50 +08:00
|
|
|
response = {
|
|
|
|
categories_count: categories_count,
|
|
|
|
categories: serialize_data(categories, SiteCategorySerializer, scope: guardian),
|
|
|
|
}
|
|
|
|
|
2024-02-21 01:24:30 +08:00
|
|
|
if include_ancestors
|
|
|
|
ancestors = Category.secured(guardian).ancestors_of(categories.map(&:id))
|
2024-04-12 16:56:32 +08:00
|
|
|
Category.preload_user_fields!(guardian, ancestors)
|
2024-03-07 22:14:50 +08:00
|
|
|
response[:ancestors] = serialize_data(ancestors, SiteCategorySerializer, scope: guardian)
|
2024-02-21 01:24:30 +08:00
|
|
|
end
|
2024-03-07 22:14:50 +08:00
|
|
|
|
|
|
|
render_json_dump(response)
|
2023-10-18 00:46:54 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
private
|
2020-01-30 02:30:48 +08:00
|
|
|
|
|
|
|
def self.topics_per_page
|
|
|
|
return SiteSetting.categories_topics if SiteSetting.categories_topics > 0
|
|
|
|
|
|
|
|
count = Category.where(parent_category: nil).count
|
|
|
|
count = (SYMMETRICAL_CATEGORIES_TO_TOPICS_FACTOR * count).to_i
|
|
|
|
count > MIN_CATEGORIES_TOPICS ? count : MIN_CATEGORIES_TOPICS
|
|
|
|
end
|
|
|
|
|
2018-03-03 10:53:29 +08:00
|
|
|
def categories_and_topics(topics_filter)
|
|
|
|
discourse_expires_in 1.minute
|
|
|
|
|
|
|
|
category_options = {
|
2020-04-30 14:48:34 +08:00
|
|
|
is_homepage: current_homepage == "categories",
|
2018-03-03 10:53:29 +08:00
|
|
|
parent_category_id: params[:parent_category_id],
|
|
|
|
include_topics: false,
|
2023-12-11 23:58:45 +08:00
|
|
|
page: params[:page],
|
2018-06-07 13:28:18 +08:00
|
|
|
}
|
2018-03-03 10:53:29 +08:00
|
|
|
|
2020-01-30 02:30:48 +08:00
|
|
|
topic_options = { per_page: CategoriesController.topics_per_page, no_definitions: true }
|
2022-11-08 00:24:55 +08:00
|
|
|
|
|
|
|
topic_options.merge!(build_topic_list_options)
|
2022-07-25 21:41:43 +08:00
|
|
|
style = SiteSetting.desktop_category_page_style
|
|
|
|
topic_options[:order] = "created" if style == "categories_and_latest_topics_created_date"
|
2018-06-07 13:28:18 +08:00
|
|
|
|
2018-03-03 10:53:29 +08:00
|
|
|
result = CategoryAndTopicLists.new
|
|
|
|
result.category_list = CategoryList.new(guardian, category_options)
|
|
|
|
|
|
|
|
if topics_filter == :latest
|
|
|
|
result.topic_list = TopicQuery.new(current_user, topic_options).list_latest
|
2023-05-26 02:24:48 +08:00
|
|
|
result.topic_list.more_topics_url =
|
|
|
|
url_for(
|
|
|
|
public_send("latest_path", sort: topic_options[:order] == "created" ? :created : nil),
|
|
|
|
)
|
2018-03-03 10:53:29 +08:00
|
|
|
elsif topics_filter == :top
|
2021-11-12 00:35:03 +08:00
|
|
|
result.topic_list =
|
|
|
|
TopicQuery.new(current_user, topic_options).list_top_for(
|
|
|
|
SiteSetting.top_page_default_timeframe.to_sym,
|
|
|
|
)
|
2023-05-26 02:24:48 +08:00
|
|
|
result.topic_list.more_topics_url = url_for(public_send("top_path"))
|
2018-03-03 10:53:29 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
render_serialized(result, CategoryAndTopicListsSerializer, root: false)
|
2013-10-21 14:17:40 +08:00
|
|
|
end
|
2013-06-05 14:45:25 +08:00
|
|
|
|
2013-10-21 14:17:40 +08:00
|
|
|
def required_param_keys
|
2020-08-13 02:28:29 +08:00
|
|
|
[:name]
|
|
|
|
end
|
|
|
|
|
|
|
|
def required_create_params
|
|
|
|
required_param_keys.each { |key| params.require(key) }
|
|
|
|
category_params
|
2018-06-07 13:28:18 +08:00
|
|
|
end
|
|
|
|
|
2013-10-21 14:17:40 +08:00
|
|
|
def category_params
|
|
|
|
@category_params ||=
|
|
|
|
begin
|
2016-06-08 01:08:59 +08:00
|
|
|
if p = params[:permissions]
|
|
|
|
p.each { |k, v| p[k] = v.to_i }
|
|
|
|
end
|
2016-06-01 04:46:40 +08:00
|
|
|
|
2014-07-10 10:01:46 +08:00
|
|
|
if SiteSetting.tagging_enabled
|
2021-09-14 20:04:54 +08:00
|
|
|
params[:allowed_tags] = params[:allowed_tags].presence || [] if params[:allowed_tags]
|
|
|
|
params[:allowed_tag_groups] = params[:allowed_tag_groups].presence || [] if params[
|
|
|
|
:allowed_tag_groups
|
|
|
|
]
|
2022-04-06 21:08:06 +08:00
|
|
|
params[:required_tag_groups] = params[:required_tag_groups].presence || [] if params[
|
|
|
|
:required_tag_groups
|
|
|
|
]
|
2021-09-14 20:04:54 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
if SiteSetting.enable_category_group_moderation?
|
|
|
|
params[:reviewable_by_group_id] = Group.where(
|
|
|
|
name: params[:reviewable_by_group_name],
|
2023-02-13 12:39:45 +08:00
|
|
|
).pick(:id) if params[:reviewable_by_group_name]
|
2013-10-21 14:17:40 +08:00
|
|
|
end
|
2013-04-19 05:07:06 +08:00
|
|
|
|
2019-04-18 05:12:32 +08:00
|
|
|
result =
|
|
|
|
params.permit(
|
|
|
|
*required_param_keys,
|
|
|
|
:position,
|
2020-08-13 02:28:29 +08:00
|
|
|
:name,
|
|
|
|
:color,
|
|
|
|
:text_color,
|
2019-04-18 05:12:32 +08:00
|
|
|
:email_in,
|
|
|
|
:email_in_allow_strangers,
|
|
|
|
:mailinglist_mirror,
|
|
|
|
:all_topics_wiki,
|
2021-04-14 13:54:09 +08:00
|
|
|
:allow_unlimited_owner_edits_on_first_post,
|
2021-06-28 03:46:11 +08:00
|
|
|
:default_slow_mode_seconds,
|
2019-04-18 05:12:32 +08:00
|
|
|
:parent_category_id,
|
|
|
|
:auto_close_hours,
|
|
|
|
:auto_close_based_on_last_post,
|
|
|
|
:uploaded_logo_id,
|
2022-10-07 23:00:44 +08:00
|
|
|
:uploaded_logo_dark_id,
|
2019-04-18 05:12:32 +08:00
|
|
|
:uploaded_background_id,
|
2023-10-20 20:48:06 +08:00
|
|
|
:uploaded_background_dark_id,
|
2019-04-18 05:12:32 +08:00
|
|
|
:slug,
|
|
|
|
:allow_badges,
|
|
|
|
:topic_template,
|
|
|
|
:sort_order,
|
|
|
|
:sort_ascending,
|
|
|
|
:topic_featured_link_allowed,
|
|
|
|
:show_subcategory_list,
|
|
|
|
:num_featured_topics,
|
|
|
|
:default_view,
|
|
|
|
:subcategory_list_style,
|
|
|
|
:default_top_period,
|
|
|
|
:minimum_required_tags,
|
|
|
|
:navigate_to_first_post_after_read,
|
|
|
|
:search_priority,
|
|
|
|
:allow_global_tags,
|
2020-05-01 01:39:11 +08:00
|
|
|
:read_only_banner,
|
2020-06-04 03:26:56 +08:00
|
|
|
:default_list_filter,
|
2021-09-14 20:04:54 +08:00
|
|
|
:reviewable_by_group_id,
|
2023-09-12 09:51:49 +08:00
|
|
|
category_setting_attributes: %i[
|
|
|
|
auto_bump_cooldown_days
|
|
|
|
num_auto_bump_daily
|
|
|
|
require_reply_approval
|
|
|
|
require_topic_approval
|
|
|
|
],
|
2022-07-28 10:23:35 +08:00
|
|
|
custom_fields: [custom_field_params],
|
2019-04-18 05:12:32 +08:00
|
|
|
permissions: [*p.try(:keys)],
|
|
|
|
allowed_tags: [],
|
2021-09-14 20:04:54 +08:00
|
|
|
allowed_tag_groups: [],
|
2022-04-06 21:08:06 +08:00
|
|
|
required_tag_groups: %i[name min_count],
|
2023-02-24 03:18:14 +08:00
|
|
|
form_template_ids: [],
|
2019-04-18 05:12:32 +08:00
|
|
|
)
|
2022-04-06 21:08:06 +08:00
|
|
|
|
|
|
|
if result[:required_tag_groups] && !result[:required_tag_groups].is_a?(Array)
|
|
|
|
raise Discourse::InvalidParameters.new(:required_tag_groups)
|
2023-01-09 20:20:10 +08:00
|
|
|
end
|
|
|
|
|
2019-04-18 05:12:32 +08:00
|
|
|
result
|
2013-04-19 05:07:06 +08:00
|
|
|
end
|
2018-06-07 13:28:18 +08:00
|
|
|
end
|
2015-09-17 15:51:32 +08:00
|
|
|
|
2022-07-28 10:23:35 +08:00
|
|
|
def custom_field_params
|
|
|
|
keys = params[:custom_fields].try(:keys)
|
|
|
|
return if keys.blank?
|
|
|
|
|
|
|
|
keys.map { |key| params[:custom_fields][key].is_a?(Array) ? { key => [] } : key }
|
|
|
|
end
|
|
|
|
|
2015-09-17 15:51:32 +08:00
|
|
|
def fetch_category
|
2019-10-29 00:11:03 +08:00
|
|
|
@category = Category.find_by_slug(params[:id]) || Category.find_by(id: params[:id].to_i)
|
2022-04-08 11:14:06 +08:00
|
|
|
raise Discourse::NotFound if @category.blank?
|
2015-09-17 15:51:32 +08:00
|
|
|
end
|
2016-08-30 04:47:44 +08:00
|
|
|
|
2015-09-17 15:51:32 +08:00
|
|
|
def initialize_staff_action_logger
|
|
|
|
@staff_action_logger = StaffActionLogger.new(current_user)
|
2018-06-07 13:28:18 +08:00
|
|
|
end
|
|
|
|
|
2017-03-09 00:31:30 +08:00
|
|
|
def include_topics(parent_category = nil)
|
2018-03-03 10:53:29 +08:00
|
|
|
style = SiteSetting.desktop_category_page_style
|
2018-11-02 22:29:44 +08:00
|
|
|
view_context.mobile_view? || params[:include_topics] ||
|
2018-03-03 10:53:29 +08:00
|
|
|
(parent_category && parent_category.subcategory_list_includes_topics?) ||
|
2022-03-05 05:11:59 +08:00
|
|
|
style == "categories_with_featured_topics" || style == "subcategories_with_featured_topics" ||
|
2020-04-30 14:48:34 +08:00
|
|
|
style == "categories_boxes_with_topics" || style == "categories_with_top_topics"
|
2016-08-30 04:47:44 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|