2014-01-30 17:10:36 -05:00
|
|
|
class GroupsController < ApplicationController
|
2018-01-31 23:17:59 -05:00
|
|
|
requires_login only: [
|
2016-11-29 03:25:02 -05:00
|
|
|
:set_notifications,
|
|
|
|
:mentionable,
|
2017-08-28 12:32:08 -04:00
|
|
|
:messageable,
|
2016-12-11 10:36:15 -05:00
|
|
|
:update,
|
2017-06-13 04:10:14 -04:00
|
|
|
:histories,
|
2017-07-21 02:12:24 -04:00
|
|
|
:request_membership,
|
2018-03-27 04:45:21 -04:00
|
|
|
:search,
|
|
|
|
:new
|
2016-11-29 03:25:02 -05:00
|
|
|
]
|
|
|
|
|
2017-08-31 00:06:56 -04:00
|
|
|
skip_before_action :preload_json, :check_xhr, only: [:posts_feed, :mentions_feed]
|
2018-01-31 15:04:09 -05:00
|
|
|
skip_before_action :check_xhr, only: [:show]
|
2015-12-14 17:17:09 -05:00
|
|
|
|
2018-03-20 03:50:46 -04:00
|
|
|
TYPE_FILTERS = {
|
2018-03-21 04:32:08 -04:00
|
|
|
my: Proc.new { |groups, user|
|
|
|
|
raise Discourse::NotFound unless user
|
|
|
|
Group.member_of(groups, user)
|
2018-03-20 03:50:46 -04:00
|
|
|
},
|
2018-03-21 04:32:08 -04:00
|
|
|
owner: Proc.new { |groups, user|
|
|
|
|
raise Discourse::NotFound unless user
|
|
|
|
Group.owner_of(groups, user)
|
2018-03-20 03:50:46 -04:00
|
|
|
},
|
|
|
|
public: Proc.new { |groups|
|
|
|
|
groups.where(public_admission: true, automatic: false)
|
|
|
|
},
|
|
|
|
close: Proc.new { |groups|
|
|
|
|
groups.where(
|
|
|
|
public_admission: false,
|
|
|
|
automatic: false
|
|
|
|
)
|
|
|
|
},
|
|
|
|
automatic: Proc.new { |groups|
|
|
|
|
groups.where(automatic: true)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-14 04:26:16 -05:00
|
|
|
def index
|
2016-12-22 01:14:03 -05:00
|
|
|
unless SiteSetting.enable_group_directory?
|
|
|
|
raise Discourse::InvalidAccess.new(:enable_group_directory)
|
|
|
|
end
|
|
|
|
|
2016-12-14 04:26:16 -05:00
|
|
|
page_size = 30
|
|
|
|
page = params[:page]&.to_i || 0
|
2018-03-19 04:14:50 -04:00
|
|
|
order = %w{name user_count}.delete(params[:order])
|
|
|
|
dir = params[:asc] ? 'ASC' : 'DESC'
|
|
|
|
groups = Group.visible_groups(current_user, order ? "#{order} #{dir}" : nil)
|
2017-07-03 15:26:46 -04:00
|
|
|
|
2018-03-19 05:16:51 -04:00
|
|
|
if (filter = params[:filter]).present?
|
|
|
|
groups = Group.search_groups(filter, groups: groups)
|
|
|
|
end
|
|
|
|
|
2018-03-20 03:50:46 -04:00
|
|
|
type_filters = TYPE_FILTERS.keys
|
|
|
|
|
2018-03-21 04:32:08 -04:00
|
|
|
if username = params[:username]
|
|
|
|
groups = TYPE_FILTERS[:my].call(groups, User.find_by_username(username))
|
|
|
|
type_filters = type_filters - [:my, :owner]
|
|
|
|
end
|
|
|
|
|
2017-07-03 15:26:46 -04:00
|
|
|
unless guardian.is_staff?
|
|
|
|
# hide automatic groups from all non stuff to de-clutter page
|
2018-03-21 04:32:08 -04:00
|
|
|
groups = groups.where("automatic IS FALSE OR groups.id = #{Group::AUTO_GROUPS[:moderators]}")
|
2018-03-20 03:50:46 -04:00
|
|
|
type_filters.delete(:automatic)
|
2017-07-03 15:26:46 -04:00
|
|
|
end
|
|
|
|
|
2017-08-08 09:45:27 -04:00
|
|
|
if Group.preloaded_custom_field_names.present?
|
|
|
|
Group.preload_custom_fields(groups, Group.preloaded_custom_field_names)
|
|
|
|
end
|
|
|
|
|
2018-03-20 03:50:46 -04:00
|
|
|
if type = params[:type]&.to_sym
|
|
|
|
groups = TYPE_FILTERS[type].call(groups, current_user)
|
|
|
|
end
|
|
|
|
|
2018-03-19 06:28:57 -04:00
|
|
|
if current_user
|
|
|
|
group_users = GroupUser.where(group: groups, user: current_user)
|
|
|
|
user_group_ids = group_users.pluck(:group_id)
|
|
|
|
owner_group_ids = group_users.where(owner: true).pluck(:group_id)
|
2018-03-21 04:32:08 -04:00
|
|
|
else
|
|
|
|
type_filters = type_filters - [:my, :owner]
|
2018-03-19 06:28:57 -04:00
|
|
|
end
|
2016-12-21 07:58:51 -05:00
|
|
|
|
2018-03-20 21:25:42 -04:00
|
|
|
count = groups.count
|
|
|
|
groups = groups.offset(page * page_size).limit(page_size)
|
|
|
|
|
2016-12-21 07:58:51 -05:00
|
|
|
render_json_dump(
|
2018-03-19 06:28:57 -04:00
|
|
|
groups: serialize_data(groups,
|
|
|
|
BasicGroupSerializer,
|
|
|
|
user_group_ids: user_group_ids || [],
|
|
|
|
owner_group_ids: owner_group_ids || []
|
|
|
|
),
|
2018-03-20 03:50:46 -04:00
|
|
|
extras: {
|
2018-03-21 04:32:08 -04:00
|
|
|
type_filters: type_filters
|
2018-03-20 03:50:46 -04:00
|
|
|
},
|
2016-12-20 01:38:27 -05:00
|
|
|
total_rows_groups: count,
|
2018-03-20 03:50:46 -04:00
|
|
|
load_more_groups: groups_path(page: page + 1, type: type),
|
2016-12-21 07:58:51 -05:00
|
|
|
)
|
2016-12-14 04:26:16 -05:00
|
|
|
end
|
|
|
|
|
2014-01-30 17:10:36 -05:00
|
|
|
def show
|
2018-01-31 15:04:09 -05:00
|
|
|
respond_to do |format|
|
|
|
|
group = find_group(:id)
|
|
|
|
|
|
|
|
format.html do
|
|
|
|
@title = group.full_name.present? ? group.full_name.capitalize : group.name
|
|
|
|
@description_meta = group.bio_cooked.present? ? PrettyText.excerpt(group.bio_cooked, 300) : @title
|
|
|
|
render :show
|
|
|
|
end
|
|
|
|
|
|
|
|
format.json do
|
2018-03-29 02:57:10 -04:00
|
|
|
groups = Group.visible_groups(current_user)
|
|
|
|
|
|
|
|
if !guardian.is_staff?
|
|
|
|
groups = groups.where(automatic: false)
|
|
|
|
end
|
|
|
|
|
|
|
|
render_json_dump(
|
|
|
|
group: serialize_data(group, GroupShowSerializer, root: nil),
|
|
|
|
extras: {
|
|
|
|
visible_group_names: groups.pluck(:name)
|
|
|
|
}
|
|
|
|
)
|
2018-01-31 15:04:09 -05:00
|
|
|
end
|
|
|
|
end
|
2014-01-30 17:10:36 -05:00
|
|
|
end
|
|
|
|
|
2018-03-27 04:45:21 -04:00
|
|
|
def new
|
|
|
|
end
|
|
|
|
|
2016-12-13 02:15:20 -05:00
|
|
|
def edit
|
|
|
|
end
|
|
|
|
|
2016-11-29 03:25:02 -05:00
|
|
|
def update
|
|
|
|
group = Group.find(params[:id])
|
2018-04-05 01:53:00 -04:00
|
|
|
guardian.ensure_can_edit!(group) unless current_user.admin
|
2016-11-29 03:25:02 -05:00
|
|
|
|
2018-04-05 01:53:00 -04:00
|
|
|
if group.update(group_params(automatic: group.automatic))
|
2016-12-11 10:36:15 -05:00
|
|
|
GroupActionLogger.new(current_user, group).log_change_group_settings
|
2018-03-27 02:23:35 -04:00
|
|
|
DiscourseEvent.trigger(:group_updated, group)
|
2016-12-11 10:36:15 -05:00
|
|
|
|
2016-11-29 03:25:02 -05:00
|
|
|
render json: success_json
|
|
|
|
else
|
|
|
|
render_json_error(group)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-02-07 10:44:03 -05:00
|
|
|
def posts
|
2014-02-18 16:43:02 -05:00
|
|
|
group = find_group(:group_id)
|
2017-10-31 16:47:47 -04:00
|
|
|
posts = group.posts_for(
|
|
|
|
guardian,
|
|
|
|
params.permit(:before_post_id, :category_id)
|
|
|
|
).limit(20)
|
2014-02-07 10:44:03 -05:00
|
|
|
render_serialized posts.to_a, GroupPostSerializer
|
|
|
|
end
|
|
|
|
|
2016-03-18 12:19:45 -04:00
|
|
|
def posts_feed
|
|
|
|
group = find_group(:group_id)
|
2017-10-31 16:47:47 -04:00
|
|
|
@posts = group.posts_for(
|
|
|
|
guardian,
|
|
|
|
params.permit(:before_post_id, :category_id)
|
|
|
|
).limit(50)
|
2016-03-18 12:19:45 -04:00
|
|
|
@title = "#{SiteSetting.title} - #{I18n.t("rss_description.group_posts", group_name: group.name)}"
|
|
|
|
@link = Discourse.base_url
|
|
|
|
@description = I18n.t("rss_description.group_posts", group_name: group.name)
|
|
|
|
render 'posts/latest', formats: [:rss]
|
|
|
|
end
|
|
|
|
|
2015-12-01 00:52:43 -05:00
|
|
|
def mentions
|
2017-12-07 16:16:53 -05:00
|
|
|
raise Discourse::NotFound unless SiteSetting.enable_mentions?
|
2015-12-01 00:52:43 -05:00
|
|
|
group = find_group(:group_id)
|
2017-10-31 16:47:47 -04:00
|
|
|
posts = group.mentioned_posts_for(
|
|
|
|
guardian,
|
|
|
|
params.permit(:before_post_id, :category_id)
|
|
|
|
).limit(20)
|
2015-12-01 00:52:43 -05:00
|
|
|
render_serialized posts.to_a, GroupPostSerializer
|
|
|
|
end
|
|
|
|
|
2016-03-18 12:19:45 -04:00
|
|
|
def mentions_feed
|
2017-12-07 16:16:53 -05:00
|
|
|
raise Discourse::NotFound unless SiteSetting.enable_mentions?
|
2016-03-18 12:19:45 -04:00
|
|
|
group = find_group(:group_id)
|
2017-10-31 16:47:47 -04:00
|
|
|
@posts = group.mentioned_posts_for(
|
|
|
|
guardian,
|
|
|
|
params.permit(:before_post_id, :category_id)
|
|
|
|
).limit(50)
|
2016-03-18 12:19:45 -04:00
|
|
|
@title = "#{SiteSetting.title} - #{I18n.t("rss_description.group_mentions", group_name: group.name)}"
|
|
|
|
@link = Discourse.base_url
|
|
|
|
@description = I18n.t("rss_description.group_mentions", group_name: group.name)
|
|
|
|
render 'posts/latest', formats: [:rss]
|
|
|
|
end
|
|
|
|
|
2014-02-06 13:06:19 -05:00
|
|
|
def members
|
2014-02-18 16:43:02 -05:00
|
|
|
group = find_group(:group_id)
|
2014-11-24 15:12:48 -05:00
|
|
|
|
2016-12-07 04:28:43 -05:00
|
|
|
limit = (params[:limit] || 20).to_i
|
2015-01-05 12:51:45 -05:00
|
|
|
offset = params[:offset].to_i
|
2016-12-08 01:26:50 -05:00
|
|
|
dir = (params[:desc] && !params[:desc].blank?) ? 'DESC' : 'ASC'
|
2016-12-22 01:55:24 -05:00
|
|
|
order = ""
|
2016-12-07 04:28:43 -05:00
|
|
|
|
|
|
|
if params[:order] && %w{last_posted_at last_seen_at}.include?(params[:order])
|
2016-12-22 01:55:24 -05:00
|
|
|
order = "#{params[:order]} #{dir} NULLS LAST"
|
2016-12-07 04:28:43 -05:00
|
|
|
end
|
|
|
|
|
2017-10-05 22:35:40 -04:00
|
|
|
users = group.users.human_users
|
|
|
|
total = users.count
|
2018-03-22 01:42:46 -04:00
|
|
|
|
2018-03-26 02:30:37 -04:00
|
|
|
if (filter = params[:filter]).present?
|
|
|
|
filter = filter.split(',') if filter.include?(',')
|
|
|
|
|
|
|
|
if current_user&.admin
|
|
|
|
users = users.filter_by_username_or_email(filter)
|
|
|
|
else
|
|
|
|
users = users.filter_by_username(filter)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-10-05 22:35:40 -04:00
|
|
|
members = users
|
2016-12-07 04:28:43 -05:00
|
|
|
.order('NOT group_users.owner')
|
|
|
|
.order(order)
|
2017-07-27 21:20:09 -04:00
|
|
|
.order(username_lower: dir)
|
2016-12-07 04:28:43 -05:00
|
|
|
.limit(limit)
|
|
|
|
.offset(offset)
|
|
|
|
|
2017-10-05 22:35:40 -04:00
|
|
|
owners = users
|
2016-12-07 04:28:43 -05:00
|
|
|
.order(order)
|
2017-07-27 21:20:09 -04:00
|
|
|
.order(username_lower: dir)
|
2016-12-07 04:28:43 -05:00
|
|
|
.where('group_users.owner')
|
2015-01-05 12:51:45 -05:00
|
|
|
|
|
|
|
render json: {
|
|
|
|
members: serialize_data(members, GroupUserSerializer),
|
2015-11-09 08:52:04 -05:00
|
|
|
owners: serialize_data(owners, GroupUserSerializer),
|
2015-01-05 12:51:45 -05:00
|
|
|
meta: {
|
|
|
|
total: total,
|
|
|
|
limit: limit,
|
|
|
|
offset: offset
|
|
|
|
}
|
|
|
|
}
|
2014-02-06 13:06:19 -05:00
|
|
|
end
|
|
|
|
|
2015-01-08 18:35:52 -05:00
|
|
|
def add_members
|
2015-11-09 08:52:04 -05:00
|
|
|
group = Group.find(params[:id])
|
2017-07-27 22:37:10 -04:00
|
|
|
group.public_admission ? ensure_logged_in : guardian.ensure_can_edit!(group)
|
2016-12-06 23:06:56 -05:00
|
|
|
|
|
|
|
users =
|
|
|
|
if params[:usernames].present?
|
|
|
|
User.where(username: params[:usernames].split(","))
|
|
|
|
elsif params[:user_ids].present?
|
|
|
|
User.find(params[:user_ids].split(","))
|
|
|
|
elsif params[:user_emails].present?
|
2017-04-26 14:47:36 -04:00
|
|
|
User.with_email(params[:user_emails].split(","))
|
2016-12-06 23:06:56 -05:00
|
|
|
else
|
|
|
|
raise Discourse::InvalidParameters.new(
|
|
|
|
'user_ids or usernames or user_emails must be present'
|
|
|
|
)
|
|
|
|
end
|
2015-11-09 08:52:04 -05:00
|
|
|
|
2016-12-06 23:06:56 -05:00
|
|
|
raise Discourse::NotFound if users.blank?
|
|
|
|
|
2017-07-27 22:37:10 -04:00
|
|
|
if group.public_admission
|
2016-12-13 03:39:44 -05:00
|
|
|
if !guardian.can_log_group_changes?(group) && current_user != users.first
|
|
|
|
raise Discourse::InvalidAccess
|
|
|
|
end
|
2016-12-06 23:06:56 -05:00
|
|
|
|
|
|
|
unless current_user.staff?
|
|
|
|
RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!
|
|
|
|
end
|
2015-11-09 08:52:04 -05:00
|
|
|
end
|
|
|
|
|
2018-03-26 02:30:37 -04:00
|
|
|
if (usernames = group.users.where(id: users.pluck(:id)).pluck(:username)).present?
|
|
|
|
render_json_error(I18n.t(
|
|
|
|
"groups.errors.member_already_exist",
|
2018-03-27 05:14:06 -04:00
|
|
|
username: usernames.sort.join(", "),
|
2018-03-26 02:30:37 -04:00
|
|
|
count: usernames.size
|
|
|
|
))
|
|
|
|
else
|
|
|
|
users.each do |user|
|
2015-11-09 08:52:04 -05:00
|
|
|
group.add(user)
|
2016-12-11 10:36:15 -05:00
|
|
|
GroupActionLogger.new(current_user, group).log_add_user_to_group(user)
|
2015-01-08 18:35:52 -05:00
|
|
|
end
|
|
|
|
|
2018-03-26 02:30:37 -04:00
|
|
|
render json: success_json.merge!(
|
|
|
|
usernames: users.map(&:username)
|
|
|
|
)
|
2015-11-09 08:52:04 -05:00
|
|
|
end
|
2015-01-08 18:35:52 -05:00
|
|
|
end
|
|
|
|
|
2016-11-25 03:45:15 -05:00
|
|
|
def mentionable
|
|
|
|
group = find_group(:name)
|
|
|
|
|
|
|
|
if group
|
|
|
|
render json: { mentionable: Group.mentionable(current_user).where(id: group.id).present? }
|
|
|
|
else
|
|
|
|
raise Discourse::InvalidAccess.new
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-08-28 12:32:08 -04:00
|
|
|
def messageable
|
|
|
|
group = find_group(:name)
|
|
|
|
|
|
|
|
if group
|
|
|
|
render json: { messageable: Group.messageable(current_user).where(id: group.id).present? }
|
|
|
|
else
|
|
|
|
raise Discourse::InvalidAccess.new
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-01-08 18:35:52 -05:00
|
|
|
def remove_member
|
2018-04-06 05:11:00 -04:00
|
|
|
group = Group.find_by(id: params[:id])
|
|
|
|
raise Discourse::NotFound unless group
|
2017-07-27 22:37:10 -04:00
|
|
|
group.public_exit ? ensure_logged_in : guardian.ensure_can_edit!(group)
|
2016-12-06 23:06:56 -05:00
|
|
|
|
|
|
|
user =
|
|
|
|
if params[:user_id].present?
|
|
|
|
User.find_by(id: params[:user_id])
|
|
|
|
elsif params[:username].present?
|
|
|
|
User.find_by_username(params[:username])
|
|
|
|
elsif params[:user_email].present?
|
|
|
|
User.find_by_email(params[:user_email])
|
|
|
|
else
|
|
|
|
raise Discourse::InvalidParameters.new('user_id or username must be present')
|
|
|
|
end
|
2015-11-09 08:52:04 -05:00
|
|
|
|
2016-12-06 23:06:56 -05:00
|
|
|
raise Discourse::NotFound unless user
|
|
|
|
|
2017-07-27 22:37:10 -04:00
|
|
|
if group.public_exit
|
2016-12-13 03:39:44 -05:00
|
|
|
if !guardian.can_log_group_changes?(group) && current_user != user
|
|
|
|
raise Discourse::InvalidAccess
|
|
|
|
end
|
2016-12-06 23:06:56 -05:00
|
|
|
|
|
|
|
unless current_user.staff?
|
|
|
|
RateLimiter.new(current_user, "public_group_membership", 3, 1.minute).performed!
|
|
|
|
end
|
2015-11-09 08:52:04 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
user.primary_group_id = nil if user.primary_group_id == group.id
|
|
|
|
|
2016-12-11 10:36:15 -05:00
|
|
|
group.remove(user)
|
|
|
|
GroupActionLogger.new(current_user, group).log_remove_user_from_group(user)
|
2015-01-08 18:35:52 -05:00
|
|
|
|
2015-11-09 08:52:04 -05:00
|
|
|
if group.save && user.save
|
|
|
|
render json: success_json
|
|
|
|
else
|
|
|
|
render_json_error(group)
|
2015-01-08 18:35:52 -05:00
|
|
|
end
|
2017-06-13 04:10:14 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def request_membership
|
2017-08-08 05:53:02 -04:00
|
|
|
params.require(:reason)
|
|
|
|
|
2017-06-13 04:10:14 -04:00
|
|
|
unless current_user.staff?
|
|
|
|
RateLimiter.new(current_user, "request_group_membership", 1, 1.day).performed!
|
|
|
|
end
|
2015-01-08 18:35:52 -05:00
|
|
|
|
2017-06-13 04:10:14 -04:00
|
|
|
group = find_group(:id)
|
|
|
|
group_name = group.name
|
2017-06-14 23:36:09 -04:00
|
|
|
|
|
|
|
usernames = [current_user.username].concat(
|
|
|
|
group.users.where('group_users.owner')
|
|
|
|
.order("users.last_seen_at DESC")
|
|
|
|
.limit(5)
|
|
|
|
.pluck("users.username")
|
|
|
|
)
|
2017-06-13 04:10:14 -04:00
|
|
|
|
|
|
|
post = PostCreator.new(current_user,
|
|
|
|
title: I18n.t('groups.request_membership_pm.title', group_name: group_name),
|
2017-08-08 05:53:02 -04:00
|
|
|
raw: params[:reason],
|
2017-06-13 04:10:14 -04:00
|
|
|
archetype: Archetype.private_message,
|
2017-06-14 23:36:09 -04:00
|
|
|
target_usernames: usernames.join(','),
|
2017-06-13 04:10:14 -04:00
|
|
|
skip_validations: true
|
|
|
|
).create!
|
|
|
|
|
|
|
|
render json: success_json.merge(relative_url: post.topic.relative_url)
|
2015-01-08 18:35:52 -05:00
|
|
|
end
|
|
|
|
|
2015-12-14 17:17:09 -05:00
|
|
|
def set_notifications
|
|
|
|
group = find_group(:id)
|
|
|
|
notification_level = params.require(:notification_level)
|
|
|
|
|
2017-04-20 15:47:25 -04:00
|
|
|
user_id = current_user.id
|
|
|
|
if guardian.is_staff?
|
|
|
|
user_id = params[:user_id] || user_id
|
|
|
|
end
|
|
|
|
|
2015-12-14 17:17:09 -05:00
|
|
|
GroupUser.where(group_id: group.id)
|
2017-07-27 21:20:09 -04:00
|
|
|
.where(user_id: user_id)
|
|
|
|
.update_all(notification_level: notification_level)
|
2015-12-14 17:17:09 -05:00
|
|
|
|
|
|
|
render json: success_json
|
|
|
|
end
|
|
|
|
|
2016-12-11 10:36:15 -05:00
|
|
|
def histories
|
|
|
|
group = find_group(:group_id)
|
2018-04-05 04:31:09 -04:00
|
|
|
guardian.ensure_can_edit!(group) unless current_user.admin
|
2016-12-11 10:36:15 -05:00
|
|
|
|
|
|
|
page_size = 25
|
|
|
|
offset = (params[:offset] && params[:offset].to_i) || 0
|
|
|
|
|
|
|
|
group_histories = GroupHistory.with_filters(group, params[:filters])
|
|
|
|
.limit(page_size)
|
|
|
|
.offset(offset * page_size)
|
|
|
|
|
|
|
|
render_json_dump(
|
|
|
|
logs: serialize_data(group_histories, BasicGroupHistorySerializer),
|
|
|
|
all_loaded: group_histories.count < page_size
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2017-07-21 02:12:24 -04:00
|
|
|
def search
|
|
|
|
groups = Group.visible_groups(current_user)
|
|
|
|
.where("groups.id <> ?", Group::AUTO_GROUPS[:everyone])
|
|
|
|
.order(:name)
|
|
|
|
|
|
|
|
if term = params[:term].to_s
|
|
|
|
groups = groups.where("name ILIKE :term OR full_name ILIKE :term", term: "%#{term}%")
|
|
|
|
end
|
|
|
|
|
|
|
|
if params[:ignore_automatic].to_s == "true"
|
|
|
|
groups = groups.where(automatic: false)
|
|
|
|
end
|
|
|
|
|
2017-08-08 09:45:27 -04:00
|
|
|
if Group.preloaded_custom_field_names.present?
|
|
|
|
Group.preload_custom_fields(groups, Group.preloaded_custom_field_names)
|
|
|
|
end
|
|
|
|
|
2017-07-21 02:12:24 -04:00
|
|
|
render_serialized(groups, BasicGroupSerializer)
|
|
|
|
end
|
|
|
|
|
2014-02-18 16:43:02 -05:00
|
|
|
private
|
|
|
|
|
2018-04-05 01:53:00 -04:00
|
|
|
def group_params(automatic: false)
|
|
|
|
permitted_params =
|
|
|
|
if automatic
|
|
|
|
%i{
|
|
|
|
visibility_level
|
|
|
|
mentionable_level
|
|
|
|
messageable_level
|
|
|
|
default_notification_level
|
|
|
|
}
|
|
|
|
else
|
|
|
|
default_params = %i{
|
|
|
|
mentionable_level
|
|
|
|
messageable_level
|
|
|
|
title
|
|
|
|
flair_url
|
|
|
|
flair_bg_color
|
|
|
|
flair_color
|
|
|
|
bio_raw
|
|
|
|
public_admission
|
|
|
|
public_exit
|
|
|
|
allow_membership_requests
|
|
|
|
full_name
|
|
|
|
default_notification_level
|
|
|
|
membership_request_template
|
|
|
|
}
|
|
|
|
|
|
|
|
if current_user.admin
|
2018-04-05 23:44:58 -04:00
|
|
|
default_params.push(*[
|
|
|
|
:incoming_email,
|
|
|
|
:primary_group,
|
|
|
|
:visibility_level,
|
|
|
|
:name,
|
|
|
|
:grant_trust_level,
|
|
|
|
:automatic_membership_email_domains,
|
|
|
|
:automatic_membership_retroactive
|
|
|
|
])
|
2018-04-05 01:53:00 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
default_params
|
|
|
|
end
|
2018-03-27 00:18:03 -04:00
|
|
|
|
|
|
|
params.require(:group).permit(*permitted_params)
|
2016-11-29 03:25:02 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def find_group(param_name)
|
|
|
|
name = params.require(param_name)
|
2018-03-29 02:57:10 -04:00
|
|
|
group = Group
|
|
|
|
group = group.find_by("lower(name) = ?", name.downcase)
|
2016-11-29 03:25:02 -05:00
|
|
|
guardian.ensure_can_see!(group)
|
|
|
|
group
|
|
|
|
end
|
2014-02-18 16:43:02 -05:00
|
|
|
|
2014-01-30 17:10:36 -05:00
|
|
|
end
|