509 lines
16 KiB
Ruby
509 lines
16 KiB
Ruby
module Admin
|
|
class UsersController < Admin::ApplicationController
|
|
layout "admin"
|
|
using StringToBoolean
|
|
|
|
USER_ALLOWED_PARAMS = %i[
|
|
new_note note_for_current_role user_status
|
|
merge_user_id add_credits remove_credits
|
|
add_org_credits remove_org_credits
|
|
organization_id identity_id
|
|
credit_action credit_amount
|
|
reputation_modifier
|
|
].freeze
|
|
|
|
EMAIL_ALLOWED_PARAMS = %i[
|
|
email_subject
|
|
email_body
|
|
].freeze
|
|
|
|
ATTRIBUTES_FOR_CSV = %i[
|
|
id name username email registered_at
|
|
].freeze
|
|
|
|
ATTRIBUTES_FOR_LAST_ACTIVITY = %i[
|
|
registered last_comment_at last_article_at latest_article_updated_at last_reacted_at profile_updated_at
|
|
last_moderation_notification last_notification_activity
|
|
].freeze
|
|
|
|
MODROLE_ACTIONS_TO_POLICIES = {
|
|
user_status: :toggle_suspension_status?,
|
|
unpublish_all_articles: :unpublish_all_articles?
|
|
}.freeze
|
|
|
|
after_action only: %i[update user_status banish full_delete merge] do
|
|
Audit::Logger.log(:moderator, current_user, params.dup)
|
|
end
|
|
|
|
# Having this method here (which also exists in admin/application_controller)
|
|
# allows us to authorize the actions of the moderator role specifically,
|
|
# while preserving the implementation for all other admin actions
|
|
def authorize_admin
|
|
if MODROLE_ACTIONS_TO_POLICIES.key?(action_name.to_sym)
|
|
authorize(User, MODROLE_ACTIONS_TO_POLICIES[action_name.to_sym])
|
|
else
|
|
super
|
|
end
|
|
end
|
|
|
|
def index
|
|
respond_to do |format|
|
|
format.html { index_for_html }
|
|
format.json { index_for_json }
|
|
end
|
|
end
|
|
|
|
def show
|
|
@user = User.find(params[:id])
|
|
set_current_tab(params[:tab])
|
|
set_unpublish_all_log
|
|
set_banishable_user
|
|
set_feedback_messages
|
|
set_related_reactions
|
|
set_user_details
|
|
end
|
|
|
|
def edit
|
|
@user = User.find(params[:id])
|
|
@notes = @user.notes.order(created_at: :desc).limit(10).load
|
|
set_feedback_messages
|
|
set_related_reactions
|
|
end
|
|
|
|
def update
|
|
@user = User.find(params[:id])
|
|
|
|
Credits::Manage.call(@user, credit_params)
|
|
add_note if user_params[:new_note]
|
|
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def reputation_modifier
|
|
@user = User.find(params[:id])
|
|
reputation_modifier_value = user_params[:reputation_modifier]
|
|
note_content = if user_params[:new_note].present?
|
|
"Changed user's reputation modifier to #{reputation_modifier_value}. " \
|
|
"Reason: #{user_params[:new_note]}"
|
|
else
|
|
"Changed user's reputation modifier to #{reputation_modifier_value}."
|
|
end
|
|
if @user.update(reputation_modifier: reputation_modifier_value)
|
|
Note.create(
|
|
author_id: current_user.id,
|
|
noteable_id: @user.id,
|
|
noteable_type: "User",
|
|
reason: "reputation_modifier_change",
|
|
content: note_content,
|
|
)
|
|
flash[:success] = I18n.t("views.admin.users.reputation.success", reputation_modifier: reputation_modifier_value)
|
|
else
|
|
flash[:error] = I18n.t("views.admin.users.reputation.error")
|
|
end
|
|
redirect_to admin_user_path(@user)
|
|
end
|
|
|
|
def destroy
|
|
role = Role.find(params[:role_id])
|
|
authorize(role, :remove_role?)
|
|
|
|
resource_type = params[:resource_type]
|
|
|
|
@user = User.find(params[:user_id])
|
|
|
|
response = ::Users::RemoveRole.call(
|
|
user: @user,
|
|
role: role.name,
|
|
resource_type: resource_type,
|
|
)
|
|
|
|
if response.success
|
|
flash[:success] =
|
|
I18n.t("admin.users_controller.role_removed",
|
|
role: I18n.t("views.admin.users.overview.roles.name.#{
|
|
role.name_labelize.underscore.parameterize(separator: '_')
|
|
}", default: role.name.to_s.humanize.titlecase)) # TODO: [@yheuhtozr] need better role i18n
|
|
else
|
|
flash[:danger] = response.error_message
|
|
end
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def export
|
|
@users = User.registered.select(ATTRIBUTES_FOR_CSV + ATTRIBUTES_FOR_LAST_ACTIVITY).includes(:organizations)
|
|
|
|
respond_to do |format|
|
|
format.csv do
|
|
response.headers["Content-Type"] = "text/csv"
|
|
response.headers["Content-Disposition"] = "attachment; filename=users.csv"
|
|
render template: "admin/users/export"
|
|
end
|
|
end
|
|
end
|
|
|
|
def user_status
|
|
@user = User.find(params[:id])
|
|
begin
|
|
Moderator::ManageActivityAndRoles.handle_user_roles(admin: current_user, user: @user, user_params: user_params)
|
|
flash[:success] = I18n.t("admin.users_controller.updated")
|
|
respond_to do |format|
|
|
format.html do
|
|
redirect_back_or_to admin_users_path
|
|
end
|
|
format.json do
|
|
render json: {
|
|
success: true,
|
|
message: I18n.t("admin.users_controller.updated_json", username: @user.username)
|
|
}, status: :ok
|
|
end
|
|
end
|
|
rescue StandardError => e
|
|
flash[:danger] = e.message
|
|
respond_to do |format|
|
|
format.html do
|
|
redirect_back_or_to admin_users_path
|
|
end
|
|
format.json do
|
|
render json: {
|
|
success: false,
|
|
message: @user.errors_as_sentence
|
|
}, status: :unprocessable_entity
|
|
end
|
|
end
|
|
end
|
|
Credits::Manage.call(@user, credit_params)
|
|
end
|
|
|
|
def export_data
|
|
user = User.find(params[:id])
|
|
send_to_admin = params[:send_to_admin].to_boolean
|
|
if send_to_admin
|
|
email = ::ForemInstance.contact_email
|
|
receiver = "admin"
|
|
else
|
|
email = user.email
|
|
receiver = "user"
|
|
end
|
|
ExportContentWorker.perform_async(user.id, email)
|
|
flash[:success] = I18n.t("admin.users_controller.exported", receiver: receiver)
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def banish
|
|
Moderator::BanishUserWorker.perform_async(current_user.id, params[:id].to_i)
|
|
flash[:success] = I18n.t("admin.users_controller.banished")
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def full_delete
|
|
@user = User.find(params[:id])
|
|
begin
|
|
Moderator::DeleteUser.call(user: @user)
|
|
link = helpers.tag.a(I18n.t("admin.users_controller.the_page"), href: admin_gdpr_delete_requests_path,
|
|
data: { "no-instant" => true })
|
|
flash[:success] = I18n.t("admin.users_controller.full_delete_html",
|
|
user: @user.username,
|
|
email: @user.email.presence || I18n.t("admin.users_controller.no_email"),
|
|
id: @user.id,
|
|
the_page: link).html_safe
|
|
rescue StandardError => e
|
|
flash[:danger] = e.message
|
|
end
|
|
redirect_to admin_users_path
|
|
end
|
|
|
|
def unpublish_all_articles
|
|
target_user = User.find(params[:id].to_i)
|
|
Moderator::UnpublishAllArticlesWorker.perform_async(target_user.id, current_user.id, "moderator")
|
|
|
|
note_content = params.dig(:note, :content).presence
|
|
note_content ||= "#{current_user.username} unpublished all articles"
|
|
Note.create(noteable: target_user, reason: "unpublish_all_articles",
|
|
content: note_content, author: current_user)
|
|
|
|
message = I18n.t("admin.users_controller.unpublished")
|
|
respond_to do |format|
|
|
format.html do
|
|
flash[:success] = message
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
format.json do
|
|
render json: { message: message }
|
|
end
|
|
end
|
|
end
|
|
|
|
def merge
|
|
@user = User.find(params[:id])
|
|
begin
|
|
Moderator::MergeUser.call(admin: current_user, keep_user: @user, delete_user_id: user_params["merge_user_id"])
|
|
rescue StandardError => e
|
|
flash[:danger] = e.message
|
|
end
|
|
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def remove_identity
|
|
identity = Identity.find(user_params[:identity_id])
|
|
@user = identity.user
|
|
|
|
begin
|
|
identity.destroy
|
|
|
|
@user.update("#{identity.provider}_username" => nil)
|
|
|
|
# GitHub repositories are tied with the existence of the GitHub identity
|
|
# as we use the user's GitHub token to fetch them from the API.
|
|
# We should delete them when a user unlinks their GitHub account.
|
|
@user.github_repos.destroy_all if identity.provider.to_sym == :github
|
|
|
|
flash[:success] =
|
|
I18n.t("admin.users_controller.identity_removed",
|
|
provider: identity.provider.capitalize)
|
|
rescue StandardError => e
|
|
flash[:danger] = e.message
|
|
end
|
|
redirect_to admin_user_path(params[:id])
|
|
end
|
|
|
|
def send_email
|
|
email_params = {
|
|
email_body: send_email_params[:email_body],
|
|
email_subject: send_email_params[:email_subject],
|
|
user_id: params[:id]
|
|
}
|
|
|
|
if NotifyMailer.with(email_params).user_contact_email.deliver_now
|
|
respond_to do |format|
|
|
message = I18n.t("admin.users_controller.email_sent")
|
|
|
|
format.html do
|
|
flash[:success] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js { render json: { result: message }, content_type: "application/json" }
|
|
end
|
|
else
|
|
respond_to do |format|
|
|
message = I18n.t("admin.users_controller.email_fail")
|
|
|
|
format.html do
|
|
flash[:danger] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js do
|
|
render json: { error: message },
|
|
content_type: "application/json",
|
|
status: :service_unavailable
|
|
end
|
|
end
|
|
end
|
|
rescue ActionController::ParameterMissing
|
|
respond_to do |format|
|
|
format.json do
|
|
render json: { error: I18n.t("admin.users_controller.parameter_missing") },
|
|
content_type: "application/json",
|
|
status: :unprocessable_entity
|
|
end
|
|
end
|
|
end
|
|
|
|
def send_email_confirmation
|
|
@user = User.find(params[:id])
|
|
if @user.send_confirmation_instructions
|
|
respond_to do |format|
|
|
message = I18n.t("admin.users_controller.confirm_sent")
|
|
|
|
format.html do
|
|
flash[:success] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js { render json: { result: message }, content_type: "application/json" }
|
|
end
|
|
else
|
|
message = I18n.t("admin.users_controller.email_fail")
|
|
|
|
respond_to do |format|
|
|
format.html do
|
|
flash[:danger] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js { render json: { error: message }, content_type: "application/json", status: :service_unavailable }
|
|
end
|
|
end
|
|
end
|
|
|
|
def verify_email_ownership
|
|
if VerificationMailer.with(user_id: params[:id]).account_ownership_verification_email.deliver_now
|
|
respond_to do |format|
|
|
message = I18n.t("admin.users_controller.verify_sent")
|
|
|
|
format.html do
|
|
flash[:success] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js { render json: { result: message }, content_type: "application/json" }
|
|
end
|
|
else
|
|
message = I18n.t("admin.users_controller.email_fail")
|
|
|
|
respond_to do |format|
|
|
format.html do
|
|
flash[:danger] = message
|
|
redirect_back(fallback_location: admin_user_path(params[:id]))
|
|
end
|
|
|
|
format.js { render json: { error: message }, content_type: "application/json", status: :service_unavailable }
|
|
end
|
|
end
|
|
end
|
|
|
|
def unlock_access
|
|
@user = User.find(params[:id])
|
|
@user.unlock_access!
|
|
flash[:success] = I18n.t("admin.users_controller.unlocked")
|
|
redirect_to admin_user_path(@user)
|
|
end
|
|
|
|
private
|
|
|
|
def index_for_html
|
|
@users = Admin::UsersQuery.call(
|
|
relation: User.registered,
|
|
search: params[:search],
|
|
role: params[:role],
|
|
roles: params[:roles],
|
|
statuses: params[:statuses],
|
|
joining_start: params[:joining_start],
|
|
joining_end: params[:joining_end],
|
|
date_format: params[:date_format],
|
|
organizations: params[:organizations],
|
|
).page(params[:page]).per(50)
|
|
|
|
@organization_limit = 3
|
|
@organizations = Organization.order(name: :desc)
|
|
@earliest_join_date = User.first.registered_at.to_s
|
|
end
|
|
|
|
def index_for_json
|
|
@users = Admin::UsersQuery.call(
|
|
relation: User.registered,
|
|
search: params[:search],
|
|
ids: params[:ids],
|
|
limit: params[:limit],
|
|
)
|
|
|
|
render json: @users.to_json(only: %i[id name username])
|
|
end
|
|
|
|
def set_user_details
|
|
@organizations = @user.organizations.order(:name)
|
|
@notes = @user.notes.order(created_at: :desc).limit(10)
|
|
@organization_memberships = @user.organization_memberships
|
|
.joins(:organization)
|
|
.order("organizations.name" => :asc)
|
|
.includes(:organization)
|
|
@last_email_verification_date = EmailAuthorization.last_verification_date(@user)
|
|
|
|
render :show
|
|
end
|
|
|
|
def add_note
|
|
Note.create(
|
|
author_id: current_user.id,
|
|
noteable_id: @user.id,
|
|
noteable_type: "User",
|
|
reason: "misc_note",
|
|
content: user_params[:new_note],
|
|
)
|
|
end
|
|
|
|
def set_feedback_messages
|
|
@related_reports = FeedbackMessage.where(id: @user.reporter_feedback_messages.ids)
|
|
.or(FeedbackMessage.where(id: @user.affected_feedback_messages.ids))
|
|
.or(FeedbackMessage.where(id: @user.offender_feedback_messages.ids))
|
|
.order(created_at: :desc).limit(15)
|
|
end
|
|
|
|
def set_related_reactions
|
|
user_article_ids = @user.articles.ids
|
|
user_comment_ids = @user.comments.ids
|
|
@related_vomit_reactions =
|
|
Reaction.where(reactable_type: "Comment", reactable_id: user_comment_ids, category: "vomit")
|
|
.or(Reaction.where(reactable_type: "Article", reactable_id: user_article_ids, category: "vomit"))
|
|
.or(Reaction.where(reactable_type: "User", reactable_id: @user.id, category: "vomit"))
|
|
.includes(:user)
|
|
.order(created_at: :desc).limit(15)
|
|
|
|
@user_vomit_reactions =
|
|
Reaction.where(reactable_type: "User", reactable_id: @user.id, category: "vomit")
|
|
.includes(:user)
|
|
.order(created_at: :desc)
|
|
@countable_flags = calculate_countable_flags(@user_vomit_reactions)
|
|
end
|
|
|
|
def user_params
|
|
params.require(:user).permit(USER_ALLOWED_PARAMS)
|
|
end
|
|
|
|
def send_email_params
|
|
params.require(EMAIL_ALLOWED_PARAMS)
|
|
params.permit(EMAIL_ALLOWED_PARAMS)
|
|
end
|
|
|
|
def credit_params
|
|
credit_params = {}
|
|
|
|
case user_params[:credit_action]
|
|
when "Add"
|
|
credit_params[:add_credits] = user_params[:credit_amount]
|
|
flash[:success] = I18n.t("admin.users_controller.credits_added")
|
|
when "Remove"
|
|
credit_params[:remove_credits] = user_params[:credit_amount]
|
|
flash[:success] = I18n.t("admin.users_controller.credits_removed")
|
|
else
|
|
return user_params
|
|
end
|
|
credit_params
|
|
end
|
|
|
|
def set_current_tab(current_tab = "overview")
|
|
@current_tab = if current_tab.in? Constants::UserDetails::TAB_LIST.map(&:underscore)
|
|
current_tab
|
|
else
|
|
"overview"
|
|
end
|
|
end
|
|
|
|
def set_banishable_user
|
|
@banishable_user = (@user.comments.where("created_at < ?", 100.days.ago).empty? &&
|
|
@user.created_at < 100.days.ago) || current_user.super_admin? || current_user.support_admin?
|
|
end
|
|
|
|
def set_unpublish_all_log
|
|
# in theory, there could be multiple "unpublish all" actions
|
|
# but let's query and display the last one for now, that should be enough for most cases
|
|
@unpublish_all_data = if @current_tab == "unpublish_logs"
|
|
AuditLog::UnpublishAllsQuery.call(@user.id)
|
|
else
|
|
# only find if the data exists for most tabs
|
|
AuditLog::UnpublishAllsQuery.new(@user.id).exists?
|
|
end
|
|
end
|
|
|
|
def calculate_countable_flags(reactions)
|
|
countable_flags = 0
|
|
reactions.each do |reaction|
|
|
countable_flags += 1 if reaction.status != "invalid"
|
|
end
|
|
countable_flags
|
|
end
|
|
end
|
|
end
|