mirror of
https://github.com/discourse/discourse.git
synced 2024-11-25 05:47:31 +08:00
616 lines
17 KiB
JavaScript
616 lines
17 KiB
JavaScript
import DiscourseURL, { userPath } from "discourse/lib/url";
|
|
import { and, notEmpty } from "@ember/object/computed";
|
|
import { fmt, propertyNotEqual, setting } from "discourse/lib/computed";
|
|
import AdminUser from "admin/models/admin-user";
|
|
import CanCheckEmails from "discourse/mixins/can-check-emails";
|
|
import Controller from "@ember/controller";
|
|
import I18n from "I18n";
|
|
import { ajax } from "discourse/lib/ajax";
|
|
import bootbox from "bootbox";
|
|
import discourseComputed from "discourse-common/utils/decorators";
|
|
import getURL from "discourse-common/lib/get-url";
|
|
import { htmlSafe } from "@ember/template";
|
|
import { iconHTML } from "discourse-common/lib/icon-library";
|
|
import { extractError, popupAjaxError } from "discourse/lib/ajax-error";
|
|
import { inject as service } from "@ember/service";
|
|
import showModal from "discourse/lib/show-modal";
|
|
|
|
export default Controller.extend(CanCheckEmails, {
|
|
adminTools: service(),
|
|
originalPrimaryGroupId: null,
|
|
customGroupIdsBuffer: null,
|
|
availableGroups: null,
|
|
userTitleValue: null,
|
|
ssoExternalEmail: null,
|
|
ssoLastPayload: null,
|
|
|
|
showBadges: setting("enable_badges"),
|
|
hasLockedTrustLevel: notEmpty("model.manual_locked_trust_level"),
|
|
|
|
primaryGroupDirty: propertyNotEqual(
|
|
"originalPrimaryGroupId",
|
|
"model.primary_group_id"
|
|
),
|
|
|
|
canDisableSecondFactor: and(
|
|
"model.second_factor_enabled",
|
|
"model.can_disable_second_factor"
|
|
),
|
|
|
|
@discourseComputed("model.customGroups")
|
|
customGroupIds(customGroups) {
|
|
return customGroups.mapBy("id");
|
|
},
|
|
|
|
@discourseComputed("customGroupIdsBuffer", "customGroupIds")
|
|
customGroupsDirty(buffer, original) {
|
|
if (buffer === null) {
|
|
return false;
|
|
}
|
|
|
|
return buffer.length === original.length
|
|
? buffer.any((id) => !original.includes(id))
|
|
: true;
|
|
},
|
|
|
|
@discourseComputed("model.automaticGroups")
|
|
automaticGroups(automaticGroups) {
|
|
return automaticGroups
|
|
.map((group) => {
|
|
const name = htmlSafe(group.name);
|
|
return `<a href="/g/${name}">${name}</a>`;
|
|
})
|
|
.join(", ");
|
|
},
|
|
|
|
@discourseComputed("model.associated_accounts")
|
|
associatedAccountsLoaded(associatedAccounts) {
|
|
return typeof associatedAccounts !== "undefined";
|
|
},
|
|
|
|
@discourseComputed("model.associated_accounts")
|
|
associatedAccounts(associatedAccounts) {
|
|
return associatedAccounts
|
|
.map((provider) => `${provider.name} (${provider.description})`)
|
|
.join(", ");
|
|
},
|
|
|
|
@discourseComputed("model.user_fields.[]")
|
|
userFields(userFields) {
|
|
return this.site.collectUserFields(userFields);
|
|
},
|
|
|
|
preferencesPath: fmt("model.username_lower", userPath("%@/preferences")),
|
|
|
|
@discourseComputed(
|
|
"model.can_delete_all_posts",
|
|
"model.staff",
|
|
"model.post_count"
|
|
)
|
|
deleteAllPostsExplanation(canDeleteAllPosts, staff, postCount) {
|
|
if (canDeleteAllPosts) {
|
|
return null;
|
|
}
|
|
|
|
if (staff) {
|
|
return I18n.t("admin.user.delete_posts_forbidden_because_staff");
|
|
}
|
|
if (postCount > this.siteSettings.delete_all_posts_max) {
|
|
return I18n.t("admin.user.cant_delete_all_too_many_posts", {
|
|
count: this.siteSettings.delete_all_posts_max,
|
|
});
|
|
} else {
|
|
return I18n.t("admin.user.cant_delete_all_posts", {
|
|
count: this.siteSettings.delete_user_max_post_age,
|
|
});
|
|
}
|
|
},
|
|
|
|
@discourseComputed("model.canBeDeleted", "model.staff")
|
|
deleteExplanation(canBeDeleted, staff) {
|
|
if (canBeDeleted) {
|
|
return null;
|
|
}
|
|
|
|
if (staff) {
|
|
return I18n.t("admin.user.delete_forbidden_because_staff");
|
|
} else {
|
|
return I18n.t("admin.user.delete_forbidden", {
|
|
count: this.siteSettings.delete_user_max_post_age,
|
|
});
|
|
}
|
|
},
|
|
|
|
@discourseComputed("model.username")
|
|
postEditsByEditorFilter(username) {
|
|
return { editor: username };
|
|
},
|
|
|
|
groupAdded(added) {
|
|
this.model
|
|
.groupAdded(added)
|
|
.catch(() => bootbox.alert(I18n.t("generic_error")));
|
|
},
|
|
|
|
groupRemoved(groupId) {
|
|
this.model
|
|
.groupRemoved(groupId)
|
|
.then(() => {
|
|
if (groupId === this.originalPrimaryGroupId) {
|
|
this.set("originalPrimaryGroupId", null);
|
|
}
|
|
})
|
|
.catch(() => bootbox.alert(I18n.t("generic_error")));
|
|
},
|
|
|
|
@discourseComputed("ssoLastPayload")
|
|
ssoPayload(lastPayload) {
|
|
return lastPayload.split("&");
|
|
},
|
|
|
|
actions: {
|
|
impersonate() {
|
|
return this.model
|
|
.impersonate()
|
|
.then(() => DiscourseURL.redirectTo("/"))
|
|
.catch((e) => {
|
|
if (e.status === 404) {
|
|
bootbox.alert(I18n.t("admin.impersonate.not_found"));
|
|
} else {
|
|
bootbox.alert(I18n.t("admin.impersonate.invalid"));
|
|
}
|
|
});
|
|
},
|
|
logOut() {
|
|
return this.model
|
|
.logOut()
|
|
.then(() => bootbox.alert(I18n.t("admin.user.logged_out")));
|
|
},
|
|
resetBounceScore() {
|
|
return this.model.resetBounceScore();
|
|
},
|
|
approve() {
|
|
return this.model.approve(this.currentUser);
|
|
},
|
|
|
|
_formatError(event) {
|
|
return `http: ${event.status} - ${event.body}`;
|
|
},
|
|
|
|
deactivate() {
|
|
return this.model
|
|
.deactivate()
|
|
.then(() =>
|
|
this.model.setProperties({ active: false, can_activate: true })
|
|
)
|
|
.catch((e) => {
|
|
const error = I18n.t("admin.user.deactivate_failed", {
|
|
error: this._formatError(e),
|
|
});
|
|
bootbox.alert(error);
|
|
});
|
|
},
|
|
sendActivationEmail() {
|
|
return this.model
|
|
.sendActivationEmail()
|
|
.then(() => bootbox.alert(I18n.t("admin.user.activation_email_sent")))
|
|
.catch(popupAjaxError);
|
|
},
|
|
activate() {
|
|
return this.model
|
|
.activate()
|
|
.then(() =>
|
|
this.model.setProperties({
|
|
active: true,
|
|
can_deactivate: !this.model.staff,
|
|
})
|
|
)
|
|
.catch((e) => {
|
|
const error = I18n.t("admin.user.activate_failed", {
|
|
error: this._formatError(e),
|
|
});
|
|
bootbox.alert(error);
|
|
});
|
|
},
|
|
revokeAdmin() {
|
|
return this.model.revokeAdmin();
|
|
},
|
|
grantAdmin() {
|
|
return this.model
|
|
.grantAdmin()
|
|
.then((result) => {
|
|
if (result.email_confirmation_required) {
|
|
bootbox.alert(I18n.t("admin.user.grant_admin_confirm"));
|
|
} else {
|
|
const controller = showModal("grant-admin-second-factor", {
|
|
model: this.model,
|
|
});
|
|
controller.setResult(result);
|
|
}
|
|
})
|
|
.catch(popupAjaxError);
|
|
},
|
|
revokeModeration() {
|
|
return this.model.revokeModeration();
|
|
},
|
|
grantModeration() {
|
|
return this.model.grantModeration();
|
|
},
|
|
saveTrustLevel() {
|
|
return this.model
|
|
.saveTrustLevel()
|
|
.then(() => window.location.reload())
|
|
.catch((e) => {
|
|
let error;
|
|
if (e.jqXHR.responseJSON && e.jqXHR.responseJSON.errors) {
|
|
error = e.jqXHR.responseJSON.errors[0];
|
|
}
|
|
error =
|
|
error ||
|
|
I18n.t("admin.user.trust_level_change_failed", {
|
|
error: this._formatError(e),
|
|
});
|
|
bootbox.alert(error);
|
|
});
|
|
},
|
|
restoreTrustLevel() {
|
|
return this.model.restoreTrustLevel();
|
|
},
|
|
lockTrustLevel(locked) {
|
|
return this.model
|
|
.lockTrustLevel(locked)
|
|
.then(() => window.location.reload())
|
|
.catch((e) => {
|
|
let error;
|
|
if (e.jqXHR.responseJSON && e.jqXHR.responseJSON.errors) {
|
|
error = e.jqXHR.responseJSON.errors[0];
|
|
}
|
|
error =
|
|
error ||
|
|
I18n.t("admin.user.trust_level_change_failed", {
|
|
error: this._formatError(e),
|
|
});
|
|
bootbox.alert(error);
|
|
});
|
|
},
|
|
unsilence() {
|
|
return this.model.unsilence();
|
|
},
|
|
silence() {
|
|
return this.model.silence();
|
|
},
|
|
|
|
anonymize() {
|
|
const user = this.model;
|
|
const message = I18n.t("admin.user.anonymize_confirm");
|
|
|
|
const performAnonymize = () => {
|
|
this.model
|
|
.anonymize()
|
|
.then((data) => {
|
|
if (data.success) {
|
|
if (data.username) {
|
|
document.location = getURL(
|
|
`/admin/users/${user.get("id")}/${data.username}`
|
|
);
|
|
} else {
|
|
document.location = getURL("/admin/users/list/active");
|
|
}
|
|
} else {
|
|
bootbox.alert(I18n.t("admin.user.anonymize_failed"));
|
|
if (data.user) {
|
|
user.setProperties(data.user);
|
|
}
|
|
}
|
|
})
|
|
.catch(() => bootbox.alert(I18n.t("admin.user.anonymize_failed")));
|
|
};
|
|
const buttons = [
|
|
{
|
|
label: I18n.t("composer.cancel"),
|
|
class: "cancel",
|
|
link: true,
|
|
},
|
|
{
|
|
label: I18n.t("admin.user.anonymize_yes"),
|
|
class: "btn btn-danger",
|
|
icon: iconHTML("exclamation-triangle"),
|
|
callback: () => {
|
|
performAnonymize();
|
|
},
|
|
},
|
|
];
|
|
|
|
bootbox.dialog(message, buttons, { classes: "delete-user-modal" });
|
|
},
|
|
|
|
disableSecondFactor() {
|
|
return this.model.disableSecondFactor();
|
|
},
|
|
|
|
clearPenaltyHistory() {
|
|
const user = this.model;
|
|
const path = `/admin/users/${user.get("id")}/penalty_history`;
|
|
|
|
return ajax(path, { type: "DELETE" })
|
|
.then(() => user.set("tl3_requirements.penalty_counts.total", 0))
|
|
.catch(popupAjaxError);
|
|
},
|
|
|
|
destroy() {
|
|
const postCount = this.get("model.post_count");
|
|
const maxPostCount = this.siteSettings.delete_all_posts_max;
|
|
const message = I18n.t("admin.user.delete_confirm");
|
|
const location = document.location.pathname;
|
|
|
|
const performDestroy = (block) => {
|
|
bootbox.dialog(I18n.t("admin.user.deleting_user"));
|
|
let formData = { context: location };
|
|
if (block) {
|
|
formData["block_email"] = true;
|
|
formData["block_urls"] = true;
|
|
formData["block_ip"] = true;
|
|
}
|
|
if (postCount <= maxPostCount) {
|
|
formData["delete_posts"] = true;
|
|
}
|
|
this.model
|
|
.destroy(formData)
|
|
.then((data) => {
|
|
if (data.deleted) {
|
|
if (/^\/admin\/users\/list\//.test(location)) {
|
|
document.location = location;
|
|
} else {
|
|
document.location = getURL("/admin/users/list/active");
|
|
}
|
|
} else {
|
|
bootbox.alert(I18n.t("admin.user.delete_failed"));
|
|
}
|
|
})
|
|
.catch(() => {
|
|
bootbox.alert(I18n.t("admin.user.delete_failed"));
|
|
});
|
|
};
|
|
|
|
const buttons = [
|
|
{
|
|
label: I18n.t("composer.cancel"),
|
|
class: "btn",
|
|
link: true,
|
|
},
|
|
{
|
|
icon: iconHTML("exclamation-triangle"),
|
|
label: I18n.t("admin.user.delete_and_block"),
|
|
class: "btn btn-danger",
|
|
callback: () => {
|
|
performDestroy(true);
|
|
},
|
|
},
|
|
{
|
|
label: I18n.t("admin.user.delete_dont_block"),
|
|
class: "btn btn-primary",
|
|
callback: () => {
|
|
performDestroy(false);
|
|
},
|
|
},
|
|
];
|
|
|
|
bootbox.dialog(message, buttons, { classes: "delete-user-modal" });
|
|
},
|
|
|
|
promptTargetUser() {
|
|
showModal("admin-merge-users-prompt", {
|
|
admin: true,
|
|
model: this.model,
|
|
});
|
|
},
|
|
|
|
showMergeConfirmation(targetUsername) {
|
|
showModal("admin-merge-users-confirmation", {
|
|
admin: true,
|
|
model: {
|
|
username: this.model.username,
|
|
targetUsername,
|
|
},
|
|
});
|
|
},
|
|
|
|
merge(targetUsername) {
|
|
const user = this.model;
|
|
const location = document.location.pathname;
|
|
|
|
let formData = { context: location };
|
|
|
|
if (targetUsername) {
|
|
formData["target_username"] = targetUsername;
|
|
}
|
|
|
|
this.model
|
|
.merge(formData)
|
|
.then((response) => {
|
|
if (response.success) {
|
|
showModal("admin-merge-users-progress", {
|
|
admin: true,
|
|
model: this.model,
|
|
});
|
|
} else {
|
|
bootbox.alert(I18n.t("admin.user.merge_failed"));
|
|
}
|
|
})
|
|
.catch(() => {
|
|
AdminUser.find(user.id).then((u) => user.setProperties(u));
|
|
bootbox.alert(I18n.t("admin.user.merge_failed"));
|
|
});
|
|
},
|
|
|
|
viewActionLogs() {
|
|
this.adminTools.showActionLogs(this, {
|
|
target_user: this.get("model.username"),
|
|
});
|
|
},
|
|
showSuspendModal() {
|
|
this.adminTools.showSuspendModal(this.model);
|
|
},
|
|
unsuspend() {
|
|
this.model.unsuspend().catch(popupAjaxError);
|
|
},
|
|
showSilenceModal() {
|
|
this.adminTools.showSilenceModal(this.model);
|
|
},
|
|
|
|
saveUsername(newUsername) {
|
|
const oldUsername = this.get("model.username");
|
|
this.set("model.username", newUsername);
|
|
|
|
const path = `/users/${oldUsername.toLowerCase()}/preferences/username`;
|
|
|
|
return ajax(path, { data: { new_username: newUsername }, type: "PUT" })
|
|
.catch((e) => {
|
|
this.set("model.username", oldUsername);
|
|
popupAjaxError(e);
|
|
})
|
|
.finally(() => this.toggleProperty("editingUsername"));
|
|
},
|
|
|
|
saveName(newName) {
|
|
const oldName = this.get("model.name");
|
|
this.set("model.name", newName);
|
|
|
|
const path = userPath(`${this.get("model.username").toLowerCase()}.json`);
|
|
|
|
return ajax(path, { data: { name: newName }, type: "PUT" })
|
|
.catch((e) => {
|
|
this.set("model.name", oldName);
|
|
popupAjaxError(e);
|
|
})
|
|
.finally(() => this.toggleProperty("editingName"));
|
|
},
|
|
|
|
saveTitle(newTitle) {
|
|
const oldTitle = this.get("model.title");
|
|
this.set("model.title", newTitle);
|
|
|
|
const path = userPath(`${this.get("model.username").toLowerCase()}.json`);
|
|
|
|
return ajax(path, { data: { title: newTitle }, type: "PUT" })
|
|
.catch((e) => {
|
|
this.set("model.title", oldTitle);
|
|
popupAjaxError(e);
|
|
})
|
|
.finally(() => this.toggleProperty("editingTitle"));
|
|
},
|
|
|
|
saveCustomGroups() {
|
|
const currentIds = this.customGroupIds;
|
|
const bufferedIds = this.customGroupIdsBuffer;
|
|
const availableGroups = this.availableGroups;
|
|
|
|
bufferedIds
|
|
.filter((id) => !currentIds.includes(id))
|
|
.forEach((id) => this.groupAdded(availableGroups.findBy("id", id)));
|
|
|
|
currentIds
|
|
.filter((id) => !bufferedIds.includes(id))
|
|
.forEach((id) => this.groupRemoved(id));
|
|
},
|
|
|
|
resetCustomGroups() {
|
|
this.set("customGroupIdsBuffer", this.model.customGroups.mapBy("id"));
|
|
},
|
|
|
|
savePrimaryGroup() {
|
|
const primaryGroupId = this.get("model.primary_group_id");
|
|
const path = `/admin/users/${this.get("model.id")}/primary_group`;
|
|
|
|
return ajax(path, {
|
|
type: "PUT",
|
|
data: { primary_group_id: primaryGroupId },
|
|
})
|
|
.then(() => this.set("originalPrimaryGroupId", primaryGroupId))
|
|
.catch(() => bootbox.alert(I18n.t("generic_error")));
|
|
},
|
|
|
|
resetPrimaryGroup() {
|
|
this.set("model.primary_group_id", this.originalPrimaryGroupId);
|
|
},
|
|
|
|
deleteSSORecord() {
|
|
return bootbox.confirm(
|
|
I18n.t("admin.user.discourse_connect.confirm_delete"),
|
|
I18n.t("no_value"),
|
|
I18n.t("yes_value"),
|
|
(confirmed) => {
|
|
if (confirmed) {
|
|
return this.model.deleteSSORecord();
|
|
}
|
|
}
|
|
);
|
|
},
|
|
|
|
checkSsoEmail() {
|
|
return ajax(userPath(`${this.model.username_lower}/sso-email.json`), {
|
|
data: { context: window.location.pathname },
|
|
}).then((result) => {
|
|
if (result) {
|
|
this.set("ssoExternalEmail", result.email);
|
|
}
|
|
});
|
|
},
|
|
|
|
checkSsoPayload() {
|
|
return ajax(userPath(`${this.model.username_lower}/sso-payload.json`), {
|
|
data: { context: window.location.pathname },
|
|
}).then((result) => {
|
|
if (result) {
|
|
this.set("ssoLastPayload", result.payload);
|
|
}
|
|
});
|
|
},
|
|
|
|
showDeletePostsConfirmation() {
|
|
showModal("admin-delete-posts-confirmation", {
|
|
admin: true,
|
|
model: this.model,
|
|
});
|
|
},
|
|
|
|
deleteAllPosts() {
|
|
let deletedPosts = 0;
|
|
let deletedPercentage = 0;
|
|
const user = this.model;
|
|
|
|
const performDelete = (progressModal) => {
|
|
this.model
|
|
.deleteAllPosts()
|
|
.then(({ posts_deleted }) => {
|
|
if (posts_deleted === 0) {
|
|
user.set("post_count", 0);
|
|
progressModal.send("closeModal");
|
|
} else {
|
|
deletedPosts += posts_deleted;
|
|
deletedPercentage = Math.floor(
|
|
(deletedPosts * 100) / user.get("post_count")
|
|
);
|
|
progressModal.setProperties({
|
|
deletedPercentage,
|
|
});
|
|
performDelete(progressModal);
|
|
}
|
|
})
|
|
.catch((e) => {
|
|
progressModal.send("closeModal");
|
|
let error;
|
|
AdminUser.find(user.get("id")).then((u) => user.setProperties(u));
|
|
error = extractError(e) || I18n.t("admin.user.delete_posts_failed");
|
|
bootbox.alert(error);
|
|
});
|
|
};
|
|
|
|
const progressModal = showModal("admin-delete-user-posts-progress", {
|
|
admin: true,
|
|
});
|
|
performDelete(progressModal);
|
|
},
|
|
},
|
|
});
|