- {{#if showApproval}}
- |
- {{#if user.can_approve}}
- {{input type="checkbox" checked=user.selected}}
- {{/if}}
- |
- {{/if}}
{{avatar user imageSize="small"}}
@@ -88,15 +71,10 @@
{{{format-duration user.created_at_age}}}
|
- {{#if showApproval}}
-
- {{#if user.approved}}
- {{i18n 'yes_value'}}
- {{else}}
- {{i18n 'no_value'}}
- {{/if}}
- |
+ {{#if siteSettings.must_approve_users}}
+ {{i18n-yes-no user.approved}} |
{{/if}}
+
{{#if user.admin}}
{{d-icon "shield-alt" title="admin.title" }}
diff --git a/app/assets/javascripts/admin/templates/users-list.hbs b/app/assets/javascripts/admin/templates/users-list.hbs
index d4d5be049f8..681eb945a52 100644
--- a/app/assets/javascripts/admin/templates/users-list.hbs
+++ b/app/assets/javascripts/admin/templates/users-list.hbs
@@ -3,9 +3,6 @@
{{nav-item route='adminUsersList.show' routeParam='active' label='admin.users.nav.active'}}
{{nav-item route='adminUsersList.show' routeParam='new' label='admin.users.nav.new'}}
- {{#if siteSettings.must_approve_users}}
- {{nav-item route='adminUsersList.show' routeParam='pending' label='admin.users.nav.pending'}}
- {{/if}}
{{nav-item route='adminUsersList.show' routeParam='staff' label='admin.users.nav.staff'}}
{{nav-item route='adminUsersList.show' routeParam='suspended' label='admin.users.nav.suspended'}}
{{nav-item route='adminUsersList.show' routeParam='silenced' label='admin.users.nav.silenced'}}
diff --git a/app/assets/javascripts/discourse/adapters/rest.js.es6 b/app/assets/javascripts/discourse/adapters/rest.js.es6
index 593bb81ea0d..92d98ba80c1 100644
--- a/app/assets/javascripts/discourse/adapters/rest.js.es6
+++ b/app/assets/javascripts/discourse/adapters/rest.js.es6
@@ -7,8 +7,7 @@ const ADMIN_MODELS = [
"embeddable-host",
"web-hook",
"web-hook-event",
- "flagged-topic",
- "moderation-history"
+ "flagged-topic"
];
export function Result(payload, responseJson) {
diff --git a/app/assets/javascripts/discourse/adapters/reviewable-topic.js.es6 b/app/assets/javascripts/discourse/adapters/reviewable-topic.js.es6
new file mode 100644
index 00000000000..726fcb7a7da
--- /dev/null
+++ b/app/assets/javascripts/discourse/adapters/reviewable-topic.js.es6
@@ -0,0 +1,7 @@
+import RestAdapter from "discourse/adapters/rest";
+
+export default RestAdapter.extend({
+ pathFor() {
+ return "/review/topics";
+ }
+});
diff --git a/app/assets/javascripts/discourse/adapters/reviewable.js.es6 b/app/assets/javascripts/discourse/adapters/reviewable.js.es6
new file mode 100644
index 00000000000..1cf4df50833
--- /dev/null
+++ b/app/assets/javascripts/discourse/adapters/reviewable.js.es6
@@ -0,0 +1,9 @@
+import RestAdapter from "discourse/adapters/rest";
+
+export default RestAdapter.extend({
+ jsonMode: true,
+
+ pathFor(store, type, findArgs) {
+ return this.appendQueryParams("/review", findArgs);
+ }
+});
diff --git a/app/assets/javascripts/discourse/components/flagged-posts.js.es6 b/app/assets/javascripts/discourse/components/flagged-posts.js.es6
deleted file mode 100644
index cc26e4e03a9..00000000000
--- a/app/assets/javascripts/discourse/components/flagged-posts.js.es6
+++ /dev/null
@@ -1,18 +0,0 @@
-export default Ember.Component.extend({
- canAct: Ember.computed.equal("filter", "active"),
- showResolvedBy: Ember.computed.equal("filter", "old"),
- allLoaded: false,
-
- actions: {
- removePost(flaggedPost) {
- this.get("flaggedPosts").removeObject(flaggedPost);
- },
-
- loadMore() {
- const flaggedPosts = this.get("flaggedPosts");
- if (flaggedPosts.get("canLoadMore")) {
- flaggedPosts.loadMore();
- }
- }
- }
-});
diff --git a/app/assets/javascripts/discourse/components/queued-post.js.es6 b/app/assets/javascripts/discourse/components/queued-post.js.es6
deleted file mode 100644
index 8711819bf08..00000000000
--- a/app/assets/javascripts/discourse/components/queued-post.js.es6
+++ /dev/null
@@ -1,114 +0,0 @@
-import { propertyEqual } from "discourse/lib/computed";
-import { bufferedProperty } from "discourse/mixins/buffered-content";
-import { popupAjaxError } from "discourse/lib/ajax-error";
-
-function updateState(state, opts) {
- opts = opts || {};
-
- return function() {
- const post = this.get("post");
- const args = { state };
-
- if (opts.deleteUser) {
- args.delete_user = true;
- }
-
- post
- .update(args)
- .then(() => {
- this.removePost(post);
- })
- .catch(popupAjaxError);
- };
-}
-
-export default Ember.Component.extend(bufferedProperty("editables"), {
- editing: propertyEqual("post", "currentlyEditing"),
- editables: null,
- _confirmDelete: updateState("rejected", { deleteUser: true }),
-
- _initEditables: function() {
- const post = this.get("post");
- const postOptions = post.get("post_options");
-
- this.set("editables", {});
- this.set("editables.raw", post.get("raw"));
- this.set("editables.category", post.get("category"));
- this.set("editables.category_id", post.get("category.id"));
- this.set("editables.title", postOptions.title);
- this.set("editables.tags", postOptions.tags);
- }.on("init"),
-
- _categoryChanged: function() {
- this.set(
- "buffered.category",
- Discourse.Category.findById(this.get("buffered.category_id"))
- );
- }.observes("buffered.category_id"),
-
- editTitleAndCategory: function() {
- return this.get("editing") && !this.get("post.topic");
- }.property("editing"),
-
- tags: function() {
- return this.get("editables.tags") || this.get("post.topic.tags") || [];
- }.property("editables.tags"),
-
- showTags: function() {
- return (
- this.siteSettings.tagging_enabled &&
- !this.get("editing") &&
- this.get("tags").length > 0
- );
- }.property("editing", "tags"),
-
- editTags: function() {
- return (
- this.siteSettings.tagging_enabled &&
- this.get("editing") &&
- !this.get("post.topic")
- );
- }.property("editing"),
-
- actions: {
- approve: updateState("approved"),
- reject: updateState("rejected"),
-
- deleteUser() {
- bootbox.confirm(
- I18n.t("queue.delete_prompt", {
- username: this.get("post.user.username")
- }),
- confirmed => {
- if (confirmed) {
- this._confirmDelete();
- }
- }
- );
- },
-
- edit() {
- // This is stupid but pagedown cannot be on the screen twice or it will break
- this.set("currentlyEditing", null);
- Ember.run.scheduleOnce("afterRender", () =>
- this.set("currentlyEditing", this.get("post"))
- );
- },
-
- confirmEdit() {
- const buffered = this.get("buffered");
-
- this.get("post")
- .update(buffered.getProperties("raw", "title", "tags", "category_id"))
- .then(() => {
- this.commitBuffer();
- this.set("currentlyEditing", null);
- });
- },
-
- cancelEdit() {
- this.rollbackBuffer();
- this.set("currentlyEditing", null);
- }
- }
-});
diff --git a/app/assets/javascripts/discourse/components/reviewable-bundled-action.js.es6 b/app/assets/javascripts/discourse/components/reviewable-bundled-action.js.es6
new file mode 100644
index 00000000000..a73f4b1965a
--- /dev/null
+++ b/app/assets/javascripts/discourse/components/reviewable-bundled-action.js.es6
@@ -0,0 +1,18 @@
+import computed from "ember-addons/ember-computed-decorators";
+
+export default Ember.Component.extend({
+ tagName: "",
+
+ multiple: Ember.computed.gt("bundle.actions.length", 1),
+ first: Ember.computed.alias("bundle.actions.firstObject"),
+
+ actions: {
+ performById(id) {
+ this.attrs.performAction(this.get("bundle.actions").findBy("id", id));
+ },
+
+ perform(action) {
+ this.attrs.performAction(action);
+ }
+ }
+});
diff --git a/app/assets/javascripts/discourse/components/reviewable-histories.js.es6 b/app/assets/javascripts/discourse/components/reviewable-histories.js.es6
new file mode 100644
index 00000000000..a5f1a7932ef
--- /dev/null
+++ b/app/assets/javascripts/discourse/components/reviewable-histories.js.es6
@@ -0,0 +1,3 @@
+export default Ember.Component.extend({
+ filteredHistories: Ember.computed.filterBy("histories", "created", false)
+});
diff --git a/app/assets/javascripts/discourse/components/reviewable-item.js.es6 b/app/assets/javascripts/discourse/components/reviewable-item.js.es6
new file mode 100644
index 00000000000..60a1faa2593
--- /dev/null
+++ b/app/assets/javascripts/discourse/components/reviewable-item.js.es6
@@ -0,0 +1,153 @@
+import { ajax } from "discourse/lib/ajax";
+import { popupAjaxError } from "discourse/lib/ajax-error";
+import computed from "ember-addons/ember-computed-decorators";
+import Category from "discourse/models/category";
+import optionalService from "discourse/lib/optional-service";
+
+let _components = {};
+
+export default Ember.Component.extend({
+ adminTools: optionalService(),
+ tagName: "",
+ updating: null,
+ editing: false,
+ _updates: null,
+
+ @computed("reviewable.type")
+ customClass(type) {
+ return type.dasherize();
+ },
+
+ // Find a component to render, if one exists. For example:
+ // `ReviewableUser` will return `reviewable-user`
+ @computed("reviewable.type")
+ reviewableComponent(type) {
+ if (_components[type] !== undefined) {
+ return _components[type];
+ }
+
+ let dasherized = Ember.String.dasherize(type);
+ let templatePath = `components/${dasherized}`;
+ let template =
+ Ember.TEMPLATES[`${templatePath}`] ||
+ Ember.TEMPLATES[`javascripts/${templatePath}`];
+ _components[type] = template ? dasherized : null;
+ return _components[type];
+ },
+
+ _performConfirmed(action) {
+ let reviewable = this.get("reviewable");
+
+ let performAction = () => {
+ let version = reviewable.get("version");
+ this.set("updating", true);
+ return ajax(
+ `/review/${reviewable.id}/perform/${action.id}?version=${version}`,
+ {
+ method: "PUT"
+ }
+ )
+ .then(result => {
+ this.attrs.remove(
+ result.reviewable_perform_result.remove_reviewable_ids
+ );
+ })
+ .catch(popupAjaxError)
+ .finally(() => this.set("updating", false));
+ };
+
+ if (action.client_action) {
+ let actionMethod = this[`client${action.client_action.classify()}`];
+ if (actionMethod) {
+ return actionMethod.call(this, reviewable, performAction);
+ } else {
+ // eslint-disable-next-line no-console
+ console.error(`No handler for ${action.client_action} found`);
+ return;
+ }
+ return;
+ } else {
+ return performAction();
+ }
+ },
+
+ clientSuspend(reviewable, performAction) {
+ this._penalize("showSuspendModal", reviewable, performAction);
+ },
+
+ clientSilence(reviewable, performAction) {
+ this._penalize("showSilenceModal", reviewable, performAction);
+ },
+
+ _penalize(adminToolMethod, reviewable, performAction) {
+ let adminTools = this.get("adminTools");
+ if (adminTools) {
+ let createdBy = reviewable.get("target_created_by");
+ let postId = reviewable.get("post_id");
+ let postEdit = reviewable.get("raw");
+ return adminTools[adminToolMethod](createdBy, {
+ postId,
+ postEdit,
+ before: performAction
+ });
+ }
+ },
+
+ actions: {
+ edit() {
+ this.set("editing", true);
+ this._updates = { payload: {} };
+ },
+
+ cancelEdit() {
+ this.set("editing", false);
+ },
+
+ saveEdit() {
+ let updates = this._updates;
+
+ // Remove empty objects
+ Object.keys(updates).forEach(name => {
+ let attr = updates[name];
+ if (typeof attr === "object" && Object.keys(attr).length === 0) {
+ delete updates[name];
+ }
+ });
+
+ this.set("updating", true);
+ return this.get("reviewable")
+ .update(updates)
+ .then(() => this.set("editing", false))
+ .catch(popupAjaxError)
+ .finally(() => this.set("updating", false));
+ },
+
+ categoryChanged(category) {
+ if (!category) {
+ category = Category.findUncategorized();
+ }
+ this._updates.category_id = category.id;
+ },
+
+ valueChanged(fieldId, event) {
+ Ember.set(this._updates, fieldId, event.target.value);
+ },
+
+ perform(action) {
+ if (this.get("updating")) {
+ return;
+ }
+
+ let msg = action.get("confirm_message");
+ if (msg) {
+ bootbox.confirm(msg, answer => {
+ if (answer) {
+ return this._performConfirmed(action);
+ }
+ });
+ } else {
+ return this._performConfirmed(action);
+ }
+ }
+ }
+});
diff --git a/app/assets/javascripts/discourse/components/scrolling-post-stream.js.es6 b/app/assets/javascripts/discourse/components/scrolling-post-stream.js.es6
index 94779cdebe9..8721f3ba734 100644
--- a/app/assets/javascripts/discourse/components/scrolling-post-stream.js.es6
+++ b/app/assets/javascripts/discourse/components/scrolling-post-stream.js.es6
@@ -3,7 +3,6 @@ import MountWidget from "discourse/components/mount-widget";
import { cloak, uncloak } from "discourse/widgets/post-stream";
import { isWorkaroundActive } from "discourse/lib/safari-hacks";
import offsetCalculator from "discourse/lib/offset-calculator";
-import optionalService from "discourse/lib/optional-service";
function findTopView($posts, viewportTop, postsWrapperTop, min, max) {
if (max < min) {
@@ -26,7 +25,6 @@ function findTopView($posts, viewportTop, postsWrapperTop, min, max) {
}
export default MountWidget.extend({
- adminTools: optionalService(),
widget: "post-stream",
_topVisible: null,
_bottomVisible: null,
@@ -329,12 +327,5 @@ export default MountWidget.extend({
this.$().off("mouseleave.post-stream");
this.appEvents.off("post-stream:refresh", this, "_refresh");
this.appEvents.off("post-stream:posted", this, "_posted");
- },
-
- showModerationHistory(post) {
- this.get("adminTools").showModerationHistory({
- filter: "post",
- post_id: post.id
- });
}
});
diff --git a/app/assets/javascripts/discourse/components/site-header.js.es6 b/app/assets/javascripts/discourse/components/site-header.js.es6
index 898ebcce2dd..ac953580d6c 100644
--- a/app/assets/javascripts/discourse/components/site-header.js.es6
+++ b/app/assets/javascripts/discourse/components/site-header.js.es6
@@ -423,8 +423,7 @@ function applyFlaggedProperties() {
});
}
-addFlagProperty("currentUser.site_flagged_posts_count");
-addFlagProperty("currentUser.post_queue_new_count");
+addFlagProperty("currentUser.reviewable_count");
export { addFlagProperty, applyFlaggedProperties };
diff --git a/app/assets/javascripts/discourse/components/topic-admin-menu-button.js.es6 b/app/assets/javascripts/discourse/components/topic-admin-menu-button.js.es6
index cf02e83e5c9..95dbcebcac2 100644
--- a/app/assets/javascripts/discourse/components/topic-admin-menu-button.js.es6
+++ b/app/assets/javascripts/discourse/components/topic-admin-menu-button.js.es6
@@ -1,20 +1,11 @@
import MountWidget from "discourse/components/mount-widget";
-import optionalService from "discourse/lib/optional-service";
export default MountWidget.extend({
classNames: "topic-admin-menu-button-container",
tagName: "span",
widget: "topic-admin-menu-button",
- adminTools: optionalService(),
buildArgs() {
return this.getProperties("topic", "fixed", "openUpwards", "rightSide");
- },
-
- showModerationHistory() {
- this.get("adminTools").showModerationHistory({
- filter: "topic",
- topic_id: this.get("topic.id")
- });
}
});
diff --git a/app/assets/javascripts/discourse/components/topic-timeline.js.es6 b/app/assets/javascripts/discourse/components/topic-timeline.js.es6
index 14f8db0a049..5f595854d39 100644
--- a/app/assets/javascripts/discourse/components/topic-timeline.js.es6
+++ b/app/assets/javascripts/discourse/components/topic-timeline.js.es6
@@ -93,12 +93,5 @@ export default MountWidget.extend(Docking, {
}
this.dispatch("topic:current-post-scrolled", "timeline-scrollarea");
- },
-
- showModerationHistory() {
- this.get("adminTools").showModerationHistory({
- filter: "topic",
- topic_id: this.get("topic.id")
- });
}
});
diff --git a/app/assets/javascripts/discourse/components/user-stream.js.es6 b/app/assets/javascripts/discourse/components/user-stream.js.es6
index 59408144df4..9060022d6fa 100644
--- a/app/assets/javascripts/discourse/components/user-stream.js.es6
+++ b/app/assets/javascripts/discourse/components/user-stream.js.es6
@@ -56,9 +56,11 @@ export default Ember.Component.extend(LoadMore, {
actions: {
removeBookmark(userAction) {
const stream = this.get("stream");
- Post.updateBookmark(userAction.get("post_id"), false).then(() => {
- stream.remove(userAction);
- });
+ Post.updateBookmark(userAction.get("post_id"), false)
+ .then(() => {
+ stream.remove(userAction);
+ })
+ .catch(popupAjaxError);
},
resumeDraft(item) {
diff --git a/app/assets/javascripts/discourse/controllers/header.js.es6 b/app/assets/javascripts/discourse/controllers/header.js.es6
deleted file mode 100644
index 12bd5bcf4f7..00000000000
--- a/app/assets/javascripts/discourse/controllers/header.js.es6
+++ /dev/null
@@ -1,9 +0,0 @@
-import { addFlagProperty as realAddFlagProperty } from "discourse/components/site-header";
-import deprecated from "discourse-common/lib/deprecated";
-
-export function addFlagProperty(prop) {
- deprecated(
- "importing `addFlagProperty` is deprecated. Use the PluginAPI instead"
- );
- realAddFlagProperty(prop);
-}
diff --git a/app/assets/javascripts/discourse/controllers/post-enqueued.js.es6 b/app/assets/javascripts/discourse/controllers/post-enqueued.js.es6
deleted file mode 100644
index 6d78d24a87e..00000000000
--- a/app/assets/javascripts/discourse/controllers/post-enqueued.js.es6
+++ /dev/null
@@ -1,8 +0,0 @@
-export default Ember.Controller.extend({
- description: Ember.computed("model.reason", function() {
- const reason = this.get("model.reason");
- return reason
- ? I18n.t("queue_reason." + reason + ".description")
- : I18n.t("queue.approval.description");
- })
-});
diff --git a/app/assets/javascripts/discourse/controllers/review-index.js.es6 b/app/assets/javascripts/discourse/controllers/review-index.js.es6
new file mode 100644
index 00000000000..9c8f161d8de
--- /dev/null
+++ b/app/assets/javascripts/discourse/controllers/review-index.js.es6
@@ -0,0 +1,98 @@
+import computed from "ember-addons/ember-computed-decorators";
+
+export default Ember.Controller.extend({
+ queryParams: [
+ "min_score",
+ "type",
+ "status",
+ "category_id",
+ "topic_id",
+ "username"
+ ],
+ type: null,
+ status: "pending",
+ min_score: null,
+ category_id: null,
+ reviewables: null,
+ topic_id: null,
+ filtersExpanded: false,
+ username: "",
+
+ init(...args) {
+ this._super(...args);
+ this.set("min_score", this.siteSettings.min_score_default_visibility);
+ this.set("filtersExpanded", !this.site.mobileView);
+ },
+
+ @computed("reviewableTypes")
+ allTypes() {
+ return (this.get("reviewableTypes") || []).map(type => {
+ return {
+ id: type,
+ name: I18n.t(`review.types.${type.underscore()}.title`)
+ };
+ });
+ },
+
+ @computed
+ statuses() {
+ return [
+ "pending",
+ "approved",
+ "rejected",
+ "ignored",
+ "reviewed",
+ "all"
+ ].map(id => {
+ return { id, name: I18n.t(`review.statuses.${id}.title`) };
+ });
+ },
+
+ @computed("filtersExpanded")
+ toggleFiltersIcon(filtersExpanded) {
+ return filtersExpanded ? "chevron-up" : "chevron-down";
+ },
+
+ actions: {
+ remove(ids) {
+ if (!ids) {
+ return;
+ }
+
+ let newList = this.get("reviewables").reject(reviewable => {
+ return ids.indexOf(reviewable.id) !== -1;
+ });
+ this.set("reviewables", newList);
+ },
+
+ resetTopic() {
+ this.set("topic_id", null);
+ this.send("refreshRoute");
+ },
+
+ refresh() {
+ // If filterScore is blank use the default
+ let filterScore = this.get("filterScore");
+ if (!filterScore || filterScore.length === 0) {
+ filterScore = this.siteSettings.min_score_default_visibility;
+ }
+
+ this.setProperties({
+ type: this.get("filterType"),
+ min_score: filterScore,
+ status: this.get("filterStatus"),
+ category_id: this.get("filterCategoryId"),
+ username: this.get("filterUsername")
+ });
+ this.send("refreshRoute");
+ },
+
+ loadMore() {
+ return this.get("reviewables").loadMore();
+ },
+
+ toggleFilters() {
+ this.toggleProperty("filtersExpanded");
+ }
+ }
+});
diff --git a/app/assets/javascripts/discourse/helpers/dasherize.js.es6 b/app/assets/javascripts/discourse/helpers/dasherize.js.es6
new file mode 100644
index 00000000000..b8240061696
--- /dev/null
+++ b/app/assets/javascripts/discourse/helpers/dasherize.js.es6
@@ -0,0 +1,5 @@
+function dasherize([value]) {
+ return (value || "").replace(".", "-").dasherize();
+}
+
+export default Ember.Helper.helper(dasherize);
diff --git a/app/assets/javascripts/discourse/helpers/editable-value.js.es6 b/app/assets/javascripts/discourse/helpers/editable-value.js.es6
new file mode 100644
index 00000000000..799815590ad
--- /dev/null
+++ b/app/assets/javascripts/discourse/helpers/editable-value.js.es6
@@ -0,0 +1,17 @@
+export function formatCurrency([reviewable, fieldId]) {
+ // The field `category_id` corresponds to `category`
+ if (fieldId === "category_id") {
+ fieldId = "category.id";
+ }
+
+ let value = Ember.get(reviewable, fieldId);
+
+ // If it's an array, say tags, make a copy so we aren't mutating the original
+ if (Array.isArray(value)) {
+ value = value.slice(0);
+ }
+
+ return value;
+}
+
+export default Ember.Helper.helper(formatCurrency);
diff --git a/app/assets/javascripts/discourse/helpers/format-score.js.es6 b/app/assets/javascripts/discourse/helpers/format-score.js.es6
new file mode 100644
index 00000000000..f3d184de0a6
--- /dev/null
+++ b/app/assets/javascripts/discourse/helpers/format-score.js.es6
@@ -0,0 +1,5 @@
+import { registerUnbound } from "discourse-common/lib/helpers";
+
+registerUnbound("format-score", function(score) {
+ return I18n.toNumber(score || 0, { precision: 1 });
+});
diff --git a/app/assets/javascripts/discourse/helpers/reviewable-history-description.js.es6 b/app/assets/javascripts/discourse/helpers/reviewable-history-description.js.es6
new file mode 100644
index 00000000000..08f0e6d3938
--- /dev/null
+++ b/app/assets/javascripts/discourse/helpers/reviewable-history-description.js.es6
@@ -0,0 +1,12 @@
+import { htmlHelper } from "discourse-common/lib/helpers";
+import { htmlStatus } from "discourse/helpers/reviewable-status";
+import { EDITED } from "discourse/models/reviewable-history";
+
+export default htmlHelper(function(rh) {
+ switch (rh.reviewable_history_type) {
+ case EDITED:
+ return I18n.t("review.history.edited");
+ default:
+ return htmlStatus(rh.status);
+ }
+});
diff --git a/app/assets/javascripts/discourse/helpers/reviewable-status.js.es6 b/app/assets/javascripts/discourse/helpers/reviewable-status.js.es6
new file mode 100644
index 00000000000..b10d431b40b
--- /dev/null
+++ b/app/assets/javascripts/discourse/helpers/reviewable-status.js.es6
@@ -0,0 +1,31 @@
+import { htmlHelper } from "discourse-common/lib/helpers";
+import { iconHTML } from "discourse-common/lib/icon-library";
+
+import {
+ PENDING,
+ APPROVED,
+ REJECTED,
+ IGNORED,
+ DELETED
+} from "discourse/models/reviewable";
+
+export function htmlStatus(status) {
+ switch (status) {
+ case PENDING:
+ return I18n.t("review.statuses.pending.title");
+ case APPROVED:
+ return `${iconHTML("check")} ${I18n.t("review.statuses.approved.title")}`;
+ case REJECTED:
+ return `${iconHTML("times")} ${I18n.t("review.statuses.rejected.title")}`;
+ case IGNORED:
+ return `${iconHTML("external-link-alt")} ${I18n.t(
+ "review.statuses.ignored.title"
+ )}`;
+ case DELETED:
+ return `${iconHTML("trash")} ${I18n.t("review.statuses.deleted.title")}`;
+ }
+}
+
+export default htmlHelper(status => {
+ return htmlStatus(status);
+});
diff --git a/app/assets/javascripts/discourse/initializers/subscribe-user-notifications.js.es6 b/app/assets/javascripts/discourse/initializers/subscribe-user-notifications.js.es6
index 651f23e130e..321d5e680cd 100644
--- a/app/assets/javascripts/discourse/initializers/subscribe-user-notifications.js.es6
+++ b/app/assets/javascripts/discourse/initializers/subscribe-user-notifications.js.es6
@@ -21,18 +21,12 @@ export default {
const appEvents = container.lookup("app-events:main");
if (user) {
- if (user.get("staff")) {
- bus.subscribe("/flagged_counts", data => {
- user.set("site_flagged_posts_count", data.total);
- });
- bus.subscribe("/queue_counts", data => {
- user.set("post_queue_new_count", data.post_queue_new_count);
- if (data.post_queue_new_count > 0) {
- user.set("show_queued_posts", 1);
- }
- });
- }
-
+ bus.subscribe("/reviewable_counts", data => {
+ user.set("reviewable_count", data.reviewable_count);
+ if (data.reviewable_count > 0) {
+ user.set("show_reviewables", 1);
+ }
+ });
bus.subscribe(
`/notification/${user.get("id")}`,
data => {
diff --git a/app/assets/javascripts/discourse/models/result-set.js.es6 b/app/assets/javascripts/discourse/models/result-set.js.es6
index 5f85ce94177..bc36f23f76d 100644
--- a/app/assets/javascripts/discourse/models/result-set.js.es6
+++ b/app/assets/javascripts/discourse/models/result-set.js.es6
@@ -10,6 +10,7 @@ export default Ember.ArrayProxy.extend({
findArgs: null,
store: null,
__type: null,
+ resultSetMeta: null,
canLoadMore: function() {
return this.get("length") < this.get("totalRows");
diff --git a/app/assets/javascripts/discourse/models/reviewable-history.js.es6 b/app/assets/javascripts/discourse/models/reviewable-history.js.es6
new file mode 100644
index 00000000000..0b1b14f54e0
--- /dev/null
+++ b/app/assets/javascripts/discourse/models/reviewable-history.js.es6
@@ -0,0 +1,9 @@
+import RestModel from "discourse/models/rest";
+
+export const CREATED = 0;
+export const TRANSITIONED_TO = 1;
+export const EDITED = 2;
+
+export default RestModel.extend({
+ created: Ember.computed.equal("reviewable_history_type", CREATED)
+});
diff --git a/app/assets/javascripts/discourse/models/reviewable.js.es6 b/app/assets/javascripts/discourse/models/reviewable.js.es6
new file mode 100644
index 00000000000..2781b7ea9c9
--- /dev/null
+++ b/app/assets/javascripts/discourse/models/reviewable.js.es6
@@ -0,0 +1,50 @@
+import { ajax } from "discourse/lib/ajax";
+import RestModel from "discourse/models/rest";
+import computed from "ember-addons/ember-computed-decorators";
+import Category from "discourse/models/category";
+
+export const PENDING = 0;
+export const APPROVED = 1;
+export const REJECTED = 2;
+export const IGNORED = 3;
+export const DELETED = 4;
+
+export default RestModel.extend({
+ pending: Ember.computed.equal("status", PENDING),
+ approved: Ember.computed.equal("status", APPROVED),
+ rejected: Ember.computed.equal("status", REJECTED),
+ ignored: Ember.computed.equal("status", IGNORED),
+
+ @computed("type")
+ humanType(type) {
+ return I18n.t(`review.types.${type.underscore()}.title`, {
+ defaultValue: ""
+ });
+ },
+
+ update(updates) {
+ // If no changes, do nothing
+ if (Object.keys(updates).length === 0) {
+ return Ember.RSVP.resolve();
+ }
+
+ let adapter = this.store.adapterFor("reviewable");
+ return ajax(
+ `/review/${this.get("id")}?version=${this.get("version")}`,
+ adapter.getPayload("PUT", { reviewable: updates })
+ ).then(updated => {
+ updated.payload = Object.assign(
+ {},
+ this.get("payload") || {},
+ updated.payload || {}
+ );
+
+ if (updated.category_id) {
+ updated.category = Category.findById(updated.category_id);
+ delete updated.category_id;
+ }
+
+ this.setProperties(updated);
+ });
+ }
+});
diff --git a/app/assets/javascripts/discourse/models/store.js.es6 b/app/assets/javascripts/discourse/models/store.js.es6
index f5b97f3856b..486da7ca2c4 100644
--- a/app/assets/javascripts/discourse/models/store.js.es6
+++ b/app/assets/javascripts/discourse/models/store.js.es6
@@ -48,7 +48,7 @@ export default Ember.Object.extend({
_plurals: {
"post-reply": "post-replies",
"post-reply-history": "post_reply_histories",
- "moderation-history": "moderation_history"
+ reviewable_history: "reviewable_histories"
},
init() {
@@ -223,6 +223,7 @@ export default Ember.Object.extend({
totalRows: pageTarget["total_rows_" + typeName] || content.length,
loadMoreUrl: pageTarget["load_more_" + typeName],
refreshUrl: pageTarget["refresh_" + typeName],
+ resultSetMeta: result.meta,
store: this,
__type: type
};
@@ -328,8 +329,6 @@ export default Ember.Object.extend({
root = root || obj;
- // Experimental: If serialized with a certain option we'll wire up embedded objects
- // automatically.
if (root.__rest_serializer === "1") {
this._hydrateEmbedded(type, obj, root);
}
diff --git a/app/assets/javascripts/discourse/routes/app-route-map.js.es6 b/app/assets/javascripts/discourse/routes/app-route-map.js.es6
index edf1ac66966..05023b3f59b 100644
--- a/app/assets/javascripts/discourse/routes/app-route-map.js.es6
+++ b/app/assets/javascripts/discourse/routes/app-route-map.js.es6
@@ -126,7 +126,6 @@ export default function() {
);
this.route("badges");
- this.route("flaggedPosts", { path: "/flagged-posts" });
this.route("deletedPosts", { path: "/deleted-posts" });
this.route(
@@ -170,6 +169,11 @@ export default function() {
}
);
+ this.route("review", { path: "/review" }, function() {
+ this.route("show", { path: "/:reviewable_id" });
+ this.route("index", { path: "/" });
+ this.route("topics", { path: "/topics" });
+ });
this.route("signup", { path: "/signup" });
this.route("login", { path: "/login" });
this.route("login-preferences");
@@ -188,8 +192,6 @@ export default function() {
this.route("show", { path: "/:id/:slug" });
});
- this.route("queued-posts", { path: "/queued-posts", resetNamespace: true });
-
this.route("full-page-search", { path: "/search" });
this.route("tags", { resetNamespace: true }, function() {
diff --git a/app/assets/javascripts/discourse/routes/application.js.es6 b/app/assets/javascripts/discourse/routes/application.js.es6
index c8f38d6d390..d596bd8cc75 100644
--- a/app/assets/javascripts/discourse/routes/application.js.es6
+++ b/app/assets/javascripts/discourse/routes/application.js.es6
@@ -52,10 +52,10 @@ const ApplicationRoute = Discourse.Route.extend(OpenComposer, {
},
postWasEnqueued(details) {
- const title = details.reason
- ? "queue_reason." + details.reason + ".title"
- : "queue.approval.title";
- showModal("post-enqueued", { model: details, title });
+ showModal("post-enqueued", {
+ model: details,
+ title: "review.approval.title"
+ });
},
composePrivateMessage(user, post) {
diff --git a/app/assets/javascripts/discourse/routes/queued-posts.js.es6 b/app/assets/javascripts/discourse/routes/queued-posts.js.es6
deleted file mode 100644
index 76c1dfb4f80..00000000000
--- a/app/assets/javascripts/discourse/routes/queued-posts.js.es6
+++ /dev/null
@@ -1,17 +0,0 @@
-import DiscourseRoute from "discourse/routes/discourse";
-
-export default DiscourseRoute.extend({
- model() {
- return this.store.find("queuedPost", { status: "new" });
- },
-
- actions: {
- removePost(post) {
- this.modelFor("queued-posts").removeObject(post);
- },
-
- refresh() {
- this.modelFor("queued-posts").refresh();
- }
- }
-});
diff --git a/app/assets/javascripts/discourse/routes/review-index.js.es6 b/app/assets/javascripts/discourse/routes/review-index.js.es6
new file mode 100644
index 00000000000..8c4700763ac
--- /dev/null
+++ b/app/assets/javascripts/discourse/routes/review-index.js.es6
@@ -0,0 +1,31 @@
+export default Discourse.Route.extend({
+ model(params) {
+ // `0` is a valid query param
+ if (params.min_score != null) {
+ params.min_score = params.min_score.toString();
+ }
+ return this.store.findAll("reviewable", params);
+ },
+
+ setupController(controller, model) {
+ let meta = model.resultSetMeta;
+ controller.setProperties({
+ reviewables: model,
+ type: meta.type,
+ filterType: meta.type,
+ filterStatus: meta.status,
+ filterTopic: meta.topic_id,
+ filterCategoryId: meta.category_id,
+ min_score: meta.min_score,
+ filterScore: meta.min_score,
+ reviewableTypes: meta.reviewable_types,
+ filterUsername: meta.username
+ });
+ },
+
+ actions: {
+ refreshRoute() {
+ this.refresh();
+ }
+ }
+});
diff --git a/app/assets/javascripts/discourse/routes/review-show.js.es6 b/app/assets/javascripts/discourse/routes/review-show.js.es6
new file mode 100644
index 00000000000..afe7b30a5d5
--- /dev/null
+++ b/app/assets/javascripts/discourse/routes/review-show.js.es6
@@ -0,0 +1,5 @@
+export default Discourse.Route.extend({
+ setupController(controller, model) {
+ controller.set("reviewable", model);
+ }
+});
diff --git a/app/assets/javascripts/discourse/routes/review-topics.js.es6 b/app/assets/javascripts/discourse/routes/review-topics.js.es6
new file mode 100644
index 00000000000..7c3f058fbd6
--- /dev/null
+++ b/app/assets/javascripts/discourse/routes/review-topics.js.es6
@@ -0,0 +1,9 @@
+export default Discourse.Route.extend({
+ model() {
+ return this.store.findAll("reviewable-topic");
+ },
+
+ setupController(controller, model) {
+ controller.set("reviewableTopics", model);
+ }
+});
diff --git a/app/assets/javascripts/discourse/routes/review.js.es6 b/app/assets/javascripts/discourse/routes/review.js.es6
new file mode 100644
index 00000000000..6343919dfcb
--- /dev/null
+++ b/app/assets/javascripts/discourse/routes/review.js.es6
@@ -0,0 +1,5 @@
+export default Discourse.Route.extend({
+ titleToken() {
+ return I18n.t("review.title");
+ }
+});
diff --git a/app/assets/javascripts/discourse/routes/user-flagged-posts.js.es6 b/app/assets/javascripts/discourse/routes/user-flagged-posts.js.es6
deleted file mode 100644
index 3485c8b72a1..00000000000
--- a/app/assets/javascripts/discourse/routes/user-flagged-posts.js.es6
+++ /dev/null
@@ -1,3 +0,0 @@
-import createAdminUserPostsRoute from "discourse/routes/build-admin-user-posts-route";
-
-export default createAdminUserPostsRoute("flagged");
diff --git a/app/assets/javascripts/discourse/templates/components/d-editor.hbs b/app/assets/javascripts/discourse/templates/components/d-editor.hbs
index 11b783648ad..244ac0e67a8 100644
--- a/app/assets/javascripts/discourse/templates/components/d-editor.hbs
+++ b/app/assets/javascripts/discourse/templates/components/d-editor.hbs
@@ -39,7 +39,14 @@
{{conditional-loading-spinner condition=loading}}
- {{textarea autocomplete="discourse" tabindex=tabindex value=value class="d-editor-input" placeholder=placeholderTranslated disabled=disabled}}
+ {{textarea
+ autocomplete="discourse"
+ tabindex=tabindex
+ value=value
+ class="d-editor-input"
+ placeholder=placeholderTranslated
+ disabled=disabled
+ change=change}}
{{popup-input-tip validation=validation}}
{{plugin-outlet name="after-d-editor" tagName="" args=outletArgs}}
diff --git a/app/assets/javascripts/discourse/templates/components/queued-post.hbs b/app/assets/javascripts/discourse/templates/components/queued-post.hbs
deleted file mode 100644
index f8a73cd8f98..00000000000
--- a/app/assets/javascripts/discourse/templates/components/queued-post.hbs
+++ /dev/null
@@ -1,96 +0,0 @@
-
-
- {{#user-link user=post.user}}
- {{avatar post.user imageSize="large"}}
- {{/user-link}}
-
-
-
-
- {{#user-link user=post.user}}
- {{post.user.username}}
- {{/user-link}}
- {{#if post.user.silenced}}
- {{d-icon "ban" title="user.silenced_tooltip"}}
- {{/if}}
-
-
-
- {{age-with-tooltip post.created_at}}
-
-
-
- {{#if editTitleAndCategory}}
-
- {{text-field value=buffered.title maxlength=siteSettings.max_topic_title_length}}
-
- {{category-chooser value=buffered.category_id}}
- {{else}}
-
- {{i18n "queue.topic"}}
- {{#if post.topic}}
- {{topic-link post.topic}}
- {{else}}
- {{editables.title}}
- {{/if}}
- {{category-badge editables.category}}
-
- {{/if}}
-
-
- {{#if editing}}
- {{d-editor value=buffered.raw}}
- {{else}}
- {{cook-text editables.raw}}
- {{/if}}
-
-
- {{#if showTags}}
-
- {{#each tags as |t|}}
- {{discourse-tag t}}
- {{/each}}
-
- {{else if editTags}}
- {{tag-chooser tags=buffered.tags categoryId=buffered.category_id}}
- {{/if}}
-
-
- {{#if editing}}
- {{d-button action=(action "confirmEdit")
- label="queue.confirm"
- disabled=post.isSaving
- class="btn-primary confirm"}}
- {{d-button action=(action "cancelEdit")
- label="queue.cancel"
- icon="times"
- disabled=post.isSaving
- class="btn-danger cancel"}}
- {{else}}
- {{d-button action=(action "approve")
- disabled=post.isSaving
- label="queue.approve"
- icon="check"
- class="btn-primary approve"}}
- {{d-button action=(action "reject")
- disabled=post.isSaving
- label="queue.reject"
- icon="times"
- class="btn-danger reject"}}
- {{#if post.can_delete_user}}
- {{d-button action=(action "deleteUser")
- disabled=post.isSaving
- label="queue.delete_user"
- icon="trash-alt"
- class="btn-danger delete-user"}}
- {{/if}}
- {{d-button action=(action "edit")
- disabled=post.isSaving
- label="queue.edit"
- icon="pencil-alt"
- class="edit"}}
- {{/if}}
-
-
-
-
+ {{#link-to 'user' post.user class="username"}}@{{post.user.username}}{{/link-to}} {{{post.excerpt}}}
+
+{{/if}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-field-category.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-field-category.hbs
new file mode 100644
index 00000000000..4ecdea1f6d8
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-field-category.hbs
@@ -0,0 +1 @@
+{{category-chooser value=value onChooseCategory=categoryChanged}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-field-editor.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-field-editor.hbs
new file mode 100644
index 00000000000..befb8bc08ae
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-field-editor.hbs
@@ -0,0 +1 @@
+{{d-editor value=value change=valueChanged}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-field-tags.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-field-tags.hbs
new file mode 100644
index 00000000000..6175da44a3c
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-field-tags.hbs
@@ -0,0 +1 @@
+{{mini-tag-chooser tags=value onChangeTags=valueChanged}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-field-text.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-field-text.hbs
new file mode 100644
index 00000000000..2b3e5f0f8e4
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-field-text.hbs
@@ -0,0 +1 @@
+{{input value=value change=valueChanged class='reviewable-input-text'}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-field-textarea.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-field-textarea.hbs
new file mode 100644
index 00000000000..1f1856ffc67
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-field-textarea.hbs
@@ -0,0 +1 @@
+{{textarea value=value change=valueChanged class="reviewable-input-textarea"}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-flagged-post.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-flagged-post.hbs
new file mode 100644
index 00000000000..f7dc947c225
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-flagged-post.hbs
@@ -0,0 +1,23 @@
+
+ {{#user-link user=reviewable.target_created_by}}
+ {{avatar reviewable.target_created_by imageSize="large"}}
+ {{/user-link}}
+
+
+
+
+
+ {{#user-link user=reviewable.target_created_by}}
+ {{reviewable.target_created_by.username}}
+ {{/user-link}}
+
+
+
+ {{reviewable-topic-link topic=reviewable.topic}}
+
+
+ {{{reviewable.cooked}}}
+
+
+ {{yield}}
+
+
+ | {{i18n "review.history.title"}} |
+
+ {{#each filteredHistories as |rh|}}
+ {{#unless rh.created}}
+
+ | {{format-date rh.created_at format="medium"}} |
+
+ {{#user-link user=rs.user}}
+ {{avatar rh.created_by imageSize="tiny"}}
+ {{rh.created_by.username}}
+ {{/user-link}}
+ |
+
+ {{reviewable-history-description rh}}
+ |
+
+ {{/unless}}
+ {{/each}}
+
+{{/if}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-item.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-item.hbs
new file mode 100644
index 00000000000..9c2c8d937b0
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-item.hbs
@@ -0,0 +1,79 @@
+
+
+
+
+ {{#if editing}}
+
+ {{#each reviewable.editable_fields as |f|}}
+
+ {{component
+ (concat "reviewable-field-" f.type)
+ tagName=''
+ value=(editable-value reviewable f.id)
+ tagCategoryId=reviewable.category.id
+ valueChanged=(action "valueChanged" f.id)
+ categoryChanged=(action "categoryChanged")}}
+
+ {{/each}}
+
+ {{else}}
+ {{#component reviewableComponent reviewable=reviewable tagName=''}}
+ {{reviewable-scores scores=reviewable.reviewable_scores}}
+ {{reviewable-histories histories=reviewable.reviewable_histories}}
+ {{/component}}
+ {{/if}}
+
+
+ {{#if editing}}
+ {{d-button
+ class="btn-primary reviewable-action save-edit"
+ disabled=updating
+ icon="check"
+ action=(action "saveEdit")
+ label="review.save"}}
+ {{d-button
+ class="btn-danger reviewable-action cancel-edit"
+ disabled=updating
+ icon="times"
+ action=(action "cancelEdit")
+ label="review.cancel"}}
+ {{else}}
+ {{#each reviewable.bundled_actions as |bundle|}}
+ {{reviewable-bundled-action
+ bundle=bundle
+ performAction=(action "perform")
+ reviewableUpdating=updating}}
+ {{/each}}
+
+ {{#if reviewable.can_edit}}
+ {{d-button
+ class="reviewable-action edit"
+ disabled=updating
+ icon="pencil-alt"
+ action=(action "edit")
+ label="review.edit"}}
+ {{/if}}
+ {{/if}}
+
+
+
+ {{#user-link user=reviewable.created_by}}
+ {{avatar reviewable.created_by imageSize="large"}}
+ {{/user-link}}
+
+
+
+
+
+ {{#user-link user=reviewable.created_by}}
+ {{reviewable.created_by.username}}
+ {{/user-link}}
+ {{#if reviewable.created_by.silenced}}
+ {{d-icon "ban" title="user.silenced_tooltip"}}
+ {{/if}}
+
+
+
+ {{#reviewable-topic-link topic=reviewable.topic}}
+ {{i18n "review.new_topic"}}
+ {{reviewable.payload.title}}
+ {{/reviewable-topic-link}}
+
+
+ {{cook-text reviewable.payload.raw}}
+
+
+ {{#if reviewable.payload.tags}}
+
+ {{#each reviewable.payload.tags as |t|}}
+ {{discourse-tag t}}
+ {{/each}}
+
+ {{/if}}
+
+ {{yield}}
+
+
+ | {{i18n "review.scores.submitted_by"}} |
+ {{i18n "review.scores.description"}} |
+ {{i18n "review.scores.score"}} |
+
+ {{#each scores as |rs|}}
+
+ |
+ {{#user-link user=rs.user}}
+ {{avatar rs.user imageSize="tiny"}}
+ {{rs.user.username}}
+ {{/user-link}}
+ {{user-flag-percentage
+ agreed=rs.agree_stats.agreed
+ disagreed=rs.agree_stats.disagreed
+ ignored=rs.agree_stats.ignored}}
+ |
+ {{rs.score_type.title}} |
+ {{format-score rs.score}} |
+
+ {{#if rs.reviewable_conversation}}
+
+
+
+ {{#each rs.reviewable_conversation.conversation_posts as |p|}}
+ {{reviewable-conversation-post post=p}}
+ {{/each}}
+
+ |
+
+ {{/if}}
+ {{/each}}
+
+{{/if}}
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-topic-link.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-topic-link.hbs
new file mode 100644
index 00000000000..6ce59f54924
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-topic-link.hbs
@@ -0,0 +1,10 @@
+
+ {{#if topic}}
+ {{i18n "review.topic"}}
+ {{topic-status topic=topic}}
+ {{topic-link topic}}
+ {{i18n "review.topic_replies" count=topic.reply_count}}
+ {{else}}
+ {{yield}}
+ {{/if}}
+
diff --git a/app/assets/javascripts/discourse/templates/components/reviewable-user.hbs b/app/assets/javascripts/discourse/templates/components/reviewable-user.hbs
new file mode 100644
index 00000000000..0afc052a447
--- /dev/null
+++ b/app/assets/javascripts/discourse/templates/components/reviewable-user.hbs
@@ -0,0 +1,8 @@
+
+
+ {{reviewable.username}}
+ {{reviewable.email}}
+
+
+ {{yield}}
+ {{{description}}}
+ {{i18n "review.approval.description"}}
- {{{i18n "queue.approval.pending_posts" count=model.pending_count}}}
+ {{{i18n "review.approval.pending_posts" count=model.pending_count}}}
{{/d-modal-body}}
diff --git a/app/assets/javascripts/discourse/templates/queued-posts.hbs b/app/assets/javascripts/discourse/templates/queued-posts.hbs
deleted file mode 100644
index a5984c1add4..00000000000
--- a/app/assets/javascripts/discourse/templates/queued-posts.hbs
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
- {{#each model as |post|}}
- {{queued-post post=post currentlyEditing=editing removePost=(route-action "removePost" post)}}
- {{else}}
- {{i18n "queue.none"}}
- {{/each}}
-
- {{d-button action=(route-action "refresh") label="refresh" icon="sync" disabled=model.refreshing class="btn-default" id='refresh-queued'}}
-
-
+
+ {{nav-item route='review.index' label='review.view_all'}}
+ {{nav-item route='review.topics' label='review.grouped_by_topic'}}
+
+
+
+
+ {{#if reviewables}}
+ {{#load-more selector=".reviewable-item" action=(action "loadMore")}}
+
+ {{#each reviewables as |r|}}
+ {{reviewable-item reviewable=r remove=(action "remove")}}
+ {{/each}}
+
+ {{/load-more}}
+ {{conditional-loading-spinner condition=reviewables.loadingMore}}
+ {{else}}
+
+ {{i18n "review.none"}}
+
+ {{/if}}
+
+
+
+
+
+ {{combo-box value=filterStatus content=statuses}}
+
+
+ {{#if filtersExpanded}}
+
+
+ {{combo-box value=filterType content=allTypes none="review.filters.type.all"}}
+
+
+
+
+ {{input value=filterScore class="score-filter"}}
+
+
+
+
+ {{category-chooser none="category.all" value=filterCategoryId}}
+
+
+
+ {{i18n "review.filtered_user"}}
+ {{user-selector
+ excludeCurrentUser=false
+ usernames=filterUsername
+ fullWidthWrap="true"
+ class="user-selector"
+ single="true"
+ canReceiveUpdates="true"}}
+
+
+ {{#if filterTopic}}
+
+ {{i18n "review.filtered_topic"}}
+ {{d-button label="review.show_all_topics" icon="times" action=(action "resetTopic")}}
+
+ {{/if}}
+ {{/if}}
+
+
+ {{d-button
+ icon="sync"
+ label="review.filters.refresh"
+
+ class="btn-primary refresh" action=(action "refresh")}}
+
+ {{#if site.mobileView}}
+ {{d-button
+ label="show_help"
+ icon=toggleFiltersIcon
+ class="btn-default expand-secondary-filters"
+ action=(action "toggleFilters")}}
+ {{/if}}
+
+
+
+
+
+ {{nav-item route='review.index' routeParam=(query-params topic_id=null) label='review.view_all'}}
+ {{nav-item route='review.topics' label='review.grouped_by_topic'}}
+
+
+ {{#if reviewableTopics}}
+
+
+ | {{i18n "review.topics.topic"}} |
+ {{i18n "review.topics.reviewable_count"}} |
+ {{i18n "review.topics.reported_by"}} |
+ |
+
+
+ {{#each reviewableTopics as |rt|}}
+
+ |
+
+ |
+
+ {{rt.stats.count}}
+ |
+
+ {{i18n "review.topics.unique_users" count=rt.stats.unique_users}}
+ |
+
+ {{#link-to "review.index" (query-params topic_id=rt.id) class="btn btn-primary btn-small"}}
+ {{d-icon "list"}}
+ {{i18n "review.topics.details"}}
+ {{/link-to}}
+ |
+
+ {{/each}}
+
+
+ {{else}}
+
+ {{i18n "review.none"}}
+
+ {{/if}}
+
- {{{i18n "queue.has_pending_posts" count=model.pending_posts_count}}}
+
+ {{{i18n "review.topic_has_pending" count=model.pending_posts_count}}}
+
- {{#if currentUser.show_queued_posts}}
- {{#link-to "queued-posts"}}
- {{d-icon "check"}}
- {{i18n "queue.view_pending"}}
- {{/link-to}}
- {{/if}}
+ {{#link-to 'review' (query-params topic_id=model.id type="ReviewableQueuedPost" status="pending")}}
+ {{i18n "review.view_pending"}}
+ {{/link-to}}
- {{#link-to 'user.flaggedPosts' model}}
+ {{#link-to 'review' (query-params username=model.username status='all' type='ReviewableFlaggedPost')}}
{{model.number_of_flagged_posts}}{{i18n 'user.staff_counters.flagged_posts'}}
- {{/link-to}}
+ {{/link-to}}
{{/if}}
{{#if model.number_of_deleted_posts}}
diff --git a/app/assets/javascripts/discourse/widgets/button.js.es6 b/app/assets/javascripts/discourse/widgets/button.js.es6
index f7349227a3d..ee6f8c46d2e 100644
--- a/app/assets/javascripts/discourse/widgets/button.js.es6
+++ b/app/assets/javascripts/discourse/widgets/button.js.es6
@@ -1,6 +1,7 @@
import { createWidget } from "discourse/widgets/widget";
import { iconNode } from "discourse-common/lib/icon-library";
import { h } from "virtual-dom";
+import DiscourseURL from "discourse/lib/url";
export const ButtonClass = {
tagName: "button.widget-button.btn",
@@ -83,6 +84,10 @@ export const ButtonClass = {
this.sendWidgetAction(attrs.secondaryAction);
}
+ if (attrs.url) {
+ return DiscourseURL.routeTo(attrs.url);
+ }
+
if (attrs.sendActionEvent) {
return this.sendWidgetAction(attrs.action, e);
}
diff --git a/app/assets/javascripts/discourse/widgets/hamburger-menu.js.es6 b/app/assets/javascripts/discourse/widgets/hamburger-menu.js.es6
index a640da5b3f4..24032f83041 100644
--- a/app/assets/javascripts/discourse/widgets/hamburger-menu.js.es6
+++ b/app/assets/javascripts/discourse/widgets/hamburger-menu.js.es6
@@ -46,8 +46,7 @@ export default createWidget("hamburger-menu", {
},
adminLinks() {
- const { currentUser, siteSettings } = this;
- let flagsPath = siteSettings.flags_default_topics ? "topics" : "active";
+ const { currentUser } = this;
const links = [
{
@@ -55,27 +54,16 @@ export default createWidget("hamburger-menu", {
className: "admin-link",
icon: "wrench",
label: "admin_title"
- },
- {
- href: `/admin/flags/${flagsPath}`,
- className: "flagged-posts-link",
- icon: "flag",
- label: "flags_title",
- badgeClass: "flagged-posts",
- badgeTitle: "notifications.total_flagged",
- badgeCount: "site_flagged_posts_count"
}
];
- if (currentUser.show_queued_posts) {
- links.push({
- route: "queued-posts",
- className: "queued-posts-link",
- label: "queue.title",
- badgeCount: "post_queue_new_count",
- badgeClass: "queued-posts"
- });
- }
+ links.push({
+ route: "review",
+ className: "review",
+ label: "review.title",
+ badgeCount: "reviewable_count",
+ badgeClass: "reviewables"
+ });
if (currentUser.admin) {
links.push({
diff --git a/app/assets/javascripts/discourse/widgets/post-admin-menu.js.es6 b/app/assets/javascripts/discourse/widgets/post-admin-menu.js.es6
index 4dd16031d1d..fd2907d4550 100644
--- a/app/assets/javascripts/discourse/widgets/post-admin-menu.js.es6
+++ b/app/assets/javascripts/discourse/widgets/post-admin-menu.js.es6
@@ -6,10 +6,7 @@ createWidget(
"post-admin-menu-button",
jQuery.extend(ButtonClass, {
tagName: "li.btn",
- click() {
- this.sendWidgetAction("closeAdminMenu");
- return this.sendWidgetAction(this.attrs.action);
- }
+ secondaryAction: "closeAdminMenu"
})
);
@@ -23,8 +20,8 @@ export function buildManageButtons(attrs, currentUser, siteSettings) {
contents.push({
icon: "list",
className: "btn-default",
- label: "admin.flags.moderation_history",
- action: "showModerationHistory"
+ label: "review.moderation_history",
+ url: `/review?topic_id=${attrs.topicId}&status=all`
});
}
diff --git a/app/assets/javascripts/discourse/widgets/topic-admin-menu.js.es6 b/app/assets/javascripts/discourse/widgets/topic-admin-menu.js.es6
index 2d6e06502ba..15d9781dc61 100644
--- a/app/assets/javascripts/discourse/widgets/topic-admin-menu.js.es6
+++ b/app/assets/javascripts/discourse/widgets/topic-admin-menu.js.es6
@@ -14,6 +14,7 @@ createWidget("admin-menu-button", {
this.attach("button", {
className,
action: attrs.action,
+ url: attrs.url,
icon: attrs.icon,
label: attrs.fullLabel || `topic.${attrs.label}`,
secondaryAction: "hideAdminMenu"
@@ -252,10 +253,10 @@ export default createWidget("topic-admin-menu", {
if (this.currentUser.get("staff")) {
buttons.push({
- action: "showModerationHistory",
- buttonClass: "btn-default",
icon: "list",
- fullLabel: "admin.flags.moderation_history"
+ buttonClass: "btn-default",
+ fullLabel: "review.moderation_history",
+ url: `/review?topic_id=${topic.id}&status=all`
});
}
diff --git a/app/assets/javascripts/polyfills.js b/app/assets/javascripts/polyfills.js
index 69c3987afe8..a4a90dfe2c5 100644
--- a/app/assets/javascripts/polyfills.js
+++ b/app/assets/javascripts/polyfills.js
@@ -178,4 +178,5 @@ if (!Array.prototype.find) {
writable: true
});
}
+
/* eslint-enable */
diff --git a/app/assets/javascripts/select-kit/components/admin-agree-flag-dropdown.js.es6 b/app/assets/javascripts/select-kit/components/admin-agree-flag-dropdown.js.es6
deleted file mode 100644
index 8ef25f08631..00000000000
--- a/app/assets/javascripts/select-kit/components/admin-agree-flag-dropdown.js.es6
+++ /dev/null
@@ -1,131 +0,0 @@
-import DropdownSelectBox from "select-kit/components/dropdown-select-box";
-import computed from "ember-addons/ember-computed-decorators";
-
-export default DropdownSelectBox.extend({
- pluginApiIdentifiers: ["admin-agree-flag-dropdown"],
- classNames: ["agree-flag", "admin-agree-flag-dropdown"],
- adminTools: Ember.inject.service(),
- nameProperty: "label",
- allowInitialValueMutation: false,
- headerIcon: "thumbs-o-up",
-
- computeHeaderContent() {
- let content = this._super(...arguments);
- content.name = `${I18n.t("admin.flags.agree")}...`;
- return content;
- },
-
- @computed("adminTools", "post.user")
- spammerDetails(adminTools, user) {
- return adminTools.spammerDetails(user);
- },
-
- canDeleteSpammer: Ember.computed.and(
- "spammerDetails.canDelete",
- "post.flaggedForSpam"
- ),
-
- computeContent() {
- const content = [];
- const post = this.get("post");
- const canDeleteSpammer = this.get("canDeleteSpammer");
-
- if (post.user_deleted) {
- content.push({
- icon: "far-eye",
- id: "confirm-agree-restore",
- action: () => this.send("perform", "restore"),
- label: I18n.t("admin.flags.agree_flag_restore_post"),
- description: I18n.t("admin.flags.agree_flag_restore_post_title")
- });
- } else {
- if (!post.get("postHidden")) {
- content.push({
- icon: "far-eye-slash",
- action: () => this.send("perform", "hide"),
- id: "confirm-agree-hide",
- label: I18n.t("admin.flags.agree_flag_hide_post"),
- description: I18n.t("admin.flags.agree_flag_hide_post_title")
- });
- }
- }
-
- content.push({
- icon: "thumbs-o-up",
- id: "confirm-agree-keep",
- description: I18n.t("admin.flags.agree_flag_title"),
- action: () => this.send("perform", "keep"),
- label: I18n.t("admin.flags.agree_flag")
- });
-
- content.push({
- icon: "ban",
- id: "confirm-agree-suspend",
- description: I18n.t("admin.flags.agree_flag_suspend_title"),
- action: () => this.send("showSuspendModal"),
- label: I18n.t("admin.flags.agree_flag_suspend")
- });
-
- content.push({
- icon: "microphone-slash",
- id: "confirm-agree-silence",
- description: I18n.t("admin.flags.agree_flag_silence_title"),
- action: () => this.send("showSilenceModal"),
- label: I18n.t("admin.flags.agree_flag_silence")
- });
-
- if (canDeleteSpammer) {
- content.push({
- title: I18n.t("admin.flags.delete_spammer_title"),
- icon: "exclamation-triangle",
- id: "delete-spammer",
- action: () => this.send("deleteSpammer"),
- label: I18n.t("admin.flags.delete_spammer")
- });
- }
-
- return content;
- },
-
- mutateValue(value) {
- const computedContentItem = this.get("computedContent").findBy(
- "value",
- value
- );
- Ember.get(computedContentItem, "originalContent.action")();
- },
-
- actions: {
- deleteSpammer() {
- let spammerDetails = this.get("spammerDetails");
- this.attrs.removeAfter(spammerDetails.deleteUser());
- },
-
- showSuspendModal() {
- let post = this.get("post");
- let user = post.get("user");
- this.get("adminTools").showSuspendModal(user, {
- post,
- before: () => {
- return this.attrs.removeAfter(post.agreeFlags("suspended"));
- }
- });
- },
-
- showSilenceModal() {
- let post = this.get("post");
- let user = post.get("user");
- this.get("adminTools").showSilenceModal(user, {
- post,
- before: () => {
- return this.attrs.removeAfter(post.agreeFlags("silenced"));
- }
- });
- },
-
- perform(action) {
- let flaggedPost = this.get("post");
- this.attrs.removeAfter(flaggedPost.agreeFlags(action));
- }
- }
-});
diff --git a/app/assets/javascripts/select-kit/components/admin-delete-flag-dropdown.js.es6 b/app/assets/javascripts/select-kit/components/admin-delete-flag-dropdown.js.es6
deleted file mode 100644
index 416df62d782..00000000000
--- a/app/assets/javascripts/select-kit/components/admin-delete-flag-dropdown.js.es6
+++ /dev/null
@@ -1,84 +0,0 @@
-import DropdownSelectBox from "select-kit/components/dropdown-select-box";
-import computed from "ember-addons/ember-computed-decorators";
-const { get } = Ember;
-
-export default DropdownSelectBox.extend({
- classNames: ["delete-flag", "admin-delete-flag-dropdown"],
- adminTools: Ember.inject.service(),
- nameProperty: "label",
- headerIcon: "far-trash-alt",
-
- computeHeaderContent() {
- let content = this._super(...arguments);
- content.name = `${I18n.t("admin.flags.delete")}...`;
- return content;
- },
-
- @computed("adminTools", "post.user")
- spammerDetails(adminTools, user) {
- return adminTools.spammerDetails(user);
- },
-
- canDeleteSpammer: Ember.computed.and(
- "spammerDetails.canDelete",
- "post.flaggedForSpam"
- ),
-
- computeContent() {
- const content = [];
- const canDeleteSpammer = this.get("canDeleteSpammer");
-
- content.push({
- icon: "external-link-alt",
- id: "delete-defer",
- action: () => this.send("deletePostDeferFlag"),
- label: I18n.t("admin.flags.delete_post_defer_flag"),
- description: I18n.t("admin.flags.delete_post_defer_flag_title")
- });
-
- content.push({
- icon: "thumbs-o-up",
- id: "delete-agree",
- action: () => this.send("deletePostAgreeFlag"),
- label: I18n.t("admin.flags.delete_post_agree_flag"),
- description: I18n.t("admin.flags.delete_post_agree_flag_title")
- });
-
- if (canDeleteSpammer) {
- content.push({
- title: I18n.t("admin.flags.delete_post_agree_flag_title"),
- icon: "exclamation-triangle",
- id: "delete-spammer",
- action: () => this.send("deleteSpammer"),
- label: I18n.t("admin.flags.delete_spammer")
- });
- }
-
- return content;
- },
-
- mutateValue(value) {
- const computedContentItem = this.get("computedContent").findBy(
- "value",
- value
- );
- get(computedContentItem, "originalContent.action")();
- },
-
- actions: {
- deleteSpammer() {
- let spammerDetails = this.get("spammerDetails");
- this.attrs.removeAfter(spammerDetails.deleteUser());
- },
-
- deletePostDeferFlag() {
- let flaggedPost = this.get("post");
- this.attrs.removeAfter(flaggedPost.deferFlags(true));
- },
-
- deletePostAgreeFlag() {
- let flaggedPost = this.get("post");
- this.attrs.removeAfter(flaggedPost.agreeFlags("delete"));
- }
- }
-});
diff --git a/app/assets/javascripts/select-kit/components/category-chooser.js.es6 b/app/assets/javascripts/select-kit/components/category-chooser.js.es6
index f0ae60f6931..6a3b541fd96 100644
--- a/app/assets/javascripts/select-kit/components/category-chooser.js.es6
+++ b/app/assets/javascripts/select-kit/components/category-chooser.js.es6
@@ -105,6 +105,12 @@ export default ComboBoxComponent.extend({
}
},
+ didClearSelection() {
+ if (this.attrs.onChooseCategory) {
+ this.attrs.onChooseCategory(null);
+ }
+ },
+
computeContent() {
return this.categoriesByScope(this.get("scopedCategoryId"));
},
diff --git a/app/assets/javascripts/select-kit/components/mini-tag-chooser.js.es6 b/app/assets/javascripts/select-kit/components/mini-tag-chooser.js.es6
index eb26c062d67..3be3b65fd1a 100644
--- a/app/assets/javascripts/select-kit/components/mini-tag-chooser.js.es6
+++ b/app/assets/javascripts/select-kit/components/mini-tag-chooser.js.es6
@@ -210,6 +210,7 @@ export default ComboBox.extend(TagsMixin, {
// TODO: FIX buffered-proxy.js to support arrays
this.get("tags").removeObjects(tags);
this.set("tags", this.get("tags").slice(0));
+ this._tagsChanged();
this.set(
"searchDebounce",
@@ -221,9 +222,17 @@ export default ComboBox.extend(TagsMixin, {
this.destroyTags(tags);
},
+ _tagsChanged() {
+ if (this.attrs.onChangeTags) {
+ this.attrs.onChangeTags({ target: { value: this.get("tags") } });
+ }
+ },
+
actions: {
onSelect(tag) {
this.set("tags", makeArray(this.get("tags")).concat(tag));
+ this._tagsChanged();
+
this._prepareSearch(this.get("filter"));
this.autoHighlight();
},
diff --git a/app/assets/javascripts/select-kit/components/select-kit.js.es6 b/app/assets/javascripts/select-kit/components/select-kit.js.es6
index cad55bf463f..aa620ad0245 100644
--- a/app/assets/javascripts/select-kit/components/select-kit.js.es6
+++ b/app/assets/javascripts/select-kit/components/select-kit.js.es6
@@ -401,6 +401,8 @@ export default Ember.Component.extend(
willSelect() {},
didSelect() {},
+ didClearSelection() {},
+
willCreate() {},
didCreate() {},
@@ -461,6 +463,7 @@ export default Ember.Component.extend(
clearSelection() {
this.deselect(this.get("selection"));
this.focusFilterOrHeader();
+ this.didClearSelection();
},
actions: {
diff --git a/app/assets/stylesheets/common.scss b/app/assets/stylesheets/common.scss
index c23f1800d6e..20c8fc58051 100644
--- a/app/assets/stylesheets/common.scss
+++ b/app/assets/stylesheets/common.scss
@@ -5,8 +5,6 @@
@import "common/foundation/mixins";
@import "common/foundation/variables";
@import "common/foundation/spacing";
-@import "common/select-kit/admin-agree-flag-dropdown";
-@import "common/select-kit/admin-delete-flag-dropdown";
@import "common/select-kit/categories-admin-dropdown";
@import "common/select-kit/category-chooser";
@import "common/select-kit/category-drop";
diff --git a/app/assets/stylesheets/common/admin/admin_base.scss b/app/assets/stylesheets/common/admin/admin_base.scss
index def018a7360..d42562f4635 100644
--- a/app/assets/stylesheets/common/admin/admin_base.scss
+++ b/app/assets/stylesheets/common/admin/admin_base.scss
@@ -723,15 +723,6 @@ section.details {
}
}
-#selected-controls {
- background-color: $tertiary-low;
- padding: 8px;
- min-height: 27px;
- position: fixed;
- bottom: 0;
- width: 1075px;
-}
-
.user-controls {
padding: 5px;
clear: both;
@@ -973,7 +964,6 @@ table#user-badges {
@import "common/admin/dashboard_next";
@import "common/admin/settings";
@import "common/admin/users";
-@import "common/admin/moderation_history";
@import "common/admin/suspend";
@import "common/admin/badges";
@import "common/admin/emails";
diff --git a/app/assets/stylesheets/common/admin/flagging.scss b/app/assets/stylesheets/common/admin/flagging.scss
index f1010ddc35f..f630655869b 100644
--- a/app/assets/stylesheets/common/admin/flagging.scss
+++ b/app/assets/stylesheets/common/admin/flagging.scss
@@ -1,3 +1,4 @@
+
.flagged-post.hidden-post {
.flagged-post-excerpt,
.flagged-post-avatar {
@@ -113,25 +114,6 @@
.flag-user-extra {
display: flex;
align-items: center;
-
- .user-flag-percentage {
- display: flex;
- align-items: center;
- margin-left: 0.5em;
-
- .percentage-label {
- margin-right: 0.25em;
- &.agreed {
- color: $success;
- }
- &.disagreed {
- color: $danger;
- }
- &.ignored {
- color: $primary-medium;
- }
- }
- }
}
}
diff --git a/app/assets/stylesheets/common/admin/moderation_history.scss b/app/assets/stylesheets/common/admin/moderation_history.scss
deleted file mode 100644
index e6cc1573292..00000000000
--- a/app/assets/stylesheets/common/admin/moderation_history.scss
+++ /dev/null
@@ -1,30 +0,0 @@
-.moderation-history {
- width: 100%;
- td.date {
- padding-right: 1em;
- }
- td,
- th {
- padding-bottom: 0.5em;
- vertical-align: top;
- }
- .history-item-action {
- .action-details {
- margin: 1em 0;
- color: $primary-medium;
- white-space: pre-wrap;
- line-height: $line-height-small;
- width: 300px;
- }
- }
-
- .history-item-actor {
- a {
- display: flex;
- align-items: center;
- span {
- margin-left: 0.5em;
- }
- }
- }
-}
diff --git a/app/assets/stylesheets/common/base/header.scss b/app/assets/stylesheets/common/base/header.scss
index ae71cd54c43..84342e829e6 100644
--- a/app/assets/stylesheets/common/base/header.scss
+++ b/app/assets/stylesheets/common/base/header.scss
@@ -78,7 +78,7 @@
.drop-down,
.panel-body {
.flagged-posts,
- .queued-posts {
+ .reviewables {
background: $danger;
min-width: 6px;
}
diff --git a/app/assets/stylesheets/common/base/reviewables.scss b/app/assets/stylesheets/common/base/reviewables.scss
new file mode 100644
index 00000000000..0656f122b2c
--- /dev/null
+++ b/app/assets/stylesheets/common/base/reviewables.scss
@@ -0,0 +1,266 @@
+.reviewable {
+ .reviewable-container {
+ display: flex;
+ flex-direction: row;
+
+ .reviewable-list {
+ flex: 1;
+ box-sizing: border-box;
+ }
+
+ .reviewable-filters {
+ width: 250px;
+ height: 100%;
+ box-sizing: border-box;
+ }
+
+ .reviewable-list + .reviewable-filters {
+ margin-left: 1em;
+ }
+ }
+}
+
+.reviewable-user-details {
+ margin: 0.5em 0;
+}
+
+.no-review {
+ margin-top: 1em;
+}
+
+.reviewable-filters {
+ background-color: $primary-very-low;
+ padding: 0.5em 1em 1em 1em;
+ margin-bottom: 1em;
+
+ .reviewable-filter {
+ display: flex;
+ flex-direction: column;
+ margin: 0 0 1em 0;
+
+ .filter-label {
+ margin: 0 0 0.5em 0;
+ }
+
+ .score-filter {
+ margin: 0;
+ width: 100%;
+ }
+
+ .category-chooser {
+ width: 100%;
+ }
+ }
+}
+
+.reviewable-topics {
+ width: 100%;
+
+ tbody {
+ td {
+ padding: 0.5em;
+ }
+ }
+
+ .reviewable-details {
+ display: flex;
+ justify-content: flex-end;
+
+ .btn {
+ display: flex;
+ align-items: center;
+ }
+ }
+}
+
+.reviewable-filters {
+ .topic-filter .btn {
+ display: flex;
+ width: auto;
+ }
+
+ .refresh {
+ height: 1em;
+ display: flex;
+ }
+
+ .score-filter {
+ width: 5em;
+ }
+}
+.user-flag-percentage {
+ display: flex;
+ align-items: center;
+ margin-left: 0.5em;
+
+ .percentage-label {
+ margin-right: 0.25em;
+ &.agreed {
+ color: $success;
+ }
+ &.disagreed {
+ color: $danger;
+ }
+ &.ignored {
+ color: $primary-medium;
+ }
+ }
+ .d-icon {
+ font-size: 0.9em;
+ }
+}
+
+.reviewable-item {
+ margin-bottom: 1em;
+ border-bottom: 1px solid dark-light-choose($primary-low, $secondary-low);
+
+ .topic-statuses {
+ float: none;
+ }
+
+ .reviewable-meta-data {
+ color: dark-light-choose($primary-medium, $secondary-medium);
+ display: flex;
+ width: 100%;
+ margin-bottom: 0.5em;
+ font-size: $font-down-1;
+ align-items: center;
+ .reviewable-type {
+ margin-right: 1em;
+ }
+ .created-at {
+ a {
+ color: dark-light-choose($primary-medium, $secondary-medium);
+ }
+ margin-right: 1em;
+ }
+ .score {
+ margin-right: 1em;
+ }
+ .status {
+ color: dark-light-choose($primary-high, $secondary-high);
+ }
+ }
+
+ .reviewable-contents {
+ display: flex;
+ }
+
+ .reviewable-actions {
+ margin-top: 0.5em;
+ display: flex;
+
+ .reviewable-action,
+ .reviewable-action-dropdown {
+ margin-right: 0.5em;
+
+ &.delete-user {
+ @extend .btn-danger;
+ }
+ }
+ }
+ padding-bottom: 1em;
+}
+
+.reviewable-histories {
+ margin-top: 1em;
+}
+
+.reviewable-scores,
+.reviewable-histories {
+ min-width: 50%;
+
+ .user {
+ display: flex;
+ align-items: center;
+
+ .user-flag-percentage {
+ margin-left: 0.5em;
+ }
+ }
+ > tr > th {
+ text-align: left;
+ }
+ > tr > th,
+ > tr > td {
+ padding: 0.25em;
+ }
+}
+
+.reviewable-conversation {
+ margin: 0.5em 0;
+
+ .reviewable-conversation-post {
+ max-width: $topic-body-width;
+ margin-bottom: 0.5em;
+
+ .username {
+ font-weight: bold;
+ margin-right: 0.25em;
+ }
+ }
+
+ .controls {
+ margin-top: 0.25em;
+ }
+}
+
+.reviewable-queued-post,
+.reviewable-flagged-post {
+ .reviewable-contents {
+ margin-top: 1em;
+ }
+
+ .post-title {
+ background-color: yellow;
+ }
+ .created-by {
+ margin-right: 1em;
+ }
+
+ .post-contents {
+ width: 100%;
+ }
+ .post-topic {
+ font-weight: bold;
+ color: $primary-medium;
+ margin-bottom: 1em;
+ }
+}
+
+.reviewable-item {
+ .post-body {
+ max-width: $topic-body-width;
+ max-height: 300px;
+ overflow-y: auto;
+
+ p,
+ aside {
+ margin: 0 0 1em 0;
+ }
+
+ p {
+ word-break: break-all;
+ }
+ }
+}
+
+.editable-fields {
+ width: 100%;
+ .editable-field {
+ .mini-tag-chooser {
+ margin: 0;
+ }
+
+ .reviewable-input-text {
+ width: 100%;
+ margin-bottom: 0;
+ }
+
+ .reviewable-input-textarea {
+ width: 100%;
+ height: 10em;
+ }
+ margin-bottom: 0.5em;
+ }
+}
diff --git a/app/assets/stylesheets/common/base/topic.scss b/app/assets/stylesheets/common/base/topic.scss
index de3a1759af9..b54bca6097b 100644
--- a/app/assets/stylesheets/common/base/topic.scss
+++ b/app/assets/stylesheets/common/base/topic.scss
@@ -154,11 +154,11 @@ a.badge-category {
}
.has-pending-posts {
+ display: flex;
+ justify-content: space-between;
+
padding: 0.5em;
background-color: $highlight-medium;
- a[href] {
- float: right;
- }
margin-top: 1em;
max-width: 757px;
}
diff --git a/app/assets/stylesheets/common/printer-friendly.scss b/app/assets/stylesheets/common/printer-friendly.scss
index 6efbb961793..38b13c29b1f 100644
--- a/app/assets/stylesheets/common/printer-friendly.scss
+++ b/app/assets/stylesheets/common/printer-friendly.scss
@@ -28,7 +28,6 @@
.edit-topic,
a.reply-to-tab,
a.reply-new,
- div.has-pending-posts,
div.time-gap,
#bottom,
#footer,
diff --git a/app/assets/stylesheets/common/select-kit/admin-agree-flag-dropdown.scss b/app/assets/stylesheets/common/select-kit/admin-agree-flag-dropdown.scss
deleted file mode 100644
index e6a4055c1ef..00000000000
--- a/app/assets/stylesheets/common/select-kit/admin-agree-flag-dropdown.scss
+++ /dev/null
@@ -1,14 +0,0 @@
-.select-kit {
- &.dropdown-select-box {
- &.admin-agree-flag-dropdown {
- .select-kit-body {
- width: 485px;
- max-width: 485px;
- }
- .select-kit-row[data-value="delete-spammer"] .texts .name,
- .select-kit-row[data-value="delete-spammer"] .icons .d-icon {
- color: $danger;
- }
- }
- }
-}
diff --git a/app/assets/stylesheets/common/select-kit/admin-delete-flag-dropdown.scss b/app/assets/stylesheets/common/select-kit/admin-delete-flag-dropdown.scss
deleted file mode 100644
index c76f9e6dd21..00000000000
--- a/app/assets/stylesheets/common/select-kit/admin-delete-flag-dropdown.scss
+++ /dev/null
@@ -1,16 +0,0 @@
-.select-kit {
- &.dropdown-select-box {
- width: auto;
- &.admin-delete-flag-dropdown {
- .dropdown-select-box-header .btn {
- background: $danger;
- color: white;
- }
-
- .select-kit-row[data-value="delete-spammer"] .texts .name,
- .select-kit-row[data-value="delete-spammer"] .icons .d-icon {
- color: $danger;
- }
- }
- }
-}
diff --git a/app/assets/stylesheets/desktop.scss b/app/assets/stylesheets/desktop.scss
index 4e4a7e4cbd6..76012fc9c09 100644
--- a/app/assets/stylesheets/desktop.scss
+++ b/app/assets/stylesheets/desktop.scss
@@ -17,7 +17,6 @@
@import "desktop/upload";
@import "desktop/user";
@import "desktop/history";
-@import "desktop/queued-posts";
@import "desktop/group";
@import "desktop/admin_customize";
diff --git a/app/assets/stylesheets/desktop/queued-posts.scss b/app/assets/stylesheets/desktop/queued-posts.scss
deleted file mode 100644
index 88f600fc8a4..00000000000
--- a/app/assets/stylesheets/desktop/queued-posts.scss
+++ /dev/null
@@ -1,53 +0,0 @@
-.queued-posts {
- .queued-post {
- padding: 1em 0;
-
- .poster {
- width: 70px;
- float: left;
- }
- .post-info {
- display: inline-block;
- float: right;
- font-size: $font-down-1;
- margin-top: 1px;
- span {
- color: dark-light-choose($primary-medium, $secondary-medium);
- }
- }
-
- .cooked {
- width: $topic-body-width;
- float: left;
-
- .d-editor-input {
- width: 98%;
- height: 15em;
- }
- }
-
- .tag-chooser {
- width: 100%;
- margin-bottom: 0.5em;
-
- .select-kit-collection {
- padding: 0;
- }
- }
-
- .queue-controls {
- button {
- float: left;
- margin-right: 0.5em;
- }
- }
- .post-title {
- color: $primary-medium;
- font-weight: bold;
-
- .badge-wrapper {
- margin-left: 1em;
- }
- }
- }
-}
diff --git a/app/assets/stylesheets/mobile.scss b/app/assets/stylesheets/mobile.scss
index 12cc495d606..daff963152e 100644
--- a/app/assets/stylesheets/mobile.scss
+++ b/app/assets/stylesheets/mobile.scss
@@ -29,6 +29,7 @@
@import "mobile/admin_report_table";
@import "mobile/admin_report_counters";
@import "mobile/menu-panel";
+@import "mobile/reviewables";
// Import all component-specific files
@import "mobile/components/*";
diff --git a/app/assets/stylesheets/mobile/reviewables.scss b/app/assets/stylesheets/mobile/reviewables.scss
new file mode 100644
index 00000000000..4d8d074d0d2
--- /dev/null
+++ b/app/assets/stylesheets/mobile/reviewables.scss
@@ -0,0 +1,76 @@
+.reviewable {
+ .reviewable-container {
+ flex-direction: column;
+
+ .reviewable-list {
+ order: 2;
+ width: 100%;
+ }
+
+ .reviewable-filters {
+ order: 1;
+ margin: 0;
+ padding: 0.5em;
+ width: 100%;
+ }
+
+ .reviewable-list + .reviewable-filters {
+ margin: 0 0 0.5em 0;
+ }
+ }
+
+ .reviewable-scores {
+ width: 100%;
+ }
+}
+
+.reviewable-filters {
+ background-color: $primary-very-low;
+ padding: 0.5em 1em 1em 1em;
+ margin-bottom: 1em;
+
+ .reviewable-filters-actions {
+ display: flex;
+ justify-content: space-between;
+ }
+
+ .reviewable-filter {
+ margin: 0 0 0.5em 0;
+
+ .filter-label {
+ margin: 0;
+ }
+ }
+}
+
+.reviewable-contents {
+ .post-body {
+ max-width: 295px;
+
+ p {
+ overflow-x: scroll;
+ }
+ }
+}
+
+.reviewable-actions {
+ .reviewable-action,
+ .reviewable-action-dropdown .dropdown-select-box-header {
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+
+ .d-icon {
+ margin: 0;
+ }
+ }
+
+ .reviewable-action,
+ .reviewable-action-dropdown {
+ flex: 1;
+ }
+
+ .reviewable-action-dropdown:last-of-type {
+ margin-right: 0;
+ }
+}
diff --git a/app/controllers/admin/flags_controller.rb b/app/controllers/admin/flags_controller.rb
index 5df6bcd0f06..75e97015779 100644
--- a/app/controllers/admin/flags_controller.rb
+++ b/app/controllers/admin/flags_controller.rb
@@ -7,8 +7,7 @@ class Admin::FlagsController < Admin::AdminController
end
def index
- # we may get out of sync, fix it here
- PostAction.update_flagged_posts_count
+ Discourse.deprecate("FlagsController#index has been deprecated, please use the Reviewable API instead", since: "2.3.0beta5", drop_from: "2.4")
offset = params[:offset].to_i
per_page = Admin::FlagsController.flags_per_page
@@ -19,47 +18,40 @@ class Admin::FlagsController < Admin::AdminController
user_id: params[:user_id],
offset: offset,
topic_id: params[:topic_id],
- per_page: per_page,
- rest_api: params[:rest_api].present?
+ per_page: per_page
)
- if params[:rest_api]
- meta = {
- types: {
- disposed_by: 'user'
- }
+ meta = {
+ types: {
+ disposed_by: 'user'
}
+ }
- if (total_rows || 0) > (offset + per_page)
- meta[:total_rows_flagged_posts] = total_rows
- meta[:load_more_flagged_posts] = admin_flags_filtered_path(
- filter: params[:filter],
- offset: offset + per_page,
- rest_api: params[:rest_api],
- topic_id: params[:topic_id]
- )
- end
-
- render_json_dump(
- {
- flagged_posts: posts,
- topics: serialize_data(topics, FlaggedTopicSerializer),
- users: serialize_data(users, FlaggedUserSerializer),
- post_actions: post_actions
- },
- rest_serializer: true,
- meta: meta
- )
- else
- render_json_dump(
- posts: posts,
- topics: serialize_data(topics, FlaggedTopicSerializer),
- users: serialize_data(users, FlaggedUserSerializer)
+ next_segment = offset + per_page
+ if (total_rows || 0) > next_segment
+ meta[:total_rows_flagged_posts] = total_rows
+ meta[:load_more_flagged_posts] = admin_flags_filtered_path(
+ filter: params[:filter],
+ offset: next_segment,
+ topic_id: params[:topic_id]
)
end
+
+ render_json_dump(
+ {
+ flagged_posts: posts,
+ topics: serialize_data(topics, FlaggedTopicSerializer),
+ users: serialize_data(users, FlaggedUserSerializer),
+ post_actions: post_actions
+ },
+ rest_serializer: true,
+ meta: meta
+ )
end
def agree
+ Discourse.deprecate("FlagsController#agree has been deprecated, please use the Reviewable API instead", since: "2.3.0beta5", drop_from: "2.4")
+
params.permit(:id, :action_on_post)
post = Post.find(params[:id])
@@ -71,65 +63,70 @@ class Admin::FlagsController < Admin::AdminController
user: current_user
)
- post_action_type = PostAction.post_action_type_for_post(post.id)
-
- if !post_action_type
- render_json_error(
- I18n.t("flags.errors.already_handled"),
- status: 409
- )
- return
- end
+ reviewable = post.reviewable_flag
+ return render_json_error(I18n.t("flags.errors.already_handled"), status: 409) if reviewable.blank?
keep_post = ['silenced', 'suspended', 'keep'].include?(params[:action_on_post])
delete_post = params[:action_on_post] == "delete"
restore_post = params[:action_on_post] == "restore"
if delete_post
- # PostDestroy calls PostAction.agree_flags!
+ # PostDestroy automatically agrees with flags
destroy_post(post)
elsif restore_post
- PostAction.agree_flags!(post, current_user, delete_post)
- PostDestroyer.new(current_user, post).recover
+ reviewable.perform(current_user, :agree_and_restore)
else
- PostAction.agree_flags!(post, current_user, delete_post)
- if !keep_post
- PostAction.hide_post!(post, post_action_type)
- end
+ reviewable.perform(
+ current_user,
+ :agree_and_keep,
+ post_was_deleted: delete_post,
+ hide_post: !keep_post
+ )
end
render body: nil
end
def disagree
+ Discourse.deprecate("FlagsController#disagree has been deprecated, please use the Reviewable API instead", since: "2.3.0beta5", drop_from: "2.4")
params.permit(:id)
post = Post.find(params[:id])
- DiscourseEvent.trigger(
- :before_staff_flag_action,
- type: 'disagree',
- post: post,
- user: current_user
- )
+ if reviewable = post.reviewable_flag
+ DiscourseEvent.trigger(
+ :before_staff_flag_action,
+ type: 'disagree',
+ post: post,
+ user: current_user
+ )
- PostAction.clear_flags!(post, current_user)
+ if post.hidden?
+ reviewable.perform(current_user, :disagree_and_restore)
+ else
+ reviewable.perform(current_user, :disagree)
+ end
+ end
render body: nil
end
def defer
+ Discourse.deprecate("FlagsController#defer has been deprecated, please use the Reviewable API instead", since: "2.3.0beta5", drop_from: "2.4")
+
params.permit(:id, :delete_post)
post = Post.find(params[:id])
- DiscourseEvent.trigger(
- :before_staff_flag_action,
- type: 'defer',
- post: post,
- user: current_user
- )
+ if reviewable = post.reviewable_flag
+ DiscourseEvent.trigger(
+ :before_staff_flag_action,
+ type: 'defer',
+ post: post,
+ user: current_user
+ )
- PostAction.defer_flags!(post, current_user, params[:delete_post])
- destroy_post(post) if params[:delete_post]
+ reviewable.perform(current_user, :ignore, post_was_deleted: params[:delete_post])
+ destroy_post(post) if params[:delete_post]
+ end
render body: nil
end
diff --git a/app/controllers/admin/moderation_history_controller.rb b/app/controllers/admin/moderation_history_controller.rb
deleted file mode 100644
index d5516dd0e05..00000000000
--- a/app/controllers/admin/moderation_history_controller.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-class Admin::ModerationHistoryController < Admin::AdminController
-
- def index
- history_filter = params[:filter]
- raise Discourse::NotFound unless ['post', 'topic'].include?(history_filter)
-
- query = UserHistory.where(
- action: UserHistory.actions.only(
- :delete_user,
- :suspend_user,
- :silence_user,
- :delete_post,
- :delete_topic,
- :post_approved,
- ).values
- )
-
- case history_filter
- when 'post'
- raise Discourse::NotFound if params[:post_id].blank?
- query = query.where(post_id: params[:post_id])
- when 'topic'
- raise Discourse::NotFound if params[:topic_id].blank?
- query = query.where(
- "topic_id = ? OR post_id IN (?)",
- params[:topic_id],
- Post.with_deleted.where(topic_id: params[:topic_id]).pluck(:id)
- )
- end
- query = query.includes(:acting_user)
- query = query.order(:created_at)
-
- render_serialized(
- query,
- UserHistorySerializer,
- root: 'moderation_history',
- rest_serializer: true
- )
- end
-
-end
diff --git a/app/controllers/admin/users_controller.rb b/app/controllers/admin/users_controller.rb
index 98eec91baf2..f231f612302 100644
--- a/app/controllers/admin/users_controller.rb
+++ b/app/controllers/admin/users_controller.rb
@@ -288,15 +288,14 @@ class Admin::UsersController < Admin::AdminController
end
def approve
- guardian.ensure_can_approve!(@user)
- @user.approve(current_user)
+ Discourse.deprecate("AdminUsersController#approve is deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+ Reviewable.bulk_perform_targets(current_user, :approve, 'ReviewableUser', [@user.id])
render body: nil
end
def approve_bulk
- User.where(id: params[:users]).each do |u|
- u.approve(current_user) if guardian.can_approve?(u)
- end
+ Discourse.deprecate("AdminUsersController#approve_bulk is deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+ Reviewable.bulk_perform_targets(current_user, :approve, 'ReviewableUser', params[:users])
render body: nil
end
@@ -366,7 +365,10 @@ class Admin::UsersController < Admin::AdminController
)
end
+ # Kept for backwards compatibility, but is replaced by the Reviewable Queue
def reject_bulk
+ Discourse.deprecate("AdminUsersController#reject_bulk is deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+
success_count = 0
d = UserDestroyer.new(current_user)
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index 007288e7779..6fd9b79daf3 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -600,7 +600,16 @@ class ApplicationController < ActionController::Base
opts = { status: opts } if opts.is_a?(Integer)
opts.fetch(:headers, {}).each { |name, value| headers[name.to_s] = value }
- render json: MultiJson.dump(create_errors_json(obj, opts)), status: opts[:status] || 422
+ render(
+ json: MultiJson.dump(create_errors_json(obj, opts)),
+ status: opts[:status] || status_code(obj)
+ )
+ end
+
+ def status_code(obj)
+ return 403 if obj.try(:forbidden)
+ return 404 if obj.try(:not_found)
+ 422
end
def success_json
@@ -761,7 +770,7 @@ class ApplicationController < ActionController::Base
protected
- def render_post_json(post, add_raw = true)
+ def render_post_json(post, add_raw: true)
post_serializer = PostSerializer.new(post, scope: guardian, root: false)
post_serializer.add_raw = add_raw
diff --git a/app/controllers/post_actions_controller.rb b/app/controllers/post_actions_controller.rb
index 81b30d6345b..e401856584a 100644
--- a/app/controllers/post_actions_controller.rb
+++ b/app/controllers/post_actions_controller.rb
@@ -9,60 +9,52 @@ class PostActionsController < ApplicationController
def create
raise Discourse::NotFound if @post.blank?
- taken = PostAction.counts_for([@post], current_user)[@post.id]
-
- guardian.ensure_post_can_act!(
+ creator = PostActionCreator.new(
+ current_user,
@post,
- PostActionType.types[@post_action_type_id],
- opts: {
- is_warning: params[:is_warning],
- taken_actions: taken
- }
+ @post_action_type_id,
+ is_warning: params[:is_warning],
+ message: params[:message],
+ take_action: params[:take_action] == 'true',
+ flag_topic: params[:flag_topic] == 'true'
)
+ result = creator.perform
- args = {}
- args[:message] = params[:message] if params[:message].present?
- args[:is_warning] = params[:is_warning] if params[:is_warning].present? && guardian.is_staff?
- args[:take_action] = true if guardian.is_staff? && params[:take_action] == 'true'
- args[:flag_topic] = true if params[:flag_topic] == 'true'
-
- begin
- post_action = PostAction.act(current_user, @post, @post_action_type_id, args)
- rescue PostAction::FailedToCreatePost => e
- return render_json_error(e.message)
- end
-
- if post_action.blank? || post_action.errors.present?
- render_json_error(post_action)
+ if result.failed?
+ render_json_error(result)
else
# We need to reload or otherwise we are showing the old values on the front end
@post.reload
if @post_action_type_id == PostActionType.types[:like]
- limiter = post_action.post_action_rate_limiter
+ limiter = result.post_action.post_action_rate_limiter
response.headers['Discourse-Actions-Remaining'] = limiter.remaining.to_s
response.headers['Discourse-Actions-Max'] = limiter.max.to_s
end
- render_post_json(@post, _add_raw = false)
+ render_post_json(@post, add_raw: false)
end
end
def destroy
- post_action = current_user.post_actions.find_by(post_id: params[:id].to_i, post_action_type_id: @post_action_type_id, deleted_at: nil)
- raise Discourse::NotFound if post_action.blank?
+ result = PostActionDestroyer.new(
+ current_user,
+ Post.find_by(id: params[:id].to_i),
+ @post_action_type_id
+ ).perform
- guardian.ensure_can_delete!(post_action)
-
- PostAction.remove_act(current_user, @post, post_action.post_action_type_id)
-
- @post.reload
- render_post_json(@post, _add_raw = false)
+ if result.failed?
+ render_json_error(result)
+ else
+ render_post_json(result.post, add_raw: false)
+ end
end
def defer_flags
guardian.ensure_can_defer_flags!(@post)
- PostAction.defer_flags!(@post, current_user)
+ if reviewable = @post.reviewable_flag
+ reviewable.perform(current_user, :ignore)
+ end
render json: { success: true }
end
diff --git a/app/controllers/posts_controller.rb b/app/controllers/posts_controller.rb
index 8317bb665c8..ce084cc08e9 100644
--- a/app/controllers/posts_controller.rb
+++ b/app/controllers/posts_controller.rb
@@ -1,5 +1,6 @@
require_dependency 'new_post_manager'
require_dependency 'post_creator'
+require_dependency 'post_action_destroyer'
require_dependency 'post_destroyer'
require_dependency 'post_merger'
require_dependency 'distributed_memoizer'
@@ -478,7 +479,8 @@ class PostsController < ApplicationController
def bookmark
if params[:bookmarked] == "true"
post = find_post_from_params
- PostAction.act(current_user, post, PostActionType.types[:bookmark])
+ result = PostActionCreator.create(current_user, post, :bookmark)
+ return render_json_error(result) if result.failed?
else
post_action = PostAction.find_by(post_id: params[:post_id], user_id: current_user.id)
raise Discourse::NotFound unless post_action
@@ -486,7 +488,8 @@ class PostsController < ApplicationController
post = Post.with_deleted.find_by(id: post_action&.post_id)
raise Discourse::NotFound unless post
- PostAction.remove_act(current_user, post, PostActionType.types[:bookmark])
+ result = PostActionDestroyer.destroy(current_user, post, :bookmark)
+ return render_json_error(result) if result.failed?
end
topic_user = TopicUser.get(post.topic, current_user)
diff --git a/app/controllers/queued_posts_controller.rb b/app/controllers/queued_posts_controller.rb
index 6b9dadb7cc7..e2afe3d590c 100644
--- a/app/controllers/queued_posts_controller.rb
+++ b/app/controllers/queued_posts_controller.rb
@@ -5,49 +5,50 @@ class QueuedPostsController < ApplicationController
before_action :ensure_staff
def index
- state = QueuedPost.states[(params[:state] || 'new').to_sym]
- state ||= QueuedPost.states[:new]
+ Discourse.deprecate("QueuedPostController#index is deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
- @queued_posts = QueuedPost.visible.where(state: state).includes(:topic, :user).order(:created_at)
- render_serialized(@queued_posts,
+ status = params[:state] || 'pending'
+ status = 'pending' if status == 'new'
+
+ reviewables = Reviewable.list_for(current_user, status: status.to_sym, type: ReviewableQueuedPost.name)
+ render_serialized(reviewables,
QueuedPostSerializer,
root: :queued_posts,
rest_serializer: true,
refresh_queued_posts: "/queued_posts?status=new")
-
end
def update
- qp = QueuedPost.where(id: params[:id]).first
-
- return render_json_error I18n.t('queue.not_found') if qp.blank?
+ Discourse.deprecate("QueuedPostController#update is deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+ reviewable = Reviewable.find_by(id: params[:id])
+ raise Discourse::NotFound if reviewable.blank?
update_params = params[:queued_post]
- qp.raw = update_params[:raw] if update_params[:raw].present?
- if qp.topic_id.blank? && params[:queued_post][:state].blank?
- qp.post_options['title'] = update_params[:title] if update_params[:title].present?
- qp.post_options['category'] = update_params[:category_id].to_i if update_params[:category_id].present?
- qp.post_options['tags'] = update_params[:tags]
+ reviewable.payload['raw'] = update_params[:raw] if update_params[:raw].present?
+ if reviewable.topic_id.blank? && update_params[:state].blank?
+ reviewable.payload['title'] = update_params[:title] if update_params[:title].present?
+ reviewable.payload['tags'] = update_params[:tags]
+ reviewable.category_id = update_params[:category_id].to_i if update_params[:category_id].present?
end
- qp.save(validate: false)
+ reviewable.save(validate: false)
- state = params[:queued_post][:state]
+ state = update_params[:state]
begin
if state == 'approved'
- qp.approve!(current_user)
+ reviewable.perform(current_user, :approve)
elsif state == 'rejected'
- qp.reject!(current_user)
- if params[:queued_post][:delete_user] == 'true' && guardian.can_delete_user?(qp.user)
- UserDestroyer.new(current_user).destroy(qp.user, user_deletion_opts)
+ reviewable.perform(current_user, :reject)
+ if update_params[:delete_user] == 'true' && guardian.can_delete_user?(reviewable.created_by)
+ UserDestroyer.new(current_user).destroy(reviewable.created_by, user_deletion_opts)
end
end
rescue StandardError => e
return render_json_error e.message
end
- render_serialized(qp, QueuedPostSerializer, root: :queued_posts)
+ render_serialized(reviewable, QueuedPostSerializer, root: :queued_posts)
end
private
diff --git a/app/controllers/reviewables_controller.rb b/app/controllers/reviewables_controller.rb
new file mode 100644
index 00000000000..2a18b64fd47
--- /dev/null
+++ b/app/controllers/reviewables_controller.rb
@@ -0,0 +1,168 @@
+class ReviewablesController < ApplicationController
+ requires_login
+
+ PER_PAGE = 10
+
+ before_action :version_required, only: [:update, :perform]
+
+ def index
+ min_score = params[:min_score].nil? ? SiteSetting.min_score_default_visibility : params[:min_score].to_f
+ offset = params[:offset].to_i
+
+ if params[:type].present?
+ raise Discourse::InvalidParameter.new(:type) unless Reviewable.valid_type?(params[:type])
+ end
+
+ status = (params[:status] || 'pending').to_sym
+ raise Discourse::InvalidParameter.new(:status) unless allowed_statuses.include?(status)
+
+ topic_id = params[:topic_id] ? params[:topic_id].to_i : nil
+ category_id = params[:category_id] ? params[:category_id].to_i : nil
+
+ filters = {
+ status: status,
+ category_id: category_id,
+ topic_id: topic_id,
+ min_score: min_score,
+ username: params[:username],
+ type: params[:type]
+ }
+
+ total_rows = Reviewable.list_for(current_user, filters).count
+ reviewables = Reviewable.list_for(current_user, filters.merge(limit: PER_PAGE, offset: offset)).to_a
+
+ # This is a bit awkward, but ActiveModel serializers doesn't seem to serialize STI. Note `hash`
+ # is mutated by the serializer and contains the side loaded records which must be merged in the end.
+ hash = {}
+ json = {
+ reviewables: reviewables.map! do |r|
+ result = r.serializer.new(r, root: nil, hash: hash, scope: guardian).as_json
+ hash[:bundled_actions].uniq!
+ (hash['actions'] || []).uniq!
+ result
+ end,
+ meta: filters.merge(
+ total_rows_reviewables: total_rows, types: meta_types, reviewable_types: Reviewable.types
+ )
+ }
+ if (offset + PER_PAGE) < total_rows
+ json[:meta][:load_more_reviewables] = review_path(filters.merge(offset: offset + PER_PAGE))
+ end
+ json.merge!(hash)
+
+ render_json_dump(json, rest_serializer: true)
+ end
+
+ def topics
+ topic_ids = Set.new
+
+ stats = {}
+ unique_users = {}
+
+ # topics isn't indexed on `reviewable_score` and doesn't know what the current user can see,
+ # so let's query from the inside out.
+ Reviewable.viewable_by(current_user).pending.each do |r|
+ topic_ids << r.topic_id
+
+ meta = stats[r.topic_id] ||= { count: 0, unique_users: 0 }
+ users = unique_users[r.topic_id] ||= Set.new
+
+ r.reviewable_scores.each do |rs|
+ users << rs.user_id
+ meta[:count] += 1
+ end
+ meta[:unique_users] = users.size
+ end
+
+ topics = Topic.where(id: topic_ids).order('reviewable_score DESC')
+ render_serialized(topics, ReviewableTopicSerializer, root: 'reviewable_topics', stats: stats)
+ end
+
+ def show
+ reviewable = find_reviewable
+
+ render_serialized(
+ reviewable,
+ reviewable.serializer,
+ rest_serializer: true,
+ root: 'reviewable',
+ meta: {
+ types: meta_types
+ }
+ )
+ end
+
+ def update
+ reviewable = find_reviewable
+ editable = reviewable.editable_for(guardian)
+ raise Discourse::InvalidAccess.new unless editable.present?
+
+ # Validate parameters are all editable
+ edit_params = params[:reviewable] || {}
+ edit_params.each do |name, value|
+ if value.is_a?(ActionController::Parameters)
+ value.each do |pay_name, pay_value|
+ raise Discourse::InvalidAccess.new unless editable.has?("#{name}.#{pay_name}")
+ end
+ else
+ raise Discourse::InvalidAccess.new unless editable.has?(name)
+ end
+ end
+
+ begin
+ if reviewable.update_fields(edit_params, current_user, version: params[:version].to_i)
+ result = edit_params.merge(version: reviewable.version)
+ render json: result
+ else
+ render_json_error(reviewable.errors)
+ end
+ rescue Reviewable::UpdateConflict
+ return render_json_error(I18n.t('reviewables.conflict'), status: 409)
+ end
+ end
+
+ def perform
+ args = { version: params[:version].to_i }
+
+ begin
+ result = find_reviewable.perform(current_user, params[:action_id].to_sym, args)
+ rescue Reviewable::InvalidAction => e
+ # Consider InvalidAction an InvalidAccess
+ raise Discourse::InvalidAccess.new(e.message)
+ rescue Reviewable::UpdateConflict
+ return render_json_error(I18n.t('reviewables.conflict'), status: 409)
+ end
+
+ if result.success?
+ render_serialized(result, ReviewablePerformResultSerializer)
+ else
+ render_json_error(result)
+ end
+ end
+
+protected
+
+ def find_reviewable
+ reviewable = Reviewable.viewable_by(current_user).where(id: params[:reviewable_id]).first
+ raise Discourse::NotFound.new if reviewable.blank?
+ reviewable
+ end
+
+ def allowed_statuses
+ @allowed_statuses ||= (%i[reviewed all] + Reviewable.statuses.keys)
+ end
+
+ def version_required
+ if params[:version].blank?
+ render_json_error(I18n.t('reviewables.missing_version'), status: 422)
+ end
+ end
+
+ def meta_types
+ {
+ created_by: 'user',
+ target_created_by: 'user'
+ }
+ end
+
+end
diff --git a/app/controllers/topics_controller.rb b/app/controllers/topics_controller.rb
index f65daef0a18..016e127bf21 100644
--- a/app/controllers/topics_controller.rb
+++ b/app/controllers/topics_controller.rb
@@ -5,6 +5,7 @@ require_dependency 'topics_bulk_action'
require_dependency 'discourse_event'
require_dependency 'rate_limiter'
require_dependency 'topic_publisher'
+require_dependency 'post_action_destroyer'
class TopicsController < ApplicationController
requires_login only: [
@@ -430,7 +431,7 @@ class TopicsController < ApplicationController
.where(user_id: current_user.id)
.where('topic_id = ?', topic.id).each do |pa|
- PostAction.remove_act(current_user, pa.post, PostActionType.types[:bookmark])
+ PostActionDestroyer.destroy(current_user, pa.post, :bookmark)
end
render body: nil
@@ -483,9 +484,8 @@ class TopicsController < ApplicationController
topic = Topic.find(params[:topic_id].to_i)
first_post = topic.ordered_posts.first
- guardian.ensure_can_see!(first_post)
-
- PostAction.act(current_user, first_post, PostActionType.types[:bookmark])
+ result = PostActionCreator.create(current_user, first_post, :bookmark)
+ return render_json_error(result) if result.failed?
render body: nil
end
diff --git a/app/controllers/user_actions_controller.rb b/app/controllers/user_actions_controller.rb
index 2d26bbbf34d..a66528dcee2 100644
--- a/app/controllers/user_actions_controller.rb
+++ b/app/controllers/user_actions_controller.rb
@@ -22,15 +22,7 @@ class UserActionsController < ApplicationController
acting_username: params[:acting_username]
}
- # Pending is restricted
- stream = if opts[:action_types].include?(UserAction::PENDING)
- guardian.ensure_can_see_notifications!(user)
- UserAction.stream_queued(opts)
- else
- UserAction.stream(opts)
- end
-
- stream = stream.to_a
+ stream = UserAction.stream(opts).to_a
if stream.length == 0 && (help_key = params['no_results_help_key'])
if user.id == guardian.user.try(:id)
help_key += ".self"
diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index d55d07a99b3..012dc86983b 100644
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -354,10 +354,7 @@ class UsersController < ApplicationController
user = User.new(new_user_params) if user.nil?
# Handle API approval
- if user.approved
- user.approved_by_id ||= current_user.id
- user.approved_at ||= Time.zone.now
- end
+ ReviewableUser.set_approved_fields!(user, current_user) if user.approved?
# Handle custom fields
user_fields = UserField.all
diff --git a/app/jobs/base.rb b/app/jobs/base.rb
index b57abae3e20..a5df165a0af 100644
--- a/app/jobs/base.rb
+++ b/app/jobs/base.rb
@@ -305,7 +305,6 @@ module Jobs
end
klass.client_push(hash)
-
else
# Otherwise execute the job right away
opts.delete(:delay_for)
diff --git a/app/jobs/regular/notify_reviewable.rb b/app/jobs/regular/notify_reviewable.rb
new file mode 100644
index 00000000000..734121a5e10
--- /dev/null
+++ b/app/jobs/regular/notify_reviewable.rb
@@ -0,0 +1,52 @@
+class Jobs::NotifyReviewable < Jobs::Base
+
+ def execute(args)
+ reviewable = Reviewable.find_by(id: args[:reviewable_id])
+ return unless reviewable.present?
+
+ @contacted = Set.new
+
+ notify_admins
+ notify_moderators if reviewable.reviewable_by_moderator?
+ notify_group(reviewable.reviewable_by_group) if reviewable.reviewable_by_group.present?
+ end
+
+protected
+
+ def users
+ return User if @contacted.blank?
+ User.where("id NOT IN (?)", @contacted)
+ end
+
+ def pending
+ Reviewable.default_visible.pending
+ end
+
+ def notify_admins
+ notify(pending.count, users.admins.pluck(:id))
+ end
+
+ def notify_moderators
+ user_ids = users.moderators.pluck(:id)
+ notify(pending.where(reviewable_by_moderator: true).count, user_ids)
+ end
+
+ def notify_group(group)
+ @group_counts = {}
+ group.users.includes(:group_users).where("users.id NOT IN (?)", @contacted).each do |u|
+ reviewable_count = u.group_users.map { |gu| count_for_group(gu.group_id) }.sum
+ MessageBus.publish("/reviewable_counts", { reviewable_count: reviewable_count }, user_ids: [u.id])
+ end
+ end
+
+ def count_for_group(group_id)
+ @group_counts[group_id] ||= pending.where(reviewable_by_group_id: group_id).count
+ end
+
+ def notify(count, user_ids)
+ data = { reviewable_count: count }
+ MessageBus.publish("/reviewable_counts", data, user_ids: user_ids)
+ @contacted += user_ids
+ end
+
+end
diff --git a/app/jobs/regular/process_post.rb b/app/jobs/regular/process_post.rb
index ef06ea52dc2..d6b3afa4d27 100644
--- a/app/jobs/regular/process_post.rb
+++ b/app/jobs/regular/process_post.rb
@@ -42,7 +42,7 @@ module Jobs
s = post.cooked
s << " #{post.topic.title}" if post.post_number == 1
if !args[:bypass_bump] && WordWatcher.new(s).should_flag?
- PostAction.act(Discourse.system_user, post, PostActionType.types[:inappropriate]) rescue PostAction::AlreadyActed
+ PostActionCreator.create(Discourse.system_user, post, :inappropriate)
end
end
end
diff --git a/app/jobs/regular/toggle_topic_closed.rb b/app/jobs/regular/toggle_topic_closed.rb
index 99a446af106..bb3412fc2d6 100644
--- a/app/jobs/regular/toggle_topic_closed.rb
+++ b/app/jobs/regular/toggle_topic_closed.rb
@@ -15,7 +15,7 @@ module Jobs
user = topic_timer.user
if Guardian.new(user).can_close?(topic)
- if state == false && PostAction.auto_close_threshold_reached?(topic)
+ if state == false && topic.auto_close_threshold_reached?
topic.set_or_create_timer(
TopicTimer.types[:open],
SiteSetting.num_hours_to_close_topic,
diff --git a/app/jobs/regular/topic_action_converter.rb b/app/jobs/regular/topic_action_converter.rb
new file mode 100644
index 00000000000..eb7a43ab1be
--- /dev/null
+++ b/app/jobs/regular/topic_action_converter.rb
@@ -0,0 +1,18 @@
+class Jobs::TopicActionConverter < Jobs::Base
+
+ # Re-creating all the user actions could be very slow, so let's do it in a job
+ # to avoid a N+1 query on a front facing operation.
+ def execute(args)
+ topic = Topic.find_by(id: args[:topic_id])
+ return if topic.blank?
+
+ UserAction.where(
+ target_topic_id: topic.id,
+ action_type: [UserAction::GOT_PRIVATE_MESSAGE, UserAction::NEW_PRIVATE_MESSAGE]).find_each do |ua|
+ UserAction.remove_action!(ua.attributes.symbolize_keys.slice(:action_type, :user_id, :acting_user_id, :target_topic_id, :target_post_id))
+ end
+ topic.posts.each { |post| UserActionManager.post_created(post) }
+ UserActionManager.topic_created(topic)
+ end
+
+end
diff --git a/app/jobs/regular/truncate_user_flag_stats.rb b/app/jobs/regular/truncate_user_flag_stats.rb
new file mode 100644
index 00000000000..9de009a7524
--- /dev/null
+++ b/app/jobs/regular/truncate_user_flag_stats.rb
@@ -0,0 +1,48 @@
+class Jobs::TruncateUserFlagStats < Jobs::Base
+
+ def self.truncate_to
+ 100
+ end
+
+ # To give users a chance to improve, we limit their flag stats to the last N flags
+ def execute(args)
+ raise Discourse::InvalidParameters.new(:user_ids) unless args[:user_ids].present?
+
+ args[:user_ids].each do |u|
+ user_stat = UserStat.find_by(user_id: u)
+ next if user_stat.blank?
+
+ total = user_stat.flags_agreed + user_stat.flags_disagreed + user_stat.flags_ignored
+ next if total < self.class.truncate_to
+
+ params = ReviewableScore.statuses.slice(:agreed, :disagreed, :ignored).
+ merge(user_id: u, truncate_to: self.class.truncate_to)
+
+ result = DB.query(<<~SQL, params)
+ SELECT SUM(CASE WHEN x.status = :agreed THEN 1 ELSE 0 END) AS agreed,
+ SUM(CASE WHEN x.status = :disagreed THEN 1 ELSE 0 END) AS disagreed,
+ SUM(CASE WHEN x.status = :ignored THEN 1 ELSE 0 END) AS ignored
+ FROM (
+ SELECT rs.status
+ FROM reviewable_scores AS rs
+ INNER JOIN reviewables AS r ON r.id = rs.reviewable_id
+ INNER JOIN posts AS p ON p.id = r.target_id
+ WHERE rs.user_id = :user_id
+ AND r.type = 'ReviewableFlaggedPost'
+ AND rs.status IN (:agreed, :disagreed, :ignored)
+ AND rs.user_id <> p.user_id
+ ORDER BY rs.created_at DESC
+ LIMIT :truncate_to
+ ) AS x
+ SQL
+
+ user_stat.update_columns(
+ flags_agreed: result[0].agreed || 0,
+ flags_disagreed: result[0].disagreed || 0,
+ flags_ignored: result[0].ignored || 0,
+ )
+ end
+
+ end
+
+end
diff --git a/app/jobs/scheduled/auto_queue_handler.rb b/app/jobs/scheduled/auto_queue_handler.rb
index 6e201b06cec..ff7d6ea8536 100644
--- a/app/jobs/scheduled/auto_queue_handler.rb
+++ b/app/jobs/scheduled/auto_queue_handler.rb
@@ -8,23 +8,16 @@ module Jobs
def execute(args)
return unless SiteSetting.auto_handle_queued_age.to_i > 0
- guardian = Guardian.new(Discourse.system_user)
-
- # Flags
- flags = FlagQuery.flagged_post_actions(filter: 'active')
- .where('post_actions.created_at < ?', SiteSetting.auto_handle_queued_age.to_i.days.ago)
-
- Post.where(id: flags.pluck(:post_id).uniq).each do |post|
- PostAction.defer_flags!(post, Discourse.system_user)
- end
-
- # Posts
- queued_posts = QueuedPost.visible
- .where(state: QueuedPost.states[:new])
+ Reviewable
+ .where(status: Reviewable.statuses[:pending])
.where('created_at < ?', SiteSetting.auto_handle_queued_age.to_i.days.ago)
+ .each do |reviewable|
- queued_posts.each do |queued_post|
- queued_post.reject!(Discourse.system_user)
+ if reviewable.is_a?(ReviewableFlaggedPost)
+ reviewable.perform(Discourse.system_user, :ignore)
+ else
+ reviewable.perform(Discourse.system_user, :reject)
+ end
end
end
end
diff --git a/app/jobs/scheduled/clean_up_uploads.rb b/app/jobs/scheduled/clean_up_uploads.rb
index 2043c43bccf..b002f040c50 100644
--- a/app/jobs/scheduled/clean_up_uploads.rb
+++ b/app/jobs/scheduled/clean_up_uploads.rb
@@ -76,7 +76,7 @@ module Jobs
result.find_each do |upload|
if upload.sha1.present?
encoded_sha = Base62.encode(upload.sha1.hex)
- next if QueuedPost.where("raw LIKE '%#{upload.sha1}%' OR raw LIKE '%#{encoded_sha}%'").exists?
+ next if ReviewableQueuedPost.where("payload->>'raw' LIKE '%#{upload.sha1}%' OR payload->>'raw' LIKE '%#{encoded_sha}%'").exists?
next if Draft.where("data LIKE '%#{upload.sha1}%' OR data LIKE '%#{encoded_sha}%'").exists?
upload.destroy
else
diff --git a/app/jobs/scheduled/pending_flags_reminder.rb b/app/jobs/scheduled/pending_flags_reminder.rb
index 4910b6a4b04..da38e2bc2e6 100644
--- a/app/jobs/scheduled/pending_flags_reminder.rb
+++ b/app/jobs/scheduled/pending_flags_reminder.rb
@@ -3,60 +3,53 @@ require_dependency 'flag_query'
module Jobs
class PendingFlagsReminder < Jobs::Scheduled
-
every 1.hour
+ attr_reader :sent_reminder
+
def execute(args)
+ @sent_reminder = false
+
if SiteSetting.notify_about_flags_after > 0
- flagged_posts_count = PostAction.flagged_posts_count
- return unless flagged_posts_count > 0
-
- flag_ids = pending_flag_ids
- if flag_ids.size > 0 && last_notified_id.to_i < flag_ids.max
+ reviewable_ids = Reviewable
+ .pending
+ .default_visible
+ .where('latest_score < ?', SiteSetting.notify_about_flags_after.to_i.hours.ago)
+ .order('id DESC')
+ .pluck(:id)
+ if reviewable_ids.size > 0 && self.class.last_notified_id < reviewable_ids[0]
usernames = active_moderator_usernames
mentions = usernames.size > 0 ? "@#{usernames.join(', @')} " : ""
- PostCreator.create(
+ @sent_reminder = PostCreator.create(
Discourse.system_user,
target_group_names: Group[:moderators].name,
archetype: Archetype.private_message,
subtype: TopicSubtype.system_message,
- title: I18n.t('flags_reminder.subject_template', count: flagged_posts_count),
+ title: I18n.t('flags_reminder.subject_template', count: reviewable_ids.size),
raw: mentions + I18n.t('flags_reminder.flags_were_submitted', count: SiteSetting.notify_about_flags_after, base_path: Discourse.base_path)
- )
+ ).present?
- self.last_notified_id = flag_ids.max
+ self.class.last_notified_id = reviewable_ids[0]
end
end
end
- def pending_flag_ids
- by_post = {}
-
- FlagQuery.flagged_post_actions(filter: 'active')
- .where('post_actions.created_at < ?', SiteSetting.notify_about_flags_after.to_i.hours.ago)
- .pluck(:post_id, :id)
- .each do |row|
-
- by_post[row[0]] ||= []
- by_post[row[0]] << row[1]
- end
-
- by_post.delete_if { |post_id, flags| flags.size < SiteSetting.min_flags_staff_visibility }
- by_post.values.flatten.uniq
+ def self.last_notified_id
+ $redis.get(last_notified_key).to_i
end
- def last_notified_id
- $redis.get(self.class.last_notified_key)&.to_i
- end
-
- def last_notified_id=(arg)
- $redis.set(self.class.last_notified_key, arg)
+ def self.last_notified_id=(arg)
+ $redis.set(last_notified_key, arg)
end
def self.last_notified_key
- "last_notified_pending_flag_id".freeze
+ "last_notified_reviewable_id".freeze
+ end
+
+ def self.clear_key
+ $redis.del(last_notified_key)
end
def active_moderator_usernames
diff --git a/app/jobs/scheduled/pending_queued_posts_reminder.rb b/app/jobs/scheduled/pending_queued_posts_reminder.rb
index 867918dcef4..01e2156b50a 100644
--- a/app/jobs/scheduled/pending_queued_posts_reminder.rb
+++ b/app/jobs/scheduled/pending_queued_posts_reminder.rb
@@ -25,7 +25,9 @@ module Jobs
end
def should_notify_ids
- QueuedPost.new_posts.visible.where('created_at < ?', SiteSetting.notify_about_queued_posts_after.hours.ago).pluck(:id)
+ ReviewableQueuedPost.where(status: Reviewable.statuses[:pending]).where(
+ 'created_at < ?', SiteSetting.notify_about_queued_posts_after.hours.ago
+ ).pluck(:id)
end
def last_notified_id
diff --git a/app/models/ignored_user.rb b/app/models/ignored_user.rb
index 34c6bdc995b..58853f8c63b 100644
--- a/app/models/ignored_user.rb
+++ b/app/models/ignored_user.rb
@@ -7,11 +7,11 @@ end
#
# Table name: ignored_users
#
-# id :integer not null, primary key
-# user_id :integer not null
+# id :bigint(8) not null, primary key
+# user_id :integer not null
# ignored_user_id :integer not null
-# created_at :datetime not null
-# updated_at :datetime not null
+# created_at :datetime not null
+# updated_at :datetime not null
#
# Indexes
#
diff --git a/app/models/invite.rb b/app/models/invite.rb
index 6e022424381..e845247d615 100644
--- a/app/models/invite.rb
+++ b/app/models/invite.rb
@@ -209,9 +209,7 @@ class Invite < ActiveRecord::Base
def self.redeem_from_email(email)
invite = Invite.find_by(email: Email.downcase(email))
- if invite
- InviteRedeemer.new(invite).redeem
- end
+ InviteRedeemer.new(invite).redeem if invite
invite
end
diff --git a/app/models/invite_redeemer.rb b/app/models/invite_redeemer.rb
index 2f63d50805e..23a6f01a5e0 100644
--- a/app/models/invite_redeemer.rb
+++ b/app/models/invite_redeemer.rb
@@ -32,9 +32,7 @@ InviteRedeemer = Struct.new(:invite, :username, :name, :password, :user_custom_f
user = User.new(user_params) if user.nil?
if !SiteSetting.must_approve_users? || (SiteSetting.must_approve_users? && invite.invited_by.staff?)
- user.approved = true
- user.approved_by_id = invite.invited_by_id
- user.approved_at = Time.zone.now
+ ReviewableUser.set_approved_fields!(user, invite.invited_by)
end
user_fields = UserField.all
@@ -132,8 +130,13 @@ InviteRedeemer = Struct.new(:invite, :username, :name, :password, :user_custom_f
end
def approve_account_if_needed
- if get_existing_user
- invited_user.approve(invite.invited_by, false)
+ if invited_user.present? && reviewable_user = ReviewableUser.find_by(target: invited_user)
+ reviewable_user.perform(
+ invite.invited_by,
+ :approve,
+ send_email: false,
+ approved_by_invite: true
+ )
end
end
diff --git a/app/models/post.rb b/app/models/post.rb
index 8e03538f527..c7382046567 100644
--- a/app/models/post.rb
+++ b/app/models/post.rb
@@ -55,7 +55,6 @@ class Post < ActiveRecord::Base
validates_with ::Validators::PostValidator, unless: :skip_validation
after_save :index_search
- after_save :create_user_action
# We can pass several creating options to a post via attributes
attr_accessor :image_sizes, :quoted_post_numbers, :no_bump, :invalidate_oneboxes, :cooking_options, :skip_unique_check, :skip_validation
@@ -194,7 +193,6 @@ class Post < ActiveRecord::Base
def recover!
super
- update_flagged_posts_count
recover_public_post_actions
TopicLink.extract_from(self)
QuotedPost.extract_from(self)
@@ -378,10 +376,6 @@ class Post < ActiveRecord::Base
])
end
- def update_flagged_posts_count
- PostAction.update_flagged_posts_count
- end
-
def delete_post_notices
self.custom_fields.delete("post_notice_type")
self.custom_fields.delete("post_notice_time")
@@ -462,8 +456,49 @@ class Post < ActiveRecord::Base
post_actions.active.where(post_action_type_id: PostActionType.flag_types_without_custom.values)
end
- def has_active_flag?
- active_flags.count != 0
+ def reviewable_flag
+ ReviewableFlaggedPost.pending.find_by(target: self)
+ end
+
+ def hide!(post_action_type_id, reason = nil)
+ return if hidden?
+
+ reason ||= hidden_at ?
+ Post.hidden_reasons[:flag_threshold_reached_again] :
+ Post.hidden_reasons[:flag_threshold_reached]
+
+ hiding_again = hidden_at.present?
+
+ self.hidden = true
+ self.hidden_at = Time.zone.now
+ self.hidden_reason_id = reason
+ save!
+
+ Topic.where(
+ "id = :topic_id AND NOT EXISTS(SELECT 1 FROM POSTS WHERE topic_id = :topic_id AND NOT hidden)",
+ topic_id: topic_id
+ ).update_all(visible: false)
+
+ # inform user
+ if user.present?
+ options = {
+ url: url,
+ edit_delay: SiteSetting.cooldown_minutes_after_hiding_posts,
+ flag_reason: I18n.t(
+ "flag_reasons.#{PostActionType.types[post_action_type_id]}",
+ locale: SiteSetting.default_locale,
+ base_path: Discourse.base_path
+ )
+ }
+
+ Jobs.enqueue_in(
+ 5.seconds,
+ :send_system_message,
+ user_id: user.id,
+ message_type: hiding_again ? :post_hidden_again : :post_hidden,
+ message_options: options
+ )
+ end
end
def unhide!
@@ -826,10 +861,6 @@ class Post < ActiveRecord::Base
SearchIndexer.index(self)
end
- def create_user_action
- UserActionCreator.log_post(self)
- end
-
def locked?
locked_by_id.present?
end
diff --git a/app/models/post_action.rb b/app/models/post_action.rb
index c814f55efea..343964b8997 100644
--- a/app/models/post_action.rb
+++ b/app/models/post_action.rb
@@ -1,10 +1,9 @@
require_dependency 'rate_limiter'
require_dependency 'system_message'
+require_dependency 'post_action_creator'
+require_dependency 'post_action_destroyer'
class PostAction < ActiveRecord::Base
- class AlreadyActed < StandardError; end
- class FailedToCreatePost < StandardError; end
-
include RateLimiter::OnCreateRecord
include Trashable
@@ -22,79 +21,7 @@ class PostAction < ActiveRecord::Base
scope :active, -> { where(disagreed_at: nil, deferred_at: nil, agreed_at: nil, deleted_at: nil) }
after_save :update_counters
- after_save :enforce_rules
- after_save :create_user_action
- after_save :update_notifications
- after_create :create_notifications
- after_commit :notify_subscribers
-
- def disposed_by_id
- disagreed_by_id || agreed_by_id || deferred_by_id
- end
-
- def disposed_at
- disagreed_at || agreed_at || deferred_at
- end
-
- def disposition
- return :disagreed if disagreed_at
- return :agreed if agreed_at
- return :deferred if deferred_at
- nil
- end
-
- def self.flag_count_by_date(start_date, end_date, category_id = nil)
- result = where('post_actions.created_at >= ? AND post_actions.created_at <= ?', start_date, end_date)
- result = result.where(post_action_type_id: PostActionType.flag_types_without_custom.values)
- result = result.joins(post: :topic).where("topics.category_id = ?", category_id) if category_id
- result.group('date(post_actions.created_at)')
- .order('date(post_actions.created_at)')
- .count
- end
-
- # Forums can choose to apply a minimum number of flags required before it shows up in
- # the admin interface. One exception is posts hidden by tl3/tl4 - we want those to
- # show up even if the minimum visibility is not met.
- def self.apply_minimum_visibility(relation)
- return relation unless SiteSetting.min_flags_staff_visibility > 1
-
- params = {
- min_flags: SiteSetting.min_flags_staff_visibility,
- hidden_reasons: Post.hidden_reasons.only(:flagged_by_tl3_user, :flagged_by_tl4_user).values
- }
-
- relation.having(<<~SQL, params)
- (COUNT(*) >= :min_flags) OR
- (SUM(CASE
- WHEN posts.hidden_reason_id IN (:hidden_reasons) THEN 1
- ELSE 0
- END) > 0)
- SQL
- end
-
- def self.update_flagged_posts_count
- flagged_relation = PostAction.active
- .flags
- .joins(post: :topic)
- .where('posts.deleted_at' => nil)
- .where('topics.deleted_at' => nil)
- .where('posts.user_id > 0')
- .group("posts.id")
-
- flagged_relation = apply_minimum_visibility(flagged_relation)
-
- posts_flagged_count = flagged_relation
- .pluck("posts.id")
- .count
-
- $redis.set('posts_flagged_count', posts_flagged_count)
- user_ids = User.staff.pluck(:id)
- MessageBus.publish('/flagged_counts', { total: posts_flagged_count }, user_ids: user_ids)
- end
-
- def self.flagged_posts_count
- $redis.get('posts_flagged_count').to_i
- end
+ validate :ensure_unique_actions, on: :create
def self.counts_for(collection, user)
return {} if collection.blank? || !user
@@ -138,23 +65,6 @@ class PostAction < ActiveRecord::Base
map
end
- def self.active_flags_counts_for(collection)
- return {} if collection.blank?
-
- collection_ids = collection.map(&:id)
-
- post_actions = PostAction.active.flags.where(post_id: collection_ids)
-
- user_actions = {}
- post_actions.each do |post_action|
- user_actions[post_action.post_id] ||= {}
- user_actions[post_action.post_id][post_action.post_action_type_id] ||= []
- user_actions[post_action.post_id][post_action.post_action_type_id] << post_action
- end
-
- user_actions
- end
-
def self.count_per_day_for_type(post_action_type, opts = nil)
opts ||= {}
result = unscoped.where(post_action_type_id: post_action_type)
@@ -166,96 +76,6 @@ class PostAction < ActiveRecord::Base
.count
end
- def self.agree_flags!(post, moderator, delete_post = false)
- actions = PostAction.active
- .where(post_id: post.id)
- .where(post_action_type_id: PostActionType.notify_flag_types.values)
-
- trigger_spam = false
- actions.each do |action|
- action.agreed_at = Time.zone.now
- action.agreed_by_id = moderator.id
- # so callback is called
- action.save
- action.add_moderator_post_if_needed(moderator, :agreed, delete_post)
- trigger_spam = true if action.post_action_type_id == PostActionType.types[:spam]
- end
-
- # Update the flags_agreed user stat
- UserStat.where(user_id: actions.map(&:user_id)).update_all("flags_agreed = flags_agreed + 1")
-
- DiscourseEvent.trigger(:confirmed_spam_post, post) if trigger_spam
-
- if actions.first.present?
- DiscourseEvent.trigger(:flag_reviewed, post)
- DiscourseEvent.trigger(:flag_agreed, actions.first)
- end
-
- update_flagged_posts_count
- end
-
- def self.clear_flags!(post, moderator)
- # -1 is the automatic system cleary
- action_type_ids =
- if moderator.id == Discourse::SYSTEM_USER_ID
- PostActionType.auto_action_flag_types.values
- else
- PostActionType.notify_flag_type_ids
- end
-
- actions = PostAction.active.where(post_id: post.id).where(post_action_type_id: action_type_ids)
-
- actions.each do |action|
- action.disagreed_at = Time.zone.now
- action.disagreed_by_id = moderator.id
- # so callback is called
- action.save
- action.add_moderator_post_if_needed(moderator, :disagreed)
- end
-
- # Update the flags_disagreed user stat
- UserStat.where(user_id: actions.map(&:user_id)).update_all("flags_disagreed = flags_disagreed + 1")
-
- # reset all cached counters
- cached = {}
- action_type_ids.each do |atid|
- column = "#{PostActionType.types[atid]}_count"
- cached[column] = 0 if ActiveRecord::Base.connection.column_exists?(:posts, column)
- end
-
- Post.with_deleted.where(id: post.id).update_all(cached)
-
- if actions.first.present?
- DiscourseEvent.trigger(:flag_reviewed, post)
- DiscourseEvent.trigger(:flag_disagreed, actions.first)
- end
-
- update_flagged_posts_count
-
- undo_hide_and_silence(post)
- end
-
- def self.defer_flags!(post, moderator, delete_post = false)
- actions = PostAction.active
- .where(post_id: post.id)
- .where(post_action_type_id: PostActionType.notify_flag_type_ids)
-
- actions.each do |action|
- action.deferred_at = Time.zone.now
- action.deferred_by_id = moderator.id
- # so callback is called
- action.save
- action.add_moderator_post_if_needed(moderator, :deferred, delete_post)
- end
-
- if actions.first.present?
- DiscourseEvent.trigger(:flag_reviewed, post)
- DiscourseEvent.trigger(:flag_deferred, actions.first)
- end
-
- update_flagged_posts_count
- end
-
def add_moderator_post_if_needed(moderator, disposition, delete_post = false)
return if !SiteSetting.auto_respond_to_flag_actions
return if related_post.nil? || related_post.topic.nil?
@@ -272,116 +92,21 @@ class PostAction < ActiveRecord::Base
topic.posts.where("user_id IN (SELECT id FROM users WHERE moderator OR admin) OR (post_type != :regular_post_type)", regular_post_type: Post.types[:regular]).exists?
end
- def self.create_message_for_post_action(user, post, post_action_type_id, opts)
- post_action_type = PostActionType.types[post_action_type_id]
-
- return unless opts[:message] && [:notify_moderators, :notify_user, :spam].include?(post_action_type)
-
- title = I18n.t("post_action_types.#{post_action_type}.email_title", title: post.topic.title, locale: SiteSetting.default_locale)
- body = I18n.t("post_action_types.#{post_action_type}.email_body", message: opts[:message], link: "#{Discourse.base_url}#{post.url}", locale: SiteSetting.default_locale)
- warning = opts[:is_warning] if opts[:is_warning].present?
- title = title.truncate(SiteSetting.max_topic_title_length, separator: /\s/)
-
- opts = {
- archetype: Archetype.private_message,
- is_warning: warning,
- title: title,
- raw: body
- }
-
- if [:notify_moderators, :spam].include?(post_action_type)
- opts[:subtype] = TopicSubtype.notify_moderators
- opts[:target_group_names] = target_moderators
- else
- opts[:subtype] = TopicSubtype.notify_user
-
- opts[:target_usernames] =
- if post_action_type == :notify_user
- post.user.username
- elsif post_action_type != :notify_moderators
- # this is a hack to allow a PM with no recipients, we should think through
- # a cleaner technique, a PM with myself is valid for flagging
- 'x'
- end
- end
-
- PostCreator.new(user, opts).create!&.id
- end
-
def self.limit_action!(user, post, post_action_type_id)
RateLimiter.new(user, "post_action-#{post.id}_#{post_action_type_id}", 4, 1.minute).performed!
end
- def self.act(user, post, post_action_type_id, opts = {})
- limit_action!(user, post, post_action_type_id)
+ def self.act(created_by, post, post_action_type_id, opts = {})
+ Discourse.deprecate("PostAction.act is deprecated. Use `PostActionCreator` instead.", output_in_test: true)
- begin
- related_post_id = create_message_for_post_action(user, post, post_action_type_id, opts)
- rescue ActiveRecord::RecordNotSaved => e
- raise FailedToCreatePost.new(e.message)
- end
+ result = PostActionCreator.new(
+ created_by,
+ post,
+ post_action_type_id,
+ message: opts[:message]
+ ).perform
- staff_took_action = opts[:take_action] || false
-
- targets_topic =
- if opts[:flag_topic] && post.topic
- post.topic.reload.posts_count != 1
- end
-
- where_attrs = {
- post_id: post.id,
- user_id: user.id,
- post_action_type_id: post_action_type_id
- }
-
- action_attrs = {
- staff_took_action: staff_took_action,
- related_post_id: related_post_id,
- targets_topic: !!targets_topic
- }
-
- # First try to revive a trashed record
- post_action = PostAction.where(where_attrs)
- .with_deleted
- .where("deleted_at IS NOT NULL")
- .first
-
- if post_action
- post_action.recover!
- action_attrs.each { |attr, val| post_action.send("#{attr}=", val) }
- post_action.save
- PostActionNotifier.post_action_created(post_action)
- else
- post_action = create(where_attrs.merge(action_attrs))
- if post_action && post_action.errors.count == 0
- BadgeGranter.queue_badge_grant(Badge::Trigger::PostAction, post_action: post_action)
- end
- end
-
- if post_action && PostActionType.notify_flag_type_ids.include?(post_action_type_id)
- DiscourseEvent.trigger(:flag_created, post_action)
- end
-
- GivenDailyLike.increment_for(user.id) if post_action_type_id == PostActionType.types[:like]
-
- # agree with other flags
- if staff_took_action
- PostAction.agree_flags!(post, user)
- post_action.try(:update_counters)
- end
-
- post_action
- rescue ActiveRecord::RecordNotUnique
- # can happen despite being .create
- # since already bookmarked
- PostAction.where(where_attrs).first
- end
-
- def self.undo_hide_and_silence(post)
- return unless post.hidden?
-
- post.unhide!
- UserSilencer.unsilence(post.user) if UserSilencer.was_silenced_for?(post)
+ result.success? ? result.post_action : nil
end
def self.copy(original_post, target_post)
@@ -398,16 +123,12 @@ class PostAction < ActiveRecord::Base
end
def self.remove_act(user, post, post_action_type_id)
+ Discourse.deprecate(
+ "PostAction.remove_act is deprecated. Use `PostActionDestroyer` instead.",
+ output_in_test: true
+ )
- limit_action!(user, post, post_action_type_id)
-
- finder = PostAction.where(post_id: post.id, user_id: user.id, post_action_type_id: post_action_type_id)
- finder = finder.with_deleted.includes(:post) if user.try(:staff?)
- if action = finder.first
- action.remove_act!(user)
- action.post.unhide! if action.staff_took_action
- GivenDailyLike.decrement_for(user.id) if post_action_type_id == PostActionType.types[:like]
- end
+ PostActionDestroyer.new(user, post, post_action_type_id).perform
end
def remove_act!(user)
@@ -458,43 +179,18 @@ class PostAction < ActiveRecord::Base
end
end
- before_create do
+ def ensure_unique_actions
post_action_type_ids = is_flag? ? PostActionType.notify_flag_types.values : post_action_type_id
- raise AlreadyActed if PostAction.where(user_id: user_id)
+
+ acted = PostAction.where(user_id: user_id)
.where(post_id: post_id)
.where(post_action_type_id: post_action_type_ids)
.where(deleted_at: nil)
.where(disagreed_at: nil)
.where(targets_topic: targets_topic)
.exists?
- end
- # Returns the flag counts for a post, taking into account that some users
- # can weigh flags differently.
- def self.flag_counts_for(post_id)
- params = {
- post_id: post_id,
- post_action_types: PostActionType.auto_action_flag_types.values,
- flags_required_to_hide_post: SiteSetting.flags_required_to_hide_post
- }
-
- DB.query_single(<<~SQL, params)
- SELECT COALESCE(SUM(CASE
- WHEN pa.disagreed_at IS NOT NULL AND pa.staff_took_action THEN :flags_required_to_hide_post
- WHEN pa.disagreed_at IS NOT NULL AND NOT pa.staff_took_action THEN 1
- ELSE 0
- END),0) AS old_flags,
- COALESCE(SUM(CASE
- WHEN pa.disagreed_at IS NULL AND pa.staff_took_action THEN :flags_required_to_hide_post
- WHEN pa.disagreed_at IS NULL AND NOT pa.staff_took_action THEN 1
- ELSE 0
- END), 0) AS new_flags
- FROM post_actions AS pa
- INNER JOIN users AS u ON u.id = pa.user_id
- WHERE pa.post_id = :post_id
- AND pa.post_action_type_id in (:post_action_types)
- AND pa.deleted_at IS NULL
- SQL
+ errors.add(:post_action_type_id) if acted
end
def post_action_type_key
@@ -536,159 +232,7 @@ class PostAction < ActiveRecord::Base
Topic.where(id: topic_id).update_all ["#{column} = ?", topic_count]
end
- if PostActionType.notify_flag_type_ids.include?(post_action_type_id)
- PostAction.update_flagged_posts_count
- end
-
end
-
- def enforce_rules
- post = Post.with_deleted.where(id: post_id).first
- PostAction.auto_close_if_threshold_reached(post.topic)
- PostAction.auto_hide_if_needed(user, post, post_action_type_key)
- SpamRule::AutoSilence.new(post.user, post).perform
- end
-
- def create_user_action
- if is_bookmark? || is_like?
- UserActionCreator.log_post_action(self)
- end
- end
-
- def update_notifications
- if self.deleted_at.present?
- PostActionNotifier.post_action_deleted(self)
- end
- end
-
- def create_notifications
- PostActionNotifier.post_action_created(self)
- end
-
- def notify_subscribers
- if (is_like? || is_flag?) && post
- post.publish_change_to_clients! :acted
- end
- end
-
- MAXIMUM_FLAGS_PER_POST = 3
-
- def self.auto_close_threshold_reached?(topic)
- return if topic.user&.staff?
- flags = PostAction.active
- .flags
- .joins(:post)
- .where("posts.topic_id = ?", topic.id)
- .where("post_actions.user_id > 0")
- .group("post_actions.user_id")
- .pluck("post_actions.user_id, COUNT(post_id)")
-
- # we need a minimum number of unique flaggers
- return if flags.count < SiteSetting.num_flaggers_to_close_topic
- # we need a minimum number of flags
- return if flags.sum { |f| f[1] } < SiteSetting.num_flags_to_close_topic
-
- true
- end
-
- def self.auto_close_if_threshold_reached(topic)
- return if topic.nil? || topic.closed?
- return unless auto_close_threshold_reached?(topic)
-
- # the threshold has been reached, we will close the topic waiting for intervention
- topic.update_status("closed", true, Discourse.system_user,
- message: I18n.t(
- "temporarily_closed_due_to_flags",
- count: SiteSetting.num_hours_to_close_topic
- )
- )
-
- topic.set_or_create_timer(
- TopicTimer.types[:open],
- SiteSetting.num_hours_to_close_topic,
- by_user: Discourse.system_user
- )
- end
-
- def self.auto_hide_if_needed(acting_user, post, post_action_type)
- return if post.hidden?
- return if (!acting_user.staff?) && post.user&.staff?
-
- if post_action_type == :spam &&
- acting_user.has_trust_level?(TrustLevel[3]) &&
- post.user&.trust_level == TrustLevel[0]
-
- hide_post!(post, post_action_type, Post.hidden_reasons[:flagged_by_tl3_user])
-
- elsif PostActionType.auto_action_flag_types.include?(post_action_type)
-
- if acting_user.has_trust_level?(TrustLevel[4]) &&
- !acting_user.staff? &&
- post.user&.trust_level != TrustLevel[4]
-
- hide_post!(post, post_action_type, Post.hidden_reasons[:flagged_by_tl4_user])
- elsif SiteSetting.flags_required_to_hide_post > 0
-
- _old_flags, new_flags = PostAction.flag_counts_for(post.id)
-
- if new_flags >= SiteSetting.flags_required_to_hide_post
- hide_post!(post, post_action_type, guess_hide_reason(post))
- end
- end
- end
- end
-
- def self.hide_post!(post, post_action_type, reason = nil)
- return if post.hidden
-
- unless reason
- reason = guess_hide_reason(post)
- end
-
- hiding_again = post.hidden_at.present?
-
- post.hidden = true
- post.hidden_at = Time.zone.now
- post.hidden_reason_id = reason
- post.save
-
- Topic.where("id = :topic_id AND NOT EXISTS(SELECT 1 FROM POSTS WHERE topic_id = :topic_id AND NOT hidden)", topic_id: post.topic_id).update_all(visible: false)
-
- # inform user
- if post.user
- options = {
- url: post.url,
- edit_delay: SiteSetting.cooldown_minutes_after_hiding_posts,
- flag_reason: I18n.t(
- "flag_reasons.#{post_action_type}",
- locale: SiteSetting.default_locale,
- base_path: Discourse.base_path
- )
- }
-
- Jobs.enqueue_in(5.seconds, :send_system_message,
- user_id: post.user.id,
- message_type: hiding_again ? :post_hidden_again : :post_hidden,
- message_options: options)
- end
- update_flagged_posts_count
- end
-
- def self.guess_hide_reason(post)
- post.hidden_at ?
- Post.hidden_reasons[:flag_threshold_reached_again] :
- Post.hidden_reasons[:flag_threshold_reached]
- end
-
- def self.post_action_type_for_post(post_id)
- post_action = PostAction.find_by(deferred_at: nil, post_id: post_id, post_action_type_id: PostActionType.notify_flag_types.values, deleted_at: nil)
- PostActionType.types[post_action.post_action_type_id] if post_action
- end
-
- def self.target_moderators
- Group[:moderators].name
- end
-
end
# == Schema Information
diff --git a/app/models/post_action_type.rb b/app/models/post_action_type.rb
index 031c1e11972..92c1702b14f 100644
--- a/app/models/post_action_type.rb
+++ b/app/models/post_action_type.rb
@@ -22,21 +22,21 @@ class PostActionType < ActiveRecord::Base
3,
:off_topic,
notify_type: true,
- auto_action_type: true
+ auto_action_type: true,
)
@flag_settings.add(
4,
:inappropriate,
topic_type: true,
notify_type: true,
- auto_action_type: true
+ auto_action_type: true,
)
@flag_settings.add(
8,
:spam,
topic_type: true,
notify_type: true,
- auto_action_type: true
+ auto_action_type: true,
)
@flag_settings.add(
6,
@@ -125,11 +125,12 @@ end
#
# Table name: post_action_types
#
-# name_key :string(50) not null
-# is_flag :boolean default(FALSE), not null
-# icon :string(20)
-# created_at :datetime not null
-# updated_at :datetime not null
-# id :integer not null, primary key
-# position :integer default(0), not null
+# name_key :string(50) not null
+# is_flag :boolean default(FALSE), not null
+# icon :string(20)
+# created_at :datetime not null
+# updated_at :datetime not null
+# id :integer not null, primary key
+# position :integer default(0), not null
+# score_bonus :float default(0.0), not null
#
diff --git a/app/models/queued_post.rb b/app/models/queued_post.rb
deleted file mode 100644
index 247db155a1c..00000000000
--- a/app/models/queued_post.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-class QueuedPost < ActiveRecord::Base
-
- class InvalidStateTransition < StandardError; end
-
- belongs_to :user
- belongs_to :topic
- belongs_to :approved_by, class_name: "User"
- belongs_to :rejected_by, class_name: "User"
-
- after_commit :trigger_queued_post_event, on: :create
-
- def create_pending_action
- UserAction.log_action!(action_type: UserAction::PENDING,
- user_id: user_id,
- acting_user_id: user_id,
- target_topic_id: topic_id,
- queued_post_id: id)
- end
-
- def trigger_queued_post_event
- DiscourseEvent.trigger(:queued_post_created, self)
- true
- end
-
- def self.states
- @states ||= Enum.new(:new, :approved, :rejected)
- end
-
- # By default queues are hidden from moderators
- def self.visible_queues
- @visible_queues ||= Set.new(['default'])
- end
-
- def self.visible
- where(queue: visible_queues.to_a)
- end
-
- def self.new_posts
- where(state: states[:new])
- end
-
- def self.new_count
- new_posts.visible.count
- end
-
- def visible?
- QueuedPost.visible_queues.include?(queue)
- end
-
- def self.broadcast_new!
- msg = { post_queue_new_count: QueuedPost.new_count }
- MessageBus.publish('/queue_counts', msg, user_ids: User.staff.pluck(:id))
- end
-
- def reject!(rejected_by)
- change_to!(:rejected, rejected_by)
- StaffActionLogger.new(rejected_by).log_post_rejected(self)
- DiscourseEvent.trigger(:rejected_post, self)
- end
-
- def create_options
- opts = { raw: raw }
- opts.merge!(post_options.symbolize_keys)
-
- opts[:cooking_options].symbolize_keys! if opts[:cooking_options]
- opts[:topic_id] = topic_id if topic_id
- opts
- end
-
- def approve!(approved_by)
- created_post = nil
-
- creator = PostCreator.new(user, create_options.merge(
- skip_validations: true,
- skip_jobs: true,
- skip_events: true
- ))
-
- QueuedPost.transaction do
- change_to!(:approved, approved_by)
-
- UserSilencer.unsilence(user, approved_by) if user.silenced?
-
- created_post = creator.create
-
- unless created_post && creator.errors.blank?
- raise StandardError.new(creator.errors.full_messages.join(" "))
- else
- # Log post approval
- StaffActionLogger.new(approved_by).log_post_approved(created_post)
- end
- end
-
- if create_options[:tags].present? &&
- created_post.post_number == 1 &&
- created_post.topic.tags.blank?
- DiscourseTagging.tag_topic_by_names(created_post.topic, Guardian.new(approved_by), create_options[:tags])
- end
-
- # Do sidekiq work outside of the transaction
- creator.enqueue_jobs
- creator.trigger_after_events
-
- DiscourseEvent.trigger(:approved_post, self, created_post)
- created_post
- end
-
- private
-
- def change_to!(state, changed_by)
- state_val = QueuedPost.states[state]
-
- updates = { state: state_val,
- "#{state}_by_id" => changed_by.id,
- "#{state}_at" => Time.now }
-
- # We use an update with `row_count` trick here to avoid stampeding requests to
- # update the same row simultaneously. Only one state change should go through and
- # we can use the DB to enforce this
- row_count = QueuedPost.where('id = ? AND state <> ?', id, state_val).update_all(updates)
- raise InvalidStateTransition.new if row_count == 0
-
- if [:rejected, :approved].include?(state)
- UserAction.where(queued_post_id: id).destroy_all
- end
-
- # Update the record in memory too, and clear the dirty flag
- updates.each { |k, v| send("#{k}=", v) }
- changes_applied
-
- QueuedPost.broadcast_new! if visible?
- end
-
-end
-
-# == Schema Information
-#
-# Table name: queued_posts
-#
-# id :integer not null, primary key
-# queue :string not null
-# state :integer not null
-# user_id :integer not null
-# raw :text not null
-# post_options :json not null
-# topic_id :integer
-# approved_by_id :integer
-# approved_at :datetime
-# rejected_by_id :integer
-# rejected_at :datetime
-# created_at :datetime not null
-# updated_at :datetime not null
-#
-# Indexes
-#
-# by_queue_status (queue,state,created_at)
-# by_queue_status_topic (topic_id,queue,state,created_at)
-#
diff --git a/app/models/report.rb b/app/models/report.rb
index 78c09753189..9a5726e6c72 100644
--- a/app/models/report.rb
+++ b/app/models/report.rb
@@ -510,7 +510,7 @@ class Report
end
if report.facets.include?(:total)
- report.total = subject_class.count
+ report.total = subject_class.count
end
if report.facets.include?(:prev30Days)
@@ -553,10 +553,19 @@ class Report
report.icon = 'flag'
report.higher_is_better = false
- basic_report_about report, PostAction, :flag_count_by_date, report.start_date, report.end_date, report.category_id
- countable = PostAction.where(post_action_type_id: PostActionType.flag_types_without_custom.values)
- countable = countable.joins(post: :topic).merge(Topic.in_category_and_subcategories(report.category_id)) if report.category_id
- add_counts report, countable, 'post_actions.created_at'
+ basic_report_about(
+ report,
+ ReviewableFlaggedPost,
+ :count_by_date,
+ report.start_date,
+ report.end_date,
+ report.category_id
+ )
+
+ countable = ReviewableFlaggedPost.scores_with_topics
+ countable.merge!(Topic.in_category_and_subcategories(report.category_id)) if report.category_id
+
+ add_counts report, countable, 'reviewable_scores.created_at'
end
def self.report_likes(report)
@@ -1280,7 +1289,7 @@ class Report
report.modes = [:table]
- report.dates_filtering = false
+ report.dates_filtering = true
report.labels = [
{
@@ -1314,25 +1323,36 @@ class Report
},
]
+ statuses = ReviewableScore.statuses
+
+ agreed = "SUM(CASE WHEN rs.status = #{statuses[:agreed]} THEN 1 ELSE 0 END)::numeric"
+ disagreed = "SUM(CASE WHEN rs.status = #{statuses[:disagreed]} THEN 1 ELSE 0 END)::numeric"
+ ignored = "SUM(CASE WHEN rs.status = #{statuses[:ignored]} THEN 1 ELSE 0 END)::numeric"
+
sql = <<~SQL
SELECT u.id,
u.username,
u.uploaded_avatar_id as avatar_id,
CASE WHEN u.silenced_till IS NOT NULL THEN 't' ELSE 'f' END as silenced,
- us.flags_disagreed AS disagreed_flags,
- us.flags_agreed AS agreed_flags,
- us.flags_ignored AS ignored_flags,
- ROUND((1-(us.flags_agreed::numeric / us.flags_disagreed::numeric)) *
- (us.flags_disagreed - us.flags_agreed)) AS score
+ #{disagreed} AS disagreed_flags,
+ #{agreed} AS agreed_flags,
+ #{ignored} AS ignored_flags,
+ ROUND((1-(#{agreed} / #{disagreed})) * (#{disagreed} - #{agreed})) AS score
FROM users AS u
- INNER JOIN user_stats AS us ON us.user_id = u.id
- WHERE u.id <> -1
- AND flags_disagreed > flags_agreed
+ INNER JOIN reviewable_scores AS rs ON rs.user_id = u.id
+ WHERE u.id > 0
+ AND rs.created_at >= :start_date
+ AND rs.created_at <= :end_date
+ GROUP BY u.id,
+ u.username,
+ u.uploaded_avatar_id,
+ u.silenced_till
+ HAVING #{disagreed} > #{agreed}
ORDER BY score DESC
LIMIT 100
SQL
- DB.query(sql).each do |row|
+ DB.query(sql, start_date: report.start_date, end_date: report.end_date).each do |row|
flagger = {}
flagger[:user_id] = row.id
flagger[:username] = row.username
diff --git a/app/models/reviewable.rb b/app/models/reviewable.rb
new file mode 100644
index 00000000000..431060bdf53
--- /dev/null
+++ b/app/models/reviewable.rb
@@ -0,0 +1,471 @@
+require_dependency 'enum'
+require_dependency 'reviewable/actions'
+require_dependency 'reviewable/conversation'
+require_dependency 'reviewable/editable_fields'
+require_dependency 'reviewable/perform_result'
+require_dependency 'reviewable_serializer'
+
+class Reviewable < ActiveRecord::Base
+ class UpdateConflict < StandardError; end
+
+ class InvalidAction < StandardError
+ def initialize(action_id, klass)
+ @action_id, @klass = action_id, klass
+ super("Can't peform `#{action_id}` on #{klass.name}")
+ end
+ end
+
+ validates_presence_of :type, :status, :created_by_id
+ belongs_to :target, polymorphic: true
+ belongs_to :created_by, class_name: 'User'
+ belongs_to :target_created_by, class_name: 'User'
+ belongs_to :reviewable_by_group, class_name: 'Group'
+
+ # Optional, for filtering
+ belongs_to :topic
+ belongs_to :category
+
+ has_many :reviewable_histories
+ has_many :reviewable_scores
+
+ after_create do
+ DiscourseEvent.trigger(:reviewable_created, self)
+ Jobs.enqueue(:notify_reviewable, reviewable_id: self.id) if pending?
+ log_history(:created, created_by)
+ end
+
+ def self.statuses
+ @statuses ||= Enum.new(
+ pending: 0,
+ approved: 1,
+ rejected: 2,
+ ignored: 3,
+ deleted: 4
+ )
+ end
+
+ # Generate `pending?`, `rejected?`, etc helper methods
+ statuses.each do |name, id|
+ define_method("#{name}?") { status == id }
+ self.class.define_method(name) { where(status: id) }
+ end
+
+ def self.default_visible
+ where("score >= ?", SiteSetting.min_score_default_visibility)
+ end
+
+ def self.valid_type?(type)
+ return false unless type =~ /^Reviewable[A-Za-z]+$/
+ type.constantize <= Reviewable
+ rescue NameError
+ false
+ end
+
+ def self.types
+ %w[ReviewableFlaggedPost ReviewableQueuedPost ReviewableUser]
+ end
+
+ # Create a new reviewable, or if the target has already been reviewed return it to the
+ # pending state and re-use it.
+ #
+ # You probably want to call this to create your reviewable rather than `.create`.
+ def self.needs_review!(
+ target: nil,
+ topic: nil,
+ created_by:,
+ payload: nil,
+ reviewable_by_moderator: false,
+ potential_spam: true
+ )
+ target_created_by_id = target.is_a?(Post) ? target.user_id : nil
+
+ topic = target.topic if topic.blank? && target.is_a?(Post)
+ category_id = topic.category_id if topic.present?
+
+ create!(
+ target: target,
+ target_created_by_id: target_created_by_id,
+ topic: topic,
+ created_by: created_by,
+ category_id: category_id,
+ reviewable_by_moderator: reviewable_by_moderator,
+ payload: payload,
+ potential_spam: potential_spam
+ )
+ rescue ActiveRecord::RecordNotUnique
+ updates = {
+ status: statuses[:pending]
+ }
+ updates[:potential_spam] = true if potential_spam
+ where(target: target).update_all(updates)
+ find_by(target: target).tap { |r| r.log_history(:transitioned, created_by) }
+ end
+
+ def add_score(
+ user,
+ reviewable_score_type,
+ created_at: nil,
+ take_action: false,
+ meta_topic_id: nil,
+ force_review: false
+ )
+
+ type_bonus = PostActionType.where(id: reviewable_score_type).pluck(:score_bonus)[0] || 0
+ take_action_bonus = take_action ? 5.0 : 0.0
+ sub_total = (ReviewableScore.user_flag_score(user) + type_bonus + take_action_bonus)
+
+ # We can force a reviewable to hit the threshold, for example with queued posts
+ if force_review && sub_total < SiteSetting.min_score_default_visibility
+ sub_total = SiteSetting.min_score_default_visibility
+ end
+
+ rs = reviewable_scores.create!(
+ user: user,
+ status: ReviewableScore.statuses[:pending],
+ reviewable_score_type: reviewable_score_type,
+ score: sub_total,
+ meta_topic_id: meta_topic_id,
+ take_action_bonus: take_action_bonus,
+ created_at: created_at || Time.zone.now
+ )
+
+ update(score: self.score + rs.score, latest_score: rs.created_at)
+ topic.update(reviewable_score: topic.reviewable_score + rs.score) if topic
+
+ rs
+ end
+
+ def history
+ reviewable_histories.order(:created_at)
+ end
+
+ def log_history(reviewable_history_type, performed_by, edited: nil)
+ reviewable_histories.create!(
+ reviewable_history_type: ReviewableHistory.types[reviewable_history_type],
+ status: status,
+ created_by: performed_by,
+ edited: edited
+ )
+ end
+
+ def actions_for(guardian, args = nil)
+ args ||= {}
+ Actions.new(self, guardian).tap { |a| build_actions(a, guardian, args) }
+ end
+
+ def editable_for(guardian, args = nil)
+ args ||= {}
+ EditableFields.new(self, guardian, args).tap { |a| build_editable_fields(a, guardian, args) }
+ end
+
+ # subclasses must implement "build_actions" to list the actions they're capable of
+ def build_actions(actions, guardian, args)
+ raise NotImplementedError
+ end
+
+ # subclasses can implement "build_editable_fields" to list stuff that can be edited
+ def build_editable_fields(actions, guardian, args)
+ end
+
+ def update_fields(params, performed_by, version: nil)
+ return true if params.blank?
+
+ (params[:payload] || {}).each { |k, v| self.payload[k] = v }
+ self.category_id = params[:category_id] if params.has_key?(:category_id)
+
+ result = false
+
+ Reviewable.transaction do
+ increment_version!(version)
+ changes_json = changes.as_json
+ changes_json.delete('version')
+
+ result = save
+ log_history(:edited, performed_by, edited: changes_json) if result
+ end
+
+ result
+ end
+
+ # Delegates to a `perform_#{action_id}` method, which returns a `PerformResult` with
+ # the result of the operation and whether the status of the reviewable changed.
+ def perform(performed_by, action_id, args = nil)
+ args ||= {}
+
+ # Ensure the user has access to the action
+ actions = actions_for(Guardian.new(performed_by), args)
+ raise InvalidAction.new(action_id, self.class) unless actions.has?(action_id)
+
+ perform_method = "perform_#{action_id}".to_sym
+ raise InvalidAction.new(action_id, self.class) unless respond_to?(perform_method)
+
+ result = nil
+ Reviewable.transaction do
+ increment_version!(args[:version])
+ result = send(perform_method, performed_by, args)
+
+ if result.success?
+ transition_to(result.transition_to, performed_by) if result.transition_to
+ update_flag_stats(**result.update_flag_stats) if result.update_flag_stats
+
+ recalculate_score if result.recalculate_score
+ end
+ end
+ result
+ end
+
+ def transition_to(status_symbol, performed_by)
+ was_pending = pending?
+
+ self.status = Reviewable.statuses[status_symbol]
+ save!
+ log_history(:transitioned, performed_by)
+ DiscourseEvent.trigger(:reviewable_transitioned_to, status_symbol, self)
+
+ if score_status = ReviewableScore.score_transitions[status_symbol]
+ reviewable_scores.pending.update_all(
+ status: score_status,
+ reviewed_by_id: performed_by.id,
+ reviewed_at: Time.zone.now
+ )
+ end
+
+ Jobs.enqueue(:notify_reviewable, reviewable_id: self.id) if was_pending
+ end
+
+ def post_options
+ Discourse.deprecate(
+ "Reviewable#post_options is deprecated. Please use #payload instead.",
+ output_in_test: true
+ )
+ end
+
+ def self.bulk_perform_targets(performed_by, action, type, target_ids, args = nil)
+ args ||= {}
+ viewable_by(performed_by).where(type: type, target_id: target_ids).each do |r|
+ r.perform(performed_by, action, args)
+ end
+ end
+
+ def self.viewable_by(user, order: nil, preload: true)
+ return none unless user.present?
+
+ result = self.order(order || 'score desc, created_at desc')
+
+ if preload
+ result = result.includes(
+ { created_by: :user_stat },
+ :topic,
+ :target,
+ :target_created_by,
+ :reviewable_histories
+ ).includes(reviewable_scores: { user: :user_stat, meta_topic: :posts })
+ end
+ return result if user.admin?
+
+ result.where(
+ '(reviewable_by_moderator AND :staff) OR (reviewable_by_group_id IN (:group_ids))',
+ staff: user.staff?,
+ group_ids: user.group_users.pluck(:group_id)
+ ).where("category_id IS NULL OR category_id IN (?)", Guardian.new(user).allowed_category_ids)
+ end
+
+ def self.pending_count(user)
+ list_for(user).count
+ end
+
+ def self.list_for(
+ user,
+ status: :pending,
+ category_id: nil,
+ topic_id: nil,
+ type: nil,
+ limit: nil,
+ offset: nil,
+ min_score: nil,
+ username: nil
+ )
+ min_score ||= SiteSetting.min_score_default_visibility
+
+ order = (status == :pending) ? 'score DESC, created_at DESC' : 'created_at DESC'
+
+ if username.present?
+ user_id = User.find_by_username(username)&.id
+ return [] if user_id.blank?
+ end
+
+ return [] if user.blank?
+ result = viewable_by(user, order: order)
+
+ result = by_status(result, status)
+ result = result.where(type: type) if type
+ result = result.where(category_id: category_id) if category_id
+ result = result.where(topic_id: topic_id) if topic_id
+ result = result.where("score >= ?", min_score) if min_score
+
+ # If a reviewable doesn't have a target, allow us to filter on who created that reviewable.
+ if user_id
+ result = result.where(
+ "(target_created_by_id IS NULL AND created_by_id = :user_id) OR (target_created_by_id = :user_id)",
+ user_id: user_id
+ )
+ end
+
+ result = result.limit(limit) if limit
+ result = result.offset(offset) if offset
+ result
+ end
+
+ def serializer
+ self.class.serializer_for(self)
+ end
+
+ def self.lookup_serializer_for(type)
+ "#{type}Serializer".constantize
+ rescue NameError
+ ReviewableSerializer
+ end
+
+ def self.serializer_for(reviewable)
+ type = reviewable.type
+ @@serializers ||= {}
+ @@serializers[type] ||= lookup_serializer_for(type)
+ end
+
+ def create_result(status, transition_to = nil)
+ result = PerformResult.new(self, status)
+ result.transition_to = transition_to
+ yield result if block_given?
+ result
+ end
+
+ def self.scores_with_topics
+ ReviewableScore.joins(reviewable: :topic).where("reviewables.type = ?", name)
+ end
+
+ def self.count_by_date(start_date, end_date, category_id = nil)
+ scores_with_topics
+ .where('reviewable_scores.created_at BETWEEN ? AND ?', start_date, end_date)
+ .where("topics.category_id = COALESCE(?, topics.category_id)", category_id)
+ .group("date(reviewable_scores.created_at)")
+ .order('date(reviewable_scores.created_at)')
+ .count
+ end
+
+protected
+
+ def recalculate_score
+ # Recalculate the pending score and return it
+ result = DB.query(<<~SQL, id: self.id, pending: ReviewableScore.statuses[:pending])
+ UPDATE reviewables
+ SET score = COALESCE((
+ SELECT sum(score)
+ FROM reviewable_scores AS rs
+ WHERE rs.reviewable_id = :id
+ ), 0.0)
+ WHERE id = :id
+ RETURNING score
+ SQL
+
+ # Update topic score
+ DB.query(<<~SQL, topic_id: topic_id, pending: Reviewable.statuses[:pending])
+ UPDATE topics
+ SET reviewable_score = COALESCE((
+ SELECT SUM(score)
+ FROM reviewables AS r
+ WHERE r.topic_id = :topic_id
+ ), 0.0)
+ WHERE id = :topic_id
+ SQL
+
+ self.score = result[0].score
+ end
+
+ def increment_version!(version = nil)
+ version_result = nil
+
+ if version
+ version_result = DB.query_single(
+ "UPDATE reviewables SET version = version + 1 WHERE id = :id AND version = :version RETURNING version",
+ version: version,
+ id: self.id
+ )
+ else
+ # We didn't supply a version to update safely, so just increase it
+ version_result = DB.query_single(
+ "UPDATE reviewables SET version = version + 1 WHERE id = :id RETURNING version",
+ id: self.id
+ )
+ end
+
+ if version_result && version_result[0]
+ self.version = version_result[0]
+ else
+ raise UpdateConflict.new
+ end
+ end
+
+ def self.by_status(partial_result, status)
+ return partial_result if status == :all
+
+ if status == :reviewed
+ partial_result.where(status: [statuses[:approved], statuses[:rejected], statuses[:ignored]])
+ else
+ partial_result.where(status: statuses[status])
+ end
+ end
+
+private
+
+ def update_flag_stats(status:, user_ids:)
+ return unless [:agreed, :disagreed, :ignored].include?(status)
+
+ # Don't count self-flags
+ user_ids -= [post&.user_id]
+ return if user_ids.blank?
+
+ result = DB.query(<<~SQL, user_ids: user_ids)
+ UPDATE user_stats
+ SET flags_#{status} = flags_#{status} + 1
+ WHERE user_id IN (:user_ids)
+ RETURNING user_id, flags_agreed + flags_disagreed + flags_ignored AS total
+ SQL
+
+ Jobs.enqueue(
+ :truncate_user_flag_stats,
+ user_ids: result.select { |r| r.total > Jobs::TruncateUserFlagStats.truncate_to }.map(&:user_id)
+ )
+ end
+end
+
+# == Schema Information
+#
+# Table name: reviewables
+#
+# id :bigint(8) not null, primary key
+# type :string not null
+# status :integer default(0), not null
+# created_by_id :integer not null
+# reviewable_by_moderator :boolean default(FALSE), not null
+# reviewable_by_group_id :integer
+# claimed_by_id :integer
+# category_id :integer
+# topic_id :integer
+# score :float default(0.0), not null
+# potential_spam :boolean default(FALSE), not null
+# target_id :integer
+# target_type :string
+# target_created_by_id :integer
+# payload :json
+# version :integer default(0), not null
+# latest_score :datetime
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewables_on_status_and_created_at (status,created_at)
+# index_reviewables_on_status_and_score (status,score)
+# index_reviewables_on_status_and_type (status,type)
+# index_reviewables_on_type_and_target_id (type,target_id) UNIQUE
+#
diff --git a/app/models/reviewable_flagged_post.rb b/app/models/reviewable_flagged_post.rb
new file mode 100644
index 00000000000..4270aafcf6e
--- /dev/null
+++ b/app/models/reviewable_flagged_post.rb
@@ -0,0 +1,274 @@
+require_dependency 'reviewable'
+
+class ReviewableFlaggedPost < Reviewable
+
+ def self.counts_for(posts)
+ result = {}
+
+ counts = DB.query(<<~SQL, pending: Reviewable.statuses[:pending])
+ SELECT r.target_id AS post_id,
+ rs.reviewable_score_type,
+ count(*) as total
+ FROM reviewables AS r
+ INNER JOIN reviewable_scores AS rs ON rs.reviewable_id = r.id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND r.status = :pending
+ GROUP BY r.target_id, rs.reviewable_score_type
+ SQL
+
+ counts.each do |c|
+ result[c.post_id] ||= {}
+ result[c.post_id][c.reviewable_score_type] = c.total
+ end
+
+ result
+ end
+
+ def post
+ @post ||= (target || Post.with_deleted.find_by(id: target_id))
+ end
+
+ def build_actions(actions, guardian, args)
+ return unless pending?
+ return if post.blank?
+
+ agree = actions.add_bundle("#{id}-agree", icon: 'thumbs-up', label: 'reviewables.actions.agree.title')
+
+ build_action(actions, :agree_and_keep, icon: 'thumbs-up', bundle: agree)
+ if guardian.can_suspend?(target_created_by)
+ build_action(actions, :agree_and_suspend, icon: 'ban', bundle: agree, client_action: 'suspend')
+ build_action(actions, :agree_and_silence, icon: 'microphone-slash', bundle: agree, client_action: 'silence')
+ end
+
+ if can_delete_spammer = potential_spam? && guardian.can_delete_all_posts?(target_created_by)
+ build_action(
+ actions,
+ :delete_spammer,
+ icon: 'exclamation-triangle',
+ bundle: agree,
+ confirm: true
+ )
+ end
+
+ if post.user_deleted?
+ build_action(actions, :agree_and_restore, icon: 'far-eye', bundle: agree)
+ elsif !post.hidden?
+ build_action(actions, :agree_and_hide, icon: 'far-eye-slash', bundle: agree)
+ end
+
+ if post.hidden?
+ build_action(actions, :disagree_and_restore, icon: 'thumbs-down')
+ else
+ build_action(actions, :disagree, icon: 'thumbs-down')
+ end
+
+ build_action(actions, :ignore, icon: 'external-link-alt')
+
+ if guardian.is_staff?
+ delete = actions.add_bundle("#{id}-delete", icon: "far-trash-alt", label: "reviewables.actions.delete.title")
+ build_action(actions, :delete_and_ignore, icon: 'external-link-alt', bundle: delete)
+ build_action(actions, :delete_and_agree, icon: 'thumbs-up', bundle: delete)
+ end
+ end
+
+ def perform_ignore(performed_by, args)
+ actions = PostAction.active
+ .where(post_id: target_id)
+ .where(post_action_type_id: PostActionType.notify_flag_type_ids)
+
+ actions.each do |action|
+ action.deferred_at = Time.zone.now
+ action.deferred_by_id = performed_by.id
+ # so callback is called
+ action.save
+ action.add_moderator_post_if_needed(performed_by, :ignored, args[:post_was_deleted])
+ end
+
+ if actions.first.present?
+ DiscourseEvent.trigger(:flag_reviewed, post)
+ DiscourseEvent.trigger(:flag_deferred, actions.first)
+ end
+
+ create_result(:success, :ignored) do |result|
+ result.update_flag_stats = { status: :ignored, user_ids: actions.map(&:user_id) }
+ result.recalculate_score = true
+ end
+ end
+
+ # Penalties are handled by the modal after the action is performed
+ def perform_agree_and_keep(performed_by, args)
+ agree(performed_by, args)
+ end
+
+ def perform_agree_and_suspend(performed_by, args)
+ agree(performed_by, args)
+ end
+
+ def perform_agree_and_silence(performed_by, args)
+ agree(performed_by, args)
+ end
+
+ def perform_delete_spammer(performed_by, args)
+ UserDestroyer.new(performed_by).destroy(
+ post.user,
+ delete_posts: true,
+ prepare_for_destroy: true,
+ block_email: true,
+ block_urls: true,
+ block_ip: true,
+ delete_as_spammer: true,
+ context: "review"
+ )
+
+ agree(performed_by, args)
+ end
+
+ def perform_agree_and_hide(performed_by, args)
+ agree(performed_by, args) do |pa|
+ post.hide!(pa.post_action_type_id)
+ end
+ end
+
+ def perform_agree_and_restore(performed_by, args)
+ agree(performed_by, args) do
+ PostDestroyer.new(performed_by, post).recover
+ end
+ end
+
+ def perform_disagree_and_restore(performed_by, args)
+ result = perform_disagree(performed_by, args)
+ PostDestroyer.new(performed_by, post).recover
+ result
+ end
+
+ def perform_disagree(performed_by, args)
+ # -1 is the automatic system clear
+ action_type_ids =
+ if performed_by.id == Discourse::SYSTEM_USER_ID
+ PostActionType.auto_action_flag_types.values
+ else
+ PostActionType.notify_flag_type_ids
+ end
+
+ actions = PostAction.active.where(post_id: target_id).where(post_action_type_id: action_type_ids)
+
+ actions.each do |action|
+ action.disagreed_at = Time.zone.now
+ action.disagreed_by_id = performed_by.id
+ # so callback is called
+ action.save
+ action.add_moderator_post_if_needed(performed_by, :disagreed)
+ end
+
+ # reset all cached counters
+ cached = {}
+ action_type_ids.each do |atid|
+ column = "#{PostActionType.types[atid]}_count"
+ cached[column] = 0 if ActiveRecord::Base.connection.column_exists?(:posts, column)
+ end
+
+ Post.with_deleted.where(id: target_id).update_all(cached)
+
+ if actions.first.present?
+ DiscourseEvent.trigger(:flag_reviewed, post)
+ DiscourseEvent.trigger(:flag_disagreed, actions.first)
+ end
+
+ # Undo hide/silence if applicable
+ if post&.hidden?
+ post.unhide!
+ UserSilencer.unsilence(post.user) if UserSilencer.was_silenced_for?(post)
+ end
+
+ create_result(:success, :rejected) do |result|
+ result.update_flag_stats = { status: :disagreed, user_ids: actions.map(&:user_id) }
+ result.recalculate_score = true
+ end
+ end
+
+ def perform_delete_and_ignore(performed_by, args)
+ result = perform_ignore(performed_by, args)
+ PostDestroyer.new(performed_by, post).destroy
+ result
+ end
+
+ def perform_delete_and_agree(performed_by, args)
+ result = agree(performed_by, args)
+ PostDestroyer.new(performed_by, post).destroy
+ result
+ end
+protected
+
+ def agree(performed_by, args)
+ actions = PostAction.active
+ .where(post_id: target_id)
+ .where(post_action_type_id: PostActionType.notify_flag_types.values)
+
+ trigger_spam = false
+ actions.each do |action|
+ action.agreed_at = Time.zone.now
+ action.agreed_by_id = performed_by.id
+ # so callback is called
+ action.save
+ action.add_moderator_post_if_needed(performed_by, :agreed, args[:post_was_deleted])
+ trigger_spam = true if action.post_action_type_id == PostActionType.types[:spam]
+ end
+
+ DiscourseEvent.trigger(:confirmed_spam_post, post) if trigger_spam
+
+ if actions.first.present?
+ DiscourseEvent.trigger(:flag_reviewed, post)
+ DiscourseEvent.trigger(:flag_agreed, actions.first)
+ yield(actions.first) if block_given?
+ end
+
+ create_result(:success, :approved) do |result|
+ result.update_flag_stats = { status: :agreed, user_ids: actions.map(&:user_id) }
+ result.recalculate_score = true
+ end
+ end
+
+ def build_action(actions, id, icon:, bundle: nil, client_action: nil, confirm: false)
+ actions.add(id, bundle: bundle) do |action|
+ prefix = "reviewables.actions.#{id}"
+ action.icon = icon
+ action.label = "#{prefix}.title"
+ action.description = "#{prefix}.description"
+ action.client_action = client_action
+ action.confirm_message = "#{prefix}.confirm" if confirm
+ end
+ end
+
+end
+
+# == Schema Information
+#
+# Table name: reviewables
+#
+# id :bigint(8) not null, primary key
+# type :string not null
+# status :integer default(0), not null
+# created_by_id :integer not null
+# reviewable_by_moderator :boolean default(FALSE), not null
+# reviewable_by_group_id :integer
+# claimed_by_id :integer
+# category_id :integer
+# topic_id :integer
+# score :float default(0.0), not null
+# potential_spam :boolean default(FALSE), not null
+# target_id :integer
+# target_type :string
+# target_created_by_id :integer
+# payload :json
+# version :integer default(0), not null
+# latest_score :datetime
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewables_on_status_and_created_at (status,created_at)
+# index_reviewables_on_status_and_score (status,score)
+# index_reviewables_on_status_and_type (status,type)
+# index_reviewables_on_type_and_target_id (type,target_id) UNIQUE
+#
diff --git a/app/models/reviewable_history.rb b/app/models/reviewable_history.rb
new file mode 100644
index 00000000000..1df79daadd7
--- /dev/null
+++ b/app/models/reviewable_history.rb
@@ -0,0 +1,32 @@
+class ReviewableHistory < ActiveRecord::Base
+ belongs_to :reviewable
+ belongs_to :created_by, class_name: 'User'
+
+ def self.types
+ @types ||= Enum.new(
+ created: 0,
+ transitioned: 1,
+ edited: 2
+ )
+ end
+
+end
+
+# == Schema Information
+#
+# Table name: reviewable_histories
+#
+# id :bigint(8) not null, primary key
+# reviewable_id :integer not null
+# reviewable_history_type :integer not null
+# status :integer not null
+# created_by_id :integer not null
+# edited :json
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewable_histories_on_created_by_id (created_by_id)
+# index_reviewable_histories_on_reviewable_id (reviewable_id)
+#
diff --git a/app/models/reviewable_queued_post.rb b/app/models/reviewable_queued_post.rb
new file mode 100644
index 00000000000..c60fd5d9358
--- /dev/null
+++ b/app/models/reviewable_queued_post.rb
@@ -0,0 +1,133 @@
+require_dependency 'reviewable'
+require_dependency 'user_destroyer'
+
+class ReviewableQueuedPost < Reviewable
+
+ after_create do
+ # Backwards compatibility, new code should listen for `reviewable_created`
+ DiscourseEvent.trigger(:queued_post_created, self)
+ end
+
+ def build_actions(actions, guardian, args)
+ return unless guardian.is_staff?
+
+ actions.add(:approve) unless approved?
+ actions.add(:reject) unless rejected?
+
+ if pending? && guardian.can_delete_user?(created_by)
+ actions.add(:delete_user) do |action|
+ action.icon = 'trash-alt'
+ action.label = 'reviewables.actions.delete_user.title'
+ action.confirm_message = 'reviewables.actions.delete_user.confirm'
+ end
+ end
+ end
+
+ def build_editable_fields(fields, guardian, args)
+ return unless guardian.is_staff?
+
+ # We can edit category / title if it's a new topic
+ if topic_id.blank?
+ fields.add('category_id', :category)
+ fields.add('payload.title', :text)
+ fields.add('payload.tags', :tags)
+ end
+
+ fields.add('payload.raw', :editor)
+ end
+
+ def create_options
+ result = payload.symbolize_keys
+ result[:cooking_options].symbolize_keys! if result[:cooking_options]
+ result[:topic_id] = topic_id if topic_id
+ result[:category] = category_id if category_id
+ result
+ end
+
+ def perform_approve(performed_by, args)
+ created_post = nil
+
+ creator = PostCreator.new(created_by, create_options.merge(
+ skip_validations: true,
+ skip_jobs: true,
+ skip_events: true,
+ skip_guardian: true
+ ))
+ created_post = creator.create
+
+ unless created_post && creator.errors.blank?
+ return create_result(:failure) { |r| r.errors = creator.errors }
+ end
+
+ payload['created_post_id'] = created_post.id
+ payload['created_topic_id'] = created_post.topic_id unless topic_id
+ save
+
+ UserSilencer.unsilence(created_by, performed_by) if created_by.silenced?
+
+ StaffActionLogger.new(performed_by).log_post_approved(created_post) if performed_by.staff?
+
+ # Backwards compatibility, new code should listen for `reviewable_transitioned_to`
+ DiscourseEvent.trigger(:approved_post, self, created_post)
+
+ create_result(:success, :approved) { |result| result.created_post = created_post }
+ end
+
+ def perform_reject(performed_by, args)
+ # Backwards compatibility, new code should listen for `reviewable_transitioned_to`
+ DiscourseEvent.trigger(:rejected_post, self)
+
+ StaffActionLogger.new(performed_by).log_post_rejected(self, DateTime.now) if performed_by.staff?
+
+ create_result(:success, :rejected)
+ end
+
+ def perform_delete_user(performed_by, args)
+ delete_options = {
+ context: I18n.t('reviewables.actions.delete_user.reason'),
+ delete_posts: true,
+ delete_as_spammer: true
+ }
+
+ if Rails.env.production?
+ delete_options.merge!(block_email: true, block_ip: true)
+ end
+
+ reviewable_ids = Reviewable.where(created_by: created_by).pluck(:id)
+ UserDestroyer.new(performed_by).destroy(created_by, delete_options)
+ create_result(:success) { |r| r.remove_reviewable_ids = reviewable_ids }
+ end
+
+end
+
+# == Schema Information
+#
+# Table name: reviewables
+#
+# id :bigint(8) not null, primary key
+# type :string not null
+# status :integer default(0), not null
+# created_by_id :integer not null
+# reviewable_by_moderator :boolean default(FALSE), not null
+# reviewable_by_group_id :integer
+# claimed_by_id :integer
+# category_id :integer
+# topic_id :integer
+# score :float default(0.0), not null
+# potential_spam :boolean default(FALSE), not null
+# target_id :integer
+# target_type :string
+# target_created_by_id :integer
+# payload :json
+# version :integer default(0), not null
+# latest_score :datetime
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewables_on_status_and_created_at (status,created_at)
+# index_reviewables_on_status_and_score (status,score)
+# index_reviewables_on_status_and_type (status,type)
+# index_reviewables_on_type_and_target_id (type,target_id) UNIQUE
+#
diff --git a/app/models/reviewable_score.rb b/app/models/reviewable_score.rb
new file mode 100644
index 00000000000..057afb5612b
--- /dev/null
+++ b/app/models/reviewable_score.rb
@@ -0,0 +1,94 @@
+class ReviewableScore < ActiveRecord::Base
+ belongs_to :reviewable
+ belongs_to :user
+ belongs_to :reviewed_by, class_name: 'User'
+ belongs_to :meta_topic, class_name: 'Topic'
+
+ # To keep things simple the types correspond to `PostActionType` for backwards
+ # compatibility, but we can add extra reasons for scores.
+ def self.types
+ @types ||= PostActionType.flag_types.merge(
+ needs_approval: 9
+ )
+ end
+
+ def self.statuses
+ @statuses ||= Enum.new(
+ pending: 0,
+ agreed: 1,
+ disagreed: 2,
+ ignored: 3
+ )
+ end
+
+ def self.score_transitions
+ {
+ approved: statuses[:agreed],
+ rejected: statuses[:disagreed],
+ ignored: statuses[:ignored]
+ }
+ end
+
+ # Generate `pending?`, `rejected?`, etc helper methods
+ statuses.each do |name, id|
+ define_method("#{name}?") { status == id }
+ self.class.define_method(name) { where(status: id) }
+ end
+
+ def score_type
+ Reviewable::Collection::Item.new(reviewable_score_type)
+ end
+
+ def took_action?
+ take_action_bonus > 0
+ end
+
+ # A user's flag score is:
+ # 1.0 + trust_level + user_accuracy_bonus
+ # (trust_level is 5 for staff)
+ def self.user_flag_score(user)
+ 1.0 + (user.staff? ? 5.0 : user.trust_level.to_f) + user_accuracy_bonus(user)
+ end
+
+ # A user's accuracy bonus is:
+ # if 5 or less flags => 0.0
+ # if > 5 flags => (agreed flags / total flags) * 5.0
+ def self.user_accuracy_bonus(user)
+ user_stat = user&.user_stat
+ return 0.0 if user_stat.blank?
+
+ total = (user_stat.flags_agreed + user_stat.flags_disagreed + user_stat.flags_ignored).to_f
+ return 0.0 if total <= 5
+
+ (user_stat.flags_agreed / total) * 5.0
+ end
+
+ def reviewable_conversation
+ return if meta_topic.blank?
+ Reviewable::Conversation.new(meta_topic)
+ end
+
+end
+
+# == Schema Information
+#
+# Table name: reviewable_scores
+#
+# id :bigint(8) not null, primary key
+# reviewable_id :integer not null
+# user_id :integer not null
+# reviewable_score_type :integer not null
+# status :integer not null
+# score :float default(0.0), not null
+# take_action_bonus :float default(0.0), not null
+# reviewed_by_id :integer
+# reviewed_at :datetime
+# meta_topic_id :integer
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewable_scores_on_reviewable_id (reviewable_id)
+# index_reviewable_scores_on_user_id (user_id)
+#
diff --git a/app/models/reviewable_user.rb b/app/models/reviewable_user.rb
new file mode 100644
index 00000000000..b1778d44575
--- /dev/null
+++ b/app/models/reviewable_user.rb
@@ -0,0 +1,84 @@
+require_dependency 'reviewable'
+
+class ReviewableUser < Reviewable
+ def self.create_for(user)
+ create(
+ created_by_id: Discourse.system_user.id,
+ target: user
+ )
+ end
+
+ def build_actions(actions, guardian, args)
+ return unless pending?
+
+ actions.add(:approve) if guardian.can_approve?(target) || args[:approved_by_invite]
+ actions.add(:reject) if guardian.can_delete_user?(target)
+ end
+
+ def perform_approve(performed_by, args)
+ ReviewableUser.set_approved_fields!(target, performed_by)
+ target.save!
+
+ DiscourseEvent.trigger(:user_approved, target)
+
+ if args[:send_email] != false && SiteSetting.must_approve_users?
+ Jobs.enqueue(
+ :critical_user_email,
+ type: :signup_after_approval,
+ user_id: target.id
+ )
+ end
+ StaffActionLogger.new(performed_by).log_user_approve(target)
+
+ create_result(:success, :approved)
+ end
+
+ def perform_reject(performed_by, args)
+ destroyer = UserDestroyer.new(performed_by)
+ destroyer.destroy(target)
+
+ create_result(:success, :rejected)
+ rescue UserDestroyer::PostsExistError
+ create_result(:failed)
+ end
+
+ # Update's the user's fields for approval but does not save. This
+ # can be used when generating a new user that is approved on create
+ def self.set_approved_fields!(user, approved_by)
+ user.approved = true
+ user.approved_by ||= approved_by
+ user.approved_at ||= Time.zone.now
+ end
+end
+
+# == Schema Information
+#
+# Table name: reviewables
+#
+# id :bigint(8) not null, primary key
+# type :string not null
+# status :integer default(0), not null
+# created_by_id :integer not null
+# reviewable_by_moderator :boolean default(FALSE), not null
+# reviewable_by_group_id :integer
+# claimed_by_id :integer
+# category_id :integer
+# topic_id :integer
+# score :float default(0.0), not null
+# potential_spam :boolean default(FALSE), not null
+# target_id :integer
+# target_type :string
+# target_created_by_id :integer
+# payload :json
+# version :integer default(0), not null
+# latest_score :datetime
+# created_at :datetime not null
+# updated_at :datetime not null
+#
+# Indexes
+#
+# index_reviewables_on_status_and_created_at (status,created_at)
+# index_reviewables_on_status_and_score (status,score)
+# index_reviewables_on_status_and_type (status,type)
+# index_reviewables_on_type_and_target_id (type,target_id) UNIQUE
+#
diff --git a/app/models/topic.rb b/app/models/topic.rb
index 028b6fc7a55..b1f428e91d5 100644
--- a/app/models/topic.rb
+++ b/app/models/topic.rb
@@ -55,17 +55,18 @@ class Topic < ActiveRecord::Base
CategoryTagStat.topic_deleted(self) if self.tags.present?
end
super(trashed_by)
- update_flagged_posts_count
self.topic_embed.trash! if has_topic_embed?
end
- def recover!
+ def recover!(recovered_by = nil)
unless deleted_at.nil?
update_category_topic_count_by(1)
CategoryTagStat.topic_recovered(self) if self.tags.present?
end
- super
- update_flagged_posts_count
+
+ # Note parens are required because superclass doesn't take `recovered_by`
+ super()
+
unless (topic_embed = TopicEmbed.with_deleted.find_by_topic_id(id)).nil?
topic_embed.recover!
end
@@ -122,7 +123,6 @@ class Topic < ActiveRecord::Base
has_many :allowed_groups, through: :topic_allowed_groups, source: :group
has_many :allowed_group_users, through: :allowed_groups, source: :users
has_many :allowed_users, through: :topic_allowed_users, source: :user
- has_many :queued_posts
has_many :topic_tags
has_many :tags, through: :topic_tags, dependent: :destroy # dependent destroy applies to the topic_tags records
@@ -143,6 +143,7 @@ class Topic < ActiveRecord::Base
has_many :topic_invites
has_many :invites, through: :topic_invites, source: :invite
has_many :topic_timers, dependent: :destroy
+ has_many :reviewables
has_one :user_warning
has_one :first_post, -> { where post_number: 1 }, class_name: 'Post'
@@ -246,7 +247,6 @@ class Topic < ActiveRecord::Base
end
SearchIndexer.index(self)
- UserActionCreator.log_topic(self)
end
after_update do
@@ -313,9 +313,7 @@ class Topic < ActiveRecord::Base
end
def has_flags?
- FlagQuery.flagged_post_actions(filter: "active")
- .where("topics.id" => id)
- .exists?
+ ReviewableFlaggedPost.pending.default_visible.where(topic_id: id).exists?
end
def is_official_warning?
@@ -365,10 +363,6 @@ class Topic < ActiveRecord::Base
fancy_title
end
- def pending_posts_count
- queued_posts.new_count
- end
-
# Returns hot topics since a date for display in email digest.
def self.for_digest(user, since, opts = nil)
opts = opts || {}
@@ -803,6 +797,8 @@ class Topic < ActiveRecord::Base
cat = Category.find_by(id: new_category_id)
return false unless cat
+ reviewables.update_all(category_id: new_category_id)
+
changed_to_category(cat)
end
@@ -963,10 +959,6 @@ class Topic < ActiveRecord::Base
Topic.reset_highest(id)
end
- def update_flagged_posts_count
- PostAction.update_flagged_posts_count
- end
-
def update_action_counts
update_column(:like_count, Post.where(topic_id: id).sum(:like_count))
end
@@ -1404,6 +1396,18 @@ class Topic < ActiveRecord::Base
update!(bumped_at: post.created_at)
end
+ def auto_close_threshold_reached?
+ return if user&.staff?
+
+ scores = ReviewableScore.pending
+ .joins(:reviewable)
+ .where("reviewables.topic_id = ?", self.id)
+ .pluck("COUNT(DISTINCT reviewable_scores.user_id), COALESCE(SUM(reviewable_scores.score), 0.0)")
+ .first
+
+ scores[0] >= SiteSetting.num_flaggers_to_close_topic && scores[1] >= SiteSetting.score_to_auto_close_topic
+ end
+
private
def invite_to_private_message(invited_by, target_user, guardian)
@@ -1529,6 +1533,7 @@ end
# spam_count :integer default(0), not null
# pinned_at :datetime
# score :float
+# percent_rank :float default(1.0), not null
# subtype :string
# slug :string
# deleted_by_id :integer
@@ -1540,6 +1545,7 @@ end
# fancy_title :string(400)
# highest_staff_post_number :integer default(0), not null
# featured_link :string
+# reviewable_score :float default(0.0), not null
#
# Indexes
#
diff --git a/app/models/topic_converter.rb b/app/models/topic_converter.rb
index 76704a7a8ce..038f50cc413 100644
--- a/app/models/topic_converter.rb
+++ b/app/models/topic_converter.rb
@@ -25,20 +25,7 @@ class TopicConverter
@topic.save
update_user_stats
update_category_topic_count_by(1)
-
- # TODO: Every post in a PRIVATE MESSAGE looks the same: each is a UserAction::NEW_PRIVATE_MESSAGE.
- # So we need to remove all those user actions and re-log all the posts.
- # Post counting depends on the correct UserActions (NEW_TOPIC, REPLY), so once a private topic
- # becomes a public topic, post counts are wrong. The reverse is not so bad because
- # we don't count NEW_PRIVATE_MESSAGE in any public stats.
- # TBD: why do so many specs fail with this change?
-
- # UserAction.where(target_topic_id: @topic.id, action_type: [UserAction::GOT_PRIVATE_MESSAGE, UserAction::NEW_PRIVATE_MESSAGE]).find_each do |ua|
- # UserAction.remove_action!(ua.attributes.symbolize_keys.slice(:action_type, :user_id, :acting_user_id, :target_topic_id, :target_post_id))
- # end
- # @topic.posts.each do |post|
- # UserActionCreator.log_post(post) unless post.post_number == 1
- # end
+ Jobs.enqueue(:topic_action_converter, topic_id: @topic.id)
watch_topic(topic)
end
@@ -52,6 +39,7 @@ class TopicConverter
@topic.archetype = Archetype.private_message
add_allowed_users
@topic.save!
+ Jobs.enqueue(:topic_action_converter, topic_id: @topic.id)
watch_topic(topic)
end
@topic
diff --git a/app/models/user.rb b/app/models/user.rb
index 2acfad883b7..891665fa874 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -93,6 +93,8 @@ class User < ActiveRecord::Base
has_many :acting_group_histories, dependent: :destroy, foreign_key: :acting_user_id, class_name: 'GroupHistory'
has_many :targeted_group_histories, dependent: :destroy, foreign_key: :target_user_id, class_name: 'GroupHistory'
+ has_many :reviewable_scores, dependent: :destroy
+
delegate :last_sent_email_address, to: :email_logs
validates_presence_of :username
@@ -114,6 +116,7 @@ class User < ActiveRecord::Base
after_create :set_random_avatar
after_create :ensure_in_trust_level_group
after_create :set_default_categories_preferences
+ after_create :create_reviewable
before_save :update_username_lower
before_save :ensure_password_is_hashed
@@ -411,19 +414,22 @@ class User < ActiveRecord::Base
end
# Approve this user
- def approve(approver, send_mail = true)
- self.approved = true
- self.approved_at = Time.zone.now
- self.approved_by = approver
+ def approve(approved_by, send_mail = true)
+ Discourse.deprecate("User#approve is deprecated. Please use the Reviewable API instead.", output_in_test: true, since: "2.3.0beta5", drop_from: "2.4")
- if result = save
- send_approval_email if send_mail
- DiscourseEvent.trigger(:user_approved, self)
+ # Backwards compatibility - in case plugins or something is using the old API which accepted
+ # either a Number or object. Probably should remove at some point
+ approved_by = User.find_by(id: approved_by) if approved_by.is_a?(Numeric)
+
+ if reviewable_user = ReviewableUser.find_by(target: self)
+ result = reviewable_user.perform(approved_by, :approve, send_email: send_mail)
+ if result.success?
+ Reviewable.set_approved_fields!(self, approved_by)
+ return true
+ end
end
- StaffActionLogger.new(approver).log_user_approve(self)
-
- result
+ false
end
def self.email_hash(email)
@@ -813,7 +819,7 @@ class User < ActiveRecord::Base
def delete_posts_in_batches(guardian, batch_size = 20)
raise Discourse::InvalidAccess unless guardian.can_delete_all_posts? self
- QueuedPost.where(user_id: id).delete_all
+ Reviewable.where(created_by_id: id).delete_all
posts.order("post_number desc").limit(batch_size).each do |p|
PostDestroyer.new(guardian.user, p).destroy
@@ -974,6 +980,8 @@ class User < ActiveRecord::Base
# Flag all posts from a user as spam
def flag_linked_posts_as_spam
+ results = []
+
disagreed_flag_post_ids = PostAction.where(post_action_type_id: PostActionType.types[:spam])
.where.not(disagreed_at: nil)
.pluck(:post_id)
@@ -981,13 +989,12 @@ class User < ActiveRecord::Base
topic_links.includes(:post)
.where.not(post_id: disagreed_flag_post_ids)
.each do |tl|
- begin
- message = I18n.t('flag_reason.spam_hosts', domain: tl.domain, base_path: Discourse.base_path)
- PostAction.act(Discourse.system_user, tl.post, PostActionType.types[:spam], message: message)
- rescue PostAction::AlreadyActed
- # If the user has already acted, just ignore it
- end
+
+ message = I18n.t('flag_reason.spam_hosts', domain: tl.domain, base_path: Discourse.base_path)
+ results << PostActionCreator.create(Discourse.system_user, tl.post, :spam, message: message)
end
+
+ results
end
def has_uploaded_avatar
@@ -1231,6 +1238,20 @@ class User < ActiveRecord::Base
Group.user_trust_level_change!(id, trust_level)
end
+ def create_reviewable
+ return unless SiteSetting.must_approve_users? || SiteSetting.invite_only?
+ return if approved?
+
+ reviewable = ReviewableUser.needs_review!(target: self, created_by: Discourse.system_user, reviewable_by_moderator: true)
+ reviewable.add_score(
+ Discourse.system_user,
+ ReviewableScore.types[:needs_approval],
+ force_review: true
+ )
+
+ reviewable
+ end
+
def create_user_stat
stat = UserStat.new(new_since: Time.now)
stat.user_id = id
@@ -1310,15 +1331,6 @@ class User < ActiveRecord::Base
end
end
- def send_approval_email
- if SiteSetting.must_approve_users
- Jobs.enqueue(:critical_user_email,
- type: :signup_after_approval,
- user_id: id
- )
- end
- end
-
def set_default_categories_preferences
return if self.staged?
@@ -1465,6 +1477,7 @@ end
# staged :boolean default(FALSE), not null
# first_seen_at :datetime
# silenced_till :datetime
+# group_locked_trust_level :integer
# manual_locked_trust_level :integer
#
# Indexes
diff --git a/app/models/user_action.rb b/app/models/user_action.rb
index 8a7d8d06020..25afc8619b8 100644
--- a/app/models/user_action.rb
+++ b/app/models/user_action.rb
@@ -1,5 +1,9 @@
class UserAction < ActiveRecord::Base
+ self.ignored_columns = %w{
+ queued_post_id
+ }
+
belongs_to :user
belongs_to :target_post, class_name: "Post"
belongs_to :target_topic, class_name: "Topic"
@@ -18,14 +22,12 @@ class UserAction < ActiveRecord::Base
EDIT = 11
NEW_PRIVATE_MESSAGE = 12
GOT_PRIVATE_MESSAGE = 13
- PENDING = 14
SOLVED = 15
ASSIGNED = 16
ORDER = Hash[*[
GOT_PRIVATE_MESSAGE,
NEW_PRIVATE_MESSAGE,
- PENDING,
NEW_TOPIC,
REPLY,
RESPONSE,
@@ -149,48 +151,6 @@ class UserAction < ActiveRecord::Base
topic_archived
}.map! { |s| "NULL as #{s}" }.join(", ")
- def self.stream_queued(opts = nil)
- opts ||= {}
-
- offset = opts[:offset] || 0
- limit = opts[:limit] || 60
-
- # this is somewhat ugly, but the serializer wants all these columns
- # it is more correct to have an object with all the fields needed
- # cause then we can catch and change if we ever add columns
- builder = DB.build <<~SQL
- SELECT
- a.id,
- t.title,
- a.action_type,
- a.created_at,
- t.id topic_id,
- u.username,
- u.name,
- u.id AS user_id,
- qp.raw,
- t.category_id,
- #{NULL_QUEUED_STREAM_COLS}
- FROM user_actions as a
- JOIN queued_posts AS qp ON qp.id = a.queued_post_id
- LEFT OUTER JOIN topics t on t.id = qp.topic_id
- JOIN users u on u.id = a.user_id
- LEFT JOIN categories c on c.id = t.category_id
- /*where*/
- /*order_by*/
- /*offset*/
- /*limit*/
- SQL
-
- builder
- .where('a.user_id = :user_id', user_id: opts[:user_id].to_i)
- .where('action_type = :pending', pending: UserAction::PENDING)
- .order_by("a.created_at desc")
- .offset(offset.to_i)
- .limit(limit.to_i)
- .query
- end
-
def self.stream(opts = nil)
opts ||= {}
@@ -281,12 +241,8 @@ class UserAction < ActiveRecord::Base
def self.log_action!(hash)
required_parameters = [:action_type, :user_id, :acting_user_id]
- if hash[:action_type] == UserAction::PENDING
- required_parameters << :queued_post_id
- else
- required_parameters << :target_post_id
- required_parameters << :target_topic_id
- end
+ required_parameters << :target_post_id
+ required_parameters << :target_topic_id
require_parameters(hash, *required_parameters)
@@ -415,7 +371,6 @@ class UserAction < ActiveRecord::Base
unless guardian.can_see_notifications?(User.where(id: user_id).first)
builder.where("a.action_type not in (#{BOOKMARK})")
- builder.where('a.action_type <> :pending', pending: UserAction::PENDING)
end
if !guardian.can_see_private_messages?(user_id) || ignore_private_messages || !guardian.user
@@ -470,7 +425,6 @@ end
# acting_user_id :integer
# created_at :datetime not null
# updated_at :datetime not null
-# queued_post_id :integer
#
# Indexes
#
diff --git a/app/models/web_hook.rb b/app/models/web_hook.rb
index 916a01edd0a..17bbb29e07b 100644
--- a/app/models/web_hook.rb
+++ b/app/models/web_hook.rb
@@ -56,6 +56,10 @@ class WebHook < ActiveRecord::Base
end
def self.enqueue_object_hooks(type, object, event, serializer = nil)
+ if type == :flag
+ Discourse.deprecate("The flags webhook is deprecated. Please use reviewable instead.")
+ end
+
if active_web_hooks(type).exists?
payload = WebHook.generate_payload(type, object, serializer)
diff --git a/app/models/web_hook_event_type.rb b/app/models/web_hook_event_type.rb
index 8841bb64e48..fe0dce46d00 100644
--- a/app/models/web_hook_event_type.rb
+++ b/app/models/web_hook_event_type.rb
@@ -7,6 +7,7 @@ class WebHookEventType < ActiveRecord::Base
TAG = 6
FLAG = 7
QUEUED_POST = 8
+ REVIEWABLE = 9
has_and_belongs_to_many :web_hooks
diff --git a/app/serializers/current_user_serializer.rb b/app/serializers/current_user_serializer.rb
index b52b9b36063..39aff7073ad 100644
--- a/app/serializers/current_user_serializer.rb
+++ b/app/serializers/current_user_serializer.rb
@@ -8,7 +8,6 @@ class CurrentUserSerializer < BasicUserSerializer
:read_first_notification?,
:admin?,
:notification_channel_position,
- :site_flagged_posts_count,
:moderator?,
:staff?,
:title,
@@ -30,8 +29,7 @@ class CurrentUserSerializer < BasicUserSerializer
:muted_category_ids,
:dismissed_banner_key,
:is_anonymous,
- :post_queue_new_count,
- :show_queued_posts,
+ :reviewable_count,
:read_faq,
:automatically_unpin_topics,
:mailing_list_mode,
@@ -58,10 +56,6 @@ class CurrentUserSerializer < BasicUserSerializer
scope.can_create_topic?(nil)
end
- def include_site_flagged_posts_count?
- object.staff?
- end
-
def read_faq
object.user_stat.read_faq?
end
@@ -106,10 +100,6 @@ class CurrentUserSerializer < BasicUserSerializer
object.user_option.redirected_to_top
end
- def site_flagged_posts_count
- PostAction.flagged_posts_count
- end
-
def can_send_private_email_messages
scope.can_send_private_messages_to_email?
end
@@ -189,20 +179,8 @@ class CurrentUserSerializer < BasicUserSerializer
object.anonymous?
end
- def post_queue_new_count
- QueuedPost.new_count
- end
-
- def include_post_queue_new_count?
- object.staff?
- end
-
- def show_queued_posts
- true
- end
-
- def include_show_queued_posts?
- object.staff? && (NewPostManager.queue_enabled? || QueuedPost.new_count > 0)
+ def reviewable_count
+ Reviewable.list_for(object).count
end
def mailing_list_mode
diff --git a/app/serializers/post_serializer.rb b/app/serializers/post_serializer.rb
index 703d312376c..d70a1062159 100644
--- a/app/serializers/post_serializer.rb
+++ b/app/serializers/post_serializer.rb
@@ -257,7 +257,7 @@ class PostSerializer < BasicPostSerializer
summary[:can_defer_flags] = true if scope.is_staff? &&
PostActionType.flag_types_without_custom.values.include?(id) &&
active_flags.present? && active_flags.has_key?(id) &&
- active_flags[id].count > 0
+ active_flags[id] > 0
end
if actions.present? && actions.has_key?(id)
diff --git a/app/serializers/queued_post_serializer.rb b/app/serializers/queued_post_serializer.rb
index b2d215cf5e2..4b5f25550b6 100644
--- a/app/serializers/queued_post_serializer.rb
+++ b/app/serializers/queued_post_serializer.rb
@@ -1,28 +1,49 @@
+# Deprecated, should be removed once users have sufficient opportunity to do so
class QueuedPostSerializer < ApplicationSerializer
- attributes :id,
- :queue,
- :user_id,
- :state,
- :topic_id,
- :approved_by_id,
- :rejected_by_id,
- :raw,
- :post_options,
- :created_at,
- :category_id,
- :can_delete_user
-
- has_one :user, serializer: AdminUserListSerializer
+ attributes(
+ :id,
+ :queue,
+ :user_id,
+ :state,
+ :topic_id,
+ :approved_by_id,
+ :rejected_by_id,
+ :raw,
+ :post_options,
+ :created_at,
+ :category_id,
+ :can_delete_user
+ )
+ has_one :created_by, serializer: AdminUserListSerializer, root: :users
has_one :topic, serializer: BasicTopicSerializer
- def category_id
- cat_id = object.topic.try(:category_id) || object.post_options['category']
- cat_id.to_i if cat_id
+ def queue
+ 'default'
end
- def include_category_id?
- category_id.present?
+ def user_id
+ object.created_by_id
+ end
+
+ def state
+ object.status + 1
+ end
+
+ def approved_by_id
+ who_did(:approved)
+ end
+
+ def rejected_by_id
+ who_did(:rejected)
+ end
+
+ def raw
+ object.payload['raw']
+ end
+
+ def post_options
+ object.payload.except('raw')
end
def can_delete_user
@@ -30,7 +51,20 @@ class QueuedPostSerializer < ApplicationSerializer
end
def include_can_delete_user?
- user && user.trust_level == TrustLevel[0]
+ created_by && created_by.trust_level == TrustLevel[0]
+ end
+
+protected
+
+ def who_did(status)
+ object.
+ reviewable_histories.
+ where(
+ reviewable_history_type: ReviewableHistory.types[:transitioned],
+ status: Reviewable.statuses[status]
+ ).
+ order(:created_at)
+ .last&.created_by_id
end
end
diff --git a/app/serializers/reviewable_action_serializer.rb b/app/serializers/reviewable_action_serializer.rb
new file mode 100644
index 00000000000..6942ccd0f59
--- /dev/null
+++ b/app/serializers/reviewable_action_serializer.rb
@@ -0,0 +1,28 @@
+class ReviewableActionSerializer < ApplicationSerializer
+ attributes :id, :icon, :label, :confirm_message, :description, :client_action
+
+ def label
+ I18n.t(object.label)
+ end
+
+ def confirm_message
+ I18n.t(object.confirm_message)
+ end
+
+ def description
+ I18n.t(object.description, default: nil)
+ end
+
+ def include_description?
+ description.present?
+ end
+
+ def include_confirm_message?
+ object.confirm_message.present?
+ end
+
+ def include_client_action?
+ object.client_action.present?
+ end
+
+end
diff --git a/app/serializers/reviewable_bundled_action_serializer.rb b/app/serializers/reviewable_bundled_action_serializer.rb
new file mode 100644
index 00000000000..06654390152
--- /dev/null
+++ b/app/serializers/reviewable_bundled_action_serializer.rb
@@ -0,0 +1,8 @@
+class ReviewableBundledActionSerializer < ApplicationSerializer
+ attributes :id, :icon, :label
+ has_many :actions, serializer: ReviewableActionSerializer, root: 'actions'
+
+ def label
+ I18n.t(object.label)
+ end
+end
diff --git a/app/serializers/reviewable_conversation_post_serializer.rb b/app/serializers/reviewable_conversation_post_serializer.rb
new file mode 100644
index 00000000000..026289ed6cf
--- /dev/null
+++ b/app/serializers/reviewable_conversation_post_serializer.rb
@@ -0,0 +1,4 @@
+class ReviewableConversationPostSerializer < ApplicationSerializer
+ attributes :id, :excerpt
+ has_one :user, serializer: BasicUserSerializer, root: 'users'
+end
diff --git a/app/serializers/reviewable_conversation_serializer.rb b/app/serializers/reviewable_conversation_serializer.rb
new file mode 100644
index 00000000000..d31d0fccdaa
--- /dev/null
+++ b/app/serializers/reviewable_conversation_serializer.rb
@@ -0,0 +1,4 @@
+class ReviewableConversationSerializer < ApplicationSerializer
+ attributes :id, :permalink, :has_more
+ has_many :conversation_posts, serializer: ReviewableConversationPostSerializer
+end
diff --git a/app/serializers/reviewable_editable_field_serializer.rb b/app/serializers/reviewable_editable_field_serializer.rb
new file mode 100644
index 00000000000..d169b69c599
--- /dev/null
+++ b/app/serializers/reviewable_editable_field_serializer.rb
@@ -0,0 +1,3 @@
+class ReviewableEditableFieldSerializer < ApplicationSerializer
+ attributes :id, :type
+end
diff --git a/app/serializers/reviewable_flagged_post_serializer.rb b/app/serializers/reviewable_flagged_post_serializer.rb
new file mode 100644
index 00000000000..ca862bd57c7
--- /dev/null
+++ b/app/serializers/reviewable_flagged_post_serializer.rb
@@ -0,0 +1,3 @@
+class ReviewableFlaggedPostSerializer < ReviewableSerializer
+ target_attributes :cooked, :raw
+end
diff --git a/app/serializers/reviewable_history_serializer.rb b/app/serializers/reviewable_history_serializer.rb
new file mode 100644
index 00000000000..afd937ecaa9
--- /dev/null
+++ b/app/serializers/reviewable_history_serializer.rb
@@ -0,0 +1,6 @@
+class ReviewableHistorySerializer < ApplicationSerializer
+
+ attributes :id, :reviewable_history_type, :status, :created_at
+ has_one :created_by, serializer: BasicUserSerializer, root: 'users'
+
+end
diff --git a/app/serializers/reviewable_perform_result_serializer.rb b/app/serializers/reviewable_perform_result_serializer.rb
new file mode 100644
index 00000000000..813bc5f99a1
--- /dev/null
+++ b/app/serializers/reviewable_perform_result_serializer.rb
@@ -0,0 +1,40 @@
+class ReviewablePerformResultSerializer < ApplicationSerializer
+
+ attributes(
+ :success,
+ :transition_to,
+ :transition_to_id,
+ :created_post_id,
+ :created_post_topic_id,
+ :remove_reviewable_ids,
+ :version
+ )
+
+ def success
+ object.success?
+ end
+
+ def transition_to_id
+ Reviewable.statuses[transition_to]
+ end
+
+ def version
+ object.reviewable.version
+ end
+
+ def created_post_id
+ object.created_post.id
+ end
+
+ def include_created_post_id?
+ object.created_post.present?
+ end
+
+ def created_post_topic_id
+ object.created_post_topic.id
+ end
+
+ def include_created_post_topic_id?
+ object.created_post_topic.present?
+ end
+end
diff --git a/app/serializers/reviewable_queued_post_serializer.rb b/app/serializers/reviewable_queued_post_serializer.rb
new file mode 100644
index 00000000000..a6e97f7d26a
--- /dev/null
+++ b/app/serializers/reviewable_queued_post_serializer.rb
@@ -0,0 +1,19 @@
+class ReviewableQueuedPostSerializer < ReviewableSerializer
+
+ payload_attributes(
+ :raw,
+ :title,
+ :archetype,
+ :category,
+ :visible,
+ :is_warning,
+ :first_post_checks,
+ :featured_link,
+ :reply_to_post_number,
+ :is_poll,
+ :typing_duration_msecs,
+ :composer_open_duration_msecs,
+ :tags
+ )
+
+end
diff --git a/app/serializers/reviewable_score_serializer.rb b/app/serializers/reviewable_score_serializer.rb
new file mode 100644
index 00000000000..017ecbafee8
--- /dev/null
+++ b/app/serializers/reviewable_score_serializer.rb
@@ -0,0 +1,18 @@
+require_dependency 'reviewable_score_type_serializer'
+
+class ReviewableScoreSerializer < ApplicationSerializer
+
+ attributes :id, :score, :agree_stats
+ has_one :user, serializer: BasicUserSerializer, root: 'users'
+ has_one :score_type, serializer: ReviewableScoreTypeSerializer
+ has_one :reviewable_conversation, serializer: ReviewableConversationSerializer
+
+ def agree_stats
+ {
+ agreed: user.user_stat.flags_agreed,
+ disagreed: user.user_stat.flags_disagreed,
+ ignored: user.user_stat.flags_ignored
+ }
+ end
+
+end
diff --git a/app/serializers/reviewable_score_type_serializer.rb b/app/serializers/reviewable_score_type_serializer.rb
new file mode 100644
index 00000000000..c4d8ecd2d53
--- /dev/null
+++ b/app/serializers/reviewable_score_type_serializer.rb
@@ -0,0 +1,10 @@
+class ReviewableScoreTypeSerializer < ApplicationSerializer
+ attributes :id, :title
+
+ # Allow us to share post action type translations for backwards compatibility
+ def title
+ I18n.t("post_action_types.#{ReviewableScore.types[id]}.title", default: nil) ||
+ I18n.t("reviewable_score_types.#{ReviewableScore.types[id]}.title")
+ end
+
+end
diff --git a/app/serializers/reviewable_serializer.rb b/app/serializers/reviewable_serializer.rb
new file mode 100644
index 00000000000..36e0e6f1245
--- /dev/null
+++ b/app/serializers/reviewable_serializer.rb
@@ -0,0 +1,97 @@
+require_dependency 'reviewable_action_serializer'
+require_dependency 'reviewable_editable_field_serializer'
+
+class ReviewableSerializer < ApplicationSerializer
+
+ class_attribute :_payload_for_serialization
+
+ attributes(
+ :id,
+ :status,
+ :type,
+ :topic_id,
+ :category_id,
+ :created_at,
+ :can_edit,
+ :score,
+ :version
+ )
+
+ has_one :created_by, serializer: BasicUserSerializer, root: 'users'
+ has_one :target_created_by, serializer: BasicUserSerializer, root: 'users'
+ has_one :topic, serializer: ListableTopicSerializer
+ has_many :editable_fields, serializer: ReviewableEditableFieldSerializer, embed: :objects
+ has_many :reviewable_scores, serializer: ReviewableScoreSerializer
+ has_many :bundled_actions, serializer: ReviewableBundledActionSerializer
+ has_many :reviewable_histories, serializer: ReviewableHistorySerializer
+
+ # Used to keep track of our payload attributes
+ class_attribute :_payload_for_serialization
+
+ def bundled_actions
+ object.actions_for(scope).bundles
+ end
+
+ def reviewable_actions
+ object.actions_for(scope).to_a
+ end
+
+ def editable_fields
+ object.editable_for(scope).to_a
+ end
+
+ def can_edit
+ editable_fields.present?
+ end
+
+ def self.create_attribute(name, field)
+ attribute(name)
+
+ class_eval <<~GETTER
+ def #{name}
+ #{field}
+ end
+
+ def include_#{name}?
+ #{name}.present?
+ end
+ GETTER
+ end
+
+ # This is easier than creating an AMS method for each attribute
+ def self.target_attributes(*attributes)
+ attributes.each do |a|
+ create_attribute(a, "object.target&.#{a}")
+ end
+ end
+
+ def self.payload_attributes(*attributes)
+ self._payload_for_serialization ||= []
+ self._payload_for_serialization += attributes.map(&:to_s)
+ end
+
+ def attributes
+ data = super
+
+ if object.target.present?
+ # Automatically add the target id as a "good name" for example a target_type of `User`
+ # becomes `user_id`
+ data[:"#{object.target_type.downcase}_id"] = object.target_id
+ end
+
+ if self.class._payload_for_serialization.present?
+ data[:payload] = (object.payload || {}).slice(*self.class._payload_for_serialization)
+ end
+
+ data
+ end
+
+ def include_topic_id?
+ object.topic_id.present?
+ end
+
+ def include_category_id?
+ object.category_id.present?
+ end
+
+end
diff --git a/app/serializers/reviewable_topic_serializer.rb b/app/serializers/reviewable_topic_serializer.rb
new file mode 100644
index 00000000000..e61111defbb
--- /dev/null
+++ b/app/serializers/reviewable_topic_serializer.rb
@@ -0,0 +1,19 @@
+class ReviewableTopicSerializer < ApplicationSerializer
+ attributes(
+ :id,
+ :title,
+ :fancy_title,
+ :slug,
+ :archived,
+ :closed,
+ :visible,
+ :archetype,
+ :relative_url,
+ :stats,
+ :reviewable_score
+ )
+
+ def stats
+ @options[:stats][object.id]
+ end
+end
diff --git a/app/serializers/reviewable_user_serializer.rb b/app/serializers/reviewable_user_serializer.rb
new file mode 100644
index 00000000000..1991a4f4ead
--- /dev/null
+++ b/app/serializers/reviewable_user_serializer.rb
@@ -0,0 +1,9 @@
+class ReviewableUserSerializer < ReviewableSerializer
+
+ target_attributes(
+ :username,
+ :email,
+ :name
+ )
+
+end
diff --git a/app/serializers/topic_view_serializer.rb b/app/serializers/topic_view_serializer.rb
index 0702366a331..8a7105bb91b 100644
--- a/app/serializers/topic_view_serializer.rb
+++ b/app/serializers/topic_view_serializer.rb
@@ -16,58 +16,62 @@ class TopicViewSerializer < ApplicationSerializer
end
end
- attributes_from_topic :id,
- :title,
- :fancy_title,
- :posts_count,
- :created_at,
- :views,
- :reply_count,
- :like_count,
- :last_posted_at,
- :visible,
- :closed,
- :archived,
- :has_summary,
- :archetype,
- :slug,
- :category_id,
- :word_count,
- :deleted_at,
- :pending_posts_count,
- :user_id,
- :featured_link,
- :featured_link_root_domain,
- :pinned_globally,
- :pinned_at,
- :pinned_until
+ attributes_from_topic(
+ :id,
+ :title,
+ :fancy_title,
+ :posts_count,
+ :created_at,
+ :views,
+ :reply_count,
+ :like_count,
+ :last_posted_at,
+ :visible,
+ :closed,
+ :archived,
+ :has_summary,
+ :archetype,
+ :slug,
+ :category_id,
+ :word_count,
+ :deleted_at,
+ :user_id,
+ :featured_link,
+ :featured_link_root_domain,
+ :pinned_globally,
+ :pinned_at,
+ :pinned_until
+ )
- attributes :draft,
- :draft_key,
- :draft_sequence,
- :posted,
- :unpinned,
- :pinned,
- :details,
- :current_post_number,
- :highest_post_number,
- :last_read_post_number,
- :last_read_post_id,
- :deleted_by,
- :has_deleted,
- :actions_summary,
- :expandable_first_post,
- :is_warning,
- :chunk_size,
- :bookmarked,
- :message_archived,
- :topic_timer,
- :private_topic_timer,
- :unicode_title,
- :message_bus_last_id,
- :participant_count,
- :destination_category_id,
- :pm_with_non_human_user
+ attributes(
+ :draft,
+ :draft_key,
+ :draft_sequence,
+ :posted,
+ :unpinned,
+ :pinned,
+ :details,
+ :current_post_number,
+ :highest_post_number,
+ :last_read_post_number,
+ :last_read_post_id,
+ :deleted_by,
+ :has_deleted,
+ :actions_summary,
+ :expandable_first_post,
+ :is_warning,
+ :chunk_size,
+ :bookmarked,
+ :message_archived,
+ :topic_timer,
+ :private_topic_timer,
+ :unicode_title,
+ :message_bus_last_id,
+ :participant_count,
+ :destination_category_id,
+ :pm_with_non_human_user,
+ :pending_posts_count
+ )
# TODO: Split off into proper object / serializer
def details
@@ -242,10 +246,6 @@ class TopicViewSerializer < ApplicationSerializer
object.topic_user&.bookmarked
end
- def include_pending_posts_count?
- scope.is_staff? && NewPostManager.queue_enabled?
- end
-
def topic_timer
TopicTimerSerializer.new(object.topic.public_topic_timer, root: false)
end
@@ -297,6 +297,14 @@ class TopicViewSerializer < ApplicationSerializer
object.topic.shared_draft.present?
end
+ def pending_posts_count
+ ReviewableQueuedPost.viewable_by(scope.user).where(topic_id: object.topic.id).pending.count
+ end
+
+ def include_pending_posts_count?
+ scope.is_staff? && NewPostManager.queue_enabled?
+ end
+
private
def private_message?(topic)
diff --git a/app/serializers/web_hook_flag_serializer.rb b/app/serializers/web_hook_flag_serializer.rb
index 847ae810e3d..895a7b82c6c 100644
--- a/app/serializers/web_hook_flag_serializer.rb
+++ b/app/serializers/web_hook_flag_serializer.rb
@@ -24,18 +24,24 @@ class WebHookFlagSerializer < ApplicationSerializer
end
def resolved_at
- object.disposed_at
+ object.disagreed_at || object.agreed_at || object.deferred_at
end
def include_resolved_at?
- object.disposed_at.present?
+ resolved_at.present?
end
def resolved_by
- User.find(object.disposed_by_id).username
+ User.find(disposed_by_id).username
end
def include_resolved_by?
- object.disposed_by_id.present?
+ disposed_by_id.present?
+ end
+
+protected
+
+ def disposed_by_id
+ object.disagreed_by_id || object.agreed_by_id || object.deferred_by_id
end
end
diff --git a/app/services/post_alerter.rb b/app/services/post_alerter.rb
index a3402bbcdf7..40d1d41d18b 100644
--- a/app/services/post_alerter.rb
+++ b/app/services/post_alerter.rb
@@ -1,5 +1,5 @@
require_dependency 'distributed_mutex'
-require_dependency 'user_action_creator'
+require_dependency 'user_action_manager'
class PostAlerter
def self.post_created(post, opts = {})
@@ -376,7 +376,7 @@ class PostAlerter
end
end
- UserActionCreator.log_notification(original_post, user, type, opts[:acting_user_id])
+ UserActionManager.notification_created(original_post, user, type, opts[:acting_user_id])
topic_title = post.topic.title
# when sending a private message email, keep the original title
diff --git a/app/services/post_owner_changer.rb b/app/services/post_owner_changer.rb
index df318659dad..5ce235f2f2b 100644
--- a/app/services/post_owner_changer.rb
+++ b/app/services/post_owner_changer.rb
@@ -1,3 +1,5 @@
+require_dependency 'post_action_destroyer'
+
class PostOwnerChanger
def initialize(params)
@@ -21,7 +23,7 @@ class PostOwnerChanger
post.topic = @topic
post.set_owner(@new_owner, @acting_user, @skip_revision)
- PostAction.remove_act(@new_owner, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(@new_owner, post, :like)
level = post.is_first_post? ? :watching : :tracking
TopicUser.change(@new_owner.id, @topic.id, notification_level: NotificationLevels.topic_levels[level])
diff --git a/app/services/spam_rule/auto_silence.rb b/app/services/spam_rule/auto_silence.rb
index 7eeb9baa9cc..3486e3a0e20 100644
--- a/app/services/spam_rule/auto_silence.rb
+++ b/app/services/spam_rule/auto_silence.rb
@@ -22,47 +22,37 @@ class SpamRule::AutoSilence
return false if @user.staged?
return false if @user.has_trust_level?(TrustLevel[1])
- if SiteSetting.num_spam_flags_to_silence_new_user > 0 &&
+ if SiteSetting.spam_score_to_silence_new_user > 0 &&
SiteSetting.num_users_to_silence_new_user > 0 &&
- num_spam_flags_against_user >= SiteSetting.num_spam_flags_to_silence_new_user &&
- num_users_who_flagged_spam_against_user >= SiteSetting.num_users_to_silence_new_user
- return true
- end
-
- if SiteSetting.num_tl3_flags_to_silence_new_user > 0 &&
- SiteSetting.num_tl3_users_to_silence_new_user > 0 &&
- num_tl3_flags_against_user >= SiteSetting.num_tl3_flags_to_silence_new_user &&
- num_tl3_users_who_flagged >= SiteSetting.num_tl3_users_to_silence_new_user
+ user_spam_stats.total_spam_score >= SiteSetting.spam_score_to_silence_new_user &&
+ user_spam_stats.spam_user_count >= SiteSetting.num_users_to_silence_new_user
return true
end
false
end
- def num_spam_flags_against_user
- Post.where(user_id: @user.id).sum(:spam_count)
- end
+ def user_spam_stats
+ return @user_spam_stats if @user_spam_stats
- def num_users_who_flagged_spam_against_user
- post_ids = Post.where('user_id = ? and spam_count > 0', @user.id).pluck(:id)
- return 0 if post_ids.empty?
- PostAction.spam_flags.where(post_id: post_ids).pluck(:user_id).uniq.size
- end
+ params = {
+ user_id: @user.id,
+ spam_type: PostActionType.types[:spam],
+ pending: ReviewableScore.statuses[:pending],
+ agreed: ReviewableScore.statuses[:agreed]
+ }
- def num_tl3_flags_against_user
- if flagged_post_ids.empty?
- 0
- else
- PostAction.where(post_id: flagged_post_ids).joins(:user).where('users.trust_level >= ?', 3).count
- end
- end
+ result = DB.query(<<~SQL, params)
+ SELECT COALESCE(SUM(rs.score), 0) AS total_spam_score,
+ COUNT(DISTINCT rs.user_id) AS spam_user_count
+ FROM reviewables AS r
+ INNER JOIN reviewable_scores AS rs ON rs.reviewable_id = r.id
+ WHERE r.target_created_by_id = :user_id
+ AND rs.reviewable_score_type = :spam_type
+ AND rs.status IN (:pending, :agreed)
+ SQL
- def num_tl3_users_who_flagged
- if flagged_post_ids.empty?
- 0
- else
- PostAction.where(post_id: flagged_post_ids).joins(:user).where('users.trust_level >= ?', 3).pluck(:user_id).uniq.size
- end
+ @user_spam_stats = result[0]
end
def flagged_post_ids
diff --git a/app/services/spam_rule/flag_sockpuppets.rb b/app/services/spam_rule/flag_sockpuppets.rb
index 16100a75653..d7fd26cdc56 100644
--- a/app/services/spam_rule/flag_sockpuppets.rb
+++ b/app/services/spam_rule/flag_sockpuppets.rb
@@ -33,10 +33,11 @@ class SpamRule::FlagSockpuppets
def flag_sockpuppet_users
message = I18n.t('flag_reason.sockpuppet', ip_address: @post.user.ip_address, base_path: Discourse.base_path)
- PostAction.act(Discourse.system_user, @post, PostActionType.types[:spam], message: message) rescue PostAction::AlreadyActed
+
+ PostActionCreator.create(Discourse.system_user, @post, :spam, message: message)
if (first_post = @post.topic.posts.by_post_number.first).try(:user).try(:new_user?)
- PostAction.act(Discourse.system_user, first_post, PostActionType.types[:spam], message: message) rescue PostAction::AlreadyActed
+ PostActionCreator.create(Discourse.system_user, first_post, :spam, message: message)
end
end
diff --git a/app/services/staff_action_logger.rb b/app/services/staff_action_logger.rb
index 5a87ba1118d..05cfe8a0a39 100644
--- a/app/services/staff_action_logger.rb
+++ b/app/services/staff_action_logger.rb
@@ -554,27 +554,27 @@ class StaffActionLogger
end
def log_post_approved(post, opts = {})
- raise Discourse::InvalidParameters.new(:post) unless post && post.is_a?(Post)
+ raise Discourse::InvalidParameters.new(:post) unless post.is_a?(Post)
UserHistory.create!(params(opts).merge(
action: UserHistory.actions[:post_approved],
post_id: post.id
))
end
- def log_post_rejected(rejected_post, opts = {})
- raise Discourse::InvalidParameters.new(:rejected_post) unless rejected_post && rejected_post.is_a?(QueuedPost)
+ def log_post_rejected(reviewable, rejected_at, opts = {})
+ raise Discourse::InvalidParameters.new(:rejected_post) unless reviewable.is_a?(Reviewable)
- topic = rejected_post.topic || Topic.with_deleted.find_by(id: rejected_post.topic_id)
+ topic = reviewable.topic || Topic.with_deleted.find_by(id: reviewable.topic_id)
topic_title = topic&.title || I18n.t('staff_action_logs.not_found')
- username = rejected_post.user&.username || I18n.t('staff_action_logs.unknown')
- name = rejected_post.user&.name || I18n.t('staff_action_logs.unknown')
+ username = reviewable.created_by.username || I18n.t('staff_action_logs.unknown')
+ name = reviewable.created_by.name || I18n.t('staff_action_logs.unknown')
details = [
- "created_at: #{rejected_post.created_at}",
- "rejected_at: #{rejected_post.rejected_at}",
+ "created_at: #{reviewable.created_at}",
+ "rejected_at: #{rejected_at}",
"user: #{username} (#{name})",
"topic: #{topic_title}",
- "raw: #{rejected_post.raw}",
+ "raw: #{reviewable.payload['raw']}",
]
UserHistory.create!(params(opts).merge(
diff --git a/app/services/user_action_creator.rb b/app/services/user_action_creator.rb
deleted file mode 100644
index 6d4b917bb89..00000000000
--- a/app/services/user_action_creator.rb
+++ /dev/null
@@ -1,153 +0,0 @@
-class UserActionCreator
- def self.disable
- @disabled = true
- end
-
- def self.enable
- @disabled = false
- end
-
- def self.log_notification(post, user, notification_type, acting_user_id = nil)
- return if @disabled
-
- action =
- case notification_type
- when Notification.types[:quoted]
- UserAction::QUOTE
- when Notification.types[:replied]
- UserAction::RESPONSE
- when Notification.types[:mentioned]
- UserAction::MENTION
- when Notification.types[:edited]
- UserAction::EDIT
- end
-
- # skip any invalid items, eg failed to save post and so on
- return unless action && post && user && post.id
-
- row = {
- action_type: action,
- user_id: user.id,
- acting_user_id: acting_user_id || post.user_id,
- target_topic_id: post.topic_id,
- target_post_id: post.id
- }
-
- if post.deleted_at.nil?
- UserAction.log_action!(row)
- else
- UserAction.remove_action!(row)
- end
- end
-
- def self.log_post(model)
- return if @disabled
-
- # first post gets nada
- return if model.is_first_post?
- return if model.topic.blank?
-
- row = {
- action_type: UserAction::REPLY,
- user_id: model.user_id,
- acting_user_id: model.user_id,
- target_post_id: model.id,
- target_topic_id: model.topic_id,
- created_at: model.created_at
- }
-
- rows = [row]
-
- if model.topic.private_message?
- rows = []
- model.topic.topic_allowed_users.each do |ta|
- row = row.dup
- row[:user_id] = ta.user_id
- row[:action_type] = ta.user_id == model.user_id ? UserAction::NEW_PRIVATE_MESSAGE : UserAction::GOT_PRIVATE_MESSAGE
- rows << row
- end
- end
-
- rows.each do |r|
- if model.deleted_at.nil?
- UserAction.log_action!(r)
- else
- UserAction.remove_action!(r)
- end
- end
- end
-
- def self.log_topic(model)
- return if @disabled
-
- # no action to log here, this can happen if a user is deleted
- # then topic has no user_id
- return unless model.user_id
-
- row = {
- action_type: model.private_message? ? UserAction::NEW_PRIVATE_MESSAGE : UserAction::NEW_TOPIC,
- user_id: model.user_id,
- acting_user_id: model.user_id,
- target_topic_id: model.id,
- target_post_id: -1,
- created_at: model.created_at
- }
-
- UserAction.remove_action!(row.merge(
- action_type: model.private_message? ? UserAction::NEW_TOPIC : UserAction::NEW_PRIVATE_MESSAGE
- ))
-
- rows = [row]
-
- if model.private_message?
- model.topic_allowed_users.reject { |a| a.user_id == model.user_id }.each do |ta|
- row = row.dup
- row[:user_id] = ta.user_id
- row[:action_type] = UserAction::GOT_PRIVATE_MESSAGE
- rows << row
- end
- end
-
- rows.each do |r|
- if model.deleted_at.nil?
- UserAction.log_action!(r)
- else
- UserAction.remove_action!(r)
- end
- end
- end
-
- def self.log_post_action(model)
- return if @disabled
-
- action = UserAction::BOOKMARK if model.is_bookmark?
- action = UserAction::LIKE if model.is_like?
-
- post = Post.with_deleted.where(id: model.post_id).first
-
- row = {
- action_type: action,
- user_id: model.user_id,
- acting_user_id: model.user_id,
- target_post_id: model.post_id,
- target_topic_id: post.topic_id,
- created_at: model.created_at
- }
-
- if model.deleted_at.nil?
- UserAction.log_action!(row)
- else
- UserAction.remove_action!(row)
- end
-
- if model.is_like?
- row[:action_type] = UserAction::WAS_LIKED
- row[:user_id] = post.user_id
- if model.deleted_at.nil?
- UserAction.log_action!(row)
- else
- UserAction.remove_action!(row)
- end
- end
- end
-end
diff --git a/app/services/user_action_manager.rb b/app/services/user_action_manager.rb
new file mode 100644
index 00000000000..7adc19fef8d
--- /dev/null
+++ b/app/services/user_action_manager.rb
@@ -0,0 +1,130 @@
+class UserActionManager
+
+ def self.disable
+ @disabled = true
+ end
+
+ def self.enable
+ @disabled = false
+ end
+
+ [:notification, :post, :topic, :post_action].each do |type|
+ self.class_eval(<<~METHODS)
+ def self.#{type}_created(*args)
+ return if @disabled
+ #{type}_rows(*args).each { |row| UserAction.log_action!(row) }
+ end
+ def self.#{type}_destroyed(*args)
+ return if @disabled
+ #{type}_rows(*args).each { |row| UserAction.remove_action!(row) }
+ end
+ METHODS
+ end
+
+private
+
+ def self.topic_rows(topic)
+ # no action to log here, this can happen if a user is deleted
+ # then topic has no user_id
+ return [] unless topic.user_id
+
+ row = {
+ action_type: topic.private_message? ? UserAction::NEW_PRIVATE_MESSAGE : UserAction::NEW_TOPIC,
+ user_id: topic.user_id,
+ acting_user_id: topic.user_id,
+ target_topic_id: topic.id,
+ target_post_id: -1,
+ created_at: topic.created_at
+ }
+
+ UserAction.remove_action!(row.merge(
+ action_type: topic.private_message? ? UserAction::NEW_TOPIC : UserAction::NEW_PRIVATE_MESSAGE
+ ))
+
+ rows = [row]
+
+ if topic.private_message?
+ topic.topic_allowed_users.reject { |a| a.user_id == topic.user_id }.each do |ta|
+ row = row.dup
+ row[:user_id] = ta.user_id
+ row[:action_type] = UserAction::GOT_PRIVATE_MESSAGE
+ rows << row
+ end
+ end
+ rows
+ end
+
+ def self.post_rows(post)
+ # first post gets nada
+ return [] if post.is_first_post? || post.topic.blank?
+
+ row = {
+ action_type: UserAction::REPLY,
+ user_id: post.user_id,
+ acting_user_id: post.user_id,
+ target_post_id: post.id,
+ target_topic_id: post.topic_id,
+ created_at: post.created_at
+ }
+
+ rows = [row]
+
+ if post.topic.private_message?
+ rows = []
+ post.topic.topic_allowed_users.each do |ta|
+ row = row.dup
+ row[:user_id] = ta.user_id
+ row[:action_type] = ta.user_id == post.user_id ? UserAction::NEW_PRIVATE_MESSAGE : UserAction::GOT_PRIVATE_MESSAGE
+ rows << row
+ end
+ end
+
+ rows
+ end
+
+ def self.notification_rows(post, user, notification_type, acting_user_id)
+ action =
+ case notification_type
+ when Notification.types[:quoted]
+ UserAction::QUOTE
+ when Notification.types[:replied]
+ UserAction::RESPONSE
+ when Notification.types[:mentioned]
+ UserAction::MENTION
+ when Notification.types[:edited]
+ UserAction::EDIT
+ end
+
+ # skip any invalid items, eg failed to save post and so on
+ return [] unless action && post && user && post.id
+
+ [{
+ action_type: action,
+ user_id: user.id,
+ acting_user_id: acting_user_id || post.user_id,
+ target_topic_id: post.topic_id,
+ target_post_id: post.id
+ }]
+ end
+
+ def self.post_action_rows(post_action)
+ action = UserAction::BOOKMARK if post_action.is_bookmark?
+ action = UserAction::LIKE if post_action.is_like?
+ return [] unless action
+
+ post = Post.with_deleted.where(id: post_action.post_id).first
+
+ row = {
+ action_type: action,
+ user_id: post_action.user_id,
+ acting_user_id: post_action.user_id,
+ target_post_id: post_action.post_id,
+ target_topic_id: post.topic_id,
+ created_at: post_action.created_at
+ }
+
+ post_action.is_like? ?
+ [row, row.merge(action_type: UserAction::WAS_LIKED, user_id: post.user_id)] :
+ [row]
+ end
+end
diff --git a/app/services/user_destroyer.rb b/app/services/user_destroyer.rb
index b2b19ad03f5..be4e91e5caa 100644
--- a/app/services/user_destroyer.rb
+++ b/app/services/user_destroyer.rb
@@ -26,12 +26,15 @@ class UserDestroyer
optional_transaction(open_transaction: opts[:transaction]) do
Draft.where(user_id: user.id).delete_all
- QueuedPost.where(user_id: user.id).delete_all
+ Reviewable.where(created_by_id: user.id).delete_all
if opts[:delete_posts]
user.posts.each do |post|
+
# agree with flags
- PostAction.agree_flags!(post, @actor) if opts[:delete_as_spammer]
+ if opts[:delete_as_spammer] && reviewable = post.reviewable_flag
+ reviewable.perform(@actor, :agree_and_keep)
+ end
# block all external urls
if opts[:block_urls]
diff --git a/app/services/user_merger.rb b/app/services/user_merger.rb
index 475a57a3b86..1f5709fd32d 100644
--- a/app/services/user_merger.rb
+++ b/app/services/user_merger.rb
@@ -281,9 +281,8 @@ class UserMerger
Post.with_deleted.where(locked_by_id: @source_user.id).update_all(locked_by_id: @target_user.id)
Post.with_deleted.where(reply_to_user_id: @source_user.id).update_all(reply_to_user_id: @target_user.id)
- QueuedPost.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
- QueuedPost.where(approved_by_id: @source_user.id).update_all(approved_by_id: @target_user.id)
- QueuedPost.where(rejected_by_id: @source_user.id).update_all(rejected_by_id: @target_user.id)
+ Reviewable.where(created_by_id: @source_user.id).update_all(created_by_id: @target_user.id)
+ ReviewableHistory.where(created_by_id: @source_user.id).update_all(created_by_id: @target_user.id)
SearchLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
diff --git a/config/initializers/012-web_hook_events.rb b/config/initializers/012-web_hook_events.rb
index a99b958dc60..3f1c2f9c649 100644
--- a/config/initializers/012-web_hook_events.rb
+++ b/config/initializers/012-web_hook_events.rb
@@ -83,12 +83,24 @@ end
end
end
-%i(
- queued_post_created
- approved_post
- rejected_post
-).each do |event|
- DiscourseEvent.on(event) do |queued_post|
- WebHook.enqueue_object_hooks(:queued_post, queued_post, event, QueuedPostSerializer)
+DiscourseEvent.on(:reviewable_created) do |reviewable|
+ WebHook.enqueue_object_hooks(:reviewable, reviewable, :reviewable_created, reviewable.serializer)
+
+ # TODO: Backwards compatibility for Queued Post webhooks. Remve in favor of Reviewable API
+ if reviewable.is_a?(ReviewableQueuedPost)
+ WebHook.enqueue_object_hooks(:queued_post, reviewable, :queued_post_created, reviewable.serializer)
+ end
+end
+
+DiscourseEvent.on(:reviewable_transitioned_to) do |status, reviewable|
+ WebHook.enqueue_object_hooks(:reviewable, reviewable, :reviewable_transitioned_to, reviewable.serializer)
+
+ # TODO: Backwards compatibility for Queued Post webhooks. Remve in favor of Reviewable API
+ if reviewable.is_a?(ReviewableQueuedPost)
+ if reviewable.approved?
+ WebHook.enqueue_object_hooks(:queued_post, reviewable, :approved_post, QueuedPostSerializer)
+ elsif reviewable.rejected?
+ WebHook.enqueue_object_hooks(:queued_post, reviewable, :rejected_post, QueuedPostSerializer)
+ end
end
end
diff --git a/config/locales/client.bs_BA.yml b/config/locales/client.bs_BA.yml
index 3f6bb9bb745..126a0f63b37 100644
--- a/config/locales/client.bs_BA.yml
+++ b/config/locales/client.bs_BA.yml
@@ -2484,7 +2484,6 @@ bs_BA:
titles:
active: "Active Users"
new: "New Users"
- pending: "Users Pending Review"
newuser: "Users at Trust Level 0 (New User)"
basic: "Users at Trust Level 1 (Basic User)"
staff: "Zaposleni"
diff --git a/config/locales/client.en.yml b/config/locales/client.en.yml
index 2e342b2e83c..3ce03babc62 100644
--- a/config/locales/client.en.yml
+++ b/config/locales/client.en.yml
@@ -222,7 +222,6 @@ en:
age: "Age"
joined: "Joined"
admin_title: "Admin"
- flags_title: "Flags"
show_more: "show more"
show_help: "options"
links: "Links"
@@ -357,23 +356,77 @@ en:
search: "Search for a Message by title:"
placeholder: "type the message title here"
- queue:
+ review:
+ moderation_history: "Moderation History"
+ view_all: "view all"
+ grouped_by_topic: "grouped by topic"
+ none: "There are no items to review."
+ view_pending: "view pending"
+ topic_has_pending:
+ one: "This topic has 1 post pending approval"
+ other: "This topic has {{count}} posts pending approval"
+ title: "Needs Review"
topic: "Topic:"
- approve: "Approve"
- reject: "Reject"
- delete_user: "Delete User"
- title: "Needs Approval"
- none: "There are no posts to review."
+ filtered_topic: "You have filtered to reviewable content in a single topic."
+ filtered_user: "User:"
+ show_all_topics: "show all topics"
+ topics:
+ topic: "Topic"
+ reviewable_count: "Reviewable Count"
+ reported_by: "Reported by"
+ details: "details"
+ unique_users:
+ one: "1 user"
+ other: "{{count}} users"
+ topic_replies:
+ one: "(1 reply)"
+ other: "({{count}} replies)"
edit: "Edit"
+ save: "Save"
cancel: "Cancel"
- view_pending: "view pending posts"
- has_pending_posts:
- one: "This topic has 1 post awaiting approval"
- other: "This topic has {{count}} posts awaiting approval"
+ new_topic: "New Topic:"
- confirm: "Save Changes"
- delete_prompt: "Are you sure you want to delete %{username}? This will remove all of their posts and block their email and IP address."
+ filters:
+ type:
+ title: "Type:"
+ all: "(all types)"
+ minimum_score: "Minimum Score:"
+ refresh: "Refresh"
+ status: "Status:"
+ category: "Category:"
+ conversation:
+ view_full: "view full conversation"
+ history:
+ title: "History"
+ edited: "Edited"
+ scores:
+ description: "Description"
+ score: "Score"
+ submitted_by: "Submitted By"
+ statuses:
+ pending:
+ title: "Pending"
+ approved:
+ title: "Approved"
+ rejected:
+ title: "Rejected"
+ ignored:
+ title: "Ignored"
+ deleted:
+ title: "Deleted"
+ reviewed:
+ title: "(All Reviewed)"
+ all:
+ title: "(Everything)"
+ types:
+ reviewable_flagged_post:
+ title: 'Flagged Post'
+ flagged_by: "Flagged By"
+ reviewable_queued_post:
+ title: 'Queued Post'
+ reviewable_user:
+ title: 'User'
approval:
title: "Post Needs Approval"
description: "We've received your new post but it needs to be approved by a moderator before it will appear. Please be patient."
@@ -2996,102 +3049,6 @@ en:
latest_changes: "Latest changes: please update often!"
by: "by"
- flags:
- title: "Flags"
- active_posts: "Flagged Posts"
- old_posts: "Old Flagged Posts"
- topics: "Flagged Topics"
- moderation_history: "Moderation History"
-
- agree: "Agree"
- agree_title: "Confirm this flag as valid and correct"
- agree_flag_hide_post: "Hide Post"
- agree_flag_hide_post_title: "Hide this post and automatically send the user a message urging them to edit it."
- agree_flag_restore_post: "Agree and Restore Post"
- agree_flag_restore_post_title: "Restore the post so that all users can see it."
- agree_flag_suspend: "Suspend User"
- agree_flag_suspend_title: "Agree with flag and suspend the user."
- agree_flag_silence: "Silence User"
- agree_flag_silence_title: "Agree with flag and silence the user."
-
- agree_flag: "Keep Post"
- agree_flag_title: "Agree with flag and keep the post unchanged."
- ignore_flag: "Ignore"
- ignore_flag_title: "Remove this flag; it requires no action at this time."
- delete: "Delete"
- delete_title: "Delete the post this flag refers to."
- delete_post_defer_flag: "Delete Post and Ignore flag"
- delete_post_defer_flag_title: "Delete post; if the first post, delete the topic"
- delete_post_agree_flag: "Delete Post and Agree with flag"
- delete_post_agree_flag_title: "Delete post; if the first post, delete the topic"
- delete_flag_modal_title: "Delete and..."
- delete_spammer: "Delete Spammer"
- delete_spammer_title: "Remove the user and all posts and topics by this user."
- disagree_flag_unhide_post: "Disagree (unhide post)"
- disagree_flag_unhide_post_title: "Remove any flags from this post and make the post visible again"
- disagree_flag: "Disagree"
- disagree_flag_title: "Deny this flag as invalid or incorrect"
- clear_topic_flags: "Done"
- clear_topic_flags_title: "The topic has been investigated and issues have been resolved. Click Done to remove the flags."
- more: "(more replies...)"
- suspend_user: "Suspend User"
- suspend_user_title: "Suspend user for this post"
- replies:
- one: "[1 reply]"
- other: "[%{count} replies]"
- delete_replies:
- one: "Also delete the %{count} reply to this post?"
- other: "Also delete the %{count} replies to this post?"
-
- dispositions:
- agreed: "agreed"
- disagreed: "disagreed"
- deferred: "ignored"
-
- flagged_by: "Flagged by"
- resolved_by: "Resolved by"
- took_action: "Took action"
- system: "System"
- error: "Something went wrong"
- reply_message: "Reply"
- no_results: "There are no flagged posts."
- topic_flagged: "This topic has been flagged."
- show_full: "show full post"
- visit_topic: "Visit the topic to take action"
- was_edited: "Post was edited after the first flag"
- previous_flags_count: "This post has already been flagged {{count}} times."
- show_details: "Show flag details"
-
- user_percentage:
- summary:
- one: "{{agreed}}, {{disagreed}}, {{ignored}} ({{count}} total flag)"
- other: "{{agreed}}, {{disagreed}}, {{ignored}} ({{count}} total flags)"
- agreed:
- one: "{{count}}% agree"
- other: "{{count}}% agree"
- disagreed:
- one: "{{count}}% disagree"
- other: "{{count}}% disagree"
- ignored:
- one: "{{count}}% ignore"
- other: "{{count}}% ignore"
-
- details: "details"
-
- flagged_topics:
- topic: "Topic"
- type: "Type"
- users: "Users"
- last_flagged: "Last Flagged"
- no_results: "There are no flagged topics."
-
- short_names:
- off_topic: "off-topic"
- inappropriate: "inappropriate"
- spam: "spam"
- notify_user: "custom"
- notify_moderators: "custom"
-
groups:
new:
title: "New Group"
@@ -3812,19 +3769,12 @@ en:
nav:
new: "New"
active: "Active"
- pending: "Pending"
staff: "Staff"
suspended: "Suspended"
silenced: "Silenced"
suspect: "Suspect"
staged: "Staged"
approved: "Approved?"
- approved_selected:
- one: "approve user"
- other: "approve users ({{count}})"
- reject_selected:
- one: "reject user"
- other: "reject users ({{count}})"
titles:
active: "Active Users"
new: "New Users"
@@ -3841,12 +3791,6 @@ en:
suspended: "Suspended Users"
suspect: "Suspect Users"
staged: "Staged Users"
- reject_successful:
- one: "Successfully rejected 1 user."
- other: "Successfully rejected %{count} users."
- reject_failures:
- one: "Failed to reject 1 user."
- other: "Failed to reject %{count} users."
not_verified: "Not verified"
check_email:
title: "Reveal this user's email address"
diff --git a/config/locales/server.ar.yml b/config/locales/server.ar.yml
index 6f52d1d964b..762fb879ea6 100644
--- a/config/locales/server.ar.yml
+++ b/config/locales/server.ar.yml
@@ -884,7 +884,6 @@ ar:
polling_interval: "عندما لا يكون التصويت طويلا، عدد المرات التي يجب تسجيل عملاء التصويت فيها بالملي ثانية."
anon_polling_interval: "المرات التي يجب الاستعلام فيها عن العملاء المجهولين بالملي ثانية."
background_polling_interval: "كم ينبغي أن يكون عدد مرات الاستعلام عن العملاء في المللي ثانية ( عندما يكون الاطار في الخلفية )"
- flags_required_to_hide_post: "عدد العلامات التى تؤدى الى خفى مشاركة تلقائيا وارسال رسالة الى المستخدم ( 0 تعنى عدم الخفى أو الارسال)"
cooldown_minutes_after_hiding_posts: "عدد الدقائق يجب على المستخدم الانتظار قبل أن يتمكنوا من تعديل موضوع مخفي عن طريق رفع الأعلام المجتمع"
max_topics_in_first_day: "أقصى عدد للمواضيع المسموح للمستخدم بانشائها خلال 24 ساعة من نشر أول مشاركة."
max_replies_in_first_day: "أقصى عدد للردود المسموح للمستخدم بنشرها حتى مرور 24 ساعة على نشر أول مشاركة"
diff --git a/config/locales/server.ca.yml b/config/locales/server.ca.yml
index 4a102f34df4..f920299e6c6 100644
--- a/config/locales/server.ca.yml
+++ b/config/locales/server.ca.yml
@@ -758,7 +758,6 @@ ca:
polling_interval: "Quan no hi ha mostreig llarg, amb quina freqüència en mil·lisegons haurien de connectar-se a clients de mostreig"
anon_polling_interval: "Amb quina freqüència en mil·lisegons podria votar els clients"
background_polling_interval: "Amb quina freqüència en mil·lisegons podrien votar els client (quan la finestra és al fons)"
- flags_required_to_hide_post: "Quantitat de banderes que fan que una publicació s'amagui automàticament i s'enviï un missatge a la persona (0 per a mai)"
cooldown_minutes_after_hiding_posts: "Quantitat de minuts que una persona ha d'esperar abans d'editar una publicació oculta amb les banderes de la comunitat"
max_topics_in_first_day: "Quantitat màxima de temes que una persona pot crear en les 24 hores posteriors a la seva primera publicació"
max_replies_in_first_day: "Quantitat màxima de respostes que una persona pot crear en les 24 hores posteriors a la seva primera publicació"
diff --git a/config/locales/server.da.yml b/config/locales/server.da.yml
index c0afaf62206..caeaea17943 100644
--- a/config/locales/server.da.yml
+++ b/config/locales/server.da.yml
@@ -776,7 +776,6 @@ da:
polling_interval: "Når der ikke hentes data langsomt, hvor tit skal en klient der er logget på hente ny data i millisekunder"
anon_polling_interval: "Hvor ofte skal anonyme brugere polle, i millisekunder."
background_polling_interval: "Hvor tit skal klienter hente data i millisekunder (når vinduet er i baggrunden)"
- flags_required_to_hide_post: "Antal flag der forårsager at et indlæg automatisk skjules, og en bresked sendt til brugeren (0 for never)"
cooldown_minutes_after_hiding_posts: "Antal minutter en bruger må vente indtil de kan redigere et indlæg der er blevet gemt via et flag"
max_topics_in_first_day: "Det maksimale antal af emner en bruger må lave i en 24 timers periode efter at have skrevet det første indlæg"
max_replies_in_first_day: "Det maksimale antal af svar en bruger må foretage i 24 timers perioden efter at have skrevet deres første indlæg"
diff --git a/config/locales/server.de.yml b/config/locales/server.de.yml
index 315911e95cd..da1cf676cbc 100644
--- a/config/locales/server.de.yml
+++ b/config/locales/server.de.yml
@@ -1241,7 +1241,6 @@ de:
polling_interval: "Polling-Intervall in Millisekunden für angemeldete Clients, wenn Long Polling nicht verwendet wird."
anon_polling_interval: "Polling-Intervall in Millisekunden für anonyme Clients."
background_polling_interval: "Polling-Intervall in Millisekunden für Clients, wenn sich das Browser-Fenster im Hintergrund befindet."
- flags_required_to_hide_post: "Anzahl an Meldungen, die dafür sorgen, dass ein Beitrag automatisch versteckt und der Benutzer benachrichtigt wird (0 für nie)"
cooldown_minutes_after_hiding_posts: "Minuten die ein Benutzer warten muss, bevor ein Beitrag bearbeitet werden kann, der wegen Meldungen anderer Benutzer versteckt wurde"
max_topics_in_first_day: "Maximale Anzahl an Themen, die ein Benutzer in den ersten 24 Stunden nach dem Schreiben seines ersten Beitrags erstellen kann."
max_replies_in_first_day: "Maximale Anzahl an Beiträgen, die ein Benutzer in den ersten 24 Stunden nach dem Schreiben seines ersten Beitrags erstellen kann."
@@ -1532,7 +1531,6 @@ de:
auto_silence_fast_typers_max_trust_level: "Maximale Vertrauensstufe, um „Schnelltipper“ stummzuschalten."
auto_silence_first_post_regex: "Regulärer Ausdruck (ohne Groß- und Kleinschreibung), der dafür sorgt dass entsprechende erste Beiträge von Benutzern stummgeschaltet und in die Genehmigungswarteschlange verschoben werden. Beispiel: raging|a[bc]a sorgt dafür, dass Beiträge, die raging, aba oder aca enthalten, zunächst stummgeschaltet werden. Dies betrifft jedoch nur den ersten Beitrag."
flags_default_topics: "Zeige gemeldete Themen standardmäßig im Administrationsbereich"
- min_flags_staff_visibility: "Die minimale Anzahl an Meldungen, die ein Beitrag haben muss, bevor ihn das Team im Administrationsbereich sehen kann."
reply_by_email_enabled: "Aktviere das Antworten auf Themen via E-Mail."
reply_by_email_address: "Vorlage für die Antwort einer per E-Mail eingehender E-Mail-Adresse, zum Beispiel: %%{reply_key}@reply.example.com oder replies+%%{reply_key}@example.com"
alternative_reply_by_email_addresses: "Liste alternativer Vorlagen für eingehende E-Mail-Adressen für das Antworten per E-Mail. Beispiel: %%{reply_key}@antwort.example.com|antworten+%%{reply_key}@example.com"
diff --git a/config/locales/server.el.yml b/config/locales/server.el.yml
index 4252101b08b..78df014e305 100644
--- a/config/locales/server.el.yml
+++ b/config/locales/server.el.yml
@@ -833,7 +833,6 @@ el:
polling_interval: "Όταν δεν χρησιμοποιείται μακρυά μέθοδος εξέτασης, πόσο συχνά θα πρέπει οι συνδεδεμένοι χρήστες να ελέγχονται σε χιλιοστά του δευτερολέπτου"
anon_polling_interval: "Πόσο συχνά θα πρέπει οι ανώνυμοι χρήστες να ελέγχονται σε χιλιοστά του δευτερολέπτου"
background_polling_interval: "Πόσο συχνά θα πρέπει οι συνδεδεμένοι πελάτες να ελέγχονται σε χιλιοστά του δευτερολέπτου (όταν το παράθυρο είναι στο παρασκήνιο)"
- flags_required_to_hide_post: "Αριθμός σημάνσεων που προκαλούν την ανάρτηση να κρυφτεί αυτομάτως και ένα μήνυμα να σταλθεί στον χρήστη (0 για να μην γίνετε ποτέ) "
cooldown_minutes_after_hiding_posts: "Αριθμός λεπτών που ένας χρήστης θα πρέπει να περιμένει πριν να μπορέσει να έπεξεργαστεί ξανά μία ανάρτηση που είναι κρυμμένη λόγω επισήμανσης από χρήστες."
max_topics_in_first_day: "Το ανώτατο όριο νημάτων τα οποία ένας χρήστης μπορεί να δημιουργήσει μέσα σε 24 ώρες από την πρώτη τους ανάρτηση"
max_replies_in_first_day: "Ο ανώτατος αριθμός απαντήσεων που ένας χρήστης δικαιούται να αναρτήσει εντός του ορίου των 24 ωρών από την δημιουργία της πρώτης ανάρτησης"
diff --git a/config/locales/server.en.yml b/config/locales/server.en.yml
index b73d57f0077..1762f56554c 100644
--- a/config/locales/server.en.yml
+++ b/config/locales/server.en.yml
@@ -347,10 +347,6 @@ en:
excerpt_image: "image"
- queue:
- delete_reason: "Deleted via post moderation queue"
- not_found: "Post not found or already updated."
-
groups:
success:
bulk_add:
@@ -793,6 +789,10 @@ en:
grant: "Grant Admin Access"
complete: "%{target_username} is now an administrator."
back_to: "Return to %{title}"
+ reviewable_score_types:
+ needs_approval:
+ title: "Needs Approval"
+
post_action_types:
off_topic:
title: "Off-Topic"
@@ -1365,7 +1365,7 @@ en:
anon_polling_interval: "How often should anonymous clients poll in milliseconds"
background_polling_interval: "How often should the clients poll in milliseconds (when the window is in the background)"
- flags_required_to_hide_post: "Number of flags that cause a post to be automatically hidden and message sent to the user (0 for never)"
+ score_required_to_hide_post: "Score threshold that causes a post to be automatically hidden and message sent to the user (0 to disable)"
cooldown_minutes_after_hiding_posts: "Number of minutes a user must wait before they can edit a post hidden via community flagging"
max_topics_in_first_day: "The maximum number of topics a user is allowed to create in the 24 hour period after creating their first post"
@@ -1375,7 +1375,7 @@ en:
tl3_additional_likes_per_day_multiplier: "Increase limit of likes per day for tl3 (regular) by multiplying with this number"
tl4_additional_likes_per_day_multiplier: "Increase limit of likes per day for tl4 (leader) by multiplying with this number"
- num_spam_flags_to_silence_new_user: "If a new user's posts get this many spam flags from num_users_to_silence_new_user different users, hide all their posts and prevent future posting. 0 to disable."
+ spam_score_to_silence_new_user: "If a new user's posts receive this score from num_users_to_silence_new_user different users, hide all their posts and prevent future posting. 0 to disable."
num_users_to_silence_new_user: "If a new user's posts get num_spam_flags_to_silence_new_user spam flags from this many different users, hide all their posts and prevent future posting. 0 to disable."
num_tl3_flags_to_silence_new_user: "If a new user's posts get this many flags from num_tl3_users_to_silence_new_user different trust level 3 users, hide all their posts and prevent future posting. 0 to disable."
num_tl3_users_to_silence_new_user: "If a new user's posts get num_tl3_flags_to_silence_new_user flags from this many different trust level 3 users, hide all their posts and prevent future posting. 0 to disable."
@@ -1719,7 +1719,7 @@ en:
max_age_unmatched_ips: "Delete unmatched screened IP entries after (N) days."
num_flaggers_to_close_topic: "Minimum number of unique flaggers that is required to automatically pause a topic for intervention"
- num_flags_to_close_topic: "Minimum number of active flags that is required to automatically pause a topic for intervention"
+ score_to_auto_close_topic: "The total flag score of that is required to automatically pause a topic for intervention"
num_hours_to_close_topic: "Number of hours to pause a topic for intervention."
auto_respond_to_flag_actions: "Enable automatic reply when disposing a flag."
@@ -1728,7 +1728,7 @@ en:
auto_silence_fast_typers_max_trust_level: "Maximum trust level to auto silence fast typers"
auto_silence_first_post_regex: "Case insensitive regex that if passed will cause first post by user to be silenced and sent to approval queue. Example: raging|a[bc]a , will cause all posts containing raging or aba or aca to be silenced on first. Only applies to first post."
flags_default_topics: "Show flagged topics by default in the admin section"
- min_flags_staff_visibility: "The minimum amount of flags on a post must have before staff can see it in the admin section"
+ min_score_default_visibility: "Don't show reviewable items unless they meet this score"
reply_by_email_enabled: "Enable replying to topics via email."
reply_by_email_address: "Template for reply by email incoming email address, for example: %%{reply_key}@reply.example.com or replies+%%{reply_key}@example.com"
@@ -2429,8 +2429,8 @@ en:
agreed: "Thanks for letting us know. We agree there is an issue and we're looking into it."
agreed_and_deleted: "Thanks for letting us know. We agree there is an issue and we've removed the post."
disagreed: "Thanks for letting us know. We're looking into it."
- deferred: "Thanks for letting us know. We're looking into it."
- deferred_and_deleted: "Thanks for letting us know. We've removed the post."
+ ignored: "Thanks for letting us know. We're looking into it."
+ ignored_and_deleted: "Thanks for letting us know. We've removed the post."
temporarily_closed_due_to_flags:
one: "This topic is temporarily closed for at least 1 hour due to a large number of community flags."
@@ -4362,3 +4362,53 @@ en:
update: "Updated"
create: "Created"
destroy: "Destroyed"
+
+
+ reviewables:
+ missing_version: "You must supply a version parameter"
+ conflict: "There was an update conflict preventing you from doing that."
+ actions:
+ agree:
+ title: "Agree..."
+ agree_and_keep:
+ title: "Keep Post"
+ description: "Agree with flag and keep the post unchanged."
+ agree_and_suspend:
+ title: "Suspend User"
+ description: "Agree with flag and suspend the user."
+ agree_and_silence:
+ title: "Silence User"
+ description: "Agree with flag and silence the user."
+ agree_and_restore:
+ title: "Restore Post"
+ description: "Restore the post so that all users can see it."
+ agree_and_hide:
+ title: "Hide Post"
+ description: "Hide this post and automatically send the user a message urging them to edit it."
+ delete_spammer:
+ title: "Delete Spammer"
+ description: "Remove the user and all their posts and topics."
+ confirm: "Are you sure you want to delete all that user's posts, topics, and block their IP and email addresses?"
+ delete:
+ title: "Delete..."
+ delete_and_ignore:
+ title: "Delete Post and Ignore flag"
+ description: "Delete post; if the first post, delete the topic as well"
+ delete_and_agree:
+ title: "Delete Post and Agree with flag"
+ description: "Delete post; if the first post, delete the topic as well"
+ disagree_and_restore:
+ title: "Disagree and Restore Post"
+ description: "Restore the post so that all users can see it."
+ disagree:
+ title: "Disagree"
+ ignore:
+ title: "Ignore"
+ approve:
+ title: "Approve"
+ reject:
+ title: "Reject"
+ delete_user:
+ title: "Delete User"
+ confirm: "Are you sure you want to delete that user? This will remove all of their posts and block their email and IP address."
+ reason: "Deleted via review queue"
diff --git a/config/locales/server.es.yml b/config/locales/server.es.yml
index 47f6df8e7ef..0ef9a8eae2e 100644
--- a/config/locales/server.es.yml
+++ b/config/locales/server.es.yml
@@ -1255,7 +1255,6 @@ es:
polling_interval: "Cuando no este en 'long polling', ¿Qué tan frecuente debe los clientes con sesión iniciada hacer 'poll' en milisegundos?"
anon_polling_interval: "¿Cuán a menudo deben hacer poll los usuarios anónimos en milisegundos"
background_polling_interval: "Cada cuántos milisegundos debería hacerse cargarse información (mientras que la ventana esté en segundo plano)"
- flags_required_to_hide_post: "Número de reportes que causan que un post se oculte auomáticamente y le sea enviado un mensaje privado al usuario (0 para nunca)"
cooldown_minutes_after_hiding_posts: "Número de minutos que un usuario debe esperar para poder editar un post oculto por los reportes de la comunidad"
max_topics_in_first_day: "El máximo número de temas que un usuario puede crear en las 24 horas posteriores a publicar su primer post"
max_replies_in_first_day: "El máximo número de respuestas que un usuario puede crear en las 24 horas posteriores a publicar su primer post"
@@ -1543,7 +1542,6 @@ es:
auto_silence_fast_typers_max_trust_level: "Máximo nivel de confianza por debajo del cual se podrán silenciar usuarios que escriban demasiado rápido en su primer post"
auto_silence_first_post_regex: "Expresión regular que no distingue mayúsculas y minúsculas que si es detectada hará que el primer post de un usuario sea silenciado y enviado a la cola de aprobación. Ejemplo: raging|a[bc]a hará que todos los posts que contengan gaging, aba o aca sean silenciados. Sólo tiene efecto en el primer mensaje de un usuario."
flags_default_topics: "Mostrar temas reportados por defecto en la sección de administración"
- min_flags_staff_visibility: "La cantidad mínima de reportes que una publicación debe tener antes de que el staff pueda verla en la sección de administración"
reply_by_email_enabled: "Habilitar la respuesta a temas por email."
reply_by_email_address: "Plantilla para la dirección de email que aparecerá al recibir correos con la función de respuesta por email: %%{reply_key}@respuesta.ejemplo.com o respuestas+%%{reply_key}@ejemplo.com"
alternative_reply_by_email_addresses: "Lista de plantillas alternativa para las direcciones de respuesta por email. Ejemplo: %%{reply_key}@reply.example.com|replies+%%{reply_key}@example.com"
diff --git a/config/locales/server.fa_IR.yml b/config/locales/server.fa_IR.yml
index 5aa0d07ef04..dbd70bf628b 100644
--- a/config/locales/server.fa_IR.yml
+++ b/config/locales/server.fa_IR.yml
@@ -807,7 +807,6 @@ fa_IR:
polling_interval: "وقتی رای گیری طولانی نیست، هر چند مدت باید وارد سیستم شود برای نظرسنجی مشتریها در هر میلیثانیه."
anon_polling_interval: "هر چند مدت باید مشتریهای ناشناس نظرسنجی بشوند در هر میلی ثانیه"
background_polling_interval: "هر چند وقت یکبار مشتریها باید نظرسنجی بشوند در هر ثانیه (وقتی پنجره در پس زمینه است)"
- flags_required_to_hide_post: "تعداد پرچم مورد نیاز برای مخفی شدن خودکار نوشته و پیام ارسالی به کاربر (0 برای هیچوقت)"
cooldown_minutes_after_hiding_posts: "تعداد دقایقی که کاربر باید قبل از ویرایش مخفی یک نوشته از طریق پرچم گزاری انجمن صبر کند"
max_topics_in_first_day: "حداکثر تعداد موضوعاتی که کاربر 24 ساعت بعد از ایجاد اولین نوشتهاش میتواند ایجاد کند."
max_replies_in_first_day: "حداکثر تعداد پاسخهایی که کاربر 24 ساعت بعد از ایجاد اولین نوشتهاش میتواند ارسال کند."
diff --git a/config/locales/server.fi.yml b/config/locales/server.fi.yml
index 6e7e51ba129..3441c4de4c1 100644
--- a/config/locales/server.fi.yml
+++ b/config/locales/server.fi.yml
@@ -1230,7 +1230,6 @@ fi:
polling_interval: "Kun long polling ei ole käytössä, kuinka usein kirjautuneet käyttäjät pollaavat, millisekunneissa."
anon_polling_interval: "Kuinka usein anonyymit käyttäjät pollaavat millisekunneissa"
background_polling_interval: "Kuinka usein asiakkaat pollaavat, millisekunneissa (kun ikkuna ei ole aktiivisena)"
- flags_required_to_hide_post: "Kuinka monta lippua aiheuttaa viestin automaattisen piilottamisen ja automaattiviestin lähettämisen kirjoittajalle (aseta 0, jos haluat pois käytöstä)"
cooldown_minutes_after_hiding_posts: "Kuinka monta minuuttia käyttäjän tulee odottaa ennen kuin voi muokata viestiään, jonka yhteisö on liputtanut piiloon."
max_topics_in_first_day: "Kuinka monta ketjua käyttäjä voi aloittaa ensimmäistä viestiään seuraavien 24 tunnin aikana"
max_replies_in_first_day: "Kuinka monta vastausta käyttäjä voi kirjoittaa ensimmäistä viestiään seuraavien 24 tunnin aikana"
@@ -1500,7 +1499,6 @@ fi:
auto_silence_fast_typers_max_trust_level: "Enimmäisluottamustaso, jolla nopea kirjoittaja voidaan hiljentää automaattisesti"
auto_silence_first_post_regex: "Isoista ja pienistä kirjaimista riippumaton säännöllinen lauseke, joka osuessaan aiheuttaa käyttäjän ensimmäisen viestin hiljennyksen ja viesti viedään arvioitavaksi. Esimerkki: hemmetti|a[bc]a aiheuttaa hiljennyksen, jos viesti sisältää sanan 'hemmetti', 'aba' tai 'aca'. Koskee vain käyttäjän ensimmäistä viestiä."
flags_default_topics: "Näytä liputetut ketjut oletuksena ylläpito-osiossa"
- min_flags_staff_visibility: "Kuinka monesti viesti täytyy liputtaa, jotta henkilökunta näkee sen ylläpito-osiossa"
reply_by_email_enabled: "Ota käyttöön vastaukset sähköpostin avulla."
reply_by_email_address: "Saapuvien sähköpostivastausten sähköpostiosoitekaava, esimerkiksi: %%{reply_key}@reply.esimerkki.fi or replies+%%{reply_key}@esimerkki.fi"
alternative_reply_by_email_addresses: "Lista vaihtoehtoisista saapuvien sähköpostivastausten sähköpostiosoitekaavoista, esimerkiksi: %%{reply_key}@reply.esimerkki.fi tai replies+%%{reply_key}@esimerkki.fi"
diff --git a/config/locales/server.fr.yml b/config/locales/server.fr.yml
index 70dfb96bdea..31c4a946db9 100644
--- a/config/locales/server.fr.yml
+++ b/config/locales/server.fr.yml
@@ -1267,7 +1267,6 @@ fr:
polling_interval: "À quelle fréquence les clients connectés devraient-ils requêter le serveur, en millisecondes (sans utiliser les requêtes longues)"
anon_polling_interval: "À quelle fréquence en millisecondes les clients anonymes doivent requêter le serveur"
background_polling_interval: "À quelle fréquence les clients devraient-ils requêter le serveur, en millisecondes (lorsque la fenêtre est en arrière-plan)"
- flags_required_to_hide_post: "Les messages seront automatiquement cachés lorsque le compteur de signalements atteint cette limite (0 pour jamais) et un avertissement sera envoyé à l'utilisateur"
cooldown_minutes_after_hiding_posts: "Nombre de minutes qu'un utilisateur doit attendre avant de pouvoir modifier un message masqué suite à un signalement de la communauté"
max_topics_in_first_day: "Le nombre maximum de sujets qu'un utilisateur est autorisé à créer dans la période de 24h après avoir créé son premier message"
max_replies_in_first_day: "Le nombre maximum de réponses qu'un utilisateur est autorisé à créer dans la période de 24h après avoir créé son premier message"
@@ -1559,7 +1558,6 @@ fr:
auto_silence_fast_typers_max_trust_level: "Niveau de confiance maximum pour automatiquement mettre sous silence les utilisateurs rédigeant des messages trop rapidement."
auto_silence_first_post_regex: "Regex non sensible à la casse qui, si elle est déclenchée, mettre sous silence le premier message de l'utilisateur et l'enverra dans la file d'attente d'approbation.\nExemple: rageux|a[bc]a mettre sous slience les premiers messages contenant rageux ou aba ou aca."
flags_default_topics: "Afficher les sujets signalés par défaut dans la section administrateur"
- min_flags_staff_visibility: "Le nombre minimum de signalements sur un message avant qu'un responsable puisse le voir sous admin."
reply_by_email_enabled: "Activer les réponses aux sujets via courriel."
reply_by_email_address: "Modèle pour la réponse par courriel entrant; exemple : %%{reply_key}@reply.example.com ou replies+%%{reply_key}@example.com"
alternative_reply_by_email_addresses: "Liste des templates alternatifs pour les adresses des courriels entrants de la réponse par courriel. Exemple : %%{reply_key}@reply.example.com|replies+%%{reply_key}@example.com"
diff --git a/config/locales/server.he.yml b/config/locales/server.he.yml
index e75e2c9e5cc..5878de7f98b 100644
--- a/config/locales/server.he.yml
+++ b/config/locales/server.he.yml
@@ -890,7 +890,6 @@ he:
polling_interval: "כאשר לא מבצעים תשאול ארוך (long polling), כל כמה זמן לקוחות מחוברים למערכת יבצעו poll, במילי-שניות"
anon_polling_interval: "באיזו תכיפות לקוחות אנונימיים (anonymous clients) יבצעו תשאול (poll), במילי-שניות"
background_polling_interval: "באיזו תכיפות צריכים לקוחות לבצע תשאול (poll) במילישניות (כאשר החלון נמצא ברקע)"
- flags_required_to_hide_post: "מספר דגלים שגורמים להסתרה אוטומטית של פוסט ולהודעה להשלח למשתמש (0 בשביל שלעולם לא יקרה)"
cooldown_minutes_after_hiding_posts: "מספר הדקות שמשתמשים חייבים לחכות לפני שהם יכולים לערוך פוסט שהוסתר בגלל דיגלול קהילתי"
max_topics_in_first_day: "הכמות המקסימלית של נושאים שמשתמשים מורשים ליצור ב 24 השעות הראשונות לאחר הפוסט הראשון שלהם"
max_replies_in_first_day: "הכמות המקסימלית של תגובות שמשתמשים מורשים ליצור ב 24 השעות הראשונות אחרי יצירת הפוסט הראשון שלהם"
diff --git a/config/locales/server.it.yml b/config/locales/server.it.yml
index 0748bb51782..e9952846c14 100644
--- a/config/locales/server.it.yml
+++ b/config/locales/server.it.yml
@@ -1021,7 +1021,6 @@ it:
polling_interval: "Se non si esegue il long polling, quanto spesso i client autenticati devono fare poll in millisecondi"
anon_polling_interval: "Frequenza in millisecondi con cui client anonimi effettuano il poll"
background_polling_interval: "Quanto spesso i client devono fare poll in millisecondi (quando la finestra è in background)"
- flags_required_to_hide_post: "Numero di segnalazioni che rendono un messaggio automaticamente nascosto. L'utente riceve un messaggio privato (0 per mai)"
cooldown_minutes_after_hiding_posts: "Quanti minuti l'utente deve attendere prima di poter modificare un messaggio che è stato nascosto a causa di segnalazioni"
max_topics_in_first_day: "Numero massimo di argomenti che un utente può creare nel periodo di 24 ore successivo alla creazione del suo primo messaggio"
max_replies_in_first_day: "Numero massimo di risposte che un utente può creare nel periodo di 24 ore successivo alla creazione del suo primo messaggio"
diff --git a/config/locales/server.ko.yml b/config/locales/server.ko.yml
index d23ebab6adf..9080244a2f0 100644
--- a/config/locales/server.ko.yml
+++ b/config/locales/server.ko.yml
@@ -813,7 +813,6 @@ ko:
polling_interval: "long polling을 안 쓸 때 로그인된 클라이언트가 몇 밀리초마다 poll해야 하는 지"
anon_polling_interval: "How often should anonymous clients poll in milliseconds"
background_polling_interval: "(페이지를 안 보고 있을 때) 클라이언트가 몇 밀리초마다 poll해야 하는 지"
- flags_required_to_hide_post: "자동으로 숨김처리 후 사용자에게 메시지를 전송할 신고 수(0은 불가)"
cooldown_minutes_after_hiding_posts: "신고 당해서 숨겨진 글을 사용자가 편집할 수 있기 전까지 기대려야 하는 시간(분)"
max_topics_in_first_day: "첫 포스트 생성 후 24시간동안 사용자가 생성할 수 있는 최대 토픽 수"
max_replies_in_first_day: "첫 포스트 생성 후 24시간동안 사용자가 쓸 수 있는 최대 답글 수"
diff --git a/config/locales/server.nl.yml b/config/locales/server.nl.yml
index f11f95a088c..6a666fc3903 100644
--- a/config/locales/server.nl.yml
+++ b/config/locales/server.nl.yml
@@ -1261,7 +1261,6 @@ nl:
polling_interval: "Als geen 'long polling' wordt toegepast, hoe vaak aangemelde clients moeten pollen in milliseconden"
anon_polling_interval: "Hoe vaak anonieme clients moeten pollen in milliseconden"
background_polling_interval: "Hoe vaak clients moeten pollen in milliseconden (als het venster in de achtergrond staat)"
- flags_required_to_hide_post: "Aantal markeringen dat zorgt voor het automatisch verbergen van een bericht en het versturen van een bericht naar de gebruiker (0 voor nooit)"
cooldown_minutes_after_hiding_posts: "Het aantal minuten dat een gebruiker moet wachten voordat deze een via de gemeenschap gemarkeerd bericht kan bewerken"
max_topics_in_first_day: "Het maximale aantal topics dat een gebruiker in de 24 uursperiode na het schrijven van een eerste bericht mag aanmaken"
max_replies_in_first_day: "Het maximale aantal antwoorden dat een gebruiker in de 24 uursperiode na het schrijven van een eerste bericht mag aanmaken"
diff --git a/config/locales/server.pl_PL.yml b/config/locales/server.pl_PL.yml
index 1769c521f2f..16e98f147a9 100644
--- a/config/locales/server.pl_PL.yml
+++ b/config/locales/server.pl_PL.yml
@@ -866,7 +866,6 @@ pl_PL:
polling_interval: "Kiedy nie long polling, jak często zalogowani klienci powinni poll w milisekundach"
anon_polling_interval: "How often should anonymous clients poll in milliseconds"
background_polling_interval: "Jak często klienci powinni poll w milisekundach (kiedy okno jest w tle)"
- flags_required_to_hide_post: "Liczba flag które sprawią że post będzie automatycznie ukryty i wiadomość zostanie wysłana do użytkownika (0 dla nigdy)"
cooldown_minutes_after_hiding_posts: "Liczba minut, ile musi odczekać użytkownik, zanim będzie mógł edytować post ukryty w wyniku oflagowania przez społeczność"
max_topics_in_first_day: "Maksymalna liczba tematów, jakie może stworzyć użytkownik w trakcie 24 godzin po utworzeniu pierwszego posta"
max_replies_in_first_day: "Maksymalna liczba odpowiedzi, jakie może stworzyć użytkownik w trakcie 24 godzin po utworzeniu pierwszego posta"
diff --git a/config/locales/server.pt.yml b/config/locales/server.pt.yml
index 0c985e067ab..2ff24d5d6d2 100644
--- a/config/locales/server.pt.yml
+++ b/config/locales/server.pt.yml
@@ -787,7 +787,6 @@ pt:
polling_interval: "Quando não está a ocorrer uma solicitação ao servidor, com que frequência devem os clientes ligados requerer uma atualização, em milissegundos"
anon_polling_interval: "Com que frequência os clientes não registados podem fazer solicitações ao servidor, em milisegundos"
background_polling_interval: "Com que frequência deverão os clientes solicitar o servidor, em milissegundos (quando a janela está em plano de fundo)"
- flags_required_to_hide_post: "Número de denúncias que fazem com que uma mensagem seja automaticamente escondida e uma mensagem enviada ao utilizador (0 se nunca)"
cooldown_minutes_after_hiding_posts: "Número de minutos que o utilizador deve esperar antes de poder editar uma mensagem oculta devido a sinalizações por parte da comunidade"
max_topics_in_first_day: "O número máximo de tópicos que o utilizador pode criar no período de 24 horas após criar a sua primeira publicação"
max_replies_in_first_day: "O número máximo de respostas que um utilizador pode criar no período de 24 horas após criar a sua primeira publicação"
diff --git a/config/locales/server.pt_BR.yml b/config/locales/server.pt_BR.yml
index 1dfff01e701..5a33e5123f3 100644
--- a/config/locales/server.pt_BR.yml
+++ b/config/locales/server.pt_BR.yml
@@ -1020,7 +1020,6 @@ pt_BR:
polling_interval: "Com que frequencia os clientes podem solicitar o servidor em milisegundos"
anon_polling_interval: "Com que frequencia os clientes não registrados podem solicitar o servidor em milisegundos"
background_polling_interval: "Com que frequência os clientes podem solicitar o servidor em milisegundos ( em segundo plano )"
- flags_required_to_hide_post: "Número de sinalizações que fazem com que uma publicação seja automaticamente escondida e que uma mensagem seja enviada ao usuário (0 para nunca)"
cooldown_minutes_after_hiding_posts: "Número de minutos que um usuário deve esperar antes de poder editar uma publicação que foi ocultada devido a sinalização da comunidade."
max_topics_in_first_day: "Número máximo de tópicos que um usuário pode criar num período de 24 horas após a criação de sua primeira publicação"
max_replies_in_first_day: "O número máximo de respostas que um usuário está habilitado para criar é de 24 horas após a criação de sua primeira postagem. "
@@ -1265,7 +1264,6 @@ pt_BR:
auto_silence_fast_typers_max_trust_level: "Nível máximo de confiança para silenciar automaticamente os tipos rápidos"
auto_silence_first_post_regex: "Regex insensitivo a maiúsculas e minúsculas que, se for transmitido, fará com que o primeiro post do usuário seja silenciado e enviado para a fila de aprovação. Exemplo: raging | a [bc] a, fará com que todas as mensagens contendo raging ou aba ou aca sejam silenciadas primeiro. Aplica-se apenas ao primeiro post."
flags_default_topics: "Mostrar os tópicos sinalizados por padrão na seção admin"
- min_flags_staff_visibility: "A quantidade mínima de sinalizadores em uma postagem deve ter antes que a equipe possa vê-la na seção administrativa"
reply_by_email_enabled: "Habilitar responder tópicos via email"
reply_by_email_address: "Template de resposta por email, por exemplo: %%{reply_key}@reply.example.com or replies+%%{reply_key}@example.com"
alternative_reply_by_email_addresses: "Lista de modelos alternativos para responder por e-mail a endereços de e-mail recebidos. Exemplo:%%{reply_key}@reply.example.com|replies+%%{reply_key}@example.com"
diff --git a/config/locales/server.ro.yml b/config/locales/server.ro.yml
index 2fa8c5f1e03..10406ce6fb3 100644
--- a/config/locales/server.ro.yml
+++ b/config/locales/server.ro.yml
@@ -760,7 +760,6 @@ ro:
polling_interval: "Atunci când nu se face long polling, cât de des ar trebui clienții autentificați să facă interogări, în milisecunde."
anon_polling_interval: "Cât de frecvent să interogheze clienții anonimi, în milisecunde"
background_polling_interval: "Cât de des să interogheze clienții, în milisecunde (când fereastra este fundal)"
- flags_required_to_hide_post: "Număr de marcaje de avertizare care fac ca o postare să fie automat ascunsă și utilizatorului să îi fie trimis automat un mesaj (0 pentru niciodată)"
cooldown_minutes_after_hiding_posts: "Numărul de minute pe care un utilizator trebuie să le aștepte până când va putea edita o postare ascunsă prin marcaje de avertizare ale comunității."
max_topics_in_first_day: "Numărul maxim de subiecte pe care un utilizator are voie să le creeze într-o perioadă de 24 de ore după ce și-a creat prima postare"
max_replies_in_first_day: "Numărul maxim de răspunsuri pe care un utilizator are voie să le creeze într-o perioadă de 24 de ore după ce și-a creat prima postare"
diff --git a/config/locales/server.ru.yml b/config/locales/server.ru.yml
index 9b566ede946..641218523a8 100644
--- a/config/locales/server.ru.yml
+++ b/config/locales/server.ru.yml
@@ -1218,8 +1218,7 @@ ru:
num_flags_to_close_topic: "Минимальное количество жалоб которое требуется для автоматической временной блокировки топика"
auto_respond_to_flag_actions: "Включить автоматический ответ при использовании флагов на сайте."
min_first_post_typing_time: "Минимальное количество времени в миллисекундах, которое пользователь должен соблюсти при наборе поста во время первой записи. Если порог не соблюден, пост автоматически попадет в очередь утверждения. Установите 0 для отключения (не рекомендуется)"
- min_flags_staff_visibility: "Минимальное количество флагов на пост, прежде чем персонал может видеть его в разделе администратора"
- reply_by_email_enabled: "Разрешить отвечать в темах с помощью электронных писем."
+ reply_by_email_enabled: "Разрешить отвечать в темах с помощью электронным писем."
reply_by_email_address: "Шаблон для ответа по email в формате: %%{reply_key}@reply.example.com или replies+%%{reply_key}@example.com"
strip_images_from_short_emails: "Удалять картинки из писем размером менее 2800 байт"
short_email_length: "Какие письма считать короткими, в байтах"
diff --git a/config/locales/server.sv.yml b/config/locales/server.sv.yml
index 468b5a1d960..b394d40f4cb 100644
--- a/config/locales/server.sv.yml
+++ b/config/locales/server.sv.yml
@@ -703,7 +703,6 @@ sv:
polling_interval: "När long polling inte är aktiverat, hur ofta bör inloggade klienter polla i millisekunder"
anon_polling_interval: "Hur ofta bör anonyma klienter polla i millisekunder"
background_polling_interval: "Hur ofta bör klienter polla i millisekunder (när fönstret är i bakgrunden)"
- flags_required_to_hide_post: "Antal flaggor som orsakar att ett inlägg automatiskt döljs och skickar ett meddelande till användaren (ange 0 för att det aldrig ska hända)"
cooldown_minutes_after_hiding_posts: "Antal minuter en användare måste vänta innan de kan redigera ett inlägg som dolt på grund av flaggningar från användare"
max_topics_in_first_day: "Högsta antal ämnen en användare får skapa under de första 24 timmarna efter att ha skapat sitt första inlägg"
max_replies_in_first_day: "Högsta antal svar en användare får skapa under de första 24 timmarna efter att ha skapat sitt första inlägg"
diff --git a/config/locales/server.tr_TR.yml b/config/locales/server.tr_TR.yml
index 474abf9da19..71da3e04465 100644
--- a/config/locales/server.tr_TR.yml
+++ b/config/locales/server.tr_TR.yml
@@ -648,7 +648,6 @@ tr_TR:
polling_interval: "Uzun sorgular yapılmadığı zaman, kaç mili saniyede bir giriş yapmış kullanıcılar poll yapmalı"
anon_polling_interval: "Kaç mili saniyede bir anonim kullanıcılar sorgu yapmalı"
background_polling_interval: "(Pencere arkaplanda olduğu zaman) kaç mili saniyede bir kullanıcılan sorgu yapmalı"
- flags_required_to_hide_post: "Gönderinin otomatik olarak gizlenip kullanıcıya ileti gönderilmesi için gereken toplam bildirim sayısı (hiçbir zaman için 0)"
cooldown_minutes_after_hiding_posts: "Topluluk tarafından bildirilerek gizlenen gönderiyi düzenleyebilmek için, kullanıcının beklemesi gereken dakika süresi "
max_topics_in_first_day: "Kullanıcının ilk gönderisini oluşturduktan sonraki 24 saatlik zaman dilimi içerisinde oluşturmasına izin verilen konu sayısı."
max_replies_in_first_day: "Kullanıcının ilk gönderisini oluşturduktan sonraki 24 saatlik zaman dilimi içerisinde oluşturabileceği cevap sayısı."
diff --git a/config/locales/server.ur.yml b/config/locales/server.ur.yml
index 1563b74dcf7..3dcb8198e19 100644
--- a/config/locales/server.ur.yml
+++ b/config/locales/server.ur.yml
@@ -901,7 +901,6 @@ ur:
polling_interval: "جب لانگ پولِنگ نہ ہو، تو لاگ ہوئے کلائنٹس کو مِلی سیکنڈوں میں کتنی دفعہ پَول کرنا چاہئے"
anon_polling_interval: "گمنام کلائنٹس کو مِلی سیکنڈوں میں کتنی دفعہ پَول کرنا چاہئے"
background_polling_interval: "کلائنٹس کو مِلی سیکنڈوں میں کتنی دفعہ پَول کرنا چاہئے (جب وِنڈو پسِ منظر میں ہو)"
- flags_required_to_hide_post: "فلَیگز کی تعداد جس کے بعد کسی پوسٹ کو خود کار طریقہ سے چھپا دیا اور صارف کو پیغام بھیج دیا جاتا ہے (کبھی نہیں کیلئے 0)"
cooldown_minutes_after_hiding_posts: "منٹوں کی تعداد جن کیلئے ایک صارف کو کمیونٹی فلَیگ بندی کے ذریعہ چھپائی گئی پوسٹ میں ترمیم کرنے سے پہلے انتظار کرنا لازمی ہے"
max_topics_in_first_day: "اُن کی پہلی پوسٹ بنانے کے بعد 24 گھنٹوں کی مدت میں ایک صارف کی طرف سے تخلیق کردہ ٹاپکس کی زیادہ سے زیادہ تعداد"
max_replies_in_first_day: "اُن کی پہلی پوسٹ بنانے کے بعد 24 گھنٹوں کی مدت میں ایک صارف کی طرف سے تخلیق کردہ جوابات کی زیادہ سے زیادہ تعداد"
diff --git a/config/locales/server.vi.yml b/config/locales/server.vi.yml
index 1059c8b5dff..2d17b48b943 100644
--- a/config/locales/server.vi.yml
+++ b/config/locales/server.vi.yml
@@ -581,7 +581,6 @@ vi:
polling_interval: "When not long polling, how often should logged on clients poll in milliseconds"
anon_polling_interval: "How often should anonymous clients poll in milliseconds"
background_polling_interval: "How often should the clients poll in milliseconds (when the window is in the background)"
- flags_required_to_hide_post: "Số lần đánh dấu làm cho bài viết sẽ được tự động ẩn và tin nhắn sẽ được gửi đến người dùng (0 là không giới hạn)"
cooldown_minutes_after_hiding_posts: "Số phút một người dùng phải chờ trước khi họ có thể sửa một bài viết ẩn bởi gắn cờ cộng đồng"
tl2_additional_likes_per_day_multiplier: "Tăng giới hạn thích mỗi ngày cho mức độ tin tưởng 2 (thành viên) bằng cách nhân với số này"
tl3_additional_likes_per_day_multiplier: "Tăng giới hạn thích mỗi ngày cho mức độ tin tưởng 3 (bình thường) bằng cách nhân với số này"
diff --git a/config/locales/server.zh_CN.yml b/config/locales/server.zh_CN.yml
index c0ee6a8bd10..730915275c9 100644
--- a/config/locales/server.zh_CN.yml
+++ b/config/locales/server.zh_CN.yml
@@ -1185,7 +1185,6 @@ zh_CN:
polling_interval: "当不再长轮询时，已登录的客户端多久应该轮询一次，以毫秒为单位"
anon_polling_interval: "匿名客户端轮询时间间隔（单位：毫秒）"
background_polling_interval: "客户端轮询的间隔，以毫秒计（当窗口在后台时）"
- flags_required_to_hide_post: "一个帖子累计多少个标记之后会被自动隐藏，并向帖子作者发送私信通知（0 为从不）"
cooldown_minutes_after_hiding_posts: "当一个帖子因为标记而隐藏之后，用户需要等待多少分钟才能编辑帖子"
max_topics_in_first_day: "新用户在24小时内在发表第一帖后允许创建的主题数"
max_replies_in_first_day: "新用户在24小时内在发表第一帖后允许创建的回复数"
@@ -1459,7 +1458,6 @@ zh_CN:
auto_silence_fast_typers_max_trust_level: "自动禁言输入快速的用户的适用信任等级"
auto_silence_first_post_regex: "检查用户首贴的大小写不相关的正则表达式。如匹配，用户将被禁言并送至审核队列。例子：raging|a[bc]a 将匹配 raging、aba 或者 aca，因此禁言该用户。只对首贴有效。"
flags_default_topics: "在管理栏目中默认显示被标记的主题"
- min_flags_staff_visibility: "在管理人员可以在管理部分中看到之前，帖子中的最小标记量"
reply_by_email_enabled: "启用通过邮件回复。"
reply_by_email_address: "通过邮件回复的回复地址模板，例如：%%{reply_key}@reply.example.com 或 replies+%%{reply_key}@example.com"
alternative_reply_by_email_addresses: "通过邮件回复的回复地址模板，例如：%%{reply_key}@reply.example.com|replies+%%{reply_key}@example.com"
diff --git a/config/locales/server.zh_TW.yml b/config/locales/server.zh_TW.yml
index 2f09e86aac5..9bbc1a108dc 100644
--- a/config/locales/server.zh_TW.yml
+++ b/config/locales/server.zh_TW.yml
@@ -1097,7 +1097,6 @@ zh_TW:
polling_interval: "當不再長輪詢時，已登錄的客戶端應該多久輪詢一次（單位 毫秒）"
anon_polling_interval: "匿名使用者用戶端輪詢時間間隔（單位 毫秒）"
background_polling_interval: "客戶端輪詢的間隔，以毫秒計（當視窗在後台時）"
- flags_required_to_hide_post: "一個帖子累計多少個標記之後會被自動隱藏，並向帖子作者發送私信通知（0 為從不）"
cooldown_minutes_after_hiding_posts: "如果一個文章因為標記而隱藏，用戶需要等待多少分鐘才能編輯該文章"
max_topics_in_first_day: "新用戶在24小時內在發表第一帖後允許創建的主題數"
max_replies_in_first_day: "新用戶在24小時內在發表第一帖後允許創建的回覆數"
diff --git a/config/routes.rb b/config/routes.rb
index 68620af6952..968bc1f0452 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -94,8 +94,6 @@ Discourse::Application.routes.draw do
get "groups/:type" => "groups#show", constraints: AdminConstraint.new
get "groups/:type/:id" => "groups#show", constraints: AdminConstraint.new
- get "moderation_history" => "moderation_history#index"
-
resources :users, id: RouteFormat.username, except: [:show] do
collection do
get "list" => "users#index"
@@ -319,6 +317,15 @@ Discourse::Application.routes.draw do
end
end
+ get "review" => "reviewables#index" # For ember app
+ get "review/:reviewable_id" => "reviewables#show", constraints: { reviewable_id: /\d+/ }
+ get "review/topics" => "reviewables#topics"
+ put "review/:reviewable_id/perform/:action_id" => "reviewables#perform", constraints: {
+ reviewable_id: /\d+/,
+ action_id: /[a-z\_]+/
+ }
+ put "review/:reviewable_id" => "reviewables#update", constraints: { reviewable_id: /\d+/ }
+
get "session/sso" => "session#sso"
get "session/sso_login" => "session#sso_login"
get "session/sso_provider" => "session#sso_provider"
@@ -440,7 +447,6 @@ Discourse::Application.routes.draw do
get "#{root_path}/:username/badges" => "users#badges", constraints: { username: RouteFormat.username }
get "#{root_path}/:username/notifications" => "users#show", constraints: { username: RouteFormat.username }
get "#{root_path}/:username/notifications/:filter" => "users#show", constraints: { username: RouteFormat.username }
- get "#{root_path}/:username/activity/pending" => "users#show", constraints: { username: RouteFormat.username }
delete "#{root_path}/:username" => "users#destroy", constraints: { username: RouteFormat.username, format: /(json|html)/ }
get "#{root_path}/by-external/:external_id" => "users#show", constraints: { external_id: /[^\/]+/ }
get "#{root_path}/:username/flagged-posts" => "users#show", constraints: { username: RouteFormat.username }
diff --git a/config/site_settings.yml b/config/site_settings.yml
index 6dcb7eb6eca..0132538bbd2 100644
--- a/config/site_settings.yml
+++ b/config/site_settings.yml
@@ -1335,12 +1335,10 @@ onebox:
spam:
add_rel_nofollow_to_user_content: true
- flags_required_to_hide_post: 3
+ score_required_to_hide_post: 10
cooldown_minutes_after_hiding_posts: 10
- num_spam_flags_to_silence_new_user: 3
+ spam_score_to_silence_new_user: 6.0
num_users_to_silence_new_user: 3
- num_tl3_flags_to_silence_new_user: 4
- num_tl3_users_to_silence_new_user: 2
notify_mods_when_user_silenced: false
flag_sockpuppets: false
newuser_spam_host_threshold: 3
@@ -1355,7 +1353,7 @@ spam:
max_age_unmatched_emails: 365
max_age_unmatched_ips: 365
num_flaggers_to_close_topic: 5
- num_flags_to_close_topic: 12
+ score_to_auto_close_topic: 25.0
num_hours_to_close_topic:
default: 4
min: 1
@@ -1367,7 +1365,9 @@ spam:
flags_default_topics:
default: false
client: true
- min_flags_staff_visibility: 1
+ min_score_default_visibility:
+ default: 0.0
+ client: true
rate_limits:
unique_posts_mins: 5
diff --git a/db/fixtures/007_web_hook_event_types.rb b/db/fixtures/007_web_hook_event_types.rb
index 7e94839fd4a..cbe6a323446 100644
--- a/db/fixtures/007_web_hook_event_types.rb
+++ b/db/fixtures/007_web_hook_event_types.rb
@@ -37,3 +37,8 @@ WebHookEventType.seed do |b|
b.id = WebHookEventType::QUEUED_POST
b.name = "queued_post"
end
+
+WebHookEventType.seed do |b|
+ b.id = WebHookEventType::REVIEWABLE
+ b.name = "reviewable"
+end
diff --git a/db/migrate/20190103160533_create_reviewables.rb b/db/migrate/20190103160533_create_reviewables.rb
new file mode 100644
index 00000000000..90da14223b5
--- /dev/null
+++ b/db/migrate/20190103160533_create_reviewables.rb
@@ -0,0 +1,41 @@
+class CreateReviewables < ActiveRecord::Migration[5.2]
+ def change
+ create_table :reviewables do |t|
+ t.string :type, null: false
+ t.integer :status, null: false, default: 0
+ t.integer :created_by_id, null: false
+
+ # Who can review this item? Moderators always can
+ t.boolean :reviewable_by_moderator, null: false, default: false
+ t.integer :reviewable_by_group_id, null: true
+
+ # On some high traffic sites they want things in review to be claimed
+ # so that two people don't work on the same thing.
+ t.integer :claimed_by_id, null: true
+
+ # For filtering
+ t.integer :category_id, null: true
+ t.integer :topic_id, null: true
+ t.float :score, null: false, default: 0
+ t.boolean :potential_spam, null: false, default: false
+
+ # Polymorphic relation of reviewable thing
+ t.integer :target_id, null: true
+ t.string :target_type, null: true
+ t.integer :target_created_by_id, null: true
+
+ t.json :payload, null: true
+
+ # Helps us prevent simultaneous updates
+ t.integer :version, null: false, default: 0
+
+ t.datetime :latest_score, null: true
+ t.timestamps
+ end
+
+ add_index :reviewables, :status
+ add_index :reviewables, [:status, :type]
+ add_index :reviewables, [:status, :score]
+ add_index :reviewables, [:type, :target_id], unique: true
+ end
+end
diff --git a/db/migrate/20190103185626_create_reviewable_users.rb b/db/migrate/20190103185626_create_reviewable_users.rb
new file mode 100644
index 00000000000..b4f53ad9545
--- /dev/null
+++ b/db/migrate/20190103185626_create_reviewable_users.rb
@@ -0,0 +1,56 @@
+class CreateReviewableUsers < ActiveRecord::Migration[5.2]
+ def up
+ # Create reviewables for approved users
+ if DB.query_single("SELECT 1 FROM site_settings WHERE name = 'must_approve_users' AND value = 't'").first
+ execute(<<~SQL)
+ INSERT INTO reviewables (
+ type,
+ status,
+ created_by_id,
+ reviewable_by_moderator,
+ target_type,
+ target_id,
+ created_at,
+ updated_at
+ )
+ SELECT 'ReviewableUser',
+ 0,
+ #{Discourse::SYSTEM_USER_ID},
+ true,
+ 'User',
+ id,
+ created_at,
+ created_at
+ FROM users
+ WHERE approved = false
+ SQL
+
+ # Migrate Created History
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 1,
+ r.created_by_id,
+ r.created_at,
+ r.created_at
+ FROM reviewables AS r
+ WHERE r.type = 'ReviewableUser'
+ SQL
+ end
+ end
+
+ def down
+ execute(<<~SQL)
+ DELETE FROM reviewables
+ WHERE type = 'ReviewableUser'
+ SQL
+ end
+end
diff --git a/db/migrate/20190110212005_create_reviewable_histories.rb b/db/migrate/20190110212005_create_reviewable_histories.rb
new file mode 100644
index 00000000000..0a54fc0629b
--- /dev/null
+++ b/db/migrate/20190110212005_create_reviewable_histories.rb
@@ -0,0 +1,14 @@
+class CreateReviewableHistories < ActiveRecord::Migration[5.2]
+ def change
+ create_table :reviewable_histories do |t|
+ t.integer :reviewable_id, null: false
+ t.integer :reviewable_history_type, null: false
+ t.integer :status, null: false
+ t.integer :created_by_id, null: false
+ t.json :edited, null: true
+ t.timestamps
+ end
+
+ add_index :reviewable_histories, :reviewable_id
+ end
+end
diff --git a/db/migrate/20190111170824_migrate_reviewable_queued_posts.rb b/db/migrate/20190111170824_migrate_reviewable_queued_posts.rb
new file mode 100644
index 00000000000..c673777db93
--- /dev/null
+++ b/db/migrate/20190111170824_migrate_reviewable_queued_posts.rb
@@ -0,0 +1,104 @@
+class MigrateReviewableQueuedPosts < ActiveRecord::Migration[5.2]
+ def up
+ execute(<<~SQL)
+ INSERT INTO reviewables (
+ type,
+ status,
+ created_by_id,
+ reviewable_by_moderator,
+ topic_id,
+ category_id,
+ payload,
+ created_at,
+ updated_at
+ )
+ SELECT 'ReviewableQueuedPost',
+ state - 1,
+ user_id,
+ true,
+ topic_id,
+ nullif(post_options->>'category', '')::int,
+ json_build_object(
+ 'old_queued_post_id', id,
+ 'raw', raw
+ )::jsonb || post_options::jsonb,
+ created_at,
+ updated_at
+ FROM queued_posts
+ SQL
+
+ # Migrate Created History
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 0,
+ 0,
+ qp.user_id,
+ qp.created_at,
+ qp.created_at
+ FROM reviewables AS r
+ INNER JOIN queued_posts AS qp ON qp.id = (payload->>'old_queued_post_id')::int
+ SQL
+
+ # Migrate Approved History
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 1,
+ qp.approved_by_id,
+ qp.approved_at,
+ qp.approved_at
+ FROM reviewables AS r
+ INNER JOIN queued_posts AS qp ON qp.id = (payload->>'old_queued_post_id')::int
+ WHERE qp.state = 2
+ SQL
+
+ # Migrate Rejected History
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 2,
+ qp.rejected_by_id,
+ qp.rejected_at,
+ qp.rejected_at
+ FROM reviewables AS r
+ INNER JOIN queued_posts AS qp ON qp.id = (payload->>'old_queued_post_id')::int
+ WHERE qp.state = 3
+ SQL
+ end
+
+ def down
+ execute(<<~SQL)
+ DELETE FROM reviewable_histories
+ WHERE reviewable_id IN (SELECT id FROM reviewables WHERE type = 'ReviewableQueuedPost')
+ SQL
+
+ execute(<<~SQL)
+ DELETE FROM reviewables
+ WHERE type = 'ReviewableQueuedPost'
+ SQL
+ end
+end
diff --git a/db/migrate/20190121202656_remove_user_action_pending.rb b/db/migrate/20190121202656_remove_user_action_pending.rb
new file mode 100644
index 00000000000..f48e87e2ea5
--- /dev/null
+++ b/db/migrate/20190121202656_remove_user_action_pending.rb
@@ -0,0 +1,8 @@
+class RemoveUserActionPending < ActiveRecord::Migration[5.2]
+ def up
+ execute "DELETE FROM user_actions WHERE action_type = 14"
+ end
+
+ def down
+ end
+end
diff --git a/db/migrate/20190130163000_create_reviewable_scores.rb b/db/migrate/20190130163000_create_reviewable_scores.rb
new file mode 100644
index 00000000000..2fa7a5a87b4
--- /dev/null
+++ b/db/migrate/20190130163000_create_reviewable_scores.rb
@@ -0,0 +1,19 @@
+class CreateReviewableScores < ActiveRecord::Migration[5.2]
+ def change
+ create_table :reviewable_scores do |t|
+ t.integer :reviewable_id, null: false
+ t.integer :user_id, null: false
+ t.integer :reviewable_score_type, null: false
+ t.integer :status, null: false
+ t.float :score, null: false, default: 0
+ t.float :take_action_bonus, null: false, default: 0
+ t.integer :reviewed_by_id, null: true
+ t.datetime :reviewed_at, null: true
+ t.integer :meta_topic_id, null: true
+ t.timestamps
+ end
+
+ add_index :reviewable_scores, :reviewable_id
+ add_index :reviewable_scores, :user_id
+ end
+end
diff --git a/db/migrate/20190130163001_migrate_reviewable_flagged_posts.rb b/db/migrate/20190130163001_migrate_reviewable_flagged_posts.rb
new file mode 100644
index 00000000000..34dfd894b6a
--- /dev/null
+++ b/db/migrate/20190130163001_migrate_reviewable_flagged_posts.rb
@@ -0,0 +1,117 @@
+class MigrateReviewableFlaggedPosts < ActiveRecord::Migration[5.2]
+ def up
+
+ # for the migration we'll do 1.0 + trust_level and not take into account user flagging accuracy
+ # It should be good enough for old flags whose scores are not as important as pending flags.
+ execute(<<~SQL)
+ INSERT INTO reviewables (
+ type,
+ status,
+ topic_id,
+ category_id,
+ payload,
+ target_type,
+ target_id,
+ target_created_by_id,
+ score,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT 'ReviewableFlaggedPost',
+ CASE
+ WHEN MAX(pa.agreed_at) IS NOT NULL THEN 1
+ WHEN MAX(pa.disagreed_at) IS NOT NULL THEN 2
+ WHEN MAX(pa.deferred_at) IS NOT NULL THEN 3
+ WHEN MAX(pa.deleted_at) IS NOT NULL THEN 4
+ ELSE 0
+ END,
+ t.id,
+ t.category_id,
+ json_build_object(),
+ 'Post',
+ pa.post_id,
+ p.user_id,
+ 0,
+ MAX(pa.user_id),
+ MIN(pa.created_at),
+ MAX(pa.updated_at)
+ FROM post_actions AS pa
+ INNER JOIN posts AS p ON pa.post_id = p.id
+ INNER JOIN topics AS t ON t.id = p.topic_id
+ INNER JOIN post_action_types AS pat ON pat.id = pa.post_action_type_id
+ WHERE pat.is_flag
+ AND pat.name_key <> 'notify_user'
+ AND p.user_id > 0
+ AND p.deleted_at IS NULL
+ AND t.deleted_at IS NULL
+ GROUP BY pa.post_id,
+ t.id,
+ t.category_id,
+ p.user_id
+ SQL
+
+ execute(<<~SQL)
+ INSERT INTO reviewable_scores (
+ reviewable_id,
+ user_id,
+ reviewable_score_type,
+ status,
+ score,
+ meta_topic_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ pa.user_id,
+ pa.post_action_type_id,
+ CASE
+ WHEN pa.agreed_at IS NOT NULL THEN 1
+ WHEN pa.disagreed_at IS NOT NULL THEN 2
+ WHEN pa.deferred_at IS NOT NULL THEN 3
+ WHEN pa.deleted_at IS NOT NULL THEN 3
+ ELSE 0
+ END,
+ 1.0 +
+ (CASE
+ WHEN pau.moderator OR pau.admin THEN 5.0
+ ELSE pau.trust_level
+ END) +
+ (CASE
+ WHEN pa.staff_took_action THEN 5.0
+ ELSE 0.0
+ END),
+ rp.topic_id,
+ pa.created_at,
+ pa.updated_at
+ FROM post_actions AS pa
+ INNER JOIN post_action_types AS pat ON pat.id = pa.post_action_type_id
+ INNER JOIN users AS pau ON pa.user_id = pau.id
+ INNER JOIN reviewables AS r ON pa.post_id = r.target_id
+ LEFT OUTER JOIN posts AS rp ON rp.id = pa.related_post_id
+ WHERE pat.is_flag
+ AND r.type = 'ReviewableFlaggedPost'
+ SQL
+
+ execute(<<~SQL)
+ UPDATE reviewables
+ SET score = COALESCE((
+ SELECT sum(score)
+ FROM reviewable_scores AS rs
+ WHERE rs.reviewable_id = reviewables.id
+ AND rs.status = 0
+ ), 0),
+ potential_spam = EXISTS(
+ SELECT 1
+ FROM reviewable_scores AS rs
+ WHERE rs.reviewable_id = reviewables.id
+ AND rs.reviewable_score_type = 8
+ )
+ SQL
+ end
+
+ def down
+ execute "DELETE FROM reviewables WHERE type = 'ReviewableFlaggedPost'"
+ execute "DELETE FROM reviewable_scores"
+ end
+end
diff --git a/db/migrate/20190215204033_add_score_bonus_to_post_action_types.rb b/db/migrate/20190215204033_add_score_bonus_to_post_action_types.rb
new file mode 100644
index 00000000000..95bcfcf18fa
--- /dev/null
+++ b/db/migrate/20190215204033_add_score_bonus_to_post_action_types.rb
@@ -0,0 +1,5 @@
+class AddScoreBonusToPostActionTypes < ActiveRecord::Migration[5.2]
+ def change
+ add_column :post_action_types, :score_bonus, :float, default: 0.0, null: false
+ end
+end
diff --git a/db/migrate/20190306184409_add_reviewable_score_to_topics.rb b/db/migrate/20190306184409_add_reviewable_score_to_topics.rb
new file mode 100644
index 00000000000..474c1f1ad16
--- /dev/null
+++ b/db/migrate/20190306184409_add_reviewable_score_to_topics.rb
@@ -0,0 +1,22 @@
+class AddReviewableScoreToTopics < ActiveRecord::Migration[5.2]
+ def up
+ add_column :topics, :reviewable_score, :float, null: false, default: 0
+
+ execute(<<~SQL)
+ UPDATE topics
+ SET reviewable_score = sums.score
+ FROM (
+ SELECT SUM(r.score) AS score,
+ r.topic_id
+ FROM reviewables AS r
+ WHERE r.status = 0
+ GROUP BY r.topic_id
+ ) AS sums
+ WHERE sums.topic_id = topics.id
+ SQL
+ end
+
+ def down
+ remove_column :topics, :reviewable_score
+ end
+end
diff --git a/db/migrate/20190313171338_add_indexes_to_reviewables.rb b/db/migrate/20190313171338_add_indexes_to_reviewables.rb
new file mode 100644
index 00000000000..3473c1957ec
--- /dev/null
+++ b/db/migrate/20190313171338_add_indexes_to_reviewables.rb
@@ -0,0 +1,11 @@
+class AddIndexesToReviewables < ActiveRecord::Migration[5.2]
+ def up
+ remove_index :reviewables, :status
+ add_index :reviewables, [:status, :created_at]
+ end
+
+ def down
+ remove_index :reviewables, [:status, :created_at]
+ add_index :reviewables, :status
+ end
+end
diff --git a/db/migrate/20190315170411_add_index_to_reviewable_histories.rb b/db/migrate/20190315170411_add_index_to_reviewable_histories.rb
new file mode 100644
index 00000000000..6953eaefbc7
--- /dev/null
+++ b/db/migrate/20190315170411_add_index_to_reviewable_histories.rb
@@ -0,0 +1,5 @@
+class AddIndexToReviewableHistories < ActiveRecord::Migration[5.2]
+ def change
+ add_index :reviewable_histories, :created_by_id
+ end
+end
diff --git a/db/migrate/20190315174428_migrate_flag_history.rb b/db/migrate/20190315174428_migrate_flag_history.rb
new file mode 100644
index 00000000000..37fc7a5cd35
--- /dev/null
+++ b/db/migrate/20190315174428_migrate_flag_history.rb
@@ -0,0 +1,131 @@
+class MigrateFlagHistory < ActiveRecord::Migration[5.2]
+ def up
+
+ # Migrate Created History
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 0,
+ 0,
+ r.created_by_id,
+ r.created_at,
+ r.created_at
+ FROM reviewables AS r
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND (
+ NOT EXISTS(
+ SELECT 1
+ FROM reviewable_histories AS rh
+ WHERE rh.reviewable_id = r.id
+ AND rh.reviewable_history_type = 0
+ )
+ )
+ SQL
+
+ # Approved
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 1,
+ pa.agreed_by_id,
+ pa.agreed_at,
+ pa.agreed_at
+ FROM reviewables AS r
+ INNER JOIN post_actions AS pa ON pa.post_id = r.target_id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND pa.agreed_at IS NOT NULL
+ AND pa.agreed_by_id IS NOT NULL
+ SQL
+
+ # Rejected
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 2,
+ pa.disagreed_by_id,
+ pa.disagreed_at,
+ pa.disagreed_at
+ FROM reviewables AS r
+ INNER JOIN post_actions AS pa ON pa.post_id = r.target_id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND pa.disagreed_at IS NOT NULL
+ AND pa.disagreed_by_id IS NOT NULL
+ SQL
+
+ # Ignored
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 3,
+ pa.deferred_by_id,
+ pa.deferred_at,
+ pa.deferred_at
+ FROM reviewables AS r
+ INNER JOIN post_actions AS pa ON pa.post_id = r.target_id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND pa.deferred_at IS NOT NULL
+ AND pa.deferred_by_id IS NOT NULL
+ SQL
+
+ # Deleted
+ execute(<<~SQL)
+ INSERT INTO reviewable_histories (
+ reviewable_id,
+ reviewable_history_type,
+ status,
+ created_by_id,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ 1,
+ 4,
+ pa.deleted_by_id,
+ pa.deleted_at,
+ pa.deleted_at
+ FROM reviewables AS r
+ INNER JOIN post_actions AS pa ON pa.post_id = r.target_id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND pa.deleted_at IS NOT NULL
+ AND pa.deleted_by_id IS NOT NULL
+ SQL
+ end
+
+ def down
+ execute(<<~SQL)
+ DELETE FROM reviewable_histories
+ WHERE reviewable_id IN (SELECT id FROM reviewables WHERE type = 'ReviewableFlaggedPost')
+ SQL
+ end
+end
diff --git a/db/migrate/20190327205525_require_reviewable_scores.rb b/db/migrate/20190327205525_require_reviewable_scores.rb
new file mode 100644
index 00000000000..85ab95f1267
--- /dev/null
+++ b/db/migrate/20190327205525_require_reviewable_scores.rb
@@ -0,0 +1,43 @@
+class RequireReviewableScores < ActiveRecord::Migration[5.2]
+ def up
+ min_score = DB.query_single("SELECT value FROM site_settings WHERE name = 'min_score_default_visibility'")[0].to_f
+ min_score = 1.0 if (min_score < 1.0)
+
+ execute(<<~SQL)
+ INSERT INTO reviewable_scores (
+ reviewable_id,
+ user_id,
+ reviewable_score_type,
+ score,
+ status,
+ created_at,
+ updated_at
+ )
+ SELECT r.id,
+ -1,
+ 9,
+ #{min_score},
+ r.status,
+ r.created_at,
+ r.created_at
+ FROM reviewables AS r
+ WHERE r.type IN ('ReviewableQueuedPost', 'ReviewableUser')
+ SQL
+
+ execute(<<~SQL)
+ UPDATE reviewables SET score = (
+ SELECT SUM(score)
+ FROM reviewable_scores
+ WHERE reviewable_scores.reviewable_id = reviewables.id
+ )
+ SQL
+ end
+
+ def down
+ execute(<<~SQL)
+ DELETE FROM reviewable_scores WHERE reviewable_id IN (
+ SELECT id FROM reviewables WHERE type IN ('ReviewableQueuedPost', 'ReviewableUser')
+ )
+ SQL
+ end
+end
diff --git a/db/post_migrate/20190121203023_drop_queued_post_id_from_user_actions.rb b/db/post_migrate/20190121203023_drop_queued_post_id_from_user_actions.rb
new file mode 100644
index 00000000000..2d504d5401c
--- /dev/null
+++ b/db/post_migrate/20190121203023_drop_queued_post_id_from_user_actions.rb
@@ -0,0 +1,9 @@
+class DropQueuedPostIdFromUserActions < ActiveRecord::Migration[5.2]
+ def up
+ remove_column :user_actions, :queued_post_id
+ end
+
+ def down
+ add_column :user_actions, :queued_post_id, :integer
+ end
+end
diff --git a/db/post_migrate/20190123171817_drop_queued_posts.rb b/db/post_migrate/20190123171817_drop_queued_posts.rb
new file mode 100644
index 00000000000..6f58fa63a48
--- /dev/null
+++ b/db/post_migrate/20190123171817_drop_queued_posts.rb
@@ -0,0 +1,5 @@
+class DropQueuedPosts < ActiveRecord::Migration[5.2]
+ def up
+ drop_table :queued_posts
+ end
+end
diff --git a/lib/discourse.rb b/lib/discourse.rb
index 96e014db23e..37421c4ff29 100644
--- a/lib/discourse.rb
+++ b/lib/discourse.rb
@@ -619,7 +619,7 @@ module Discourse
end
end
- def self.deprecate(warning, drop_from: nil, since: nil, raise_error: false)
+ def self.deprecate(warning, drop_from: nil, since: nil, raise_error: false, output_in_test: false)
location = caller_locations[1].yield_self { |l| "#{l.path}:#{l.lineno}:in \`#{l.label}\`" }
warning = ["Deprecation notice:", warning]
warning << "(deprecated since Discourse #{since})" if since
@@ -635,6 +635,10 @@ module Discourse
STDERR.puts(warning)
end
+ if output_in_test && Rails.env == "test"
+ STDERR.puts(warning)
+ end
+
digest = Digest::MD5.hexdigest(warning)
redis_key = "deprecate-notice-#{digest}"
diff --git a/lib/email/receiver.rb b/lib/email/receiver.rb
index e8b5ac56297..03e9c845ef5 100644
--- a/lib/email/receiver.rb
+++ b/lib/email/receiver.rb
@@ -1,6 +1,5 @@
require "digest"
require_dependency "new_post_manager"
-require_dependency "post_action_creator"
require_dependency "html_to_markdown"
require_dependency "plain_text_to_markdown"
require_dependency "upload_creator"
@@ -936,11 +935,8 @@ module Email
end
def create_post_action(user, post, type)
- PostActionCreator.new(user, post).perform(type)
- rescue PostAction::AlreadyActed
- # it's cool, don't care
- rescue Discourse::InvalidAccess => e
- raise InvalidPostAction.new(e)
+ result = PostActionCreator.new(user, post, type).perform
+ raise InvalidPostAction.new if result.failed? && result.forbidden
end
def is_whitelisted_attachment?(attachment)
diff --git a/lib/flag_query.rb b/lib/flag_query.rb
index cd0ed150892..0f5e8741f90 100644
--- a/lib/flag_query.rb
+++ b/lib/flag_query.rb
@@ -12,34 +12,26 @@ module FlagQuery
end
def self.flagged_posts_report(current_user, opts = nil)
+ Discourse.deprecate("FlagQuery is deprecated, use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+
opts ||= {}
offset = opts[:offset] || 0
per_page = opts[:per_page] || 25
- actions = flagged_post_actions(opts)
+ reviewables = ReviewableFlaggedPost.default_visible.viewable_by(current_user, order: 'created_at DESC')
+ reviewables = reviewables.where(topic_id: opts[:topic_id]) if opts[:topic_id]
+ reviewables = reviewables.where(target_created_by_id: opts[:user_id]) if opts[:user_id]
+ reviewables = reviewables.limit(per_page).offset(offset)
- guardian = Guardian.new(current_user)
-
- if !guardian.is_admin?
- actions = actions.where(
- 'category_id IN (:allowed_category_ids) OR archetype = :private_message',
- allowed_category_ids: guardian.allowed_category_ids,
- private_message: Archetype.private_message
- )
+ if opts[:filter] == 'old'
+ reviewables = reviewables.where("status <> ?", Reviewable.statuses[:pending])
+ else
+ reviewables = reviewables.pending
end
- total_rows = actions.count
+ total_rows = reviewables.count
- post_ids_relation = actions.limit(per_page)
- .offset(offset)
- .group(:post_id)
- .order('MIN(post_actions.created_at) DESC')
-
- if opts[:filter] != "old"
- post_ids_relation = PostAction.apply_minimum_visibility(post_ids_relation)
- end
-
- post_ids = post_ids_relation.pluck(:post_id).uniq
+ post_ids = reviewables.map(&:target_id).uniq
posts = DB.query(<<~SQL, post_ids: post_ids)
SELECT p.id,
@@ -52,7 +44,6 @@ module FlagQuery
p.hidden,
p.deleted_at,
p.user_deleted,
- NULL as post_actions,
NULL as post_action_ids,
(SELECT created_at FROM post_revisions WHERE post_id = p.id AND user_id = p.user_id ORDER BY created_at DESC LIMIT 1) AS last_revised_at,
(SELECT COUNT(*) FROM post_actions WHERE (disagreed_at IS NOT NULL OR agreed_at IS NOT NULL OR deferred_at IS NOT NULL) AND post_id = p.id)::int AS previous_flags_count
@@ -71,68 +62,56 @@ module FlagQuery
post_lookup[p.id] = p
end
- post_actions = actions.order('post_actions.created_at DESC')
- .includes(related_post: { topic: { ordered_posts: :user } })
- .where(post_id: post_ids)
-
all_post_actions = []
+ reviewables.each do |r|
+ post = post_lookup[r.target_id]
+ post.post_action_ids ||= []
- post_actions.each do |pa|
- post = post_lookup[pa.post_id]
+ r.reviewable_scores.order('created_at desc').each do |rs|
+ action = {
+ id: rs.id,
+ post_id: post.id,
+ user_id: rs.user_id,
+ post_action_type_id: rs.reviewable_score_type,
+ created_at: rs.created_at,
+ disposed_by_id: rs.reviewed_by_id,
+ disposed_at: rs.reviewed_at,
+ disposition: ReviewableScore.statuses[rs.status],
+ targets_topic: r.payload['targets_topic'],
+ staff_took_action: rs.took_action?
+ }
+ action[:name_key] = PostActionType.types.key(rs.reviewable_score_type)
- if opts[:rest_api]
- post.post_action_ids ||= []
- else
- post.post_actions ||= []
- end
+ if rs.meta_topic.present?
+ meta_posts = rs.meta_topic.ordered_posts
- # TODO: add serializer so we can skip this
- action = {
- id: pa.id,
- post_id: pa.post_id,
- user_id: pa.user_id,
- post_action_type_id: pa.post_action_type_id,
- created_at: pa.created_at,
- disposed_by_id: pa.disposed_by_id,
- disposed_at: pa.disposed_at,
- disposition: pa.disposition,
- related_post_id: pa.related_post_id,
- targets_topic: pa.targets_topic,
- staff_took_action: pa.staff_took_action
- }
- action[:name_key] = PostActionType.types.key(pa.post_action_type_id)
+ conversation = {}
+ if response = meta_posts[0]
+ action[:related_post_id] = response.id
- if pa.related_post && pa.related_post.topic
- conversation = {}
- related_topic = pa.related_post.topic
- if response = related_topic.ordered_posts[0]
- conversation[:response] = {
- excerpt: excerpt(response.cooked),
- user_id: response.user_id
- }
- user_ids << response.user_id
- if reply = related_topic.ordered_posts[1]
- conversation[:reply] = {
- excerpt: excerpt(reply.cooked),
- user_id: reply.user_id
+ conversation[:response] = {
+ excerpt: excerpt(response.cooked),
+ user_id: response.user_id
}
- user_ids << reply.user_id
- conversation[:has_more] = related_topic.posts_count > 2
+ user_ids << response.user_id
+ if reply = meta_posts[1]
+ conversation[:reply] = {
+ excerpt: excerpt(reply.cooked),
+ user_id: reply.user_id
+ }
+ user_ids << reply.user_id
+ conversation[:has_more] = rs.meta_topic.posts_count > 2
+ end
end
+
+ action.merge!(permalink: rs.meta_topic.relative_url, conversation: conversation)
end
- action.merge!(permalink: related_topic.relative_url, conversation: conversation)
- end
-
- if opts[:rest_api]
post.post_action_ids << action[:id]
all_post_actions << action
- else
- post.post_actions << action
+ user_ids << action[:user_id]
+ user_ids << rs.reviewed_by_id if rs.reviewed_by_id
end
-
- user_ids << pa.user_id
- user_ids << pa.disposed_by_id if pa.disposed_by_id
end
post_custom_field_names = []
@@ -154,6 +133,7 @@ module FlagQuery
result
end
+ guardian = Guardian.new(current_user)
users = User.includes(:user_stat).where(id: user_ids.to_a).to_a
User.preload_custom_fields(users, User.whitelisted_user_custom_fields(guardian))
@@ -167,100 +147,78 @@ module FlagQuery
end
def self.flagged_post_actions(opts = nil)
+ Discourse.deprecate("FlagQuery is deprecated, please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+
opts ||= {}
- post_actions = PostAction.flags
- .joins("INNER JOIN posts ON posts.id = post_actions.post_id")
- .joins("INNER JOIN topics ON topics.id = posts.topic_id")
- .joins("LEFT JOIN users ON users.id = posts.user_id")
- .where("posts.user_id > 0")
-
- if opts[:topic_id]
- post_actions = post_actions.where("topics.id = ?", opts[:topic_id])
- end
-
- if opts[:user_id]
- post_actions = post_actions.where("posts.user_id = ?", opts[:user_id])
- end
+ scores = ReviewableScore.includes(:reviewable).where('reviewables.type' => 'ReviewableFlaggedPost')
+ scores = scores.where('reviewables.topic_id' => opts[:topic_id]) if opts[:topic_id]
+ scores = scores.where('reviewables.target_created_by_id' => opts[:user_id]) if opts[:user_id]
if opts[:filter] == 'without_custom'
- return post_actions.where(
- 'post_action_type_id' => PostActionType.flag_types_without_custom.values
- )
+ return scores.where(reviewable_score_type: PostActionType.flag_types_without_custom.values)
end
if opts[:filter] == "old"
- post_actions.where("post_actions.disagreed_at IS NOT NULL OR
- post_actions.deferred_at IS NOT NULL OR
- post_actions.agreed_at IS NOT NULL")
+ scores = scores.where('reviewables.status <> ?', Reviewable.statuses[:pending])
else
- post_actions.active
- .where("posts.deleted_at" => nil)
- .where("topics.deleted_at" => nil)
+ scores = scores.where('reviewables.status' => Reviewable.statuses[:pending])
end
+ scores
end
def self.flagged_topics
- results = DB.query(<<~SQL)
- SELECT pa.post_action_type_id,
- pa.post_id,
- p.topic_id,
- pa.created_at AS last_flag_at,
+ Discourse.deprecate("FlagQuery has been deprecated. Please use the Reviewable API instead.", since: "2.3.0beta5", drop_from: "2.4")
+
+ params = {
+ pending: Reviewable.statuses[:pending],
+ min_score: SiteSetting.min_score_default_visibility
+ }
+
+ results = DB.query(<<~SQL, params)
+ SELECT rs.reviewable_score_type,
+ p.id AS post_id,
+ r.topic_id,
+ rs.created_at,
p.user_id
- FROM post_actions AS pa
- INNER JOIN posts AS p ON pa.post_id = p.id
- INNER JOIN topics AS t ON t.id = p.topic_id
- WHERE pa.post_action_type_id IN (#{PostActionType.notify_flag_type_ids.join(',')})
- AND pa.disagreed_at IS NULL
- AND pa.deferred_at IS NULL
- AND pa.agreed_at IS NULL
- AND pa.deleted_at IS NULL
- AND p.user_id > 0
- AND p.deleted_at IS NULL
- AND t.deleted_at IS NULL
- ORDER BY pa.created_at DESC
+ FROM reviewables AS r
+ INNER JOIN reviewable_scores AS rs ON rs.reviewable_id = r.id
+ INNER JOIN posts AS p ON p.id = r.target_id
+ WHERE r.type = 'ReviewableFlaggedPost'
+ AND r.status = :pending
+ AND r.score >= :min_score
+ ORDER BY rs.created_at DESC
SQL
ft_by_id = {}
- counts_by_post = {}
user_ids = Set.new
- results.each do |pa|
-
- ft = ft_by_id[pa.topic_id] ||= OpenStruct.new(
- topic_id: pa.topic_id,
+ results.each do |r|
+ ft = ft_by_id[r.topic_id] ||= OpenStruct.new(
+ topic_id: r.topic_id,
flag_counts: {},
user_ids: Set.new,
- last_flag_at: pa.last_flag_at,
- meets_minimum: false
+ last_flag_at: r.created_at,
)
- counts_by_post[pa.post_id] ||= 0
- sum = counts_by_post[pa.post_id] += 1
- ft.meets_minimum = true if sum >= SiteSetting.min_flags_staff_visibility
+ ft.flag_counts[r.reviewable_score_type] ||= 0
+ ft.flag_counts[r.reviewable_score_type] += 1
- ft.flag_counts[pa.post_action_type_id] ||= 0
- ft.flag_counts[pa.post_action_type_id] += 1
-
- ft.user_ids << pa.user_id
- user_ids << pa.user_id
+ ft.user_ids << r.user_id
+ user_ids << r.user_id
end
all_topics = Topic.where(id: ft_by_id.keys).to_a
all_topics.each { |t| ft_by_id[t.id].topic = t }
- flagged_topics = ft_by_id.values.select { |ft| ft.meets_minimum }
Topic.preload_custom_fields(all_topics, TopicList.preloaded_custom_fields)
-
{
- flagged_topics: flagged_topics,
+ flagged_topics: ft_by_id.values,
users: User.where(id: user_ids)
}
end
- private
-
def self.excerpt(cooked)
excerpt = Post.excerpt(cooked, 200, keep_emoji_images: true)
# remove the first link if it's the first node
diff --git a/lib/flag_settings.rb b/lib/flag_settings.rb
index 3fb700d7cc6..d82a97ff30c 100644
--- a/lib/flag_settings.rb
+++ b/lib/flag_settings.rb
@@ -17,14 +17,15 @@ class FlagSettings
@without_custom_types = Enum.new
end
- def add(id, name, details = nil)
+ def add(id, name, topic_type: nil, notify_type: nil, auto_action_type: nil, custom_type: nil)
details ||= {}
@all_flag_types[name] = id
- @topic_flag_types[name] = id if !!details[:topic_type]
- @notify_types[name] = id if !!details[:notify_type]
- @auto_action_types[name] = id if !!details[:auto_action_type]
- if !!details[:custom_type]
+ @topic_flag_types[name] = id if !!topic_type
+ @notify_types[name] = id if !!notify_type
+ @auto_action_types[name] = id if !!auto_action_type
+
+ if !!custom_type
@custom_types[name] = id
else
@without_custom_types[name] = id
diff --git a/lib/guardian/post_guardian.rb b/lib/guardian/post_guardian.rb
index f0e63f6c789..f70d7661202 100644
--- a/lib/guardian/post_guardian.rb
+++ b/lib/guardian/post_guardian.rb
@@ -192,10 +192,11 @@ module PostGuardian
end
def can_delete_post_action?(post_action)
- # You can only undo your own actions
- is_my_own?(post_action) && not(post_action.is_private_message?) &&
+ return false unless is_my_own?(post_action) && !post_action.is_private_message?
+
+ # Bookmarks do not have a time constraint
+ return true if post_action.is_bookmark?
- # Make sure they want to delete it within the window
post_action.created_at > SiteSetting.post_undo_action_window_mins.minutes.ago
end
diff --git a/lib/has_errors.rb b/lib/has_errors.rb
index 6c5dd02a1d8..a68c752ce13 100644
--- a/lib/has_errors.rb
+++ b/lib/has_errors.rb
@@ -2,6 +2,7 @@
# child objects with errors
module HasErrors
attr_reader :errors
+ attr_accessor :forbidden, :not_found, :conflict
def errors
@errors ||= ActiveModel::Errors.new(self)
@@ -23,10 +24,18 @@ module HasErrors
raise ActiveRecord::Rollback.new
end
+ def add_error(msg)
+ errors[:base] << msg unless errors[:base].include?(msg)
+ end
+
def add_errors_from(obj)
- obj.errors.full_messages.each do |msg|
- errors[:base] << msg unless errors[:base].include?(msg)
+ return if obj.blank?
+
+ if obj.is_a?(StandardError)
+ return add_error(obj.message)
end
+
+ obj.errors.full_messages.each { |msg| add_error(msg) }
end
end
diff --git a/lib/new_post_manager.rb b/lib/new_post_manager.rb
index a77082cdc20..92baa71cce4 100644
--- a/lib/new_post_manager.rb
+++ b/lib/new_post_manager.rb
@@ -1,6 +1,5 @@
require_dependency 'post_creator'
require_dependency 'new_post_result'
-require_dependency 'post_enqueuer'
require_dependency 'word_watcher'
# Determines what actions should be taken with new posts.
@@ -127,7 +126,7 @@ class NewPostManager
end
end
- result = manager.enqueue('default')
+ result = manager.enqueue
if is_fast_typer?(manager)
UserSilencer.silence(manager.user, Discourse.system_user, keep_posts: true, reason: I18n.t("user.new_user_typed_too_fast"))
@@ -178,23 +177,44 @@ class NewPostManager
perform_create_post unless handled
end
- # Enqueue this post in a queue
- def enqueue(queue, reason = nil)
+ # Enqueue this post
+ def enqueue(reason = nil)
result = NewPostResult.new(:enqueued)
- enqueuer = PostEnqueuer.new(@user, queue)
- queued_args = { post_options: @args.dup }
- queued_args[:raw] = queued_args[:post_options].delete(:raw)
- queued_args[:topic_id] = queued_args[:post_options].delete(:topic_id)
+ reviewable = ReviewableQueuedPost.new(
+ created_by: @user,
+ payload: { raw: @args[:raw] },
+ topic_id: @args[:topic_id],
+ reviewable_by_moderator: true
+ )
+ reviewable.payload['title'] = @args[:title] if @args[:title].present?
- post = enqueuer.enqueue(queued_args)
+ create_options = reviewable.create_options
- QueuedPost.broadcast_new! if post && post.errors.empty?
+ creator = @args[:topic_id] ?
+ PostCreator.new(@user, create_options) :
+ TopicCreator.new(@user, Guardian.new(@user), create_options)
- result.queued_post = post
+ errors = Set.new
+ creator.valid?
+ creator.errors.full_messages.each { |msg| errors << msg }
+ errors = creator.errors.full_messages.uniq
+ if errors.blank?
+ if reviewable.save
+ reviewable.add_score(
+ Discourse.system_user,
+ ReviewableScore.types[:needs_approval],
+ force_review: true
+ )
+ else
+ reviewable.errors.full_messages.each { |msg| errors << msg }
+ end
+ end
+
+ result.reviewable = reviewable
result.reason = reason if reason
- result.check_errors_from(enqueuer)
- result.pending_count = QueuedPost.new_posts.where(user_id: @user.id).count
+ result.check_errors(errors)
+ result.pending_count = Reviewable.where(created_by: @user).pending.count
result
end
diff --git a/lib/new_post_result.rb b/lib/new_post_result.rb
index 78725ea11f0..f4971545fa0 100644
--- a/lib/new_post_result.rb
+++ b/lib/new_post_result.rb
@@ -7,7 +7,7 @@ class NewPostResult
attr_accessor :reason
attr_accessor :post
- attr_accessor :queued_post
+ attr_accessor :reviewable
attr_accessor :pending_count
def initialize(action, success = false)
@@ -23,6 +23,23 @@ class NewPostResult
end
end
+ def check_errors(arr)
+ if arr.empty?
+ @success = true
+ else
+ arr.each { |e| errors[:base] << e unless errors[:base].include?(e) }
+ end
+ end
+
+ def queued_post
+ Discourse.deprecate(
+ "NewPostManager#queued_post is deprecated. Please use #reviewable instead.",
+ output_in_test: true
+ )
+
+ reviewable
+ end
+
def success?
@success
end
diff --git a/lib/plugin/instance.rb b/lib/plugin/instance.rb
index 83941d436d0..4a4d81ac9b3 100644
--- a/lib/plugin/instance.rb
+++ b/lib/plugin/instance.rb
@@ -604,6 +604,15 @@ class Plugin::Instance
end
end
+ def register_reviewable_type(reviewable_type_class)
+ types = Reviewable.types
+ types << reviewable_type_class.name
+
+ reloadable_patch do
+ Reviewable.send(:define_singleton_method, :types) { types }
+ end
+ end
+
protected
def register_assets!
diff --git a/lib/post_action_creator.rb b/lib/post_action_creator.rb
index 21b951a638a..ce582cc7cb7 100644
--- a/lib/post_action_creator.rb
+++ b/lib/post_action_creator.rb
@@ -1,23 +1,298 @@
-# creates post actions based on a post and a user
+require_dependency 'post_action_result'
+
class PostActionCreator
+ class CreateResult < PostActionResult
+ attr_accessor :post_action, :reviewable, :reviewable_score
+ end
+
+ # Shortcut methods for easier invocation
+ class << self
+ def create(created_by, post, action_key, message: nil, created_at: nil)
+ new(created_by, post, PostActionType.types[action_key], message: message, created_at: created_at).perform
+ end
+
+ [:like, :off_topic, :spam, :inappropriate, :bookmark].each do |action|
+ define_method(action) do |created_by, post|
+ create(created_by, post, action)
+ end
+ end
+ [:notify_moderators, :notify_user].each do |action|
+ define_method(action) do |created_by, post, message = nil|
+ create(created_by, post, action, message: message)
+ end
+ end
+ end
+
+ def initialize(
+ created_by,
+ post,
+ post_action_type_id,
+ is_warning: false,
+ message: nil,
+ take_action: false,
+ flag_topic: false,
+ created_at: nil
+ )
+ @created_by = created_by
+ @created_at = created_at || Time.zone.now
- def initialize(user, post)
- @user = user
@post = post
+ @post_action_type_id = post_action_type_id
+ @post_action_name = PostActionType.types[@post_action_type_id]
+
+ @is_warning = is_warning
+ @take_action = take_action && guardian.is_staff?
+
+ @message = message
+ @flag_topic = flag_topic
+ @meta_post = nil
end
- def perform(action)
- guardian.ensure_post_can_act!(@post, PostActionType.types[action], opts: {
- taken_actions: PostAction.counts_for([@post].compact, @user)[@post&.id]
- })
+ def perform
+ result = CreateResult.new
- PostAction.act(@user, @post, action)
+ unless guardian.post_can_act?(
+ @post,
+ @post_action_name,
+ opts: {
+ is_warning: @is_warning,
+ taken_actions: PostAction.counts_for([@post].compact, @created_by)[@post&.id]
+ }
+ )
+ result.forbidden = true
+ result.add_error(I18n.t("invalid_access"))
+ return result
+ end
+
+ PostAction.limit_action!(@created_by, @post, @post_action_type_id)
+
+ # create meta topic / post if needed
+ if @message.present? && [:notify_moderators, :notify_user, :spam].include?(@post_action_name)
+ creator = create_message_creator
+ post = creator.create
+ if creator.errors.present?
+ result.add_errors_from(creator)
+ return result
+ end
+ @meta_post = post
+ end
+
+ begin
+ post_action = create_post_action
+
+ if post_action.blank? || post_action.errors.present?
+ result.add_errors_from(post_action)
+ else
+ create_reviewable(result)
+ enforce_rules
+ UserActionManager.post_action_created(post_action)
+ PostActionNotifier.post_action_created(post_action)
+ notify_subscribers
+
+ result.success = true
+ result.post_action = post_action
+
+ end
+ rescue ActiveRecord::RecordNotUnique
+ # If the user already performed this action, it's proably due to a different browser tab
+ # or non-debounced clicking. We can ignore.
+ result.success = true
+ result.post_action = PostAction.find_by(
+ user: @created_by,
+ post: @post,
+ post_action_type_id: @post_action_type_id
+ )
+ end
+
+ result
end
- private
+private
+
+ def notify_subscribers
+ if self.class.notify_types.include?(@post_action_name)
+ @post.publish_change_to_clients! :acted
+ end
+ end
+
+ def self.notify_types
+ @notify_types ||= ([:like] + PostActionType.notify_flag_types.keys)
+ end
+
+ def enforce_rules
+ auto_close_if_threshold_reached
+ auto_hide_if_needed
+ SpamRule::AutoSilence.new(@post.user, @post).perform
+ end
+
+ def auto_close_if_threshold_reached
+ return if topic.nil? || topic.closed?
+ return unless topic.auto_close_threshold_reached?
+
+ # the threshold has been reached, we will close the topic waiting for intervention
+ topic.update_status("closed", true, Discourse.system_user,
+ message: I18n.t(
+ "temporarily_closed_due_to_flags",
+ count: SiteSetting.num_hours_to_close_topic
+ )
+ )
+
+ topic.set_or_create_timer(
+ TopicTimer.types[:open],
+ SiteSetting.num_hours_to_close_topic,
+ by_user: Discourse.system_user
+ )
+ end
+
+ def auto_hide_if_needed
+ return if @post.hidden?
+ return if !@created_by.staff? && @post.user&.staff?
+
+ if @post_action_name == :spam &&
+ @created_by.has_trust_level?(TrustLevel[3]) &&
+ @post.user&.trust_level == TrustLevel[0]
+ @post.hide!(@post_action_type_id, Post.hidden_reasons[:flagged_by_tl3_user])
+ elsif PostActionType.auto_action_flag_types.include?(@post_action_name)
+ if @created_by.has_trust_level?(TrustLevel[4]) &&
+ !@created_by.staff? &&
+ @post.user&.trust_level != TrustLevel[4]
+
+ @post.hide!(@post_action_type_id, Post.hidden_reasons[:flagged_by_tl4_user])
+ elsif SiteSetting.score_required_to_hide_post > 0
+ score = ReviewableFlaggedPost.find_by(target: @post)&.score || 0
+ if score >= SiteSetting.score_required_to_hide_post
+ @post.hide!(@post_action_type_id)
+ end
+ end
+ end
+ end
+
+ def create_post_action
+ @targets_topic = !!(
+ if @flag_topic && @post.topic
+ @post.topic.reload.posts_count != 1
+ end
+ )
+
+ where_attrs = {
+ post_id: @post.id,
+ user_id: @created_by.id,
+ post_action_type_id: @post_action_type_id
+ }
+
+ action_attrs = {
+ staff_took_action: @take_action,
+ related_post_id: @meta_post&.id,
+ targets_topic: @targets_topic,
+ created_at: @created_at
+ }
+
+ # First try to revive a trashed record
+ post_action = PostAction.where(where_attrs)
+ .with_deleted
+ .where("deleted_at IS NOT NULL")
+ .first
+
+ if post_action
+ post_action.recover!
+ action_attrs.each { |attr, val| post_action.send("#{attr}=", val) }
+ post_action.save
+ PostActionNotifier.post_action_created(post_action)
+ else
+ post_action = PostAction.create(where_attrs.merge(action_attrs))
+ if post_action && post_action.errors.count == 0
+ BadgeGranter.queue_badge_grant(Badge::Trigger::PostAction, post_action: post_action)
+ end
+ end
+
+ if post_action && PostActionType.notify_flag_type_ids.include?(@post_action_type_id)
+ DiscourseEvent.trigger(:flag_created, post_action)
+ end
+
+ GivenDailyLike.increment_for(@created_by.id) if @post_action_type_id == PostActionType.types[:like]
+
+ # agree with other flags
+ if @take_action && reviewable = @post.reviewable_flag
+ reviewable.perform(@created_by, :agree_and_keep)
+ post_action.try(:update_counters)
+ end
+
+ post_action
+ rescue ActiveRecord::RecordNotUnique
+ # can happen despite being .create
+ # since already bookmarked
+ PostAction.where(where_attrs).first
+ end
+
+ def create_message_creator
+ title = I18n.t(
+ "post_action_types.#{@post_action_name}.email_title",
+ title: @post.topic.title,
+ locale: SiteSetting.default_locale
+ )
+
+ body = I18n.t(
+ "post_action_types.#{@post_action_name}.email_body",
+ message: @message,
+ link: "#{Discourse.base_url}#{@post.url}",
+ locale: SiteSetting.default_locale
+ )
+
+ create_args = {
+ archetype: Archetype.private_message,
+ is_warning: @is_warning,
+ title: title.truncate(SiteSetting.max_topic_title_length, separator: /\s/),
+ raw: body
+ }
+
+ if [:notify_moderators, :spam].include?(@post_action_name)
+ create_args[:subtype] = TopicSubtype.notify_moderators
+ create_args[:target_group_names] = Group[:moderators].name
+ else
+ create_args[:subtype] = TopicSubtype.notify_user
+
+ create_args[:target_usernames] =
+ if @post_action_name == :notify_user
+ @post.user.username
+ elsif @post_action_name != :notify_moderators
+ # this is a hack to allow a PM with no recipients, we should think through
+ # a cleaner technique, a PM with myself is valid for flagging
+ 'x'
+ end
+ end
+
+ PostCreator.new(@created_by, create_args)
+ end
+
+ def create_reviewable(result)
+ return unless PostActionType.notify_flag_type_ids.include?(@post_action_type_id)
+ return if @post.user_id.to_i < 0
+
+ result.reviewable = ReviewableFlaggedPost.needs_review!(
+ created_by: @created_by,
+ target: @post,
+ topic: @post.topic,
+ reviewable_by_moderator: true,
+ potential_spam: @post_action_type_id == PostActionType.types[:spam],
+ payload: {
+ targets_topic: @targets_topic
+ }
+ )
+ result.reviewable_score = result.reviewable.add_score(
+ @created_by,
+ @post_action_type_id,
+ created_at: @created_at,
+ take_action: @take_action,
+ meta_topic_id: @meta_post&.topic_id,
+ )
+ end
def guardian
- @guardian ||= Guardian.new(@user)
+ @guardian ||= Guardian.new(@created_by)
+ end
+
+ def topic
+ @post.topic
end
end
diff --git a/lib/post_action_destroyer.rb b/lib/post_action_destroyer.rb
new file mode 100644
index 00000000000..f4569f13011
--- /dev/null
+++ b/lib/post_action_destroyer.rb
@@ -0,0 +1,63 @@
+require_dependency 'post_action_result'
+
+class PostActionDestroyer
+ class DestroyResult < PostActionResult
+ attr_accessor :post
+ end
+
+ def initialize(destroyed_by, post, post_action_type_id)
+ @destroyed_by, @post, @post_action_type_id = destroyed_by, post, post_action_type_id
+ end
+
+ def self.destroy(destroyed_by, post, action_key)
+ new(destroyed_by, post, PostActionType.types[action_key]).perform
+ end
+
+ def perform
+ result = DestroyResult.new
+
+ if @post.blank?
+ result.not_found = true
+ return result
+ end
+
+ finder = PostAction.where(
+ user: @destroyed_by,
+ post: @post,
+ post_action_type_id: @post_action_type_id
+ )
+ finder = finder.with_deleted if @destroyed_by.staff?
+ post_action = finder.first
+
+ if post_action.blank?
+ result.not_found = true
+ return result
+ end
+
+ unless guardian.can_delete?(post_action)
+ result.forbidden = true
+ result.add_error(I18n.t("invalid_access"))
+ return result
+ end
+
+ RateLimiter.new(@destroyed_by, "post_action-#{@post.id}_#{@post_action_type_id}", 4, 1.minute).performed!
+
+ post_action.remove_act!(@destroyed_by)
+ post_action.post.unhide! if post_action.staff_took_action
+ GivenDailyLike.decrement_for(@destroyed_by.id) if @post_action_type_id == PostActionType.types[:like]
+
+ UserActionManager.post_action_destroyed(post_action)
+ PostActionNotifier.post_action_deleted(post_action)
+
+ result.success = true
+ result.post = @post.reload
+
+ result
+ end
+
+protected
+
+ def guardian
+ @guardian ||= Guardian.new(@destroyed_by)
+ end
+end
diff --git a/lib/post_action_result.rb b/lib/post_action_result.rb
new file mode 100644
index 00000000000..a6586e628ed
--- /dev/null
+++ b/lib/post_action_result.rb
@@ -0,0 +1,19 @@
+require_dependency 'has_errors'
+
+class PostActionResult
+ include HasErrors
+
+ attr_accessor :success
+
+ def initialize
+ @success = false
+ end
+
+ def success?
+ @success
+ end
+
+ def failed?
+ !success
+ end
+end
diff --git a/lib/post_creator.rb b/lib/post_creator.rb
index 68f23ea59e1..e05bd0c4d7e 100644
--- a/lib/post_creator.rb
+++ b/lib/post_creator.rb
@@ -169,6 +169,7 @@ class PostCreator
create_topic
create_post_notice
save_post
+ UserActionManager.post_created(@post)
extract_links
track_topic
update_topic_stats
diff --git a/lib/post_destroyer.rb b/lib/post_destroyer.rb
index 04512fcbc8e..4719d4f5d1d 100644
--- a/lib/post_destroyer.rb
+++ b/lib/post_destroyer.rb
@@ -60,10 +60,14 @@ class PostDestroyer
elsif @user.id == @post.user_id
mark_for_deletion(delete_removed_posts_after)
end
+
+ UserActionManager.post_destroyed(@post)
+
DiscourseEvent.trigger(:post_destroyed, @post, @opts, @user)
WebHook.enqueue_post_hooks(:post_destroyed, @post, payload)
if @post.is_first_post? && @post.topic
+ UserActionManager.topic_destroyed(@post.topic)
DiscourseEvent.trigger(:topic_destroyed, @post.topic, @user)
WebHook.enqueue_topic_hooks(:topic_destroyed, @post.topic, topic_payload)
end
@@ -76,11 +80,12 @@ class PostDestroyer
user_recovered
end
topic = Topic.with_deleted.find @post.topic_id
- topic.recover! if @post.is_first_post?
+ topic.recover!(@user) if @post.is_first_post?
topic.update_statistics
- recover_user_actions
+ UserActionManager.post_created(@post)
DiscourseEvent.trigger(:post_recovered, @post, @opts, @user)
if @post.is_first_post?
+ UserActionManager.topic_created(@post.topic)
DiscourseEvent.trigger(:topic_recovered, topic, @user)
StaffActionLogger.new(@user).log_topic_delete_recover(topic, "recover_topic", @opts.slice(:context)) if @user.id != @post.user_id
end
@@ -129,7 +134,6 @@ class PostDestroyer
end
trash_public_post_actions
trash_user_actions
- @post.update_flagged_posts_count
remove_associated_replies
remove_associated_notifications
if @post.topic && @post.is_first_post?
@@ -141,11 +145,14 @@ class PostDestroyer
update_associated_category_latest_topic
update_user_counts
TopicUser.update_post_action_cache(post_id: @post.id)
+
DB.after_commit do
- if @opts[:defer_flags]
- defer_flags
- else
- agree_with_flags
+ if reviewable = @post.reviewable_flag
+ if @opts[:defer_flags]
+ ignore(reviewable)
+ else
+ agree(reviewable)
+ end
end
end
end
@@ -167,7 +174,6 @@ class PostDestroyer
Post.transaction do
@post.update_column(:user_deleted, true)
- @post.update_flagged_posts_count
@post.topic_links.each(&:destroy)
end
end
@@ -177,7 +183,6 @@ class PostDestroyer
Post.transaction do
@post.update_column(:user_deleted, false)
@post.skip_unique_check = true
- @post.update_flagged_posts_count
end
# has internal transactions, if we nest then there are some very high risk deadlocks
@@ -240,8 +245,8 @@ class PostDestroyer
end
end
- def agree_with_flags
- if @post.has_active_flag? && @user.human? && @user.staff?
+ def agree(reviewable)
+ if @user.human? && @user.staff? && rs = reviewable.reviewable_scores.order('created_at DESC').first
Jobs.enqueue(
:send_system_message,
user_id: @post.user_id,
@@ -250,7 +255,7 @@ class PostDestroyer
flagged_post_raw_content: @post.raw,
url: @post.url,
flag_reason: I18n.t(
- "flag_reasons.#{@post.active_flags.last.post_action_type.name_key}",
+ "flag_reasons.#{PostActionType.types[rs.reviewable_score_type]}",
locale: SiteSetting.default_locale,
base_path: Discourse.base_path
)
@@ -258,11 +263,13 @@ class PostDestroyer
)
end
- PostAction.agree_flags!(@post, @user, delete_post: true)
+ result = reviewable.perform(@user, :agree_and_keep, post_was_deleted: true)
+ reviewable.transition_to(result.transition_to, @user)
end
- def defer_flags
- PostAction.defer_flags!(@post, @user, delete_post: true)
+ def ignore(reviewable)
+ reviewable.perform_ignore(@user, post_was_deleted: true)
+ reviewable.transition_to(:ignored, @user)
end
def trash_user_actions
@@ -278,11 +285,6 @@ class PostDestroyer
end
end
- def recover_user_actions
- # TODO: Use a trash concept for `user_actions` to avoid churn and simplify this?
- UserActionCreator.log_post(@post)
- end
-
def remove_associated_replies
post_ids = PostReply.where(reply_id: @post.id).pluck(:post_id)
diff --git a/lib/post_enqueuer.rb b/lib/post_enqueuer.rb
deleted file mode 100644
index a62caa46447..00000000000
--- a/lib/post_enqueuer.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-require_dependency 'topic_creator'
-require_dependency 'queued_post'
-require_dependency 'has_errors'
-
-class PostEnqueuer
- include HasErrors
-
- def initialize(user, queue)
- @user = user
- @queue = queue
- end
-
- def enqueue(args)
- queued_post = QueuedPost.new(queue: @queue,
- state: QueuedPost.states[:new],
- user_id: @user.id,
- topic_id: args[:topic_id],
- raw: args[:raw],
- post_options: args[:post_options] || {})
-
- validate_method = :"validate_#{@queue}"
- if respond_to?(validate_method)
- return unless send(validate_method, queued_post.create_options)
- end
-
- if queued_post.save
- queued_post.create_pending_action
- else
- add_errors_from(queued_post)
- end
-
- queued_post
- end
-
- def validate_new_topic(create_options)
- topic_creator = TopicCreator.new(@user, Guardian.new(@user), create_options)
- validate_child(topic_creator)
- end
-
- def validate_new_post(create_options)
- post_creator = PostCreator.new(@user, create_options)
- validate_child(post_creator)
- end
-
-end
diff --git a/lib/post_revisor.rb b/lib/post_revisor.rb
index bd0a800596f..adb93820c2e 100644
--- a/lib/post_revisor.rb
+++ b/lib/post_revisor.rb
@@ -292,8 +292,8 @@ class PostRevisor
end
def ninja_edit?
- return false if @post.has_active_flag?
return false if (@revised_at - @last_version_at) > SiteSetting.editing_grace_period.to_i
+ return false if @post.reviewable_flag.present?
if new_raw = @fields[:raw]
@@ -343,18 +343,16 @@ class PostRevisor
prev_owner = User.find(@post.user_id)
new_owner = User.find(@fields["user_id"])
- # UserActionCreator will create new UserAction records for the new owner
-
UserAction.where(target_post_id: @post.id)
.where(user_id: prev_owner.id)
.where(action_type: USER_ACTIONS_TO_REMOVE)
- .destroy_all
+ .update_all(user_id: new_owner.id)
if @post.post_number == 1
UserAction.where(target_topic_id: @post.topic_id)
.where(user_id: prev_owner.id)
.where(action_type: UserAction::NEW_TOPIC)
- .destroy_all
+ .update_all(user_id: new_owner.id)
end
end
diff --git a/lib/reviewable/actions.rb b/lib/reviewable/actions.rb
new file mode 100644
index 00000000000..ae0e353f3e4
--- /dev/null
+++ b/lib/reviewable/actions.rb
@@ -0,0 +1,57 @@
+require_dependency 'reviewable/collection'
+
+class Reviewable < ActiveRecord::Base
+ class Actions < Reviewable::Collection
+ attr_reader :bundles
+
+ def initialize(reviewable, guardian, args = nil)
+ super(reviewable, guardian, args)
+ @bundles = []
+ end
+
+ # Add common actions here to make them easier for reviewables to re-use. If it's a
+ # one off, add it manually.
+ def self.common_actions
+ {
+ approve: Action.new(:approve, 'thumbs-up', 'reviewables.actions.approve.title'),
+ reject: Action.new(:reject, 'thumbs-down', 'reviewables.actions.reject.title'),
+ }
+ end
+
+ class Bundle < Item
+ attr_accessor :icon, :label, :actions
+
+ def initialize(id, icon: nil, label: nil)
+ super(id)
+ @icon = icon
+ @label = label
+ @actions = []
+ end
+ end
+
+ class Action < Item
+ attr_accessor :icon, :label, :description, :confirm_message, :client_action
+
+ def initialize(id, icon = nil, label = nil)
+ super(id)
+ @icon, @label = icon, label
+ end
+ end
+
+ def add_bundle(id, icon: nil, label: nil)
+ bundle = Bundle.new(id, icon: icon, label: label)
+ @bundles << bundle
+ bundle
+ end
+
+ def add(id, bundle: nil)
+ action = Actions.common_actions[id] || Action.new(id)
+ yield action if block_given?
+ @content << action
+
+ bundle ||= add_bundle(id)
+ bundle.actions << action
+ end
+
+ end
+end
diff --git a/lib/reviewable/collection.rb b/lib/reviewable/collection.rb
new file mode 100644
index 00000000000..8604045efdc
--- /dev/null
+++ b/lib/reviewable/collection.rb
@@ -0,0 +1,39 @@
+class Reviewable < ActiveRecord::Base
+ class Collection
+ class Item
+ include ActiveModel::Serialization
+ attr_reader :id
+
+ def initialize(id)
+ @id = id
+ end
+ end
+
+ def initialize(reviewable, guardian, args = nil)
+ args ||= {}
+
+ @reviewable, @guardian, @args = reviewable, guardian, args
+ @content = []
+ end
+
+ def has?(id)
+ @content.any? { |a| a.id.to_s == id.to_s }
+ end
+
+ def blank?
+ @content.blank?
+ end
+
+ def present?
+ !blank?
+ end
+
+ def each
+ @content.each { |i| yield i }
+ end
+
+ def to_a
+ @content
+ end
+ end
+end
diff --git a/lib/reviewable/conversation.rb b/lib/reviewable/conversation.rb
new file mode 100644
index 00000000000..9ca7194d280
--- /dev/null
+++ b/lib/reviewable/conversation.rb
@@ -0,0 +1,30 @@
+class Reviewable < ActiveRecord::Base
+ class Conversation
+ include ActiveModel::Serialization
+
+ class Post
+ include ActiveModel::Serialization
+ attr_reader :id, :user, :excerpt
+
+ def initialize(post)
+ @user = post.user
+ @id = post.id
+ @excerpt = FlagQuery.excerpt(post.cooked)
+ end
+ end
+
+ attr_reader :id, :permalink, :has_more, :conversation_posts
+
+ def initialize(meta_topic)
+ @id = meta_topic.id
+ @has_more = false
+ @permalink = meta_topic.relative_url
+ @posts = []
+
+ meta_posts = meta_topic.ordered_posts.where(post_type: ::Post.types[:regular]).limit(2)
+
+ @conversation_posts = meta_posts.map { |mp| Reviewable::Conversation::Post.new(mp) }
+ @has_more = meta_topic.posts_count > 2
+ end
+ end
+end
diff --git a/lib/reviewable/editable_fields.rb b/lib/reviewable/editable_fields.rb
new file mode 100644
index 00000000000..0106d20e1e2
--- /dev/null
+++ b/lib/reviewable/editable_fields.rb
@@ -0,0 +1,18 @@
+require_dependency 'reviewable/collection'
+
+class Reviewable < ActiveRecord::Base
+ class EditableFields < Reviewable::Collection
+ class Field < Item
+ attr_reader :type
+
+ def initialize(id, type)
+ super(id)
+ @type = type
+ end
+ end
+
+ def add(id, type)
+ @content << Field.new(id, type)
+ end
+ end
+end
diff --git a/lib/reviewable/perform_result.rb b/lib/reviewable/perform_result.rb
new file mode 100644
index 00000000000..239e0da8006
--- /dev/null
+++ b/lib/reviewable/perform_result.rb
@@ -0,0 +1,24 @@
+class Reviewable < ActiveRecord::Base
+ class PerformResult
+ include ActiveModel::Serialization
+
+ attr_reader :reviewable, :status, :created_post, :created_post_topic
+ attr_accessor :transition_to, :remove_reviewable_ids, :errors, :recalculate_score,
+ :update_flag_stats
+
+ def initialize(reviewable, status)
+ @status = status
+ @reviewable = reviewable
+ @remove_reviewable_ids = [reviewable.id] if success?
+ end
+
+ def created_post=(created_post)
+ @created_post = created_post
+ @created_post_topic = created_post.topic
+ end
+
+ def success?
+ @status == :success
+ end
+ end
+end
diff --git a/lib/tasks/user_actions.rake b/lib/tasks/user_actions.rake
index f457454978e..555e894b79c 100644
--- a/lib/tasks/user_actions.rake
+++ b/lib/tasks/user_actions.rake
@@ -2,13 +2,38 @@ desc "rebuild the user_actions table"
task "user_actions:rebuild" => :environment do
MessageBus.off
UserAction.delete_all
- PostAction.all.each { |i| UserActionCreator.log_post_action(i) }
- Topic.all.each { |i| UserActionCreator.log_topic(i) }
- Post.all.each { |i| UserActionCreator.log_post(i) }
+ PostAction.all.each do |i|
+ if i.deleted_at.nil?
+ UserActionManager.post_action_created(i)
+ else
+ UserActionManager.post_action_destroyed(i)
+ end
+ end
+ Topic.all.each { |i| UserActionManager.log_topic(i) }
+ Post.all.each do |i|
+ if i.deleted_at.nil?
+ UserActionManager.post_created(i)
+ else
+ UserActionManager.post_destroyed(i)
+ end
+ end
Notification.all.each do |notification|
- UserActionCreator.log_notification(notification.post,
- notification.user,
- notification.notification_type,
- notification.user)
+
+ if notification.post.deleted_at.nil?
+ UserActionManager.notification_created(
+ notification.post,
+ notification.user,
+ notification.notification_type,
+ notification.user
+ )
+ else
+ UserActionManager.notification_destroyed(
+ notification.post,
+ notification.user,
+ notification.notification_type,
+ notification.user
+ )
+ end
+
end
end
diff --git a/lib/topic_creator.rb b/lib/topic_creator.rb
index 49831cddcd2..65a439e4731 100644
--- a/lib/topic_creator.rb
+++ b/lib/topic_creator.rb
@@ -44,6 +44,7 @@ class TopicCreator
create_warning(topic)
watch_topic(topic)
create_shared_draft(topic)
+ UserActionManager.topic_created(topic)
topic
end
diff --git a/lib/topic_view.rb b/lib/topic_view.rb
index 08cfa02eadb..5705ab3ff7c 100644
--- a/lib/topic_view.rb
+++ b/lib/topic_view.rb
@@ -383,7 +383,7 @@ class TopicView
end
def all_active_flags
- @all_active_flags ||= PostAction.active_flags_counts_for(@posts)
+ @all_active_flags ||= ReviewableFlaggedPost.counts_for(@posts)
end
def links
@@ -421,10 +421,10 @@ class TopicView
end
# This is pending a larger refactor, that allows custom orders
- # for now we need to look for the highest_post_number in the stream
- # the cache on topics is not correct if there are deleted posts at
- # the end of the stream (for mods), nor is it correct for filtered
- # streams
+ # for now we need to look for the highest_post_number in the stream
+ # the cache on topics is not correct if there are deleted posts at
+ # the end of the stream (for mods), nor is it correct for filtered
+ # streams
def highest_post_number
@highest_post_number ||= @filtered_posts.maximum(:post_number)
end
diff --git a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/advanced_user_narrative.rb b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/advanced_user_narrative.rb
index 0239d695dc2..4de4b2b0c1b 100644
--- a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/advanced_user_narrative.rb
+++ b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/advanced_user_narrative.rb
@@ -149,13 +149,7 @@ module DiscourseNarrativeBot
if SiteSetting.delete_removed_posts_after < 1
opts[:delete_removed_posts_after] = 1
- # Flag it and defer so the stub doesn't get destroyed
- flag = PostAction.create!(
- user: self.discobot_user,
- post: post, post_action_type_id:
- PostActionType.types[:notify_moderators]
- )
-
+ flag = PostActionCreator.notify_moderators(self.discobot_user, post).post_action
PostAction.defer_flags!(post, self.discobot_user)
end
diff --git a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/new_user_narrative.rb b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/new_user_narrative.rb
index 600ee90664b..d26a61ae603 100644
--- a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/new_user_narrative.rb
+++ b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/new_user_narrative.rb
@@ -523,7 +523,7 @@ module DiscourseNarrativeBot
end
def like_post(post)
- PostAction.act(self.discobot_user, post, PostActionType.types[:like])
+ PostActionCreator.like(self.discobot_user, post)
end
def welcome_topic
diff --git a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/track_selector.rb b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/track_selector.rb
index 74bd2a455d1..a5a86ec536d 100644
--- a/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/track_selector.rb
+++ b/plugins/discourse-narrative-bot/lib/discourse_narrative_bot/track_selector.rb
@@ -238,7 +238,7 @@ module DiscourseNarrativeBot
def like_user_post
if @post.raw.match(/thank/i)
- PostAction.act(self.discobot_user, @post, PostActionType.types[:like])
+ PostActionCreator.like(self.discobot_user, @post)
end
end
diff --git a/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/new_user_narrative_spec.rb b/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/new_user_narrative_spec.rb
index 7377d37ee30..a74ca8b4603 100644
--- a/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/new_user_narrative_spec.rb
+++ b/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/new_user_narrative_spec.rb
@@ -422,7 +422,7 @@ describe DiscourseNarrativeBot::NewUserNarrative do
context 'when image is not found' do
it 'should create the right replies' do
- PostAction.act(user, post_2, PostActionType.types[:like])
+ PostActionCreator.like(user, post_2)
described_class.any_instance.expects(:enqueue_timeout_job).with(user)
DiscourseNarrativeBot::TrackSelector.new(:reply, user, post_id: post.id).select
@@ -503,7 +503,7 @@ describe DiscourseNarrativeBot::NewUserNarrative do
.to eq(new_post.id)
described_class.any_instance.expects(:enqueue_timeout_job).with(user)
- PostAction.act(user, post_2, PostActionType.types[:like])
+ PostActionCreator.like(user, post_2)
expected_raw = <<~RAW
#{I18n.t('discourse_narrative_bot.new_user_narrative.images.reply')}
diff --git a/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/track_selector_spec.rb b/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/track_selector_spec.rb
index 027d2fc4dbe..353cb93415b 100644
--- a/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/track_selector_spec.rb
+++ b/plugins/discourse-narrative-bot/spec/discourse_narrative_bot/track_selector_spec.rb
@@ -656,7 +656,7 @@ describe DiscourseNarrativeBot::TrackSelector do
user
expect do
- PostAction.act(user, another_post, PostActionType.types[:like])
+ PostActionCreator.like(user, another_post)
end.to_not change { Post.count }
end
end
diff --git a/plugins/poll/plugin.rb b/plugins/poll/plugin.rb
index 20de8e64b8d..7b64ddf5790 100644
--- a/plugins/poll/plugin.rb
+++ b/plugins/poll/plugin.rb
@@ -419,7 +419,7 @@ after_initialize do
end
on(:approved_post) do |queued_post, created_post|
- if queued_post.post_options["is_poll"]
+ if queued_post.payload["is_poll"]
created_post.validate_polls(true)
end
end
diff --git a/plugins/poll/spec/lib/new_post_manager_spec.rb b/plugins/poll/spec/lib/new_post_manager_spec.rb
index 19edb832e8d..bce4cbd30c1 100644
--- a/plugins/poll/spec/lib/new_post_manager_spec.rb
+++ b/plugins/poll/spec/lib/new_post_manager_spec.rb
@@ -26,12 +26,12 @@ describe NewPostManager do
first_post_checks: true
}
- expect { NewPostManager.new(user, params).perform }
- .to change { QueuedPost.count }.by(1)
+ result = NewPostManager.new(user, params).perform
+ expect(result.action).to eq(:enqueued)
+ expect(result.reviewable).to be_present
- QueuedPost.last.approve!(admin)
-
- expect(Poll.where(post: Post.last).exists?).to eq(true)
+ review_result = result.reviewable.perform(admin, :approve)
+ expect(Poll.where(post: review_result.post).exists?).to eq(true)
end
end
end
diff --git a/script/import_scripts/base.rb b/script/import_scripts/base.rb
index 454b88395a1..8b8f3a841dc 100644
--- a/script/import_scripts/base.rb
+++ b/script/import_scripts/base.rb
@@ -596,12 +596,9 @@ class ImportScripts::Base
skipped += 1
puts "Skipping bookmark for user id #{params[:user_id]} and post id #{params[:post_id]}"
else
- begin
- PostAction.act(user, post, PostActionType.types[:bookmark])
- created += 1
- rescue PostAction::AlreadyActed
- skipped += 1
- end
+ result = PostActionCreator.create(user, post, :bookmark)
+ created += 1 if result.success?
+ skipped += 1 if result.failed?
end
end
diff --git a/script/import_scripts/discuz_x.rb b/script/import_scripts/discuz_x.rb
index 83d2cae916e..a575f2a84c8 100644
--- a/script/import_scripts/discuz_x.rb
+++ b/script/import_scripts/discuz_x.rb
@@ -398,7 +398,7 @@ class ImportScripts::DiscuzX < ImportScripts::Base
end
elsif (m['status'] & 2) >> 1 == 1 # waiting for approve
mapped[:post_create_action] = lambda do |action_post|
- PostAction.act(Discourse.system_user, action_post, 6, take_action: false)
+ PostActionCreator.notify_user(Discourse.system_user, action_post)
end
end
skip ? nil : mapped
diff --git a/script/import_scripts/jive_api.rb b/script/import_scripts/jive_api.rb
index 923904aef83..8594df95171 100644
--- a/script/import_scripts/jive_api.rb
+++ b/script/import_scripts/jive_api.rb
@@ -184,8 +184,7 @@ class ImportScripts::JiveApi < ImportScripts::Base
break if likes["error"]
likes["list"].each do |like|
next unless user_id = user_id_from_imported_user_id(like["id"])
- next if PostAction.exists?(user_id: user_id, post_id: post_id, post_action_type_id: PostActionType.types[:like])
- PostAction.act(User.find(user_id), Post.find(post_id), PostActionType.types[:like])
+ PostActionCreator.like(User.find(user_id), Post.find(post_id))
end
break if likes["list"].size < USER_COUNT || likes.dig("links", "next").blank?
@@ -287,8 +286,7 @@ class ImportScripts::JiveApi < ImportScripts::Base
favorites["list"].each do |favorite|
next unless user_id = user_id_from_imported_user_id(favorite["author"]["id"])
next unless post_id = post_id_from_imported_post_id(favorite["favoriteObject"]["id"])
- next if PostAction.exists?(user_id: user_id, post_id: post_id, post_action_type_id: PostActionType.types[:bookmark])
- PostAction.act(User.find(user_id), Post.find(post_id), PostActionType.types[:bookmark])
+ PostActionCreator.create(User.find(user_id), Post.find(post_id), :bookmark)
end
break if favorites["list"].size < POST_COUNT || favorites.dig("links", "next").blank?
diff --git a/script/import_scripts/nodebb/nodebb.rb b/script/import_scripts/nodebb/nodebb.rb
index adec5a7680c..d198d5d8c25 100644
--- a/script/import_scripts/nodebb/nodebb.rb
+++ b/script/import_scripts/nodebb/nodebb.rb
@@ -410,11 +410,7 @@ class ImportScripts::NodeBB < ImportScripts::Base
post["upvoted_by"].each do |upvoter_id|
user = User.new
user.id = user_id_from_imported_user_id(upvoter_id) || Discourse::SYSTEM_USER_ID
-
- begin
- PostAction.act(user, p, PostActionType.types[:like])
- rescue PostAction::AlreadyActed
- end
+ PostActionCreator.like(user, p)
end
end
}
diff --git a/script/import_scripts/question2answer.rb b/script/import_scripts/question2answer.rb
index f9d248791b5..701b0a98ee7 100644
--- a/script/import_scripts/question2answer.rb
+++ b/script/import_scripts/question2answer.rb
@@ -310,7 +310,7 @@ EOM
post = Post.find_by(id: post_id_from_imported_post_id("thread-#{like['postid']}"))
user = User.find_by(id: user_id_from_imported_user_id(like["userid"]))
begin
- PostAction.act(user, post, 2) if user && post
+ PostActionCreator.like(user, post) if user && post
rescue => e
puts "error acting on post #{e}"
end
diff --git a/script/import_scripts/stack_overflow.rb b/script/import_scripts/stack_overflow.rb
index 06754fa0b26..d8ab14cc627 100644
--- a/script/import_scripts/stack_overflow.rb
+++ b/script/import_scripts/stack_overflow.rb
@@ -165,8 +165,6 @@ class ImportScripts::StackOverflow < ImportScripts::Base
end
end
- LIKE ||= PostActionType.types[:like]
-
def import_likes
puts "", "Importing post likes..."
@@ -196,7 +194,7 @@ class ImportScripts::StackOverflow < ImportScripts::Base
next unless post_id = post_id_from_imported_post_id(l["PostId"])
next unless user = User.find_by(id: user_id)
next unless post = Post.find_by(id: post_id)
- PostAction.act(user, post, LIKE) rescue nil
+ PostActionCreator.like(user, post) rescue nil
end
end
@@ -229,7 +227,7 @@ class ImportScripts::StackOverflow < ImportScripts::Base
next unless post_id = post_id_from_imported_post_id(l["PostCommentId"])
next unless user = User.find_by(id: user_id)
next unless post = Post.find_by(id: post_id)
- PostAction.act(user, post, LIKE) rescue nil
+ PostActionCreator.like(user, post) rescue nil
end
end
end
diff --git a/spec/components/filter_best_posts_spec.rb b/spec/components/filter_best_posts_spec.rb
index f1b06dfd566..532c1f4c5fd 100644
--- a/spec/components/filter_best_posts_spec.rb
+++ b/spec/components/filter_best_posts_spec.rb
@@ -75,13 +75,13 @@ describe FilterBestPosts do
end
it "doesn't count likes from admins" do
- PostAction.act(admin, p3, PostActionType.types[:like])
+ PostActionCreator.like(admin, p3)
best = FilterBestPosts.new(topic, @filtered_posts, 99, only_moderator_liked: true)
expect(best.posts.count).to eq(0)
end
it "should find the post liked by the moderator" do
- PostAction.act(moderator, p2, PostActionType.types[:like])
+ PostActionCreator.like(moderator, p2)
best = FilterBestPosts.new(topic, @filtered_posts, 99, only_moderator_liked: true)
expect(best.posts.count).to eq(1)
end
diff --git a/spec/components/flag_query_spec.rb b/spec/components/flag_query_spec.rb
index aee160780e7..804de7adfe1 100644
--- a/spec/components/flag_query_spec.rb
+++ b/spec/components/flag_query_spec.rb
@@ -6,15 +6,14 @@ describe FlagQuery do
let(:codinghorror) { Fabricate(:coding_horror) }
describe "flagged_topics" do
- it "respects `min_flags_staff_visibility`" do
+ it "respects `min_score_default_visibility`" do
admin = Fabricate(:admin)
moderator = Fabricate(:moderator)
post = create_post
- PostAction.act(moderator, post, PostActionType.types[:spam])
-
- SiteSetting.min_flags_staff_visibility = 1
+ SiteSetting.min_score_default_visibility = 2.0
+ PostActionCreator.spam(moderator, post)
result = FlagQuery.flagged_topics
expect(result[:flagged_topics]).to be_present
@@ -22,12 +21,12 @@ describe FlagQuery do
expect(ft.topic).to eq(post.topic)
expect(ft.flag_counts).to eq(PostActionType.types[:spam] => 1)
- SiteSetting.min_flags_staff_visibility = 2
+ SiteSetting.min_score_default_visibility = 10.0
result = FlagQuery.flagged_topics
expect(result[:flagged_topics]).to be_blank
- PostAction.act(admin, post, PostActionType.types[:inappropriate])
+ PostActionCreator.create(admin, post, :inappropriate)
result = FlagQuery.flagged_topics
expect(result[:flagged_topics]).to be_present
ft = result[:flagged_topics].first
@@ -37,14 +36,24 @@ describe FlagQuery do
PostActionType.types[:inappropriate] => 1
)
end
+ end
+ describe "flagged_post_actions" do
+
+ it "returns the proper count" do
+ moderator = Fabricate(:moderator)
+ post = create_post
+ PostActionCreator.spam(moderator, post)
+ expect(FlagQuery.flagged_post_actions(topic_id: post.topic_id).count).to eq(1)
+ expect(FlagQuery.flagged_post_actions(topic_id: post.topic_id, filter: 'old').count).to eq(0)
+ end
end
describe "flagged_posts_report" do
it "does not return flags on system posts" do
admin = Fabricate(:admin)
post = create_post(user: Discourse.system_user)
- PostAction.act(codinghorror, post, PostActionType.types[:spam])
+ PostActionCreator.create(codinghorror, post, :spam)
posts, topics, users = FlagQuery.flagged_posts_report(admin)
expect(posts).to be_blank
@@ -62,28 +71,35 @@ describe FlagQuery do
user2 = Fabricate(:user)
user3 = Fabricate(:user)
- PostAction.act(codinghorror, post, PostActionType.types[:spam])
- PostAction.act(user2, post, PostActionType.types[:spam])
- mod_message = PostAction.act(user3, post, PostActionType.types[:notify_moderators], message: "this is a :one::zero:")
+ PostActionCreator.spam(codinghorror, post)
+ PostActionCreator.create(user2, post, :spam)
+ result = PostActionCreator.new(
+ user3,
+ post,
+ PostActionType.types[:notify_moderators],
+ message: "this is a :one::zero:"
+ ).perform
+ mod_message = result.post_action
- PostAction.act(codinghorror, post2, PostActionType.types[:spam])
- PostAction.act(user2, post2, PostActionType.types[:spam])
+ PostActionCreator.spam(codinghorror, post2)
+ PostActionCreator.spam(user2, post2)
- posts, topics, users = FlagQuery.flagged_posts_report(admin)
+ posts, topics, users, all_actions = FlagQuery.flagged_posts_report(admin)
expect(posts.count).to eq(2)
first = posts.first
expect(users.count).to eq(5)
- expect(first[:post_actions].count).to eq(2)
+ expect(first[:post_action_ids].count).to eq(2)
expect(topics.count).to eq(2)
second = posts[1]
+ expect(second[:post_action_ids].count).to eq(3)
- expect(second[:post_actions].count).to eq(3)
- expect(second[:post_actions].first[:permalink]).to eq(mod_message.related_post.topic.relative_url)
- expect(second[:post_actions].first[:conversation][:response][:excerpt]).to match("![]()
+ action = all_actions.find { |a| a[:id] == second[:post_action_ids][0] }
+ expect(action[:permalink]).to eq(mod_message.related_post.topic.relative_url)
+ expect(action[:conversation][:response][:excerpt]).to match() { "width" => 0, "height" => 222 } } }
- end
-end
-
-Fabricator(:queued_topic, from: :queued_post) do
- topic nil
- raw 'This post should be queued up, and more importantly, this is a new topic'
- post_options do
- { category: 1,
- title: 'This is a new topic' }
- end
-end
diff --git a/spec/fabricators/reviewable_fabricator.rb b/spec/fabricators/reviewable_fabricator.rb
new file mode 100644
index 00000000000..a1619961566
--- /dev/null
+++ b/spec/fabricators/reviewable_fabricator.rb
@@ -0,0 +1,58 @@
+Fabricator(:reviewable) do
+ reviewable_by_moderator true
+ type 'ReviewableUser'
+ created_by { Fabricate(:user) }
+ target_id { Fabricate(:user).id }
+ target_type "User"
+ target_created_by { Fabricate(:user) }
+ category
+ score 1.23
+ payload {
+ { list: [1, 2, 3], name: 'bandersnatch' }
+ }
+end
+
+Fabricator(:reviewable_queued_post_topic, class_name: :reviewable_queued_post) do
+ reviewable_by_moderator true
+ type 'ReviewableQueuedPost'
+ created_by { Fabricate(:user) }
+ category
+ payload {
+ {
+ raw: "hello world post contents.",
+ title: "queued post title",
+ tags: ['cool', 'neat'],
+ extra: "some extra data",
+ archetype: 'regular'
+ }
+ }
+end
+
+Fabricator(:reviewable_queued_post) do
+ reviewable_by_moderator true
+ type 'ReviewableQueuedPost'
+ created_by { Fabricate(:user) }
+ topic
+ payload {
+ {
+ raw: "hello world post contents.",
+ reply_to_post_number: 1,
+ via_email: true,
+ raw_email: 'store_me',
+ auto_track: true,
+ custom_fields: { hello: 'world' },
+ cooking_options: { cat: 'hat' },
+ cook_method: Post.cook_methods[:raw_html],
+ image_sizes: { "http://foo.bar/image.png" => { "width" => 0, "height" => 222 } }
+ }
+ }
+end
+
+Fabricator(:reviewable_flagged_post) do
+ reviewable_by_moderator true
+ type 'ReviewableFlaggedPost'
+ created_by { Fabricate(:user) }
+ topic
+ target_type 'Post'
+ target { Fabricate(:post) }
+end
diff --git a/spec/fabricators/web_hook_fabricator.rb b/spec/fabricators/web_hook_fabricator.rb
index 0197f143874..8f73eda38cf 100644
--- a/spec/fabricators/web_hook_fabricator.rb
+++ b/spec/fabricators/web_hook_fabricator.rb
@@ -84,3 +84,11 @@ Fabricator(:queued_post_web_hook, from: :web_hook) do
web_hook.web_hook_event_types = [transients[:queued_post_hook]]
end
end
+
+Fabricator(:reviewable_web_hook, from: :web_hook) do
+ transient reviewable_hook: WebHookEventType.find_by(name: 'reviewable')
+
+ after_build do |web_hook, transients|
+ web_hook.web_hook_event_types = [transients[:reviewable_hook]]
+ end
+end
diff --git a/spec/integration/flags_spec.rb b/spec/integration/flags_spec.rb
index 76a303a2f3e..12902917b36 100644
--- a/spec/integration/flags_spec.rb
+++ b/spec/integration/flags_spec.rb
@@ -10,7 +10,7 @@ describe PostAction do
expect(events.map { |e| e[:event_name] }).to_not include(:flag_reviewed)
flagged_post = Fabricate(:post)
- PostAction.act(admin, flagged_post, PostActionType.types[:spam])
+ PostActionCreator.spam(admin, flagged_post)
events = DiscourseEvent.track_events { PostDestroyer.new(admin, flagged_post).destroy }
expect(events.map { |e| e[:event_name] }).to include(:flag_reviewed)
end
diff --git a/spec/integration/spam_rules_spec.rb b/spec/integration/spam_rules_spec.rb
index 6691aa3fc75..bcfa4930bdb 100644
--- a/spec/integration/spam_rules_spec.rb
+++ b/spec/integration/spam_rules_spec.rb
@@ -11,8 +11,8 @@ describe "spam rules for users" do
let(:user2) { Fabricate(:user) }
before do
- SiteSetting.flags_required_to_hide_post = 0
- SiteSetting.num_spam_flags_to_silence_new_user = 2
+ SiteSetting.score_required_to_hide_post = 0
+ SiteSetting.spam_score_to_silence_new_user = 4.0
SiteSetting.num_users_to_silence_new_user = 2
end
@@ -24,7 +24,7 @@ describe "spam rules for users" do
let!(:spam_post2) { create_post(user: spammer) }
before do
- PostAction.act(user1, spam_post, PostActionType.types[:spam])
+ PostActionCreator.create(user1, spam_post, :spam)
end
it 'should not hide the post' do
@@ -33,7 +33,7 @@ describe "spam rules for users" do
context 'spam posts are flagged enough times, but not by enough users' do
it 'should not hide the post' do
- PostAction.act(user1, spam_post2, PostActionType.types[:spam])
+ PostActionCreator.create(user1, spam_post2, :spam)
expect(spam_post.reload).to_not be_hidden
expect(spam_post2.reload).to_not be_hidden
@@ -42,36 +42,21 @@ describe "spam rules for users" do
end
context 'one spam post is flagged enough times by enough users' do
- let!(:another_topic) { Fabricate(:topic) }
+ let!(:another_topic) { Fabricate(:topic) }
let!(:private_messages_count) { spammer.private_topics_count }
- let!(:mod_pm_count) { moderator.private_topics_count }
-
- before do
- PostAction.act(user2, spam_post, PostActionType.types[:spam])
+ let!(:mod_pm_count) { moderator.private_topics_count }
+ let!(:reviewable) { PostActionCreator.spam(user2, spam_post).reviewable }
+ it 'should hide the posts' do
expect(Guardian.new(spammer).can_create_topic?(nil)).to be(false)
expect { PostCreator.create(spammer, title: 'limited time offer for you', raw: 'better buy this stuff ok', archetype_id: 1) }.to raise_error(Discourse::InvalidAccess)
expect(PostCreator.create(spammer, topic_id: another_topic.id, raw: 'my reply is spam in your topic', archetype_id: 1)).to eq(nil)
- end
-
- it 'should hide the posts' do
expect(spammer.reload).to be_silenced
expect(spam_post.reload).to be_hidden
expect(spam_post2.reload).to be_hidden
expect(spammer.reload.private_topics_count).to eq(private_messages_count + 1)
end
- # The following cases describe when a staff user takes some action, but the user
- # still won't be able to make posts.
- # A staff user needs to clear the silenced flag from the user record.
-
- context "a post's flags are cleared" do
- it 'should silence the spammer' do
- PostAction.clear_flags!(spam_post, admin); spammer.reload
- expect(spammer.reload).to be_silenced
- end
- end
-
context "a post is deleted" do
it 'should silence the spammer' do
spam_post.trash!(moderator); spammer.reload
@@ -87,10 +72,10 @@ describe "spam rules for users" do
end
end
- context 'flags_required_to_hide_post takes effect too' do
+ context 'score_required_to_hide_post takes effect too' do
it 'should silence the spammer' do
- SiteSetting.flags_required_to_hide_post = 2
- PostAction.act(user2, spam_post, PostActionType.types[:spam])
+ SiteSetting.score_required_to_hide_post = 2.0
+ PostActionCreator.create(user2, spam_post, :spam)
expect(spammer.reload).to be_silenced
expect(Guardian.new(spammer).can_create_topic?(nil)).to be false
end
@@ -106,8 +91,8 @@ describe "spam rules for users" do
let!(:private_messages_count) { spammer.private_topics_count }
it 'should not allow spammer to create new posts' do
- PostAction.act(user1, spam_post, PostActionType.types[:spam])
- PostAction.act(user2, spam_post, PostActionType.types[:spam])
+ PostActionCreator.create(user1, spam_post, :spam)
+ PostActionCreator.create(user2, spam_post, :spam)
expect(spam_post.reload).to_not be_hidden
expect(Guardian.new(spammer).can_create_topic?(nil)).to be(true)
@@ -124,8 +109,8 @@ describe "spam rules for users" do
let!(:private_messages_count) { spammer.private_topics_count }
it 'should not hide the post' do
- PostAction.act(user1, spam_post, PostActionType.types[:spam])
- PostAction.act(user2, spam_post, PostActionType.types[:spam])
+ PostActionCreator.create(user1, spam_post, :spam)
+ PostActionCreator.create(user2, spam_post, :spam)
expect(spam_post.reload).to_not be_hidden
end
diff --git a/spec/integration/watched_words_spec.rb b/spec/integration/watched_words_spec.rb
index 6fe25b22d29..f144f5533d5 100644
--- a/spec/integration/watched_words_spec.rb
+++ b/spec/integration/watched_words_spec.rb
@@ -144,7 +144,6 @@ describe WatchedWord do
end
it "is compatible with flag_sockpuppets" do
- # e.g., handle PostAction::AlreadyActed
SiteSetting.flag_sockpuppets = true
ip_address = '182.189.119.174'
user1 = Fabricate(:user, ip_address: ip_address, created_at: 2.days.ago)
diff --git a/spec/jobs/auto_queue_handler_spec.rb b/spec/jobs/auto_queue_handler_spec.rb
index 89b84a2f5f5..06efca0f7bd 100644
--- a/spec/jobs/auto_queue_handler_spec.rb
+++ b/spec/jobs/auto_queue_handler_spec.rb
@@ -5,40 +5,46 @@ describe Jobs::AutoQueueHandler do
subject { Jobs::AutoQueueHandler.new.execute({}) }
context "old flag" do
- let!(:old) { Fabricate(:flag, created_at: 61.days.ago) }
- let!(:not_old) { Fabricate(:flag, created_at: 59.days.ago) }
+ let!(:old) { Fabricate(:reviewable_flagged_post, created_at: 61.days.ago) }
+ let!(:not_old) { Fabricate(:reviewable_flagged_post, created_at: 59.days.ago) }
it "defers the old flag if auto_handle_queued_age is 60" do
SiteSetting.auto_handle_queued_age = 60
subject
- expect(not_old.reload.deferred_at).to be_nil
- expect(old.reload.deferred_at).to_not be_nil
+ expect(not_old.reload).to be_pending
+ expect(old.reload).not_to be_pending
end
it "doesn't defer the old flag if auto_handle_queued_age is 0" do
SiteSetting.auto_handle_queued_age = 0
subject
- expect(not_old.reload.deferred_at).to be_nil
- expect(old.reload.deferred_at).to be_nil
+ expect(not_old.reload).to be_pending
+ expect(old.reload).to be_pending
end
end
- context "old queued post" do
- let!(:old) { Fabricate(:queued_post, created_at: 61.days.ago, queue: 'default') }
- let!(:not_old) { Fabricate(:queued_post, created_at: 59.days.ago, queue: 'default') }
+ context "reviewables" do
+ let!(:new_post) { Fabricate(:reviewable_queued_post, created_at: 59.days.ago) }
+ let!(:old_post) { Fabricate(:reviewable_queued_post, created_at: 61.days.ago) }
+ let!(:new_user) { Fabricate(:reviewable, created_at: 10.days.ago) }
+ let!(:old_user) { Fabricate(:reviewable, created_at: 80.days.ago) }
it "rejects the post when auto_handle_queued_age is 60" do
SiteSetting.auto_handle_queued_age = 60
subject
- expect(not_old.reload.state).to eq(QueuedPost.states[:new])
- expect(old.reload.state).to eq(QueuedPost.states[:rejected])
+ expect(new_post.reload.pending?).to eq(true)
+ expect(old_post.reload.rejected?).to eq(true)
+ expect(new_user.reload.pending?).to eq(true)
+ expect(old_user.reload.rejected?).to eq(true)
end
- it "doesn't reject the post when auto_handle_queued_age is 0" do
+ it "leaves reviewables as pending auto_handle_queued_age is 0" do
SiteSetting.auto_handle_queued_age = 0
subject
- expect(not_old.reload.state).to eq(QueuedPost.states[:new])
- expect(old.reload.state).to eq(QueuedPost.states[:new])
+ expect(new_post.reload.pending?).to eq(true)
+ expect(new_user.reload.pending?).to eq(true)
+ expect(old_post.reload.pending?).to eq(true)
+ expect(old_user.reload.pending?).to eq(true)
end
end
diff --git a/spec/jobs/clean_up_uploads_spec.rb b/spec/jobs/clean_up_uploads_spec.rb
index e76398a123a..c7f4e6a3746 100644
--- a/spec/jobs/clean_up_uploads_spec.rb
+++ b/spec/jobs/clean_up_uploads_spec.rb
@@ -238,12 +238,9 @@ describe Jobs::CleanUpUploads do
upload = fabricate_upload
upload2 = fabricate_upload
- QueuedPost.create(
- queue: "uploads",
- state: QueuedPost.states[:new],
- user_id: Fabricate(:user).id,
- raw: "#{upload.sha1}\n#{upload2.short_url}",
- post_options: {}
+ ReviewableQueuedPost.create(
+ created_by: Fabricate(:user),
+ payload: { raw: "#{upload.sha1}\n#{upload2.short_url}" },
)
Jobs::CleanUpUploads.new.execute(nil)
diff --git a/spec/jobs/grant_new_user_of_the_month_badges_spec.rb b/spec/jobs/grant_new_user_of_the_month_badges_spec.rb
index 7882bfdbf4c..d7616f62032 100644
--- a/spec/jobs/grant_new_user_of_the_month_badges_spec.rb
+++ b/spec/jobs/grant_new_user_of_the_month_badges_spec.rb
@@ -14,9 +14,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
granter.execute({})
@@ -32,9 +32,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
SystemMessage.any_instance.expects(:create).never
granter.execute({})
@@ -51,9 +51,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
SystemMessage.any_instance.expects(:create).never
granter.execute({})
@@ -71,9 +71,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
granter.execute({})
@@ -88,9 +88,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
p = Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
expect(granter.scores.keys).not_to include(user.id)
end
@@ -99,9 +99,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
user = Fabricate(:user, created_at: 1.week.ago)
p = Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
expect(granter.scores.keys).not_to include(user.id)
end
@@ -112,9 +112,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, topic: topic, user: user)
p = Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
expect(granter.scores.keys).not_to include(user.id)
end
@@ -124,7 +124,7 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
p = Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
expect(granter.scores.keys).not_to include(user.id)
end
@@ -134,9 +134,9 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
Fabricate(:post, user: user)
p = Fabricate(:post, user: user)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
old_user = Fabricate(:user, created_at: 6.months.ago)
- PostAction.act(old_user, p, PostActionType.types[:like])
+ PostActionCreator.like(old_user, p)
expect(granter.scores.keys).to include(user.id)
end
@@ -154,14 +154,14 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
um = Fabricate(:user, trust_level: 3, moderator: true)
ua = Fabricate(:user, trust_level: 0, admin: true)
- PostAction.act(u0, p, PostActionType.types[:like])
- PostAction.act(u1, p, PostActionType.types[:like])
- PostAction.act(u2, p, PostActionType.types[:like])
- PostAction.act(u3, p, PostActionType.types[:like])
- PostAction.act(u4, p, PostActionType.types[:like])
- PostAction.act(um, p, PostActionType.types[:like])
- PostAction.act(ua, p, PostActionType.types[:like])
- PostAction.act(Discourse.system_user, p, PostActionType.types[:like])
+ PostActionCreator.like(u0, p)
+ PostActionCreator.like(u1, p)
+ PostActionCreator.like(u2, p)
+ PostActionCreator.like(u3, p)
+ PostActionCreator.like(u4, p)
+ PostActionCreator.like(um, p)
+ PostActionCreator.like(ua, p)
+ PostActionCreator.like(Discourse.system_user, p)
expect(granter.scores[user.id]).to eq(1.55)
# It goes down the more they post
@@ -179,18 +179,18 @@ describe Jobs::GrantNewUserOfTheMonthBadges do
p = Fabricate(:post, user: u1)
Fabricate(:post, user: u1)
- PostAction.act(ou1, p, PostActionType.types[:like])
- PostAction.act(ou2, p, PostActionType.types[:like])
+ PostActionCreator.like(ou1, p)
+ PostActionCreator.like(ou2, p)
p = Fabricate(:post, user: u2)
Fabricate(:post, user: u2)
- PostAction.act(ou1, p, PostActionType.types[:like])
- PostAction.act(ou2, p, PostActionType.types[:like])
+ PostActionCreator.like(ou1, p)
+ PostActionCreator.like(ou2, p)
p = Fabricate(:post, user: u3)
Fabricate(:post, user: u3)
- PostAction.act(ou1, p, PostActionType.types[:like])
- PostAction.act(ou2, p, PostActionType.types[:like])
+ PostActionCreator.like(ou1, p)
+ PostActionCreator.like(ou2, p)
expect(granter.scores.keys.size).to eq(2)
end
diff --git a/spec/jobs/notify_reviewable_spec.rb b/spec/jobs/notify_reviewable_spec.rb
new file mode 100644
index 00000000000..c1b3fa55113
--- /dev/null
+++ b/spec/jobs/notify_reviewable_spec.rb
@@ -0,0 +1,88 @@
+require 'rails_helper'
+
+describe Jobs::NotifyReviewable do
+ describe '.execute' do
+ let!(:admin) { Fabricate(:admin, moderator: true) }
+ let!(:moderator) { Fabricate(:moderator) }
+ let!(:group_user) { Fabricate(:group_user) }
+ let(:user) { group_user.user }
+ let(:group) { group_user.group }
+
+
+ it "will notify users of new reviewable content" do
+ GroupUser.create!(group_id: group.id, user_id: moderator.id)
+
+ # Content for admins only
+ r1 = Fabricate(:reviewable, reviewable_by_moderator: false)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r1.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(1)
+ expect(messages.any? { |m| m.user_ids.include?(moderator.id) }).to eq(false)
+ expect(messages.any? { |m| m.user_ids.include?(user.id) }).to eq(false)
+
+ # Content for moderators
+ r2 = Fabricate(:reviewable, reviewable_by_moderator: true)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r2.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(2)
+ mod_msg = messages.find { |m| m.user_ids.include?(moderator.id) }
+ expect(mod_msg.data[:reviewable_count]).to eq(1)
+ expect(mod_msg.user_ids).to_not include(admin.id)
+ expect(messages.any? { |m| m.user_ids.include?(user.id) }).to eq(false)
+
+ # Content for a group
+ r3 = Fabricate(:reviewable, reviewable_by_moderator: true, reviewable_by_group: group)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r3.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(3)
+ mod_messages = messages.select { |m| m.user_ids.include?(moderator.id) }
+ expect(mod_messages.size).to eq(1)
+ expect(mod_messages[0].data[:reviewable_count]).to eq(2)
+ group_msg = messages.find { |m| m.user_ids.include?(user.id) }
+ expect(group_msg.data[:reviewable_count]).to eq(1)
+ end
+
+ it "respects visibility" do
+ SiteSetting.min_score_default_visibility = 2.0
+
+ GroupUser.create!(group_id: group.id, user_id: moderator.id)
+
+ # Content for admins only
+ r1 = Fabricate(:reviewable, reviewable_by_moderator: false)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r1.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(0)
+
+ # Content for moderators
+ r2 = Fabricate(:reviewable, reviewable_by_moderator: true)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r2.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(0)
+ mod_msg = messages.find { |m| m.user_ids.include?(moderator.id) }
+ expect(mod_msg.data[:reviewable_count]).to eq(0)
+
+ # Content for a group
+ r3 = Fabricate(:reviewable, reviewable_by_moderator: true, reviewable_by_group: group)
+ messages = MessageBus.track_publish("/reviewable_counts") do
+ described_class.new.execute(reviewable_id: r3.id)
+ end
+ admin_msg = messages.find { |m| m.user_ids.include?(admin.id) }
+ expect(admin_msg.data[:reviewable_count]).to eq(0)
+ mod_messages = messages.select { |m| m.user_ids.include?(moderator.id) }
+ expect(mod_messages.size).to eq(1)
+ expect(mod_messages[0].data[:reviewable_count]).to eq(0)
+ group_msg = messages.find { |m| m.user_ids.include?(user.id) }
+ expect(group_msg.data[:reviewable_count]).to eq(0)
+ end
+ end
+end
diff --git a/spec/jobs/pending_flags_reminder_spec.rb b/spec/jobs/pending_flags_reminder_spec.rb
index 5a820e12d53..69f3c69c5f5 100644
--- a/spec/jobs/pending_flags_reminder_spec.rb
+++ b/spec/jobs/pending_flags_reminder_spec.rb
@@ -1,74 +1,74 @@
require 'rails_helper'
describe Jobs::PendingFlagsReminder do
+ let(:job) { described_class.new }
+
+ def create_flag(created_at)
+ PostActionCreator.create(Fabricate(:user), Fabricate(:post), :spam, created_at: created_at).reviewable
+ end
+
+ def execute
+ job.tap { job.execute({}) }
+ end
+
+ it "doesn't notify when there are no flags" do
+ expect(execute.sent_reminder).to eq(false)
+ end
+
context "notify_about_flags_after is 0" do
before { SiteSetting.notify_about_flags_after = 0 }
it "never notifies" do
- Fabricate(:flag, created_at: 50.hours.ago)
- PostCreator.expects(:create).never
- described_class.new.execute({})
+ create_flag(50.hours.ago)
+ expect(execute.sent_reminder).to eq(false)
end
end
context "notify_about_flags_after is 48" do
before do
SiteSetting.notify_about_flags_after = 48
- $redis.del described_class.last_notified_key
+ described_class.clear_key
end
after do
- $redis.del described_class.last_notified_key
+ described_class.clear_key
end
it "doesn't send message when flags are less than 48 hours old" do
- Fabricate(:flag, created_at: 47.hours.ago)
- PostCreator.expects(:create).never
- described_class.new.execute({})
+ create_flag(47.hours.ago)
+ expect(execute.sent_reminder).to eq(false)
end
it "doesn't send a message if there are no new flags older than 48 hours old" do
- old_flag = Fabricate(:flag, created_at: 50.hours.ago)
- Fabricate(:flag, created_at: 47.hours.ago)
- job = described_class.new
- job.last_notified_id = old_flag.id
- PostCreator.expects(:create).never
- job.execute({})
- expect(job.last_notified_id).to eq(old_flag.id)
+ old_reviewable = create_flag(50.hours.ago)
+ create_flag(47.hours.ago)
+
+ described_class.last_notified_id = old_reviewable.id
+ execute
+ expect(job.sent_reminder).to eq(false)
+ expect(described_class.last_notified_id).to eq(old_reviewable.id)
end
it "sends message when there is a flag older than 48 hours" do
- Fabricate(:flag, created_at: 49.hours.ago)
- PostCreator.expects(:create).once.returns(true)
- described_class.new.execute({})
+ create_flag(49.hours.ago)
+ expect(execute.sent_reminder).to eq(true)
end
- context "min_flags_staff_visibility" do
- it "doesn't send a message when min_flags_staff_visibility is not met" do
- SiteSetting.min_flags_staff_visibility = 2
- Fabricate(:flag, created_at: 49.hours.ago)
- Fabricate(:flag, created_at: 51.hours.ago)
- PostCreator.expects(:create).never
- described_class.new.execute({})
+ context "min_score_default_visibility" do
+ before do
+ create_flag(49.hours.ago)
+ create_flag(51.hours.ago)
end
- it "doesn't send a message when min_flags_staff_visibility is met on new flags but not old" do
- SiteSetting.min_flags_staff_visibility = 2
- flag = Fabricate(:flag, created_at: 24.hours.ago)
- Fabricate(:flag, post: flag.post, created_at: 49.hours.ago)
- Fabricate(:flag, created_at: 51.hours.ago)
- PostCreator.expects(:create).never
- described_class.new.execute({})
+ it "doesn't send a message when min_score_default_visibility is not met" do
+ SiteSetting.min_score_default_visibility = 3.0
+ expect(execute.sent_reminder).to eq(false)
end
- it "sends a message when min_flags_staff_visibility is met" do
- SiteSetting.min_flags_staff_visibility = 2
- f = Fabricate(:flag, created_at: 49.hours.ago)
- Fabricate(:flag, post: f.post, created_at: 51.hours.ago)
- PostCreator.expects(:create).once.returns(true)
- described_class.new.execute({})
+ it "sends a message when min_score_default_visibility is met" do
+ SiteSetting.min_score_default_visibility = 2.0
+ expect(execute.sent_reminder).to eq(true)
end
end
-
end
end
diff --git a/spec/jobs/pending_queued_posts_reminder_spec.rb b/spec/jobs/pending_queued_posts_reminder_spec.rb
index 3db6b6357e8..4cbd5f5518b 100644
--- a/spec/jobs/pending_queued_posts_reminder_spec.rb
+++ b/spec/jobs/pending_queued_posts_reminder_spec.rb
@@ -1,13 +1,15 @@
require "rails_helper"
describe Jobs::PendingQueuedPostReminder do
+ let(:job) { described_class.new }
+
context "notify_about_queued_posts_after is 0" do
before { SiteSetting.notify_about_queued_posts_after = 0 }
it "never emails" do
described_class.any_instance.expects(:should_notify_ids).never
expect {
- described_class.new.execute({})
+ job.execute({})
}.to_not change { Post.count }
end
end
@@ -17,32 +19,33 @@ describe Jobs::PendingQueuedPostReminder do
SiteSetting.notify_about_queued_posts_after = 24
end
- it "doesn't create system message if there are no queued posts" do
- described_class.any_instance.stubs(:should_notify_ids).returns([])
- described_class.any_instance.stubs(:last_notified_id).returns(nil)
- expect {
- described_class.new.execute({})
- }.to_not change { Post.count }
- end
+ context "when we haven't been notified in a while" do
- it "creates system message if there are new queued posts" do
- described_class.any_instance.stubs(:should_notify_ids).returns([1, 2])
- described_class.any_instance.stubs(:last_notified_id).returns(nil)
- expect {
- described_class.new.execute({})
- }.to change { Post.count }.by(1)
- expect(Topic.where(
- subtype: TopicSubtype.system_message,
- title: I18n.t('system_messages.queued_posts_reminder.subject_template', count: 2)
- ).exists?).to eq(true)
+ before do
+ job.last_notified_id = nil
+ end
+
+ it "doesn't create system message if there are no queued posts" do
+ expect {
+ job.execute({})
+ }.to_not change { Post.count }
+ end
+
+ it "creates system message if there are new queued posts" do
+ Fabricate(:reviewable_queued_post, created_at: 48.hours.ago)
+ Fabricate(:reviewable_queued_post, created_at: 45.hours.ago)
+ expect { job.execute({}) }.to change { Post.count }.by(1)
+ expect(Topic.where(
+ subtype: TopicSubtype.system_message,
+ title: I18n.t('system_messages.queued_posts_reminder.subject_template', count: 2)
+ ).exists?).to eq(true)
+ end
end
it "doesn't create system message again about the same posts" do
- described_class.any_instance.stubs(:should_notify_ids).returns([2])
- described_class.any_instance.stubs(:last_notified_id).returns(2)
- expect {
- described_class.new.execute({})
- }.to_not change { Post.count }
+ reviewable = Fabricate(:reviewable_queued_post, created_at: 48.hours.ago)
+ job.last_notified_id = reviewable.id
+ expect { described_class.new.execute({}) }.to_not change { Post.count }
end
end
end
diff --git a/spec/jobs/truncate_user_flag_stats_spec.rb b/spec/jobs/truncate_user_flag_stats_spec.rb
new file mode 100644
index 00000000000..7ededb51e69
--- /dev/null
+++ b/spec/jobs/truncate_user_flag_stats_spec.rb
@@ -0,0 +1,74 @@
+require 'rails_helper'
+
+describe Jobs::TruncateUserFlagStats do
+ let(:user) { Fabricate(:user) }
+ let(:other_user) { Fabricate(:user) }
+
+ before do
+ # We might make this a site setting eventually
+ Jobs::TruncateUserFlagStats.stubs(:truncate_to).returns(2)
+ end
+
+ def perform(*users)
+ described_class.new.execute(user_ids: users.map(&:id))
+ users.each { |u| u.reload }
+ end
+
+ it "raises an error without user ids" do
+ expect {
+ described_class.new.execute({})
+ }.to raise_error(Discourse::InvalidParameters)
+ end
+
+ it "does nothing if the user doesn't have enough flags" do
+ user.user_stat.update_columns(flags_agreed: 1)
+ perform(user)
+
+ expect(user.user_stat.flags_agreed).to eq(1)
+ expect(user.user_stat.flags_disagreed).to eq(0)
+ expect(user.user_stat.flags_ignored).to eq(0)
+ end
+
+ it "removes the statuses of old flags (integration test)" do
+ p0 = Fabricate(:post)
+ p1 = Fabricate(:post)
+ p2 = Fabricate(:post, user: user)
+ p3 = Fabricate(:post)
+
+ r0 = PostActionCreator.spam(user, p0).reviewable
+ r1 = PostActionCreator.spam(user, p1).reviewable
+ r2 = PostActionCreator.spam(user, p2).reviewable
+ r3 = PostActionCreator.spam(user, p3).reviewable
+
+ PostActionCreator.spam(other_user, p3).reviewable
+ PostActionCreator.spam(other_user, p2).reviewable
+ PostActionCreator.spam(other_user, p1).reviewable
+
+ r0.perform(Discourse.system_user, :agree_and_keep)
+ r1.perform(Discourse.system_user, :disagree)
+ r2.perform(Discourse.system_user, :ignore)
+ r3.perform(Discourse.system_user, :agree_and_keep)
+
+ user.user_stat.reload
+ other_user.user_stat.reload
+
+ expect(user.user_stat.flags_agreed).to eq(2)
+ expect(user.user_stat.flags_disagreed).to eq(1)
+ expect(user.user_stat.flags_ignored).to eq(0)
+
+ expect(other_user.user_stat.flags_agreed).to eq(1)
+ expect(other_user.user_stat.flags_disagreed).to eq(1)
+ expect(other_user.user_stat.flags_ignored).to eq(1)
+
+ perform(user, other_user)
+
+ expect(user.user_stat.flags_agreed).to eq(1)
+ expect(user.user_stat.flags_disagreed).to eq(1)
+ expect(user.user_stat.flags_ignored).to eq(0)
+
+ expect(other_user.user_stat.flags_agreed).to eq(0)
+ expect(other_user.user_stat.flags_disagreed).to eq(1)
+ expect(other_user.user_stat.flags_ignored).to eq(1)
+ end
+
+end
diff --git a/spec/models/directory_item_spec.rb b/spec/models/directory_item_spec.rb
index 4b26bffd7c6..619d18eb697 100644
--- a/spec/models/directory_item_spec.rb
+++ b/spec/models/directory_item_spec.rb
@@ -49,7 +49,7 @@ describe DirectoryItem do
context 'refresh' do
before do
- UserActionCreator.enable
+ UserActionManager.enable
end
it "creates the record for the user and handles likes" do
@@ -58,7 +58,7 @@ describe DirectoryItem do
user2 = Fabricate(:user)
- PostAction.act(user2, post, PostActionType.types[:like])
+ PostActionCreator.like(user2, post)
DirectoryItem.refresh!
diff --git a/spec/models/notification_spec.rb b/spec/models/notification_spec.rb
index 3bca8db0ac6..1365001df0d 100644
--- a/spec/models/notification_spec.rb
+++ b/spec/models/notification_spec.rb
@@ -269,7 +269,7 @@ describe Notification do
topic: post.topic
))
- PostAction.act(user, post, PostActionType.types[:like])
+ PostActionCreator.like(user, post)
end.to change { Notification.count }.by(2)
expect(Notification.filter_by_display_username_and_type(
diff --git a/spec/models/post_action_spec.rb b/spec/models/post_action_spec.rb
index 1b16944a8b0..9f05b32ccb3 100644
--- a/spec/models/post_action_spec.rb
+++ b/spec/models/post_action_spec.rb
@@ -1,5 +1,4 @@
require 'rails_helper'
-require_dependency 'post_destroyer'
describe PostAction do
it { is_expected.to rate_limit }
@@ -16,38 +15,24 @@ describe PostAction do
GivenDailyLike.find_for(user_id, dt).pluck(:likes_given)[0] || 0
end
- describe "rate limits" do
-
- it "limits redo/undo" do
-
- RateLimiter.enable
-
- PostAction.act(eviltrout, post, PostActionType.types[:like])
- PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
- PostAction.act(eviltrout, post, PostActionType.types[:like])
- PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
-
- expect {
- PostAction.act(eviltrout, post, PostActionType.types[:like])
- }.to raise_error(RateLimiter::LimitExceeded)
-
- end
+ it "disallows the same action from happening twice" do
+ PostAction.create(user: eviltrout, post: post, post_action_type_id: PostActionType.types[:like])
+ pa = PostAction.new(user: eviltrout, post: post, post_action_type_id: PostActionType.types[:like])
+ expect(pa).not_to be_valid
end
- describe "messaging" do
+ context "messaging" do
- it "doesn't generate title longer than 255 characters" do
- topic = create_topic(title: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc sit amet rutrum neque. Pellentesque suscipit vehicula facilisis. Phasellus lacus sapien, aliquam nec convallis sit amet, vestibulum laoreet ante. Curabitur et pellentesque tortor. Donec non.")
- post = create_post(topic: topic)
- expect { PostAction.act(admin, post, PostActionType.types[:notify_user], message: "WAT") }.not_to raise_error
- end
-
- it "notify moderators integration test" do
+ it "notifies moderators (integration test)" do
post = create_post
mod = moderator
Group.refresh_automatic_groups!
- action = PostAction.act(codinghorror, post, PostActionType.types[:notify_moderators], message: "this is my special long message")
+ result = PostActionCreator.notify_moderators(
+ codinghorror,
+ post,
+ "this is my special long message"
+ )
posts = Post.joins(:topic)
.select('posts.id, topics.subtype, posts.topic_id')
@@ -55,7 +40,8 @@ describe PostAction do
.to_a
expect(posts.count).to eq(1)
- expect(action.related_post_id).to eq(posts[0].id.to_i)
+ expect(result.post_action.related_post_id).to eq(posts[0].id.to_i)
+ expect(result.reviewable_score.meta_topic_id).to eq(posts[0].topic_id)
expect(posts[0].subtype).to eq(TopicSubtype.notify_moderators)
topic = posts[0].topic
@@ -73,149 +59,38 @@ describe PostAction do
# reply to PM should not clear flag
PostCreator.new(mod, topic_id: posts[0].topic_id, raw: "This is my test reply to the user, it should clear flags").create
- action.reload
- expect(action.deleted_at).to eq(nil)
+ result.post_action.reload
+ expect(result.post_action.deleted_at).to eq(nil)
# Acting on the flag should not post an automated status message (since a moderator already replied)
expect(topic.posts.count).to eq(2)
- PostAction.agree_flags!(post, admin)
- expect(action.user.user_stat.flags_agreed).to eq(1)
- expect(action.user.user_stat.flags_disagreed).to eq(0)
+ result.reviewable.perform(admin, :agree_and_keep)
topic.reload
expect(topic.posts.count).to eq(2)
# Clearing the flags should not post an automated status message
- new_action = PostAction.act(mod, post, PostActionType.types[:notify_moderators], message: "another special message")
- PostAction.clear_flags!(post, admin)
- expect(new_action.user.user_stat.flags_agreed).to eq(0)
- expect(new_action.user.user_stat.flags_disagreed).to eq(1)
+ result = PostActionCreator.notify_moderators(mod, post, "another special message")
+ result.reviewable.perform(admin, :disagree)
topic.reload
expect(topic.posts.count).to eq(2)
# Acting on the flag should post an automated status message
another_post = create_post
- action = PostAction.act(codinghorror, another_post, PostActionType.types[:notify_moderators], message: "foobar")
- topic = action.related_post.topic
+ result = PostActionCreator.notify_moderators(codinghorror, another_post, "foobar")
+ topic = result.post_action.related_post.topic
expect(topic.posts.count).to eq(1)
- PostAction.agree_flags!(another_post, admin)
- expect(action.user.user_stat.flags_agreed).to eq(2)
- expect(action.user.user_stat.flags_disagreed).to eq(0)
+ result.reviewable.perform(admin, :agree_and_keep)
topic.reload
expect(topic.posts.count).to eq(2)
expect(topic.posts.last.post_type).to eq(Post.types[:moderator_action])
end
- describe 'notify_moderators' do
- before do
- PostAction.stubs(:create)
- end
-
- it "creates a pm if selected" do
- post = build(:post, id: 1000)
- PostCreator.any_instance.expects(:create).returns(post)
- PostAction.act(build(:user), build(:post), PostActionType.types[:notify_moderators], message: "this is my special message")
- end
- end
-
- describe "notify_user" do
- before do
- PostAction.stubs(:create)
- post = build(:post)
- post.user = build(:user)
- end
-
- it "sends an email to user if selected" do
- PostCreator.any_instance.expects(:create).returns(build(:post))
- PostAction.act(build(:user), post, PostActionType.types[:notify_user], message: "this is my special message")
- end
- end
- end
-
- describe "flag counts" do
- before do
- PostAction.update_flagged_posts_count
- end
-
- it "increments the numbers correctly" do
- expect(PostAction.flagged_posts_count).to eq(0)
-
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
- expect(PostAction.flagged_posts_count).to eq(1)
-
- PostAction.clear_flags!(post, Discourse.system_user)
- expect(PostAction.flagged_posts_count).to eq(0)
- end
-
- it "respects min_flags_staff_visibility" do
- SiteSetting.min_flags_staff_visibility = 2
- expect(PostAction.flagged_posts_count).to eq(0)
-
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
- expect(PostAction.flagged_posts_count).to eq(0)
-
- PostAction.act(eviltrout, post, PostActionType.types[:off_topic])
- expect(PostAction.flagged_posts_count).to eq(1)
- end
-
- it "tl3 hidden posts will supersede min_flags_staff_visibility" do
- SiteSetting.min_flags_staff_visibility = 2
- expect(PostAction.flagged_posts_count).to eq(0)
-
- codinghorror.update_column(:trust_level, 3)
- post.user.update_column(:trust_level, 0)
- PostAction.act(codinghorror, post, PostActionType.types[:spam])
- expect(PostAction.flagged_posts_count).to eq(1)
- end
-
- it "tl4 hidden posts will supersede min_flags_staff_visibility" do
- SiteSetting.min_flags_staff_visibility = 2
- expect(PostAction.flagged_posts_count).to eq(0)
-
- codinghorror.update_column(:trust_level, 4)
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
-
- expect(PostAction.flagged_posts_count).to eq(1)
- end
-
- it "should reset counts when a topic is deleted" do
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
- post.topic.trash!
- expect(PostAction.flagged_posts_count).to eq(0)
- end
-
- it "should ignore flags on non-human users" do
- post = create_post(user: Discourse.system_user)
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
- expect(PostAction.flagged_posts_count).to eq(0)
- end
-
- it "should ignore validated flags" do
- post = create_post
-
- PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
- expect(post.hidden).to eq(false)
- expect(post.hidden_at).to be_blank
- PostAction.defer_flags!(post, admin)
- expect(PostAction.flagged_posts_count).to eq(0)
-
- post.reload
- expect(post.hidden).to eq(false)
- expect(post.hidden_at).to be_blank
-
- PostAction.hide_post!(post, PostActionType.types[:off_topic])
-
- post.reload
- expect(post.hidden).to eq(true)
- expect(post.hidden_at).to be_present
- end
-
end
describe "update_counters" do
-
it "properly updates topic counters" do
freeze_time Date.today
# we need this to test it
@@ -223,8 +98,8 @@ describe PostAction do
expect(value_for(moderator.id, Date.today)).to eq(0)
- PostAction.act(moderator, post, PostActionType.types[:like])
- PostAction.act(codinghorror, second_post, PostActionType.types[:like])
+ PostActionCreator.like(moderator, post)
+ PostActionCreator.like(codinghorror, second_post)
post.topic.reload
expect(post.topic.like_count).to eq(2)
@@ -263,11 +138,11 @@ describe PostAction do
describe "undo/redo repeatedly" do
it "doesn't create a second action for the same user/type" do
- PostAction.act(codinghorror, post, PostActionType.types[:like])
- PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
+ PostActionDestroyer.destroy(codinghorror, post, :like)
+ PostActionCreator.like(codinghorror, post)
expect(PostAction.where(post: post).with_deleted.count).to eq(1)
- PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(codinghorror, post, :like)
# Check that we don't lose consistency into negatives
expect(post.reload.like_count).to eq(0)
@@ -280,7 +155,7 @@ describe PostAction do
end
it 'should generate and remove notifications correctly' do
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
expect(Notification.count).to eq(1)
@@ -289,11 +164,11 @@ describe PostAction do
expect(notification.user_id).to eq(post.user_id)
expect(notification.notification_type).to eq(Notification.types[:liked])
- PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(codinghorror, post, :like)
expect(Notification.count).to eq(0)
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
expect(Notification.count).to eq(1)
@@ -310,13 +185,14 @@ describe PostAction do
)
expect do
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
end.to_not change { Notification.count }
end
it 'notifies on likes correctly' do
- PostAction.act(eviltrout, post, PostActionType.types[:like])
- PostAction.act(admin, post, PostActionType.types[:like])
+ SiteSetting.post_undo_action_window_mins = 120
+ PostActionCreator.like(eviltrout, post)
+ PostActionCreator.like(admin, post)
# one like
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
@@ -332,7 +208,7 @@ describe PostAction do
freeze_time 1.hour.from_now
expect do
- PostAction.act(admin2, post, PostActionType.types[:like])
+ PostActionCreator.like(admin2, post)
end.to_not change { Notification.count }
# adds info to the notification
@@ -345,7 +221,7 @@ describe PostAction do
expect(notification.data_hash["username2"]).to eq(eviltrout.username)
# this is a tricky thing ... removing a like should fix up the notifications
- PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(eviltrout, post, :like)
# rebuilds the missing notification
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
@@ -367,12 +243,12 @@ describe PostAction do
# this gets skipped
admin3 = Fabricate(:admin)
- PostAction.act(admin3, post, PostActionType.types[:like])
+ PostActionCreator.like(admin3, post)
freeze_time 2.days.from_now
admin4 = Fabricate(:admin)
- PostAction.act(admin4, post, PostActionType.types[:like])
+ PostActionCreator.like(admin4, post)
# first happend within the same day, no need to notify
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
@@ -388,21 +264,13 @@ describe PostAction do
SiteSetting.likes_notification_consolidation_threshold = 0
expect do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end.to change { likee.reload.notifications.count }.by(1)
SiteSetting.likes_notification_consolidation_threshold = 1
expect do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end.to_not change { likee.reload.notifications.count }
end
@@ -419,11 +287,7 @@ describe PostAction do
expect do
3.times do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end
end.to change { likee.reload.notifications.count }.by(1)
@@ -443,11 +307,7 @@ describe PostAction do
expect do
2.times do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end
end.to_not change { likee.reload.notifications.count }
@@ -458,11 +318,7 @@ describe PostAction do
# Like from a different user shouldn't be consolidated
expect do
- PostAction.act(
- Fabricate(:user),
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(Fabricate(:user), Fabricate(:post, user: likee))
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
@@ -477,11 +333,7 @@ describe PostAction do
).since)
expect do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
@@ -505,7 +357,7 @@ describe PostAction do
expect do
[liker2, liker].each do |user|
- PostAction.act(user, post, PostActionType.types[:like])
+ PostActionCreator.like(user, post)
end
end.to change { likee.reload.notifications.count }.by(1)
@@ -518,11 +370,7 @@ describe PostAction do
expect do
2.times do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end
end.to change { likee.reload.notifications.count }.by(2)
@@ -530,11 +378,7 @@ describe PostAction do
.to contain_exactly(Notification.types[:liked])
expect do
- PostAction.act(
- liker,
- Fabricate(:post, user: likee),
- PostActionType.types[:like]
- )
+ PostActionCreator.like(liker, Fabricate(:post, user: likee))
end.to change { likee.reload.notifications.count }.by(-1)
notification = likee.notifications.last
@@ -554,7 +398,7 @@ describe PostAction do
MutedUser.create!(user_id: post.user.id, muted_user_id: mutee.id)
expect do
- PostAction.act(mutee, post, PostActionType.types[:like])
+ PostActionCreator.like(mutee, post)
end.to_not change { Notification.count }
end
@@ -568,7 +412,7 @@ describe PostAction do
)
expect do
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
end.to_not change { Notification.count }
end
@@ -578,7 +422,7 @@ describe PostAction do
MutedUser.create!(user_id: post.user.id, muted_user_id: admin.id)
expect do
- PostAction.act(admin, post, PostActionType.types[:like])
+ PostActionCreator.like(admin, post)
end.to change { Notification.count }.by(1)
notification = Notification.last
@@ -590,7 +434,7 @@ describe PostAction do
it 'should increase the `like_count` and `like_score` when a user likes something' do
freeze_time Date.today
- PostAction.act(codinghorror, post, PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, post)
post.reload
expect(post.like_count).to eq(1)
expect(post.like_score).to eq(1)
@@ -599,21 +443,21 @@ describe PostAction do
expect(value_for(codinghorror.id, Date.today)).to eq(1)
# When a staff member likes it
- PostAction.act(moderator, post, PostActionType.types[:like])
+ PostActionCreator.like(moderator, post)
post.reload
expect(post.like_count).to eq(2)
expect(post.like_score).to eq(4)
expect(post.topic.like_count).to eq(2)
# Removing likes
- PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(codinghorror, post, :like)
post.reload
expect(post.like_count).to eq(1)
expect(post.like_score).to eq(3)
expect(post.topic.like_count).to eq(1)
expect(value_for(codinghorror.id, Date.today)).to eq(0)
- PostAction.remove_act(moderator, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(moderator, post, :like)
post.reload
expect(post.like_count).to eq(0)
expect(post.like_score).to eq(0)
@@ -623,18 +467,18 @@ describe PostAction do
it "shouldn't change given_likes unless likes are given or removed" do
freeze_time(Time.zone.now)
- PostAction.act(codinghorror, Fabricate(:post), PostActionType.types[:like])
+ PostActionCreator.like(codinghorror, Fabricate(:post))
expect(value_for(codinghorror.id, Date.today)).to eq(1)
PostActionType.types.each do |type_name, type_id|
post = Fabricate(:post)
- PostAction.act(codinghorror, post, type_id)
+ PostActionCreator.create(codinghorror, post, type_name)
actual_count = value_for(codinghorror.id, Date.today)
expected_count = type_name == :like ? 2 : 1
expect(actual_count).to eq(expected_count), "Expected likes_given to be #{expected_count} when adding '#{type_name}', but got #{actual_count}"
- PostAction.remove_act(codinghorror, post, type_id)
+ PostActionDestroyer.new(codinghorror, post, type_id).perform
actual_count = value_for(codinghorror.id, Date.today)
expect(actual_count).to eq(1), "Expected likes_given to be 1 when removing '#{type_name}', but got #{actual_count}"
end
@@ -643,65 +487,39 @@ describe PostAction do
describe 'flagging' do
- context "flag_counts_for" do
- it "returns the correct flag counts" do
- post = create_post
-
- SiteSetting.flags_required_to_hide_post = 7
-
- # A post with no flags has 0 for flag counts
- expect(PostAction.flag_counts_for(post.id)).to eq([0, 0])
-
- _flag = PostAction.act(eviltrout, post, PostActionType.types[:spam])
- expect(PostAction.flag_counts_for(post.id)).to eq([0, 1])
-
- # If staff takes action, it is ranked higher
- PostAction.act(admin, post, PostActionType.types[:spam], take_action: true)
- expect(PostAction.flag_counts_for(post.id)).to eq([0, 8])
-
- # If a flag is dismissed
- PostAction.clear_flags!(post, admin)
- expect(PostAction.flag_counts_for(post.id)).to eq([0, 8])
- end
+ it 'does not allow you to flag stuff twice, even if the reason is different' do
+ post = Fabricate(:post)
+ expect(PostActionCreator.spam(eviltrout, post)).to be_success
+ expect(PostActionCreator.off_topic(eviltrout, post)).to be_failed
end
- it 'does not allow you to flag stuff with the same reason more than once' do
+ it 'allows you to flag stuff again if your previous flag was removed' do
post = Fabricate(:post)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- expect { PostAction.act(eviltrout, post, PostActionType.types[:off_topic]) }.to raise_error(PostAction::AlreadyActed)
- end
-
- it 'allows you to flag stuff with another reason' do
- post = Fabricate(:post)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- PostAction.remove_act(eviltrout, post, PostActionType.types[:spam])
- expect { PostAction.act(eviltrout, post, PostActionType.types[:off_topic]) }.not_to raise_error()
+ PostActionCreator.spam(eviltrout, post)
+ PostActionDestroyer.destroy(eviltrout, post, :spam)
+ expect(PostActionCreator.spam(eviltrout, post)).to be_success
end
it 'should update counts when you clear flags' do
post = Fabricate(:post)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
+ reviewable = PostActionCreator.spam(eviltrout, post).reviewable
- post.reload
- expect(post.spam_count).to eq(1)
+ expect(post.reload.spam_count).to eq(1)
- PostAction.clear_flags!(post, Discourse.system_user)
+ reviewable.perform(Discourse.system_user, :disagree)
- post.reload
- expect(post.spam_count).to eq(0)
+ expect(post.reload.spam_count).to eq(0)
end
it "will not allow regular users to auto hide staff posts" do
mod = Fabricate(:moderator)
post = Fabricate(:post, user: mod)
- SiteSetting.flags_required_to_hide_post = 2
+ SiteSetting.score_required_to_hide_post = 2.0
Discourse.stubs(:site_contact_user).returns(admin)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- PostAction.act(Fabricate(:walter_white), post, PostActionType.types[:spam])
-
- post.reload
+ PostActionCreator.spam(eviltrout, post)
+ PostActionCreator.spam(Fabricate(:walter_white), post)
expect(post.hidden).to eq(false)
expect(post.hidden_at).to be_blank
@@ -711,11 +529,11 @@ describe PostAction do
mod = Fabricate(:moderator)
post = Fabricate(:post, user: mod)
- SiteSetting.flags_required_to_hide_post = 2
+ SiteSetting.score_required_to_hide_post = 8.0
Discourse.stubs(:site_contact_user).returns(admin)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- PostAction.act(Fabricate(:admin), post, PostActionType.types[:spam])
+ PostActionCreator.spam(eviltrout, post)
+ PostActionCreator.spam(Fabricate(:admin), post)
post.reload
@@ -727,11 +545,11 @@ describe PostAction do
post = create_post
walterwhite = Fabricate(:walter_white)
- SiteSetting.flags_required_to_hide_post = 2
+ SiteSetting.score_required_to_hide_post = 3.0
Discourse.stubs(:site_contact_user).returns(admin)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- PostAction.act(walterwhite, post, PostActionType.types[:spam])
+ PostActionCreator.spam(eviltrout, post)
+ PostActionCreator.spam(walterwhite, post)
job_args = Jobs::SendSystemMessage.jobs.last["args"].first
expect(job_args["user_id"]).to eq(post.user.id)
@@ -753,8 +571,8 @@ describe PostAction do
expect(post.hidden_at).to be_present # keep the most recent hidden_at time
expect(post.topic.visible).to eq(true)
- PostAction.act(eviltrout, post, PostActionType.types[:spam])
- PostAction.act(walterwhite, post, PostActionType.types[:off_topic])
+ PostActionCreator.spam(eviltrout, post)
+ PostActionCreator.off_topic(walterwhite, post)
job_args = Jobs::SendSystemMessage.jobs.last["args"].first
expect(job_args["user_id"]).to eq(post.user.id)
@@ -781,7 +599,7 @@ describe PostAction do
post = create_post
post.update!(user: nil)
- PostAction.act(codinghorror, post, PostActionType.types[:spam], take_action: true)
+ PostActionCreator.new(moderator, post, PostActionType.types[:spam], take_action: true).perform
post.reload
expect(post.hidden).to eq(true)
end
@@ -792,7 +610,7 @@ describe PostAction do
Discourse.stubs(:site_contact_user).returns(admin)
- PostAction.act(Fabricate(:leader), post, PostActionType.types[:spam])
+ PostActionCreator.spam(Fabricate(:leader), post)
post.reload
@@ -804,13 +622,11 @@ describe PostAction do
it "hide non-tl4 posts that are flagged by a tl4 user" do
SiteSetting.site_contact_username = admin.username
- post_action_type = PostActionType.types[:spam]
tl4_user = Fabricate(:trust_level_4)
-
user = Fabricate(:leader)
post = create_post(user: user)
- PostAction.act(tl4_user, post, post_action_type)
+ PostActionCreator.spam(tl4_user, post)
post.reload
@@ -819,20 +635,20 @@ describe PostAction do
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flagged_by_tl4_user])
post = create_post(user: user)
- PostAction.act(Fabricate(:leader), post, post_action_type)
+ PostActionCreator.spam(Fabricate(:leader), post)
post.reload
expect(post.hidden).to be_falsey
post = create_post(user: user)
- PostAction.act(Fabricate(:moderator), post, post_action_type)
+ PostActionCreator.spam(Fabricate(:moderator), post)
post.reload
expect(post.hidden).to be_falsey
user = Fabricate(:trust_level_4)
post = create_post(user: user)
- PostAction.act(tl4_user, post, post_action_type)
+ PostActionCreator.spam(tl4_user, post)
post.reload
expect(post.hidden).to be_falsey
@@ -840,28 +656,40 @@ describe PostAction do
it "can flag the topic instead of a post" do
post1 = create_post
- _post2 = create_post(topic: post1.topic)
- post_action = PostAction.act(Fabricate(:user), post1, PostActionType.types[:spam], flag_topic: true)
- expect(post_action.targets_topic).to eq(true)
+ create_post(topic: post1.topic)
+ result = PostActionCreator.new(
+ Fabricate(:user),
+ post1,
+ PostActionType.types[:spam],
+ flag_topic: true
+ ).perform
+ expect(result.post_action.targets_topic).to eq(true)
+ expect(result.reviewable.payload['targets_topic']).to eq(true)
end
it "will flag the first post if you flag a topic but there is only one post in the topic" do
post = create_post
- post_action = PostAction.act(Fabricate(:user), post, PostActionType.types[:spam], flag_topic: true)
- expect(post_action.targets_topic).to eq(false)
- expect(post_action.post_id).to eq(post.id)
+ result = PostActionCreator.new(
+ Fabricate(:user),
+ post,
+ PostActionType.types[:spam],
+ flag_topic: true
+ ).perform
+ expect(result.post_action.targets_topic).to eq(false)
+ expect(result.post_action.post_id).to eq(post.id)
+ expect(result.reviewable.payload['targets_topic']).to eq(false)
end
it "will unhide the post when a moderator undos the flag on which s/he took action" do
Discourse.stubs(:site_contact_user).returns(admin)
post = create_post
- PostAction.act(moderator, post, PostActionType.types[:spam], take_action: true)
+ PostActionCreator.new(moderator, post, PostActionType.types[:spam], take_action: true).perform
post.reload
expect(post.hidden).to eq(true)
- PostAction.remove_act(moderator, post, PostActionType.types[:spam])
+ PostActionDestroyer.destroy(moderator, post, :spam)
post.reload
expect(post.hidden).to eq(false)
@@ -877,8 +705,8 @@ describe PostAction do
let(:flagger2) { Fabricate(:user) }
before do
- SiteSetting.flags_required_to_hide_post = 0
- SiteSetting.num_flags_to_close_topic = 3
+ SiteSetting.score_required_to_hide_post = 0
+ SiteSetting.score_to_auto_close_topic = 12.0
SiteSetting.num_flaggers_to_close_topic = 2
SiteSetting.num_hours_to_close_topic = 1
end
@@ -886,7 +714,7 @@ describe PostAction do
it "will automatically pause a topic due to large community flagging" do
# reaching `num_flaggers_to_close_topic` isn't enough
[flagger1, flagger2].each do |flagger|
- PostAction.act(flagger, post1, PostActionType.types[:inappropriate])
+ PostActionCreator.inappropriate(flagger, post1)
end
expect(topic.reload.closed).to eq(false)
@@ -896,7 +724,7 @@ describe PostAction do
# reaching `num_flags_to_close_topic` isn't enough
[post1, post2, post3].each do |post|
- PostAction.act(flagger1, post, PostActionType.types[:inappropriate])
+ PostActionCreator.inappropriate(flagger1, post)
end
expect(topic.reload.closed).to eq(false)
@@ -907,7 +735,7 @@ describe PostAction do
# reaching both should close the topic
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
- PostAction.act(flagger, post, PostActionType.types[:inappropriate])
+ PostActionCreator.inappropriate(flagger, post)
end
end
@@ -927,7 +755,7 @@ describe PostAction do
it "will not close topics opened by staff" do
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
- PostAction.act(flagger, post, PostActionType.types[:inappropriate])
+ PostActionCreator.inappropriate(flagger, post)
end
end
@@ -939,10 +767,10 @@ describe PostAction do
freeze_time
SiteSetting.num_flaggers_to_close_topic = 1
- SiteSetting.num_flags_to_close_topic = 1
+ SiteSetting.score_to_auto_close_topic = 2.0
post = Fabricate(:post, topic: topic)
- PostAction.act(flagger1, post, PostActionType.types[:spam])
+ PostActionCreator.spam(flagger1, post)
expect(topic.reload.closed).to eq(true)
timer = TopicTimer.last
@@ -962,7 +790,7 @@ describe PostAction do
freeze_time timer.execute_at
SiteSetting.num_flaggers_to_close_topic = 10
- SiteSetting.num_flags_to_close_topic = 10
+ SiteSetting.score_to_auto_close_topic = 20.0
Jobs::ToggleTopicClosed.new.execute(topic_timer_id: timer.id, state: false)
@@ -973,7 +801,7 @@ describe PostAction do
freeze_time
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
- PostAction.act(flagger, post, PostActionType.types[:inappropriate])
+ PostActionCreator.inappropriate(flagger, post)
end
end
@@ -991,25 +819,31 @@ describe PostAction do
it "prevents user to act twice at the same time" do
# flags are already being tested
- all_types_except_flags = PostActionType.types.except(PostActionType.flag_types_without_custom)
+ all_types_except_flags = PostActionType.types.except(*PostActionType.flag_types_without_custom.keys)
all_types_except_flags.values.each do |action|
- expect do
- PostAction.act(eviltrout, post, action)
- PostAction.act(eviltrout, post, action)
- end.to raise_error(PostAction::AlreadyActed)
+ expect(PostActionCreator.new(eviltrout, post, action).perform).to be_success
+ expect(PostActionCreator.new(eviltrout, post, action).perform).to be_failed
end
end
- describe ".create_message_for_post_action" do
+ describe "messages" do
it "does not create a message when there is no message" do
- message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[:spam], {})
- expect(message_id).to be_nil
+ result = PostActionCreator.spam(Discourse.system_user, post)
+ expect(result).to be_success
+ expect(result.post_action.related_post_id).to be_nil
+ expect(result.reviewable_score.meta_topic_id).to be_nil
end
[:notify_moderators, :notify_user, :spam].each do |post_action_type|
it "creates a message for #{post_action_type}" do
- message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[post_action_type], message: "WAT")
- expect(message_id).to be_present
+ result = PostActionCreator.new(
+ Discourse.system_user,
+ post,
+ PostActionType.types[post_action_type],
+ message: 'WAT'
+ ).perform
+ expect(result).to be_success
+ expect(result.post_action.related_post_id).to be_present
end
end
@@ -1019,14 +853,8 @@ describe PostAction do
messageable_level = group.messageable_level
group.update!(messageable_level: Group::ALIAS_LEVELS[:nobody])
- expect do
- PostAction.create_message_for_post_action(
- Fabricate(:user),
- post,
- PostActionType.types[:notify_moderators],
- message: 'testing',
- )
- end.to raise_error(ActiveRecord::RecordNotSaved)
+ result = PostActionCreator.notify_moderators(Fabricate(:user), post, 'testing')
+ expect(result).to be_failed
ensure
group.update!(messageable_level: messageable_level)
end
@@ -1036,8 +864,10 @@ describe PostAction do
SiteSetting.max_topic_title_length = 50
post.topic.title = 'This is a test topic ' * 2
post.topic.save!
- message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[:notify_moderators], message: "WAT")
- expect(message_id).to be_present
+
+ result = PostActionCreator.notify_moderators(Discourse.system_user, post, 'WAT')
+ expect(result).to be_success
+ expect(result.post_action.related_post_id).to be_present
end
end
@@ -1045,8 +875,7 @@ describe PostAction do
it "returns the correct map" do
user = Fabricate(:user)
post = Fabricate(:post)
- post_action = PostAction.create(user_id: user.id, post_id: post.id, post_action_type_id: 1)
-
+ post_action = PostActionCreator.create(user, post, :bookmark).post_action
map = PostAction.lookup_for(user, [post.topic], post_action.post_action_type_id)
expect(map).to eq(post.topic_id => [post.post_number])
@@ -1058,47 +887,43 @@ describe PostAction do
it "should not add a moderator post when it's disabled" do
post = create_post
- action = PostAction.act(moderator, post, PostActionType.types[:spam], message: "WAT")
- action.reload
- topic = action.related_post.topic
+ result = PostActionCreator.create(moderator, post, :spam, message: "WAT")
+ topic = result.post_action.related_post.topic
expect(topic.posts.count).to eq(1)
SiteSetting.auto_respond_to_flag_actions = false
- PostAction.agree_flags!(post, admin)
- expect(action.user.user_stat.flags_agreed).to eq(1)
-
- topic.reload
- expect(topic.posts.count).to eq(1)
+ result.reviewable.perform(admin, :agree_and_keep)
+ expect(topic.reload.posts.count).to eq(1)
end
it "should create a notification in the related topic" do
Jobs.run_immediately!
post = Fabricate(:post)
user = Fabricate(:user)
- action = PostAction.act(user, post, PostActionType.types[:spam], message: "WAT")
- topic = action.reload.related_post.topic
+ result = PostActionCreator.create(user, post, :spam, message: "WAT")
+ topic = result.post_action.related_post.topic
+ reviewable = result.reviewable
expect(user.notifications.count).to eq(0)
SiteSetting.auto_respond_to_flag_actions = true
- PostAction.agree_flags!(post, admin)
- expect(action.user.user_stat.flags_agreed).to eq(1)
+ reviewable.perform(admin, :agree_and_keep)
user_notifications = user.notifications
- expect(user_notifications.count).to eq(1)
expect(user_notifications.last.topic).to eq(topic)
end
- it "should not add a moderator post when post is flagged via private message" do
+ skip "should not add a moderator post when post is flagged via private message" do
Jobs.run_immediately!
post = Fabricate(:post)
user = Fabricate(:user)
- action = PostAction.act(user, post, PostActionType.types[:notify_user], message: "WAT")
+ result = PostActionCreator.create(user, post, :notify_user, message: "WAT")
+ action = result.post_action
action.reload.related_post.topic
expect(user.notifications.count).to eq(0)
SiteSetting.auto_respond_to_flag_actions = true
- PostAction.agree_flags!(post, admin)
- expect(action.user.user_stat.flags_agreed).to eq(0)
+ result.reviewable.perform(admin, :agree_and_keep)
+ expect(user.reload.user_stat.flags_agreed).to eq(0)
user_notifications = user.notifications
expect(user_notifications.count).to eq(0)
@@ -1162,35 +987,47 @@ describe PostAction do
describe "triggers Discourse events" do
let(:post) { Fabricate(:post) }
- it 'flag created' do
- event = DiscourseEvent.track_events { PostAction.act(eviltrout, post, PostActionType.types[:spam]) }.last
- expect(event[:event_name]).to eq(:flag_created)
+ it 'triggers a flag_created event' do
+ event = DiscourseEvent.track(:flag_created) { PostActionCreator.spam(eviltrout, post) }
+ expect(event).to be_present
end
context "resolving flags" do
- before do
- @flag = PostAction.act(eviltrout, post, PostActionType.types[:spam])
+ let(:result) { PostActionCreator.spam(eviltrout, post) }
+ let(:post_action) { result.post_action }
+ let(:reviewable) { result.reviewable }
+
+ it 'creates events for agreed' do
+ events = DiscourseEvent.track_events { reviewable.perform(moderator, :agree_and_keep) }
+
+ reviewed_event = events.find { |e| e[:event_name] == :flag_reviewed }
+ expect(reviewed_event).to be_present
+
+ event = events.find { |e| e[:event_name] == :flag_agreed }
+ expect(event).to be_present
+ expect(event[:params]).to eq([post_action])
end
- it 'flag agreed' do
- events = DiscourseEvent.track_events { PostAction.agree_flags!(post, moderator) }.last(2)
- expect(events[0][:event_name]).to eq(:flag_reviewed)
- expect(events[1][:event_name]).to eq(:flag_agreed)
- expect(events[1][:params].first).to eq(@flag)
+ it 'creates events for disagreed' do
+ events = DiscourseEvent.track_events { reviewable.perform(moderator, :disagree) }
+
+ reviewed_event = events.find { |e| e[:event_name] == :flag_reviewed }
+ expect(reviewed_event).to be_present
+
+ event = events.find { |e| e[:event_name] == :flag_disagreed }
+ expect(event).to be_present
+ expect(event[:params]).to eq([post_action])
end
- it 'flag disagreed' do
- events = DiscourseEvent.track_events { PostAction.clear_flags!(post, moderator) }.last(2)
- expect(events[0][:event_name]).to eq(:flag_reviewed)
- expect(events[1][:event_name]).to eq(:flag_disagreed)
- expect(events[1][:params].first).to eq(@flag)
- end
+ it 'creates events for ignored' do
+ events = DiscourseEvent.track_events { reviewable.perform(moderator, :ignore) }
- it 'flag deferred' do
- events = DiscourseEvent.track_events { PostAction.defer_flags!(post, moderator) }.last(2)
- expect(events[0][:event_name]).to eq(:flag_reviewed)
- expect(events[1][:event_name]).to eq(:flag_deferred)
- expect(events[1][:params].first).to eq(@flag)
+ reviewed_event = events.find { |e| e[:event_name] == :flag_reviewed }
+ expect(reviewed_event).to be_present
+
+ event = events.find { |e| e[:event_name] == :flag_deferred }
+ expect(event).to be_present
+ expect(event[:params]).to eq([post_action])
end
end
end
diff --git a/spec/models/post_mover_spec.rb b/spec/models/post_mover_spec.rb
index 65783ed31dd..836c186ed82 100644
--- a/spec/models/post_mover_spec.rb
+++ b/spec/models/post_mover_spec.rb
@@ -44,8 +44,8 @@ describe PostMover do
Jobs.run_immediately!
p1.replies << p3
p2.replies << p4
- UserActionCreator.enable
- @like = PostAction.act(another_user, p4, PostActionType.types[:like])
+ UserActionManager.enable
+ @like = PostActionCreator.like(another_user, p4)
end
context 'success' do
@@ -452,7 +452,7 @@ describe PostMover do
end
it "preserves post actions in the new post" do
- PostAction.act(another_user, p1, PostActionType.types[:like])
+ PostActionCreator.like(another_user, p1)
new_topic = topic.move_posts(user, [p1.id], title: "new testing topic name")
new_post = new_topic.posts.where(post_number: 1).first
@@ -573,8 +573,8 @@ describe PostMover do
Jobs.run_immediately!
p1.replies << p3
p2.replies << p4
- UserActionCreator.enable
- @like = PostAction.act(another_user, p4, PostActionType.types[:like])
+ UserActionManager.enable
+ @like = PostActionCreator.like(another_user, p4)
end
context 'move to new message' do
diff --git a/spec/models/post_spec.rb b/spec/models/post_spec.rb
index ae4d32bcd01..da3354ea19c 100644
--- a/spec/models/post_spec.rb
+++ b/spec/models/post_spec.rb
@@ -1,5 +1,4 @@
require 'rails_helper'
-require_dependency 'post_destroyer'
describe Post do
before { Oneboxer.stubs :onebox }
@@ -159,44 +158,39 @@ describe Post do
let(:admin) { Fabricate(:admin) }
it 'is_flagged? is accurate' do
- PostAction.act(user, post, PostActionType.types[:off_topic])
- post.reload
- expect(post.is_flagged?).to eq(true)
+ PostActionCreator.off_topic(user, post)
+ expect(post.reload.is_flagged?).to eq(true)
- PostAction.remove_act(user, post, PostActionType.types[:off_topic])
- post.reload
- expect(post.is_flagged?).to eq(false)
+ PostActionDestroyer.destroy(user, post, :off_topic)
+ expect(post.reload.is_flagged?).to eq(false)
end
it 'is_flagged? is true if flag was deferred' do
- PostAction.act(user, post, PostActionType.types[:off_topic])
- PostAction.defer_flags!(post.reload, admin)
- post.reload
- expect(post.is_flagged?).to eq(true)
+ result = PostActionCreator.off_topic(user, post)
+ result.reviewable.perform(admin, :ignore)
+ expect(post.reload.is_flagged?).to eq(true)
end
it 'is_flagged? is true if flag was cleared' do
- PostAction.act(user, post, PostActionType.types[:off_topic])
- PostAction.clear_flags!(post.reload, admin)
- post.reload
- expect(post.is_flagged?).to eq(true)
+ result = PostActionCreator.off_topic(user, post)
+ result.reviewable.perform(admin, :disagree)
+ expect(post.reload.is_flagged?).to eq(true)
end
- it 'has_active_flag? is false for deferred flags' do
- PostAction.act(user, post, PostActionType.types[:spam])
- post.reload
- expect(post.has_active_flag?).to eq(true)
+ it 'reviewable_flag is nil when ignored' do
+ result = PostActionCreator.spam(user, post)
+ expect(post.reviewable_flag).to eq(result.reviewable)
- PostAction.defer_flags!(post, admin)
- post.reload
- expect(post.has_active_flag?).to eq(false)
+ result.reviewable.perform(admin, :ignore)
+ expect(post.reviewable_flag).to be_nil
end
- it 'has_active_flag? is false for cleared flags' do
- PostAction.act(user, post, PostActionType.types[:spam])
- PostAction.clear_flags!(post.reload, admin)
- post.reload
- expect(post.has_active_flag?).to eq(false)
+ it 'reviewable_flag is nil when disagreed' do
+ result = PostActionCreator.spam(user, post)
+ expect(post.reviewable_flag).to eq(result.reviewable)
+
+ result.reviewable.perform(admin, :disagree)
+ expect(post.reload.reviewable_flag).to be_nil
end
end
diff --git a/spec/models/post_timing_spec.rb b/spec/models/post_timing_spec.rb
index 7027c6b0902..fc095e37c53 100644
--- a/spec/models/post_timing_spec.rb
+++ b/spec/models/post_timing_spec.rb
@@ -89,7 +89,7 @@ describe PostTiming do
end
user2 = Fabricate(:coding_horror, created_at: 1.day.ago)
- PostAction.act(user2, post, PostActionType.types[:like])
+ PostActionCreator.like(user2, post)
expect(post.user.unread_notifications).to eq(1)
diff --git a/spec/models/queued_post_spec.rb b/spec/models/queued_post_spec.rb
deleted file mode 100644
index 90aa85a1ba4..00000000000
--- a/spec/models/queued_post_spec.rb
+++ /dev/null
@@ -1,205 +0,0 @@
-require 'rails_helper'
-require_dependency 'queued_post'
-
-describe QueuedPost do
-
- describe '#states' do
- context "verify enum sequence" do
- before do
- @states = QueuedPost.states
- end
-
- it "'new' should be at 1st position" do
- expect(@states[:new]).to eq(1)
- end
-
- it "'rejected' should be at 3rd position" do
- expect(@states[:rejected]).to eq(3)
- end
- end
- end
-
- context "creating a post" do
- let(:topic) { Fabricate(:topic) }
- let(:user) { Fabricate(:user) }
- let(:admin) { Fabricate(:admin) }
- let(:qp) { Fabricate(:queued_post, topic: topic, user: user) }
-
- it "returns the appropriate options for posting" do
- create_options = qp.create_options
-
- expect(create_options[:topic_id]).to eq(topic.id)
- expect(create_options[:raw]).to eq('This post should be queued up')
- expect(create_options[:reply_to_post_number]).to eq(1)
- expect(create_options[:via_email]).to eq(true)
- expect(create_options[:raw_email]).to eq('store_me')
- expect(create_options[:auto_track]).to eq(true)
- expect(create_options[:custom_fields]).to eq('hello' => 'world')
- expect(create_options[:cooking_options]).to eq(cat: 'hat')
- expect(create_options[:cook_method]).to eq(Post.cook_methods[:raw_html])
- expect(create_options[:not_create_option]).to eq(nil)
- expect(create_options[:image_sizes]).to eq("http://foo.bar/image.png" => { "width" => 0, "height" => 222 })
- end
-
- it "follows the correct workflow for approval" do
- qp.create_pending_action
- post = qp.approve!(admin)
-
- # Creates the post with the attributes
- expect(post).to be_present
- expect(post).to be_valid
- expect(post.topic).to eq(topic)
- expect(post.custom_fields['hello']).to eq('world')
-
- # Updates the QP record
- expect(qp.approved_by).to eq(admin)
- expect(qp.state).to eq(QueuedPost.states[:approved])
- expect(qp.approved_at).to be_present
-
- # It removes the pending action
- expect(UserAction.where(queued_post_id: qp.id).count).to eq(0)
-
- # We can't approve twice
- expect(-> { qp.approve!(admin) }).to raise_error(QueuedPost::InvalidStateTransition)
- end
-
- it "skips validations" do
- qp.post_options[:title] = 'too short'
- post = qp.approve!(admin)
- expect(post).to be_present
- end
-
- it "logs post approvals" do
- qp.approve!(admin)
- expect(UserHistory.where(action: UserHistory.actions[:post_approved]).count).to eq(1)
- end
-
- it "follows the correct workflow for rejection" do
- qp.create_pending_action
- qp.reject!(admin)
-
- # Updates the QP record
- expect(qp.rejected_by).to eq(admin)
- expect(qp.state).to eq(QueuedPost.states[:rejected])
- expect(qp.rejected_at).to be_present
-
- # It removes the pending action
- expect(UserAction.where(queued_post_id: qp.id).count).to eq(0)
-
- # Logs staff action for rejected post
- post_rejected_logs = UserHistory.where(action: UserHistory.actions[:post_rejected])
- expect(post_rejected_logs.count).to eq(1)
- expect(post_rejected_logs.first.details).to include(qp.raw)
-
- # We can't reject twice
- expect(-> { qp.reject!(admin) }).to raise_error(QueuedPost::InvalidStateTransition)
- end
- end
-
- context "creating a topic" do
- let(:user) { Fabricate(:user) }
- let(:admin) { Fabricate(:admin) }
-
- context "with a valid topic" do
- let!(:category) { Fabricate(:category) }
- let(:qp) { QueuedPost.create(queue: 'eviltrout',
- state: QueuedPost.states[:new],
- user_id: user.id,
- raw: 'This post should be queued up',
- post_options: {
- title: 'This is the topic title to queue up',
- archetype: 'regular',
- category: category.id,
- tags: ['evil', 'trout'],
- meta_data: { evil: 'trout' }
- }) }
-
- it "returns the appropriate options for creating a topic" do
- create_options = qp.create_options
-
- expect(create_options[:category]).to eq(category.id)
- expect(create_options[:archetype]).to eq('regular')
- expect(create_options[:meta_data]).to eq('evil' => 'trout')
- end
-
- it "creates the post and topic" do
- SiteSetting.tagging_enabled = true
- SiteSetting.min_trust_level_to_tag_topics = 4
- topic_count, post_count = Topic.count, Post.count
- post = qp.approve!(admin)
-
- expect(Topic.count).to eq(topic_count + 1)
- expect(Post.count).to eq(post_count + 1)
-
- expect(post).to be_present
- expect(post).to be_valid
-
- topic = post.topic
- expect(topic).to be_present
- expect(topic.category).to eq(category)
- expect(topic.tags.map(&:name)).to contain_exactly('evil', 'trout')
-
- expect(UserHistory.where(action: UserHistory.actions[:post_approved]).count).to eq(1)
- end
-
- it "rejecting doesn't create the post and topic" do
- topic_count, post_count = Topic.count, Post.count
-
- qp.reject!(admin)
-
- expect(Topic.count).to eq(topic_count)
- expect(Post.count).to eq(post_count)
- end
- end
- end
-
- context "visibility" do
- it "works as expected in the invisible queue" do
- qp = Fabricate(:queued_post, queue: 'invisible')
- expect(qp).to_not be_visible
- expect(QueuedPost.visible).to_not include(qp)
- expect(QueuedPost.new_count).to eq(0)
- end
-
- it "works as expected in the visible queue" do
- qp = Fabricate(:queued_post, queue: 'default')
- expect(qp).to be_visible
- expect(QueuedPost.visible).to include(qp)
- expect(QueuedPost.new_count).to eq(1)
- end
- end
-
- describe 'create' do
- subject { Fabricate.build(:queued_post) }
-
- it 'triggers a extensibility event' do
- event = DiscourseEvent.track_events { subject.save! }.first
-
- expect(event[:event_name]).to eq(:queued_post_created)
- expect(event[:params].first).to eq(subject)
- end
- end
-
- describe 'approve' do
- subject { Fabricate(:queued_post) }
-
- it 'triggers a extensibility event' do
- event = DiscourseEvent.track_events { subject.approve!(Discourse.system_user) }.last
-
- expect(event[:event_name]).to eq(:approved_post)
- expect(event[:params].first).to eq(subject)
- end
- end
-
- describe 'reject' do
- subject { Fabricate(:queued_post) }
-
- it 'triggers a extensibility event' do
- event = DiscourseEvent.track_events { subject.reject!(Discourse.system_user) }.last
-
- expect(event[:event_name]).to eq(:rejected_post)
- expect(event[:params].first).to eq(subject)
- end
- end
-
-end
diff --git a/spec/models/report_spec.rb b/spec/models/report_spec.rb
index 3fe9898faa5..4efcbead189 100644
--- a/spec/models/report_spec.rb
+++ b/spec/models/report_spec.rb
@@ -162,21 +162,16 @@ describe Report do
context "with #{pluralized}" do
before(:each) do
freeze_time DateTime.parse('2017-03-01 12:00')
- fabricator = case arg
- when :signup
- :user
- when :email
- :email_log
+
+ if arg == :flag
+ user = Fabricate(:user)
+ builder = -> (dt) { PostActionCreator.create(user, Fabricate(:post), :spam, created_at: dt) }
else
- arg
+ factories = { signup: :user, email: :email_log }
+ builder = -> (dt) { Fabricate(factories[arg] || arg, created_at: dt) }
end
- Fabricate(fabricator)
- Fabricate(fabricator, created_at: 1.hours.ago)
- Fabricate(fabricator, created_at: 1.hours.ago)
- Fabricate(fabricator, created_at: 1.day.ago)
- Fabricate(fabricator, created_at: 2.days.ago)
- Fabricate(fabricator, created_at: 30.days.ago)
- Fabricate(fabricator, created_at: 35.days.ago)
+
+ [DateTime.now, 1.hour.ago, 1.hour.ago, 1.day.ago, 2.days.ago, 30.days.ago, 35.days.ago].each(&builder)
end
it "returns today's data" do
@@ -472,17 +467,15 @@ describe Report do
before do
freeze_time DateTime.parse('2017-03-01 12:00')
- UserActionCreator.enable
+ UserActionManager.enable
arpit = Fabricate(:user)
sam = Fabricate(:user)
jeff = Fabricate(:user, created_at: 1.day.ago)
- topic = Fabricate(:topic, user: jeff, created_at: 1.day.ago)
- post = Fabricate(:post, topic: topic, user: jeff, created_at: 1.day.ago)
-
- PostAction.act(arpit, post, PostActionType.types[:like])
- PostAction.act(sam, post, PostActionType.types[:like])
+ post = create_post(user: jeff, created_at: 1.day.ago)
+ PostActionCreator.like(arpit, post)
+ PostActionCreator.like(sam, post)
end
it "returns a report with data" do
@@ -516,7 +509,7 @@ describe Report do
before do
freeze_time
- PostAction.act(flagger, post, PostActionType.types[:spam], message: 'bad')
+ PostActionCreator.new(flagger, post, PostActionType.types[:spam], message: 'bad').perform
end
it "returns a report with data" do
@@ -622,8 +615,8 @@ describe Report do
context "flags" do
before do
flagged_post = Fabricate(:post)
- PostAction.act(jeff, flagged_post, PostActionType.types[:off_topic])
- PostAction.agree_flags!(flagged_post, jeff)
+ result = PostActionCreator.off_topic(jeff, flagged_post)
+ result.reviewable.perform(jeff, :agree_and_keep)
end
it "returns the correct flag counts" do
@@ -753,12 +746,10 @@ describe Report do
post1 = Fabricate(:post, topic: Fabricate(:topic, category: c1))
post2 = Fabricate(:post)
post3 = Fabricate(:post)
- PostAction.act(user, post0, PostActionType.types[:off_topic])
- PostAction.act(user, post1, PostActionType.types[:off_topic])
- PostAction.act(user, post2, PostActionType.types[:off_topic])
- PostAction.act(user, post3, PostActionType.types[:off_topic]).tap do |pa|
- pa.created_at = 45.days.ago
- end.save
+ PostActionCreator.off_topic(user, post0)
+ PostActionCreator.off_topic(user, post1)
+ PostActionCreator.off_topic(user, post2)
+ PostActionCreator.create(user, post3, :off_topic, created_at: 45.days.ago)
end
context "with category filtering" do
@@ -936,13 +927,13 @@ describe Report do
before(:each) do
topic = Fabricate(:topic, category: c1)
post = Fabricate(:post, topic: topic)
- PostAction.act(Fabricate(:user), post, PostActionType.types[:like])
+ PostActionCreator.like(Fabricate(:user), post)
topic = Fabricate(:topic, category: c2)
post = Fabricate(:post, topic: topic)
- PostAction.act(Fabricate(:user), post, PostActionType.types[:like])
- PostAction.act(Fabricate(:user), post, PostActionType.types[:like])
- PostAction.act(Fabricate(:user), post, PostActionType.types[:like]).tap do |pa|
+ PostActionCreator.like(Fabricate(:user), post)
+ PostActionCreator.like(Fabricate(:user), post)
+ PostActionCreator.like(Fabricate(:user), post).post_action.tap do |pa|
pa.created_at = 45.days.ago
end.save!
end
@@ -970,18 +961,18 @@ describe Report do
it "it works" do
10.times do
post_disagreed = Fabricate(:post)
- PostAction.act(joffrey, post_disagreed, PostActionType.types[:spam])
- PostAction.clear_flags!(post_disagreed, moderator)
+ result = PostActionCreator.spam(joffrey, post_disagreed)
+ result.reviewable.perform(moderator, :disagree)
end
3.times do
post_disagreed = Fabricate(:post)
- PostAction.act(robin, post_disagreed, PostActionType.types[:spam])
- PostAction.clear_flags!(post_disagreed, moderator)
+ result = PostActionCreator.spam(robin, post_disagreed)
+ result.reviewable.perform(moderator, :disagree)
end
post_agreed = Fabricate(:post)
- PostAction.act(robin, post_agreed, PostActionType.types[:off_topic])
- PostAction.agree_flags!(post_agreed, moderator)
+ result = PostActionCreator.off_topic(robin, post_agreed)
+ result.reviewable.perform(moderator, :agree_and_keep)
report = Report.find('user_flagging_ratio')
diff --git a/spec/models/reviewable_flagged_post_spec.rb b/spec/models/reviewable_flagged_post_spec.rb
new file mode 100644
index 00000000000..0faf8d2527c
--- /dev/null
+++ b/spec/models/reviewable_flagged_post_spec.rb
@@ -0,0 +1,199 @@
+require 'rails_helper'
+
+RSpec.describe ReviewableFlaggedPost, type: :model do
+
+ def pending_count
+ ReviewableFlaggedPost.default_visible.pending.count
+ end
+
+ let(:user) { Fabricate(:user) }
+ let(:post) { Fabricate(:post) }
+ let(:moderator) { Fabricate(:moderator) }
+
+ it "sets `potential_spam` when a spam flag is added" do
+ reviewable = PostActionCreator.off_topic(user, post).reviewable
+ expect(reviewable.potential_spam?).to eq(false)
+ PostActionCreator.spam(Fabricate(:user), post)
+ expect(reviewable.reload.potential_spam?).to eq(true)
+ end
+
+ describe "actions" do
+ let!(:result) { PostActionCreator.spam(user, post) }
+ let(:reviewable) { result.reviewable }
+ let(:score) { result.reviewable_score }
+ let(:guardian) { Guardian.new(moderator) }
+
+ describe "actions_for" do
+ it "returns appropriate defaults" do
+ actions = reviewable.actions_for(guardian)
+ expect(actions.has?(:agree_and_hide)).to eq(true)
+ expect(actions.has?(:agree_and_keep)).to eq(true)
+ expect(actions.has?(:agree_and_silence)).to eq(true)
+ expect(actions.has?(:agree_and_suspend)).to eq(true)
+ expect(actions.has?(:delete_spammer)).to eq(true)
+ expect(actions.has?(:disagree)).to eq(true)
+ expect(actions.has?(:ignore)).to eq(true)
+ expect(actions.has?(:delete_and_ignore)).to eq(true)
+ expect(actions.has?(:delete_and_agree)).to eq(true)
+
+ expect(actions.has?(:disagree_and_restore)).to eq(false)
+ end
+
+ it "returns `agree_and_restore` if the post is user deleted" do
+ post.update(user_deleted: true)
+ expect(reviewable.actions_for(guardian).has?(:agree_and_restore)).to eq(true)
+ end
+
+ it "returns appropriate actions for a hidden post" do
+ post.update(hidden: true, hidden_at: Time.now)
+ expect(reviewable.actions_for(guardian).has?(:agree_and_hide)).to eq(false)
+ expect(reviewable.actions_for(guardian).has?(:disagree_and_restore)).to eq(true)
+ end
+
+ it "won't return the penalty options if the user is not regular" do
+ post.user.update(moderator: true)
+ expect(reviewable.actions_for(guardian).has?(:agree_and_silence)).to eq(false)
+ expect(reviewable.actions_for(guardian).has?(:agree_and_suspend)).to eq(false)
+ end
+ end
+
+ it "agree_and_keep agrees with the flags and keeps the post" do
+ reviewable.perform(moderator, :agree_and_keep)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post).not_to be_hidden
+ end
+
+ it "agree_and_suspend agrees with the flags and keeps the post" do
+ reviewable.perform(moderator, :agree_and_suspend)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post).not_to be_hidden
+ end
+
+ it "agree_and_silence agrees with the flags and keeps the post" do
+ reviewable.perform(moderator, :agree_and_silence)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post).not_to be_hidden
+ end
+
+ it "agree_and_hide agrees with the flags and hides the post" do
+ reviewable.perform(moderator, :agree_and_hide)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post).to be_hidden
+ end
+
+ it "agree_and_restore agrees with the flags and restores the post" do
+ post.update(user_deleted: true)
+ reviewable.perform(moderator, :agree_and_restore)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post.user_deleted?).to eq(false)
+ end
+
+ it "supports deleting a spammer" do
+ reviewable.perform(moderator, :delete_spammer)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post.reload.deleted_at).to be_present
+ expect(User.find_by(id: reviewable.target_created_by_id)).to be_blank
+ end
+
+ it "ignores the flags" do
+ reviewable.perform(moderator, :ignore)
+ expect(reviewable).to be_ignored
+ expect(score.reload).to be_ignored
+ end
+
+ it "delete_and_defer ignores the flags and deletes post" do
+ reviewable.perform(moderator, :delete_and_ignore)
+ expect(reviewable).to be_ignored
+ expect(score.reload).to be_ignored
+ expect(post.reload.deleted_at).to be_present
+ end
+
+ it "delete_and_agree agrees with the flags and deletes post" do
+ reviewable.perform(moderator, :delete_and_agree)
+ expect(reviewable).to be_approved
+ expect(score.reload).to be_agreed
+ expect(post.reload.deleted_at).to be_present
+ end
+
+ it "disagrees with the flags" do
+ reviewable.perform(moderator, :disagree)
+ expect(reviewable).to be_rejected
+ expect(score.reload).to be_disagreed
+ end
+
+ it "disagrees with the flags and restores the post" do
+ post.update(hidden: true, hidden_at: Time.now)
+ reviewable.perform(moderator, :disagree_and_restore)
+ expect(reviewable).to be_rejected
+ expect(score.reload).to be_disagreed
+ expect(post.user_deleted?).to eq(false)
+ end
+
+ end
+
+ describe "pending count" do
+ it "increments the numbers correctly" do
+ expect(pending_count).to eq(0)
+
+ result = PostActionCreator.off_topic(user, post)
+ expect(pending_count).to eq(1)
+
+ result.reviewable.perform(Discourse.system_user, :disagree)
+ expect(pending_count).to eq(0)
+ end
+
+ it "respects min_score_default_visibility" do
+ SiteSetting.min_score_default_visibility = 7.5
+ expect(pending_count).to eq(0)
+
+ PostActionCreator.off_topic(user, post)
+ expect(pending_count).to eq(0)
+
+ PostActionCreator.spam(moderator, post)
+ expect(pending_count).to eq(1)
+ end
+
+ it "should reset counts when a topic is deleted" do
+ PostActionCreator.off_topic(user, post)
+ expect(pending_count).to eq(1)
+
+ PostDestroyer.new(moderator, post).destroy
+ expect(pending_count).to eq(0)
+ end
+
+ it "should not review non-human users" do
+ post = create_post(user: Discourse.system_user)
+ reviewable = PostActionCreator.off_topic(user, post).reviewable
+ expect(reviewable).to be_blank
+ expect(pending_count).to eq(0)
+ end
+
+ it "should ignore handled flags" do
+ post = create_post
+ reviewable = PostActionCreator.off_topic(user, post).reviewable
+ expect(post.hidden).to eq(false)
+ expect(post.hidden_at).to be_blank
+
+ reviewable.perform(moderator, :ignore)
+ expect(pending_count).to eq(0)
+
+ post.reload
+ expect(post.hidden).to eq(false)
+ expect(post.hidden_at).to be_blank
+
+ post.hide!(PostActionType.types[:off_topic])
+
+ post.reload
+ expect(post.hidden).to eq(true)
+ expect(post.hidden_at).to be_present
+ end
+
+ end
+
+end
diff --git a/spec/models/reviewable_history_spec.rb b/spec/models/reviewable_history_spec.rb
new file mode 100644
index 00000000000..743d2f85654
--- /dev/null
+++ b/spec/models/reviewable_history_spec.rb
@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+RSpec.describe ReviewableHistory, type: :model do
+
+ let(:user) { Fabricate(:user) }
+ let(:admin) { Fabricate(:admin) }
+ let(:moderator) { Fabricate(:moderator) }
+
+ it "adds a `created` history event when a reviewable is created" do
+ reviewable = ReviewableUser.needs_review!(target: user, created_by: admin)
+ reviewable.perform(moderator, :approve)
+ reviewable = ReviewableUser.needs_review!(target: user, created_by: admin)
+
+ history = reviewable.history
+ expect(history.size).to eq(3)
+
+ expect(history[0].reviewable_history_type).to eq(ReviewableHistory.types[:created])
+ expect(history[0].status).to eq(Reviewable.statuses[:pending])
+ expect(history[0].created_by).to eq(admin)
+ end
+
+ it "adds a `transitioned` event when transitioning" do
+ reviewable = ReviewableUser.needs_review!(target: user, created_by: admin)
+ reviewable.perform(moderator, :approve)
+ reviewable = ReviewableUser.needs_review!(target: user, created_by: admin)
+
+ history = reviewable.history
+ expect(history.size).to eq(3)
+ expect(history[1].reviewable_history_type).to eq(ReviewableHistory.types[:transitioned])
+ expect(history[1].status).to eq(Reviewable.statuses[:approved])
+ expect(history[1].created_by).to eq(moderator)
+
+ expect(history[2].reviewable_history_type).to eq(ReviewableHistory.types[:transitioned])
+ expect(history[2].status).to eq(Reviewable.statuses[:pending])
+ expect(history[2].created_by).to eq(admin)
+ end
+
+ it "adds an `edited` event when edited" do
+ reviewable = Fabricate(:reviewable)
+ old_category = reviewable.category
+
+ reviewable.update_fields({ category_id: nil }, moderator)
+
+ history = reviewable.history
+ expect(history.size).to eq(2)
+
+ expect(history[1].reviewable_history_type).to eq(ReviewableHistory.types[:edited])
+ expect(history[1].created_by).to eq(moderator)
+ expect(history[1].edited).to eq("category_id" => [old_category.id, nil])
+ end
+
+end
diff --git a/spec/models/reviewable_queued_post_spec.rb b/spec/models/reviewable_queued_post_spec.rb
new file mode 100644
index 00000000000..17cba67f6ed
--- /dev/null
+++ b/spec/models/reviewable_queued_post_spec.rb
@@ -0,0 +1,170 @@
+require 'rails_helper'
+
+RSpec.describe ReviewableQueuedPost, type: :model do
+
+ let!(:category) { Fabricate(:category) }
+ let(:moderator) { Fabricate(:moderator) }
+
+ context "creating a post" do
+ let!(:topic) { Fabricate(:topic, category: category) }
+ let(:reviewable) { Fabricate(:reviewable_queued_post, topic: topic) }
+
+ context "create" do
+ it "triggers queued_post_created" do
+ event = DiscourseEvent.track(:queued_post_created) { reviewable.save! }
+ expect(event).to be_present
+ expect(event[:params][0]).to eq(reviewable)
+ end
+
+ it "returns the appropriate create options" do
+ create_options = reviewable.create_options
+
+ expect(create_options[:topic_id]).to eq(topic.id)
+ expect(create_options[:raw]).to eq('hello world post contents.')
+ expect(create_options[:reply_to_post_number]).to eq(1)
+ expect(create_options[:via_email]).to eq(true)
+ expect(create_options[:raw_email]).to eq('store_me')
+ expect(create_options[:auto_track]).to eq(true)
+ expect(create_options[:custom_fields]).to eq('hello' => 'world')
+ expect(create_options[:cooking_options]).to eq(cat: 'hat')
+ expect(create_options[:cook_method]).to eq(Post.cook_methods[:raw_html])
+ expect(create_options[:not_create_option]).to eq(nil)
+ expect(create_options[:image_sizes]).to eq("http://foo.bar/image.png" => { "width" => 0, "height" => 222 })
+ end
+ end
+
+ context "actions" do
+
+ context "approve" do
+ it 'triggers an extensibility event' do
+ event = DiscourseEvent.track(:approved_post) { reviewable.perform(moderator, :approve) }
+ expect(event).to be_present
+ expect(event[:params].first).to eq(reviewable)
+ end
+
+ it "creates a post" do
+ topic_count, post_count = Topic.count, Post.count
+ result = reviewable.perform(moderator, :approve)
+ expect(result.success?).to eq(true)
+ expect(result.created_post).to be_present
+ expect(result.created_post).to be_valid
+ expect(result.created_post.topic).to eq(topic)
+ expect(result.created_post.custom_fields['hello']).to eq('world')
+ expect(result.created_post_topic).to eq(topic)
+ expect(result.created_post.user).to eq(reviewable.created_by)
+ expect(reviewable.payload['created_post_id']).to eq(result.created_post.id)
+
+ expect(Topic.count).to eq(topic_count)
+ expect(Post.count).to eq(post_count + 1)
+
+ # We can't approve twice
+ expect(-> { reviewable.perform(moderator, :approve) }).to raise_error(Reviewable::InvalidAction)
+ end
+
+ it "skips validations" do
+ reviewable.payload['raw'] = 'x'
+ result = reviewable.perform(moderator, :approve)
+ expect(result.created_post).to be_present
+ end
+
+ it "Allows autosilenced users to post" do
+ newuser = reviewable.created_by
+ newuser.update!(trust_level: 0)
+ post = Fabricate(:post, user: newuser)
+ PostActionCreator.spam(moderator, post)
+ SiteSetting.spam_score_to_silence_new_user = 1
+ SiteSetting.num_users_to_silence_new_user = 1
+ expect(Guardian.new(newuser).can_create_post?(topic)).to eq(false)
+
+ result = reviewable.perform(moderator, :approve)
+ expect(result.success?).to eq(true)
+ end
+
+ end
+
+ context "reject" do
+ it 'triggers an extensibility event' do
+ event = DiscourseEvent.track(:rejected_post) { reviewable.perform(moderator, :reject) }
+ expect(event).to be_present
+ expect(event[:params].first).to eq(reviewable)
+ end
+
+ it "doesn't create a post" do
+ post_count = Post.count
+ result = reviewable.perform(moderator, :reject)
+ expect(result.success?).to eq(true)
+ expect(result.created_post).to be_nil
+ expect(Post.count).to eq(post_count)
+
+ # We can't reject twice
+ expect(-> { reviewable.perform(moderator, :reject) }).to raise_error(Reviewable::InvalidAction)
+ end
+ end
+
+ context "delete_user" do
+ it "deletes the user and rejects the post" do
+ other_reviewable = Fabricate(:reviewable_queued_post, created_by: reviewable.created_by)
+
+ result = reviewable.perform(moderator, :delete_user)
+ expect(result.success?).to eq(true)
+ expect(User.find_by(id: reviewable.created_by)).to be_blank
+ expect(result.remove_reviewable_ids).to include(reviewable.id)
+ expect(result.remove_reviewable_ids).to include(other_reviewable.id)
+
+ expect(ReviewableQueuedPost.where(id: reviewable.id)).to be_blank
+ expect(ReviewableQueuedPost.where(id: other_reviewable.id)).to be_blank
+ end
+ end
+ end
+ end
+
+ context "creating a topic" do
+ let(:reviewable) { Fabricate(:reviewable_queued_post_topic, category: category) }
+
+ context "editing" do
+ let(:guardian) { Guardian.new(moderator) }
+
+ it "is editable and returns the fields" do
+ fields = reviewable.editable_for(guardian)
+ expect(fields.has?('category_id')).to eq(true)
+ expect(fields.has?('payload.raw')).to eq(true)
+ expect(fields.has?('payload.title')).to eq(true)
+ expect(fields.has?('payload.tags')).to eq(true)
+ end
+ end
+
+ it "returns the appropriate create options for a topic" do
+ create_options = reviewable.create_options
+ expect(create_options[:category]).to eq(reviewable.category.id)
+ expect(create_options[:archetype]).to eq('regular')
+ end
+
+ it "creates the post and topic when approved" do
+ topic_count, post_count = Topic.count, Post.count
+ result = reviewable.perform(moderator, :approve)
+
+ expect(result.success?).to eq(true)
+ expect(result.created_post).to be_present
+ expect(result.created_post).to be_valid
+ expect(result.created_post_topic).to be_present
+ expect(result.created_post_topic).to be_valid
+ expect(reviewable.payload['created_post_id']).to eq(result.created_post.id)
+ expect(reviewable.payload['created_topic_id']).to eq(result.created_post_topic.id)
+
+ expect(Topic.count).to eq(topic_count + 1)
+ expect(Post.count).to eq(post_count + 1)
+ end
+
+ it "creates the post and topic when rejected" do
+ topic_count, post_count = Topic.count, Post.count
+ result = reviewable.perform(moderator, :reject)
+
+ expect(result.success?).to eq(true)
+ expect(result.created_post).to be_blank
+ expect(result.created_post_topic).to be_blank
+
+ expect(Topic.count).to eq(topic_count)
+ expect(Post.count).to eq(post_count)
+ end
+ end
+end
diff --git a/spec/models/reviewable_score_spec.rb b/spec/models/reviewable_score_spec.rb
new file mode 100644
index 00000000000..b32d5a7250e
--- /dev/null
+++ b/spec/models/reviewable_score_spec.rb
@@ -0,0 +1,143 @@
+require 'rails_helper'
+
+RSpec.describe ReviewableScore, type: :model do
+
+ context "transitions" do
+ let(:user) { Fabricate(:user, trust_level: 3) }
+ let(:post) { Fabricate(:post) }
+ let(:moderator) { Fabricate(:moderator) }
+
+ it "scores agreements properly" do
+ reviewable = PostActionCreator.off_topic(user, post).reviewable
+ rs = reviewable.reviewable_scores.find_by(user: user)
+ expect(rs.score).to eq(4.0)
+ expect(reviewable.score).to eq(4.0)
+ expect(reviewable.latest_score).to be_present
+
+ reviewable.perform(moderator, :agree_and_keep)
+ expect(rs.reload).to be_agreed
+ expect(rs.reviewed_by).to eq(moderator)
+ expect(rs.reviewed_at).to be_present
+ expect(reviewable.score).to eq(4.0)
+ end
+
+ it "scores disagreements properly" do
+ reviewable = PostActionCreator.spam(user, post).reviewable
+ rs = reviewable.reviewable_scores.find_by(user: user)
+ expect(rs).to be_pending
+ expect(rs.score).to eq(4.0)
+ expect(reviewable.score).to eq(4.0)
+ expect(reviewable.latest_score).to be_present
+
+ reviewable.perform(moderator, :disagree)
+ expect(rs.reload).to be_disagreed
+ expect(rs.reviewed_by).to eq(moderator)
+ expect(rs.reviewed_at).to be_present
+ expect(reviewable.score).to eq(4.0)
+ end
+
+ it "increases the score by the post action type's score bonus" do
+ PostActionType.where(name_key: 'spam').update_all(score_bonus: 2.25)
+ reviewable = PostActionCreator.spam(user, post).reviewable
+ score = reviewable.reviewable_scores.find_by(user: user)
+ expect(score).to be_pending
+ expect(score.score).to eq(6.25)
+ expect(reviewable.score).to eq(6.25)
+ end
+ end
+
+ describe "overall score" do
+ let(:user0) { Fabricate(:user, trust_level: 1) }
+ let(:user1) { Fabricate(:user, trust_level: 2) }
+ let(:user2) { Fabricate(:user, trust_level: 3) }
+ let(:moderator) { Fabricate(:moderator) }
+ let(:post) { Fabricate(:post) }
+ let(:topic) { post.topic }
+
+ it "gives a bonus for take_action" do
+ result = PostActionCreator.new(
+ moderator,
+ post,
+ PostActionType.types[:spam],
+ take_action: true
+ ).perform
+
+ expect(result.reviewable_score.take_action_bonus).to eq(5.0)
+ expect(result.reviewable.score).to eq(11.0)
+ expect(topic.reviewable_score).to eq(11.0)
+ end
+
+ it "is the total of the pending reviewable scores" do
+ reviewable = PostActionCreator.spam(user0, post).reviewable
+ expect(reviewable.score).to eq(2.0)
+ expect(topic.reload.reviewable_score).to eq(2.0)
+
+ reviewable = PostActionCreator.inappropriate(user1, post).reviewable
+ expect(reviewable.score).to eq(5.0)
+ expect(topic.reload.reviewable_score).to eq(5.0)
+
+ reviewable.perform(Discourse.system_user, :agree_and_keep)
+ expect(reviewable.score).to eq(5.0)
+ expect(topic.reload.reviewable_score).to eq(5.0)
+
+ reviewable = PostActionCreator.off_topic(user2, post).reviewable
+ expect(reviewable.score).to eq(9.0)
+ expect(topic.reload.reviewable_score).to eq(9.0)
+ end
+ end
+
+ describe ".user_accuracy_bonus" do
+ let(:user) { Fabricate(:user) }
+ let(:user_stat) { user.user_stat }
+
+ it "returns 0 for a user with no flags" do
+ expect(ReviewableScore.user_accuracy_bonus(user)).to eq(0.0)
+ end
+
+ it "returns 0 until the user has made more than 5 flags" do
+ user_stat.flags_agreed = 4
+ user_stat.flags_disagreed = 1
+ expect(ReviewableScore.user_accuracy_bonus(user)).to eq(0.0)
+ end
+
+ it "returns (agreed_flags / total) * 5.0" do
+ user_stat.flags_agreed = 4
+ user_stat.flags_disagreed = 2
+ expect(ReviewableScore.user_accuracy_bonus(user).floor(2)).to eq(3.33)
+
+ user_stat.flags_agreed = 121
+ user_stat.flags_disagreed = 44
+ user_stat.flags_ignored = 4
+ expect(ReviewableScore.user_accuracy_bonus(user).floor(2)).to eq(3.57)
+ end
+
+ end
+
+ describe ".user_flag_score" do
+ context "a user with no flags" do
+ it "returns 1.0 + trust_level" do
+ expect(ReviewableScore.user_flag_score(Fabricate.build(:user, trust_level: 2))).to eq(3.0)
+ expect(ReviewableScore.user_flag_score(Fabricate.build(:user, trust_level: 3))).to eq(4.0)
+ end
+
+ it "returns 6.0 for staff" do
+ expect(ReviewableScore.user_flag_score(Fabricate.build(:moderator, trust_level: 2))).to eq(6.0)
+ expect(ReviewableScore.user_flag_score(Fabricate.build(:admin, trust_level: 1))).to eq(6.0)
+ end
+ end
+
+ context "a user with some flags" do
+ let(:user) { Fabricate(:user) }
+ let(:user_stat) { user.user_stat }
+
+ it "returns 1.0 + trust_level + accuracy_bonus" do
+ user.trust_level = 2
+ user_stat.flags_agreed = 12
+ user_stat.flags_disagreed = 2
+ user_stat.flags_ignored = 2
+ expect(ReviewableScore.user_flag_score(user)).to eq(6.75)
+ end
+ end
+ end
+
+end
diff --git a/spec/models/reviewable_spec.rb b/spec/models/reviewable_spec.rb
new file mode 100644
index 00000000000..777219db046
--- /dev/null
+++ b/spec/models/reviewable_spec.rb
@@ -0,0 +1,260 @@
+require 'rails_helper'
+
+RSpec.describe Reviewable, type: :model do
+
+ context ".create" do
+ let(:admin) { Fabricate(:admin) }
+ let(:user) { Fabricate(:user) }
+
+ let(:reviewable) { Fabricate.build(:reviewable, created_by: admin) }
+ let(:queued_post) { Fabricate.build(:reviewable_queued_post) }
+
+ it "can create a reviewable object" do
+ expect(reviewable).to be_present
+ expect(reviewable.pending?).to eq(true)
+ expect(reviewable.created_by).to eq(admin)
+
+ expect(reviewable.editable_for(Guardian.new(admin))).to be_blank
+
+ expect(reviewable.payload).to be_present
+ expect(reviewable.version).to eq(0)
+ expect(reviewable.payload['name']).to eq('bandersnatch')
+ expect(reviewable.payload['list']).to eq([1, 2, 3])
+ end
+
+ it "can add a target" do
+ reviewable.target = user
+ reviewable.save!
+
+ expect(reviewable.target_type).to eq('User')
+ expect(reviewable.target_id).to eq(user.id)
+ expect(reviewable.target).to eq(user)
+ end
+ end
+
+ context ".needs_review!" do
+ let(:admin) { Fabricate(:admin) }
+ let(:user) { Fabricate(:user) }
+
+ it "will return a new reviewable the first them, and re-use the second time" do
+ r0 = ReviewableUser.needs_review!(target: user, created_by: admin)
+ expect(r0).to be_present
+
+ r0.update_column(:status, Reviewable.statuses[:approved])
+
+ r1 = ReviewableUser.needs_review!(target: user, created_by: admin)
+ expect(r1.id).to eq(r0.id)
+ expect(r1.pending?).to eq(true)
+ end
+
+ it "will add a topic and category from a post" do
+ post = Fabricate(:post)
+ reviewable = ReviewableFlaggedPost.needs_review!(target: post, created_by: Fabricate(:user))
+ expect(reviewable.topic).to eq(post.topic)
+ expect(reviewable.category).to eq(post.topic.category)
+ end
+
+ it "can create multiple objects with a NULL target" do
+ r0 = ReviewableQueuedPost.needs_review!(created_by: admin, payload: { raw: 'hello world I am a post' })
+ expect(r0).to be_present
+ r0.update_column(:status, Reviewable.statuses[:approved])
+
+ r1 = ReviewableQueuedPost.needs_review!(created_by: admin, payload: { raw: "another post's contents" })
+
+ expect(ReviewableQueuedPost.count).to eq(2)
+ expect(r1.id).not_to eq(r0.id)
+ expect(r1.pending?).to eq(true)
+ expect(r0.pending?).to eq(false)
+ end
+ end
+
+ context ".list_for" do
+ let(:user) { Fabricate(:user) }
+
+ it "returns an empty list for nil user" do
+ expect(Reviewable.list_for(nil)).to eq([])
+ end
+
+ context "with a pending item" do
+ let(:post) { Fabricate(:post) }
+ let(:reviewable) { Fabricate(:reviewable, target: post) }
+
+ it "works with the reviewable by moderator flag" do
+ reviewable.reviewable_by_moderator = true
+ reviewable.save!
+
+ expect(Reviewable.list_for(user, status: :pending)).to be_empty
+ user.update_column(:moderator, true)
+ expect(Reviewable.list_for(user, status: :pending)).to eq([reviewable])
+
+ # Admins can review everything
+ user.update_columns(moderator: false, admin: true)
+ expect(Reviewable.list_for(user, status: :pending)).to eq([reviewable])
+ end
+
+ it "works with the reviewable by group" do
+ group = Fabricate(:group)
+ reviewable.reviewable_by_group_id = group.id
+ reviewable.save!
+
+ expect(Reviewable.list_for(user, status: :pending)).to be_empty
+ gu = GroupUser.create!(group_id: group.id, user_id: user.id)
+ expect(Reviewable.list_for(user, status: :pending)).to eq([reviewable])
+
+ # Admins can review everything
+ gu.destroy
+ user.update_columns(moderator: false, admin: true)
+ expect(Reviewable.list_for(user, status: :pending)).to eq([reviewable])
+ end
+
+ context 'Reviewing as an admin' do
+ before { user.update_columns(moderator: false, admin: true) }
+
+ it 'can filter by the target_created_by_id attribute' do
+ different_reviewable = Fabricate(:reviewable)
+ reviewables = Reviewable.list_for(user, username: different_reviewable.target_created_by.username)
+ expect(reviewables).to include(different_reviewable)
+ reviewables = Reviewable.list_for(user, username: user.username)
+ expect(reviewables).not_to include(different_reviewable)
+ end
+
+ it 'can filter by the created_by_id attribute if there is no target' do
+ qp = Fabricate(:reviewable_queued_post)
+ reviewables = Reviewable.list_for(user, username: qp.created_by.username)
+ expect(reviewables).to include(qp)
+ reviewables = Reviewable.list_for(user, username: user.username)
+ expect(reviewables).not_to include(qp)
+ end
+
+ it 'Does not filter by status when status parameter is set to all' do
+ rejected_reviewable = Fabricate(:reviewable, target: post, status: Reviewable.statuses[:rejected])
+
+ reviewables = Reviewable.list_for(user, status: :all)
+
+ expect(reviewables).to match_array [reviewable, rejected_reviewable]
+ end
+ end
+ end
+
+ context "with a category restriction" do
+ let(:category) { Fabricate(:category, read_restricted: true) }
+ let(:topic) { Fabricate(:topic, category: category) }
+ let(:post) { Fabricate(:post, topic: topic) }
+ let!(:moderator) { Fabricate(:moderator) }
+ let(:admin) { Fabricate(:admin) }
+
+ it "respects category id on the reviewable" do
+ Group.refresh_automatic_group!(:staff)
+
+ reviewable = ReviewableFlaggedPost.needs_review!(
+ target: post,
+ created_by: Fabricate(:user),
+ reviewable_by_moderator: true
+ )
+ expect(reviewable.category).to eq(category)
+ expect(Reviewable.list_for(moderator)).not_to include(reviewable)
+ expect(Reviewable.list_for(admin)).to include(reviewable)
+
+ category.set_permissions(staff: :full)
+ category.save
+
+ expect(Reviewable.list_for(moderator)).to include(reviewable)
+ end
+ end
+
+ end
+
+ it "valid_types returns the appropriate types" do
+ expect(Reviewable.valid_type?('ReviewableUser')).to eq(true)
+ expect(Reviewable.valid_type?('ReviewableQueuedPost')).to eq(true)
+ expect(Reviewable.valid_type?('ReviewableFlaggedPost')).to eq(true)
+ expect(Reviewable.valid_type?(nil)).to eq(false)
+ expect(Reviewable.valid_type?("")).to eq(false)
+ expect(Reviewable.valid_type?("Reviewable")).to eq(false)
+ expect(Reviewable.valid_type?("ReviewableDoesntExist")).to eq(false)
+ expect(Reviewable.valid_type?("User")).to eq(false)
+ end
+
+ context "events" do
+ let!(:moderator) { Fabricate(:moderator) }
+ let(:reviewable) { Fabricate(:reviewable) }
+
+ it "triggers events on create, transition_to" do
+ event = DiscourseEvent.track(:reviewable_created) { reviewable.save! }
+ expect(event).to be_present
+ expect(event[:params].first).to eq(reviewable)
+
+ event = DiscourseEvent.track(:reviewable_transitioned_to) do
+ reviewable.transition_to(:approved, moderator)
+ end
+ expect(event).to be_present
+ expect(event[:params][0]).to eq(:approved)
+ expect(event[:params][1]).to eq(reviewable)
+ end
+ end
+
+ context "message bus notifications" do
+ let(:moderator) { Fabricate(:moderator) }
+
+ it "triggers a notification on create" do
+ Jobs.expects(:enqueue).with(:notify_reviewable, has_key(:reviewable_id))
+ Fabricate(:reviewable_queued_post)
+ end
+
+ it "triggers a notification on pending -> approve" do
+ reviewable = Fabricate(:reviewable_queued_post)
+ Jobs.expects(:enqueue).with(:notify_reviewable, has_key(:reviewable_id))
+ reviewable.perform(moderator, :approve)
+ end
+
+ it "triggers a notification on pending -> reject" do
+ reviewable = Fabricate(:reviewable_queued_post)
+ Jobs.expects(:enqueue).with(:notify_reviewable, has_key(:reviewable_id))
+ reviewable.perform(moderator, :reject)
+ end
+
+ it "doesn't trigger a notification on approve -> reject" do
+ reviewable = Fabricate(:reviewable_queued_post, status: Reviewable.statuses[:approved])
+ Jobs.expects(:enqueue).with(:notify_reviewable, has_key(:reviewable_id)).never
+ reviewable.perform(moderator, :reject)
+ end
+
+ it "doesn't trigger a notification on reject -> approve" do
+ reviewable = Fabricate(:reviewable_queued_post, status: Reviewable.statuses[:approved])
+ Jobs.expects(:enqueue).with(:notify_reviewable, has_key(:reviewable_id)).never
+ reviewable.perform(moderator, :reject)
+ end
+ end
+
+ describe "flag_stats" do
+ let(:user) { Fabricate(:user) }
+ let(:post) { Fabricate(:post) }
+ let(:reviewable) { PostActionCreator.spam(user, post).reviewable }
+
+ it "increases flags_agreed when agreed" do
+ expect(user.user_stat.flags_agreed).to eq(0)
+ reviewable.perform(Discourse.system_user, :agree_and_keep)
+ expect(user.user_stat.reload.flags_agreed).to eq(1)
+ end
+
+ it "increases flags_disagreed when disagreed" do
+ expect(user.user_stat.flags_disagreed).to eq(0)
+ reviewable.perform(Discourse.system_user, :disagree)
+ expect(user.user_stat.reload.flags_disagreed).to eq(1)
+ end
+
+ it "increases flags_ignored when ignored" do
+ expect(user.user_stat.flags_ignored).to eq(0)
+ reviewable.perform(Discourse.system_user, :ignore)
+ expect(user.user_stat.reload.flags_ignored).to eq(1)
+ end
+
+ it "doesn't increase stats when you flag yourself" do
+ expect(user.user_stat.flags_agreed).to eq(0)
+ user_post = Fabricate(:post, user: user)
+ self_flag = PostActionCreator.spam(user, user_post).reviewable
+ self_flag.perform(Discourse.system_user, :agree_and_keep)
+ expect(user.user_stat.reload.flags_agreed).to eq(0)
+ end
+ end
+end
diff --git a/spec/models/reviewable_user_spec.rb b/spec/models/reviewable_user_spec.rb
new file mode 100644
index 00000000000..f35edff669e
--- /dev/null
+++ b/spec/models/reviewable_user_spec.rb
@@ -0,0 +1,123 @@
+require 'rails_helper'
+
+RSpec.describe ReviewableUser, type: :model do
+
+ let(:moderator) { Fabricate(:moderator) }
+ let(:user) { Fabricate(:user) }
+ let(:admin) { Fabricate(:admin) }
+
+ context "actions_for" do
+ let(:reviewable) { Fabricate(:reviewable) }
+ it "returns approve/disapprove in the pending state" do
+ actions = reviewable.actions_for(Guardian.new(moderator))
+ expect(actions.has?(:approve)).to eq(true)
+ expect(actions.has?(:reject)).to eq(true)
+ end
+
+ it "doesn't return anything in the approved state" do
+ reviewable.status = Reviewable.statuses[:approved]
+ actions = reviewable.actions_for(Guardian.new(moderator))
+ expect(actions.has?(:approve)).to eq(false)
+ expect(actions.has?(:reject)).to eq(false)
+ end
+ end
+
+ context "#update_fields" do
+ let(:moderator) { Fabricate(:moderator) }
+ let(:reviewable) { Fabricate(:reviewable) }
+
+ it "doesn't raise errors with an empty update" do
+ expect(reviewable.update_fields(nil, moderator)).to eq(true)
+ expect(reviewable.update_fields({}, moderator)).to eq(true)
+ end
+ end
+
+ context "perform" do
+ let(:reviewable) { Fabricate(:reviewable) }
+ context "approve" do
+ it "allows us to approve a user" do
+ result = reviewable.perform(moderator, :approve)
+ expect(result.success?).to eq(true)
+
+ expect(reviewable.pending?).to eq(false)
+ expect(reviewable.approved?).to eq(true)
+ expect(reviewable.target.approved?).to eq(true)
+ expect(reviewable.target.approved_by_id).to eq(moderator.id)
+ expect(reviewable.target.approved_at).to be_present
+ expect(reviewable.version > 0).to eq(true)
+ end
+
+ it "allows us to reject a user" do
+ result = reviewable.perform(moderator, :reject)
+ expect(result.success?).to eq(true)
+
+ expect(reviewable.pending?).to eq(false)
+ expect(reviewable.rejected?).to eq(true)
+
+ # Rejecting deletes the user record
+ reviewable.reload
+ expect(reviewable.target).to be_blank
+ end
+ end
+ end
+
+ describe 'when must_approve_users is true' do
+ before do
+ SiteSetting.must_approve_users = true
+ end
+
+ it "creates the ReviewableUser for a user, with moderator access" do
+ reviewable = ReviewableUser.find_by(target: user)
+ expect(reviewable).to be_present
+ expect(reviewable.reviewable_by_moderator).to eq(true)
+ end
+
+ context "email jobs" do
+ let(:reviewable) { ReviewableUser.find_by(target: user) }
+ before do
+ reviewable
+
+ # We can ignore these notifications for the purpose of this test
+ Jobs.stubs(:enqueue).with(:notify_reviewable, has_key(:reviewable_id))
+ end
+
+ after do
+ ReviewableUser.find_by(target: user).perform(admin, :approve)
+ end
+
+ it "enqueues a 'signup after approval' email if must_approve_users is true" do
+ Jobs.expects(:enqueue).with(
+ :critical_user_email, has_entries(type: :signup_after_approval)
+ )
+ end
+
+ it "doesn't enqueue a 'signup after approval' email if must_approve_users is false" do
+ SiteSetting.must_approve_users = false
+ Jobs.expects(:enqueue).with(
+ :critical_user_email, has_entries(type: :signup_after_approval)
+ ).never
+ end
+ end
+
+ it 'triggers a extensibility event' do
+ user && admin # bypass the user_created event
+ event = DiscourseEvent.track_events {
+ ReviewableUser.find_by(target: user).perform(admin, :approve)
+ }.first
+
+ expect(event[:event_name]).to eq(:user_approved)
+ expect(event[:params].first).to eq(user)
+ end
+
+ it 'triggers a extensibility event' do
+ user && admin # bypass the user_created event
+ event = DiscourseEvent.track_events {
+ ReviewableUser.find_by(target: user).perform(admin, :approve)
+ }.first
+
+ expect(event[:event_name]).to eq(:user_approved)
+ expect(event[:params].first).to eq(user)
+ end
+ end
+
+end
diff --git a/spec/models/topic_converter_spec.rb b/spec/models/topic_converter_spec.rb
index d8f9d6ebf44..2421b23e4dc 100644
--- a/spec/models/topic_converter_spec.rb
+++ b/spec/models/topic_converter_spec.rb
@@ -7,7 +7,7 @@ describe TopicConverter do
let(:author) { Fabricate(:user) }
let(:category) { Fabricate(:category, topic_count: 1) }
let(:private_message) { Fabricate(:private_message_topic, user: author) } # creates a topic without a first post
- let(:first_post) { Fabricate(:post, topic: private_message, user: author) }
+ let(:first_post) { create_post(user: author, topic: private_message) }
let(:other_user) { private_message.topic_allowed_users.find { |u| u.user != author }.user }
context 'success' do
@@ -54,7 +54,7 @@ describe TopicConverter do
it "updates user stats" do
first_post
- topic_user = TopicUser.create!(user_id: author.id, topic_id: private_message.id, posted: true)
+ topic_user = TopicUser.find_by(user_id: author.id, topic_id: private_message.id)
expect(private_message.user.user_stat.topic_count).to eq(0)
expect(private_message.user.user_stat.post_count).to eq(0)
private_message.convert_to_public_topic(admin)
@@ -65,24 +65,20 @@ describe TopicConverter do
context "with a reply" do
before do
- UserActionCreator.enable
+ Jobs.run_immediately!
+ UserActionManager.enable
first_post
create_post(topic: private_message, user: other_user)
private_message.reload
end
- after do
- UserActionCreator.disable
- end
-
it "updates UserActions" do
TopicConverter.new(private_message, admin).convert_to_public_topic
expect(author.user_actions.where(action_type: UserAction::NEW_PRIVATE_MESSAGE).count).to eq(0)
expect(author.user_actions.where(action_type: UserAction::NEW_TOPIC).count).to eq(1)
- # TODO:
- # expect(other_user.user_actions.where(action_type: UserAction::NEW_PRIVATE_MESSAGE).count).to eq(0)
- # expect(other_user.user_actions.where(action_type: UserAction::GOT_PRIVATE_MESSAGE).count).to eq(0)
- # expect(other_user.user_actions.where(action_type: UserAction::REPLY).count).to eq(1)
+ expect(other_user.user_actions.where(action_type: UserAction::NEW_PRIVATE_MESSAGE).count).to eq(0)
+ expect(other_user.user_actions.where(action_type: UserAction::GOT_PRIVATE_MESSAGE).count).to eq(0)
+ expect(other_user.user_actions.where(action_type: UserAction::REPLY).count).to eq(1)
end
end
end
@@ -117,11 +113,11 @@ describe TopicConverter do
end
it "changes user_action type" do
- UserActionCreator.enable
+ Jobs.run_immediately!
+ UserActionManager.enable
topic.convert_to_private_message(admin)
expect(author.user_actions.where(action_type: UserAction::NEW_TOPIC).count).to eq(0)
expect(author.user_actions.where(action_type: UserAction::NEW_PRIVATE_MESSAGE).count).to eq(1)
- UserActionCreator.disable
end
end
diff --git a/spec/models/topic_spec.rb b/spec/models/topic_spec.rb
index 2fb6a681fd7..65ecec8caa9 100644
--- a/spec/models/topic_spec.rb
+++ b/spec/models/topic_spec.rb
@@ -781,10 +781,11 @@ describe Topic do
end
context "user actions" do
- let(:actions) { topic.user.user_actions }
-
it "should set up actions correctly" do
- UserActionCreator.enable
+ UserActionManager.enable
+
+ post = create_post(archetype: 'private_message', target_usernames: [Fabricate(:coding_horror).username])
+ actions = post.user.user_actions
expect(actions.map { |a| a.action_type }).not_to include(UserAction::NEW_TOPIC)
expect(actions.map { |a| a.action_type }).to include(UserAction::NEW_PRIVATE_MESSAGE)
diff --git a/spec/models/trust_level3_requirements_spec.rb b/spec/models/trust_level3_requirements_spec.rb
index b2d9c580f8d..ba9bbd8818d 100644
--- a/spec/models/trust_level3_requirements_spec.rb
+++ b/spec/models/trust_level3_requirements_spec.rb
@@ -14,6 +14,10 @@ describe TrustLevel3Requirements do
TopicViewItem.add(id, '11.22.33.44', user_id, at, _skip_redis = true)
end
+ def like_at(created_by, post, created_at)
+ PostActionCreator.new(created_by, post, PostActionType.types[:like], created_at: created_at).perform
+ end
+
describe "requirements" do
describe "penalty_counts" do
@@ -260,15 +264,16 @@ describe TrustLevel3Requirements do
describe "num_likes_given" do
it "counts likes given in the last 100 days" do
- UserActionCreator.enable
+ UserActionManager.enable
recent_post1 = create_post(created_at: 1.hour.ago)
recent_post2 = create_post(created_at: 10.days.ago)
old_post = create_post(created_at: 102.days.ago)
- Fabricate(:like, user: user, post: recent_post1, created_at: 2.hours.ago)
- Fabricate(:like, user: user, post: recent_post2, created_at: 5.days.ago)
- Fabricate(:like, user: user, post: old_post, created_at: 101.days.ago)
+ user.save
+ like_at(user, recent_post1, 2.hours.ago)
+ like_at(user, recent_post2, 5.days.ago)
+ like_at(user, old_post, 101.days.ago)
expect(tl3_requirements.num_likes_given).to eq(2)
end
@@ -276,7 +281,7 @@ describe TrustLevel3Requirements do
describe "num_likes_received" do
it "counts likes received in the last 100 days" do
- UserActionCreator.enable
+ UserActionManager.enable
t = Fabricate(:topic, user: user, created_at: 102.days.ago)
old_post = create_post(topic: t, user: user, created_at: 102.days.ago)
@@ -285,10 +290,10 @@ describe TrustLevel3Requirements do
liker = Fabricate(:user)
liker2 = Fabricate(:user)
- Fabricate(:like, user: liker, post: recent_post1, created_at: 2.hours.ago)
- Fabricate(:like, user: liker2, post: recent_post1, created_at: 2.hours.ago)
- Fabricate(:like, user: liker, post: recent_post2, created_at: 5.days.ago)
- Fabricate(:like, user: liker, post: old_post, created_at: 101.days.ago)
+ like_at(liker, recent_post1, 2.hours.ago)
+ like_at(liker2, recent_post1, 2.hours.ago)
+ like_at(liker, recent_post2, 5.days.ago)
+ like_at(liker, old_post, 101.days.ago)
expect(tl3_requirements.num_likes_received).to eq(3)
expect(tl3_requirements.num_likes_received_days).to eq(2)
diff --git a/spec/models/user_action_spec.rb b/spec/models/user_action_spec.rb
index 9a172ded34f..a3542662914 100644
--- a/spec/models/user_action_spec.rb
+++ b/spec/models/user_action_spec.rb
@@ -3,7 +3,7 @@ require 'rails_helper'
describe UserAction do
before do
- UserActionCreator.enable
+ UserActionManager.enable
end
it { is_expected.to validate_presence_of :action_type }
@@ -166,13 +166,13 @@ describe UserAction do
end
it "creates a new stream entry" do
- PostAction.act(liker, post, PostActionType.types[:like])
+ PostActionCreator.like(liker, post)
expect(likee_stream.count).to eq(@old_count + 1)
end
context "successful like" do
before do
- PostAction.act(liker, post, PostActionType.types[:like])
+ PostActionCreator.like(liker, post)
@liker_action = liker.user_actions.find_by(action_type: UserAction::LIKE)
@likee_action = likee.user_actions.find_by(action_type: UserAction::WAS_LIKED)
end
@@ -183,7 +183,7 @@ describe UserAction do
expect(likee.user_stat.reload.likes_received).to eq(1)
expect(liker.user_stat.reload.likes_given).to eq(1)
- PostAction.remove_act(liker, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(liker, post, :like)
expect(likee.user_stat.reload.likes_received).to eq(0)
expect(liker.user_stat.reload.likes_given).to eq(0)
end
@@ -199,7 +199,7 @@ describe UserAction do
expect(@likee_action).not_to eq(nil)
expect(likee.user_stat.reload.likes_received).to eq(0)
- PostAction.remove_act(liker, post, PostActionType.types[:like])
+ PostActionDestroyer.destroy(liker, post, :like)
expect(liker.user_stat.reload.likes_given).to eq(0)
expect(likee.user_stat.reload.likes_received).to eq(0)
end
@@ -214,7 +214,7 @@ describe UserAction do
end
it "doesn't add the entry to the stream" do
- PostAction.act(liker, post, PostActionType.types[:like])
+ PostActionCreator.like(liker, post)
expect(likee_stream.count).not_to eq(@old_count + 1)
end
@@ -228,7 +228,7 @@ describe UserAction do
end
before do
- @post = Fabricate(:old_post)
+ @post = create_post(created_at: DateTime.now - 100)
process_alerts(@post)
end
@@ -250,7 +250,8 @@ describe UserAction do
before do
@other_user = Fabricate(:coding_horror)
@mentioned = Fabricate(:admin)
- @response = Fabricate(:post, reply_to_post_number: 1, topic: @post.topic, user: @other_user, raw: "perhaps @#{@mentioned.username} knows how this works?")
+
+ @response = PostCreator.new(@other_user, reply_to_post_number: 1, topic_id: @post.topic_id, raw: "perhaps @#{@mentioned.username} knows how this works?").create
process_alerts(@response)
end
@@ -275,17 +276,17 @@ describe UserAction do
before do
@post = Fabricate(:post)
@user = @post.user
- PostAction.act(@user, @post, PostActionType.types[:bookmark])
+ PostActionCreator.create(@user, @post, :bookmark)
@action = @user.user_actions.find_by(action_type: UserAction::BOOKMARK)
end
- it 'should create a bookmark action correctly' do
+ it 'creates the bookmark, and removes it properly' do
expect(@action.action_type).to eq(UserAction::BOOKMARK)
expect(@action.target_post_id).to eq(@post.id)
expect(@action.acting_user_id).to eq(@user.id)
expect(@action.user_id).to eq(@user.id)
- PostAction.remove_act(@user, @post, PostActionType.types[:bookmark])
+ PostActionDestroyer.destroy(@user, @post, :bookmark)
expect(@user.user_actions.find_by(action_type: UserAction::BOOKMARK)).to eq(nil)
end
end
@@ -319,7 +320,7 @@ describe UserAction do
end
it 'correctly secures stream' do
- PostAction.act(user, private_message, PostActionType.types[:bookmark])
+ PostActionCreator.create(user, private_message, :bookmark)
expect(count_bookmarks).to eq(1)
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index a227bcf7e8f..2c045829d16 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -124,48 +124,23 @@ describe User do
end
end
- describe '.approve' do
+ describe 'reviewable' do
let(:user) { Fabricate(:user) }
let(:admin) { Fabricate(:admin) }
- it "enqueues a 'signup after approval' email if must_approve_users is true" do
+ it "creates a reviewable for the user if must_approve_users is true" do
SiteSetting.must_approve_users = true
- Jobs.expects(:enqueue).with(
- :critical_user_email, has_entries(type: :signup_after_approval)
- )
- user.approve(admin)
+ user
+
+ reviewable = ReviewableUser.find_by(target: user)
+ expect(reviewable).to be_present
+ expect(reviewable.score > 0).to eq(true)
+ expect(reviewable.reviewable_scores).to be_present
end
- it "doesn't enqueue a 'signup after approval' email if must_approve_users is false" do
- SiteSetting.must_approve_users = false
- Jobs.expects(:enqueue).never
- user.approve(admin)
- end
-
- it 'triggers a extensibility event' do
- user && admin # bypass the user_created event
- event = DiscourseEvent.track_events { user.approve(admin) }.first
-
- expect(event[:event_name]).to eq(:user_approved)
- expect(event[:params].first).to eq(user)
- end
-
- context 'after approval' do
- before do
- user.approve(admin)
- end
-
- it 'marks the user as approved' do
- expect(user).to be_approved
- end
-
- it 'has the admin as the approved by' do
- expect(user.approved_by).to eq(admin)
- end
-
- it 'has a value for approved_at' do
- expect(user.approved_at).to be_present
- end
+ it "doesn't create a reviewable if must_approve_users is false" do
+ user
+ expect(ReviewableUser.find_by(target: user)).to be_blank
end
end
@@ -176,19 +151,19 @@ describe User do
it "creates a bookmark with the true parameter" do
expect {
- PostAction.act(@post.user, @post, PostActionType.types[:bookmark])
+ PostActionCreator.create(@post.user, @post, :bookmark)
}.to change(PostAction, :count).by(1)
end
describe 'when removing a bookmark' do
before do
- PostAction.act(@post.user, @post, PostActionType.types[:bookmark])
+ PostActionCreator.create(@post.user, @post, :bookmark)
end
it 'reduces the bookmark count of the post' do
active = PostAction.where(deleted_at: nil)
expect {
- PostAction.remove_act(@post.user, @post, PostActionType.types[:bookmark])
+ PostActionDestroyer.destroy(@post.user, @post, :bookmark)
}.to change(active, :count).by(-1)
end
end
@@ -202,7 +177,7 @@ describe User do
@post3 = Fabricate(:post, user: @user)
@posts = [@post1, @post2, @post3]
@guardian = Guardian.new(Fabricate(:admin))
- @queued_post = Fabricate(:queued_post, user: @user)
+ Fabricate(:reviewable_queued_post, created_by: @user)
end
it 'deletes only one batch of posts' do
@@ -215,7 +190,7 @@ describe User do
it 'correctly deletes posts and topics' do
@user.delete_posts_in_batches(@guardian, 20)
expect(Post.where(id: @posts.map(&:id))).to be_empty
- expect(QueuedPost.where(user_id: @user.id).count).to eq(0)
+ expect(Reviewable.where(created_by: @user).count).to eq(0)
@posts.each do |p|
if p.is_first_post?
expect(Topic.find_by(id: p.topic_id)).to be_nil
@@ -920,16 +895,15 @@ describe User do
end
it "does not flags post as spam if the previous flag for that post was disagreed" do
+ results = user.flag_linked_posts_as_spam
+
+ expect(post.reload.spam_count).to eq(1)
+
+ results.each { |result| result.reviewable.perform(admin, :disagree) }
+
user.flag_linked_posts_as_spam
- post.reload
- expect(post.spam_count).to eq(1)
-
- PostAction.clear_flags!(post, admin)
- user.flag_linked_posts_as_spam
-
- post.reload
- expect(post.spam_count).to eq(0)
+ expect(post.reload.spam_count).to eq(0)
end
end
@@ -1071,7 +1045,7 @@ describe User do
before do
# To make testing easier, say 1 reply is too much
SiteSetting.newuser_max_replies_per_topic = 1
- UserActionCreator.enable
+ UserActionManager.enable
end
context "for a user who didn't create the topic" do
@@ -1410,16 +1384,13 @@ describe User do
it "doesn't count disagreed flags" do
post_agreed = Fabricate(:post)
- PostAction.act(user, post_agreed, PostActionType.types[:off_topic])
- PostAction.agree_flags!(post_agreed, moderator)
+ PostActionCreator.inappropriate(user, post_agreed).reviewable.perform(moderator, :agree_and_keep)
post_deferred = Fabricate(:post)
- PostAction.act(user, post_deferred, PostActionType.types[:inappropriate])
- PostAction.defer_flags!(post_deferred, moderator)
+ PostActionCreator.inappropriate(user, post_deferred).reviewable.perform(moderator, :ignore)
post_disagreed = Fabricate(:post)
- PostAction.act(user, post_disagreed, PostActionType.types[:spam])
- PostAction.clear_flags!(post_disagreed, moderator)
+ PostActionCreator.inappropriate(user, post_disagreed).reviewable.perform(moderator, :disagree)
expect(user.number_of_flags_given).to eq(2)
end
@@ -1984,8 +1955,8 @@ describe User do
user = Fabricate(:user)
post = Fabricate(:post)
- PostAction.act(user, post, PostActionType.types[:like])
- PostAction.remove_act(user, post, PostActionType.types[:like])
+ PostActionCreator.like(user, post)
+ PostActionDestroyer.destroy(user, post, :like)
UserAction.create!(user_id: user.id, action_type: UserAction::LIKE)
UserAction.create!(user_id: -1, action_type: UserAction::LIKE, target_user_id: user.id)
diff --git a/spec/models/user_summary_spec.rb b/spec/models/user_summary_spec.rb
index 84fab05156a..0b7453d453a 100644
--- a/spec/models/user_summary_spec.rb
+++ b/spec/models/user_summary_spec.rb
@@ -39,11 +39,11 @@ describe UserSummary do
end
it "is robust enough to handle bad data" do
- UserActionCreator.enable
+ UserActionManager.enable
liked_post = create_post
user = Fabricate(:user)
- PostAction.act(user, liked_post, PostActionType.types[:like])
+ PostActionCreator.like(user, liked_post)
users = UserSummary.new(user, Guardian.new).most_liked_users
diff --git a/spec/models/web_hook_spec.rb b/spec/models/web_hook_spec.rb
index 3156c35777f..1c9389a4f36 100644
--- a/spec/models/web_hook_spec.rb
+++ b/spec/models/web_hook_spec.rb
@@ -285,6 +285,8 @@ describe WebHook do
end
it 'should enqueue the right hooks for user events' do
+ SiteSetting.must_approve_users = true
+
Fabricate(:user_web_hook, active: true)
user
@@ -301,7 +303,7 @@ describe WebHook do
payload = JSON.parse(job_args["payload"])
expect(payload["id"]).to eq(admin.id)
- user.approve(admin)
+ ReviewableUser.find_by(target: user).perform(admin, :approve)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("user_approved")
@@ -421,66 +423,85 @@ describe WebHook do
expect(payload["id"]).to eq(tag.id)
end
+ # NOTE: Backwards compatibility, people should use reviewable instead
it 'should enqueue the right hooks for flag events' do
post = Fabricate(:post)
admin = Fabricate(:admin)
moderator = Fabricate(:moderator)
Fabricate(:flag_web_hook)
- post_action = PostAction.act(admin, post, PostActionType.types[:spam])
+ result = PostActionCreator.spam(admin, post)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("flag_created")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(post_action.id)
+ expect(payload["id"]).to eq(result.post_action.id)
- PostAction.agree_flags!(post, moderator)
+ result.reviewable.perform(moderator, :agree_and_keep)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("flag_agreed")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(post_action.id)
+ expect(payload["id"]).to eq(result.post_action.id)
- post_action = PostAction.act(Fabricate(:user), post, PostActionType.types[:spam])
- PostAction.clear_flags!(post, moderator)
+ result = PostActionCreator.spam(Fabricate(:user), post)
+ result.reviewable.perform(moderator, :disagree)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("flag_disagreed")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(post_action.id)
+ expect(payload["id"]).to eq(result.post_action.id)
post = Fabricate(:post)
- post_action = PostAction.act(admin, post, PostActionType.types[:spam])
- PostAction.defer_flags!(post, moderator)
+ result = PostActionCreator.spam(admin, post)
+ result.reviewable.perform(moderator, :ignore)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("flag_deferred")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(post_action.id)
+ expect(payload["id"]).to eq(result.post_action.id)
end
+ # NOTE: Backwards compatibility, people should use reviewable instead
it 'should enqueue the right hooks for queued post events' do
Fabricate(:queued_post_web_hook)
- queued_post = Fabricate(:queued_post)
+ reviewable = Fabricate(:reviewable_queued_post)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("queued_post_created")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(queued_post.id)
+ expect(payload["id"]).to eq(reviewable.id)
- queued_post.approve!(Discourse.system_user)
+ reviewable.perform(Discourse.system_user, :approve)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("approved_post")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(queued_post.id)
+ expect(payload["id"]).to eq(reviewable.id)
- queued_post.reject!(Discourse.system_user)
+ reviewable.perform(Discourse.system_user, :reject)
job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
expect(job_args["event_name"]).to eq("rejected_post")
payload = JSON.parse(job_args["payload"])
- expect(payload["id"]).to eq(queued_post.id)
+ expect(payload["id"]).to eq(reviewable.id)
+ end
+
+ it 'should enqueue the right hooks for reviewables' do
+ Fabricate(:reviewable_web_hook)
+ reviewable = Fabricate(:reviewable)
+ job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
+
+ expect(job_args["event_name"]).to eq("reviewable_created")
+ payload = JSON.parse(job_args["payload"])
+ expect(payload["id"]).to eq(reviewable.id)
+
+ reviewable.perform(Discourse.system_user, :reject)
+ job_args = Jobs::EmitWebHookEvent.jobs.last["args"].first
+
+ expect(job_args["event_name"]).to eq("reviewable_transitioned_to")
+ payload = JSON.parse(job_args["payload"])
+ expect(payload["id"]).to eq(reviewable.id)
end
end
end
diff --git a/spec/rails_helper.rb b/spec/rails_helper.rb
index 7cca874f3c2..63c2df73214 100644
--- a/spec/rails_helper.rb
+++ b/spec/rails_helper.rb
@@ -155,7 +155,7 @@ RSpec.configure do |config|
RateLimiter.disable
PostActionNotifier.disable
SearchIndexer.disable
- UserActionCreator.disable
+ UserActionManager.disable
NotificationEmailer.disable
SiteSetting.provider.all.each do |setting|
diff --git a/spec/requests/admin/flagged_topics_controller_spec.rb b/spec/requests/admin/flagged_topics_controller_spec.rb
index 3d27ac33af6..7456afa524b 100644
--- a/spec/requests/admin/flagged_topics_controller_spec.rb
+++ b/spec/requests/admin/flagged_topics_controller_spec.rb
@@ -1,6 +1,13 @@
require 'rails_helper'
RSpec.describe Admin::FlaggedTopicsController do
+ let(:post) { Fabricate(:post) }
+ let(:user) { Fabricate(:user) }
+
+ before do
+ PostActionCreator.spam(user, post)
+ end
+
let!(:flag) { Fabricate(:flag) }
shared_examples "successfully retrieve list of flagged topics" do
diff --git a/spec/requests/admin/flags_controller_spec.rb b/spec/requests/admin/flags_controller_spec.rb
index c509e097a00..b1436e33b3b 100644
--- a/spec/requests/admin/flags_controller_spec.rb
+++ b/spec/requests/admin/flags_controller_spec.rb
@@ -19,11 +19,11 @@ RSpec.describe Admin::FlagsController do
data = ::JSON.parse(response.body)
expect(data["users"]).to eq([])
- expect(data["posts"]).to eq([])
+ expect(data["flagged_posts"]).to eq([])
end
it 'should return the right response' do
- PostAction.act(user, post_1, PostActionType.types[:spam])
+ PostActionCreator.create(user, post_1, :spam)
get '/admin/flags.json'
@@ -31,7 +31,7 @@ RSpec.describe Admin::FlagsController do
data = ::JSON.parse(response.body)
expect(data["users"].length).to eq(2)
- expect(data["posts"].length).to eq(1)
+ expect(data["flagged_posts"].length).to eq(1)
end
end
@@ -39,10 +39,11 @@ RSpec.describe Admin::FlagsController do
it 'should raise a reasonable error if a flag was deferred and then someone else agreed' do
Jobs.run_immediately!
- _post_action = PostAction.act(user, post_1, PostActionType.types[:spam], message: 'bad')
+ reviewable = PostActionCreator.spam(user, post_1).reviewable
post "/admin/flags/defer/#{post_1.id}.json"
expect(response.status).to eq(200)
+ expect(reviewable.reload).to be_ignored
post "/admin/flags/agree/#{post_1.id}.json", params: { action_on_post: 'keep' }
# 409 means conflict which is what is happening here
@@ -54,13 +55,20 @@ RSpec.describe Admin::FlagsController do
it 'should be able to agree and keep content' do
Jobs.run_immediately!
- post_action = PostAction.act(user, post_1, PostActionType.types[:spam], message: 'bad')
+ result = PostActionCreator.spam(user, post_1)
+ reviewable = result.reviewable
post "/admin/flags/agree/#{post_1.id}.json", params: { action_on_post: 'keep' }
expect(response.status).to eq(200)
- post_action.reload
- expect(post_action.agreed_by_id).to eq(admin.id)
+ expect(reviewable.reload).to be_approved
+
+ approve_history = reviewable.reviewable_histories.where(
+ created_by: admin,
+ reviewable_history_type: ReviewableHistory.types[:transitioned],
+ status: Reviewable.statuses[:approved]
+ )
+ expect(approve_history).to be_present
expect(user.user_stat.reload.flags_agreed).to eq(1)
post_1.reload
@@ -71,7 +79,7 @@ RSpec.describe Admin::FlagsController do
SiteSetting.allow_user_locale = true
Jobs.run_immediately!
- post_action = PostAction.act(user, post_1, PostActionType.types[:spam], message: 'bad')
+ post_action = PostActionCreator.new(user, post_1, PostActionType.types[:spam], message: 'bad').perform.post_action
admin.update!(locale: 'ja')
post "/admin/flags/agree/#{post_1.id}.json", params: { action_on_post: 'delete' }
@@ -93,7 +101,7 @@ RSpec.describe Admin::FlagsController do
Jobs.run_immediately!
category.update_column(:topic_id, first_post.topic_id)
- PostAction.act(user, first_post, PostActionType.types[:spam], message: 'bad')
+ PostActionCreator.new(user, first_post, PostActionType.types[:spam], message: 'bad').perform
post "/admin/flags/agree/#{first_post.id}.json", params: { action_on_post: 'delete' }
expect(response.status).to eq(403)
@@ -105,13 +113,13 @@ RSpec.describe Admin::FlagsController do
context '#disagree' do
it "unhides the post and unsilences the user if disagreed" do
- SiteSetting.num_spam_flags_to_silence_new_user = 1
+ SiteSetting.spam_score_to_silence_new_user = 1.0
SiteSetting.num_users_to_silence_new_user = 1
new_user = Fabricate(:newuser)
new_post = create_post(user: new_user)
- PostAction.act(Fabricate(:leader), new_post, PostActionType.types[:spam])
+ PostActionCreator.spam(Fabricate(:leader), new_post)
post "/admin/flags/disagree/#{new_post.id}.json"
expect(response.status).to eq(200)
diff --git a/spec/requests/admin/moderation_history_controller_spec.rb b/spec/requests/admin/moderation_history_controller_spec.rb
deleted file mode 100644
index 866664cae48..00000000000
--- a/spec/requests/admin/moderation_history_controller_spec.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Admin::BackupsController do
- let(:admin) { Fabricate(:admin) }
-
- before do
- sign_in(admin)
- end
-
- describe "parameters" do
- it "returns 404 without a valid filter" do
- get "/admin/moderation_history.json"
- expect(response).not_to be_successful
- end
-
- it "returns 404 without a valid id" do
- get "/admin/moderation_history.json?filter=topic"
- expect(response).not_to be_successful
- end
- end
-
- describe "for a post" do
- it "returns an empty array when the post doesn't exist" do
- get "/admin/moderation_history.json?filter=post&post_id=99999999"
- expect(response.status).to eq(200)
- expect(::JSON.parse(response.body)['moderation_history']).to be_blank
- end
-
- it "returns a history when the post exists" do
- p = Fabricate(:post)
- p = Fabricate(:post, topic: p.topic)
- PostDestroyer.new(Discourse.system_user, p).destroy
- get "/admin/moderation_history.json?filter=post&post_id=#{p.id}"
- expect(response.status).to eq(200)
- expect(::JSON.parse(response.body)['moderation_history']).to be_present
- end
-
- it 'includes post approval record' do
- queued_post = Fabricate(:queued_post)
- post = queued_post.approve!(Discourse.system_user)
-
- get "/admin/moderation_history.json?filter=post&post_id=#{post.id}"
-
- expect(response.status).to eq(200)
-
- moderation_history = JSON.parse(response.body)['moderation_history'].first
- expect(moderation_history['action_name']).to eq('post_approved')
- end
- end
-
- describe "for a topic" do
- it "returns empty history when the topic doesn't exist" do
- get "/admin/moderation_history.json?filter=topic&topic_id=1234"
- expect(response.status).to eq(200)
- expect(::JSON.parse(response.body)['moderation_history']).to be_blank
- end
-
- it "returns a history when the topic exists" do
- p = Fabricate(:post)
- PostDestroyer.new(Discourse.system_user, p).destroy
- get "/admin/moderation_history.json?filter=topic&topic_id=#{p.topic_id}"
- expect(response.status).to eq(200)
- expect(::JSON.parse(response.body)['moderation_history']).to be_present
- end
- end
-end
diff --git a/spec/requests/admin/users_controller_spec.rb b/spec/requests/admin/users_controller_spec.rb
index 48324b84936..f4a8fca488c 100644
--- a/spec/requests/admin/users_controller_spec.rb
+++ b/spec/requests/admin/users_controller_spec.rb
@@ -56,7 +56,11 @@ RSpec.describe Admin::UsersController do
end
describe '#approve' do
- let(:evil_trout) { Fabricate(:evil_trout, approved: false) }
+ before do
+ SiteSetting.must_approve_users = true
+ end
+
+ let(:evil_trout) { Fabricate(:evil_trout) }
it "raises an error when the user doesn't have permission" do
sign_in(user)
@@ -76,7 +80,11 @@ RSpec.describe Admin::UsersController do
end
describe '#approve_bulk' do
- let(:evil_trout) { Fabricate(:evil_trout, approved: false) }
+ before do
+ SiteSetting.must_approve_users = true
+ end
+
+ let(:evil_trout) { Fabricate(:evil_trout) }
it "does nothing without uesrs" do
put "/admin/users/approve-bulk.json"
diff --git a/spec/requests/post_action_users_controller_spec.rb b/spec/requests/post_action_users_controller_spec.rb
index 1fdf4bb529a..29d525e493b 100644
--- a/spec/requests/post_action_users_controller_spec.rb
+++ b/spec/requests/post_action_users_controller_spec.rb
@@ -7,8 +7,8 @@ describe PostActionUsersController do
it 'always allows you to see your own actions' do
notify_mod = PostActionType.types[:notify_moderators]
- PostAction.act(post.user, post, notify_mod, message: 'well something is wrong here!')
- PostAction.act(Fabricate(:user), post, notify_mod, message: 'well something is not wrong here!')
+ PostActionCreator.new(post.user, post, notify_mod, message: 'well something is wrong here!').perform
+ PostActionCreator.new(Fabricate(:user), post, notify_mod, message: 'well something is not wrong here!').perform
get "/post_action_users.json", params: { id: post.id, post_action_type_id: notify_mod }
expect(response.status).to eq(200)
@@ -61,7 +61,7 @@ describe PostActionUsersController do
5.times do
user = Fabricate(:user)
user_ids << user["id"]
- PostAction.act(user, post, PostActionType.types[:like])
+ PostActionCreator.like(user, post)
end
get "/post_action_users.json",
diff --git a/spec/requests/post_actions_controller_spec.rb b/spec/requests/post_actions_controller_spec.rb
index 882b107eb76..7c39283e130 100644
--- a/spec/requests/post_actions_controller_spec.rb
+++ b/spec/requests/post_actions_controller_spec.rb
@@ -232,10 +232,12 @@ RSpec.describe PostActionsController do
expect(response.status).to eq(200)
- post_action = PostAction.last
-
- expect(post_action.post_id).to eq(post_1.id)
+ post_action = PostAction.find_by(post: post_1)
expect(post_action.staff_took_action).to eq(true)
+
+ reviewable = ReviewableFlaggedPost.find_by(target: post_1)
+ score = reviewable.reviewable_scores.first
+ expect(score.took_action?).to eq(true)
end
it "doesn't pass take_action through if the user isn't staff" do
@@ -243,35 +245,32 @@ RSpec.describe PostActionsController do
post "/post_actions.json", params: {
id: post_1.id,
- post_action_type_id: PostActionType.types[:like]
+ post_action_type_id: PostActionType.types[:inappropriate]
}
expect(response.status).to eq(200)
- post_action = PostAction.last
-
- expect(post_action.post_id).to eq(post_1.id)
+ post_action = PostAction.find_by(post: post_1)
expect(post_action.staff_took_action).to eq(false)
+
+ reviewable = ReviewableFlaggedPost.find_by(target: post_1)
+ score = reviewable.reviewable_scores.first
+ expect(score.took_action?).to eq(false)
end
end
end
describe '#defer_flags' do
- let!(:flag) do
- PostAction.create!(
- post_id: flagged_post.id,
- user_id: Fabricate(:user).id,
- post_action_type_id: PostActionType.types[:spam]
- )
- end
let(:flagged_post) { Fabricate(:post, user: Fabricate(:coding_horror)) }
+ let!(:reviewable) do
+ PostActionCreator.spam(Fabricate(:user), flagged_post).reviewable
+ end
context "not logged in" do
it "should not allow them to clear flags" do
post "/post_actions/defer_flags.json", params: { id: flagged_post.id }
expect(response.status).to eq(403)
- flag.reload
- expect(flag.deferred_at).to be_nil
+ expect(reviewable.reload).not_to be_ignored
end
end
@@ -281,8 +280,7 @@ RSpec.describe PostActionsController do
it "raises an error without a post_action_type_id" do
post "/post_actions/defer_flags.json", params: { id: flagged_post.id }
expect(response.status).to eq(400)
- flag.reload
- expect(flag.deferred_at).to be_nil
+ expect(reviewable.reload).not_to be_ignored
end
it "raises an error when the user doesn't have access" do
@@ -293,19 +291,17 @@ RSpec.describe PostActionsController do
}
expect(response).to be_forbidden
- flag.reload
- expect(flag.deferred_at).to be_nil
+ expect(reviewable.reload).not_to be_ignored
end
context "success" do
- it "delegates to defer_flags" do
+ it "performs the ignore" do
post "/post_actions/defer_flags.json", params: {
id: flagged_post.id, post_action_type_id: PostActionType.types[:spam]
}
expect(response.status).to eq(200)
- flag.reload
- expect(flag.deferred_at).to be_present
+ expect(reviewable.reload).to be_ignored
end
it "works with a deleted post" do
@@ -316,8 +312,7 @@ RSpec.describe PostActionsController do
}
expect(response.status).to eq(200)
- flag.reload
- expect(flag.deferred_at).to be_present
+ expect(reviewable.reload).to be_ignored
end
end
end
diff --git a/spec/requests/posts_controller_spec.rb b/spec/requests/posts_controller_spec.rb
index 89cf1fdbe8d..f993926b966 100644
--- a/spec/requests/posts_controller_spec.rb
+++ b/spec/requests/posts_controller_spec.rb
@@ -249,23 +249,24 @@ describe PostsController do
before do
sign_in(moderator)
- PostAction.act(moderator, post1, PostActionType.types[:off_topic])
- PostAction.act(moderator, post2, PostActionType.types[:off_topic])
+ PostActionCreator.off_topic(moderator, post1)
+ PostActionCreator.off_topic(moderator, post2)
Jobs::SendSystemMessage.clear
end
it "defers the child posts by default" do
- expect(PostAction.flagged_posts_count).to eq(2)
+ expect(ReviewableFlaggedPost.pending.count).to eq(2)
delete "/posts/destroy_many.json", params: { post_ids: [post1.id, post2.id] }
expect(Jobs::SendSystemMessage.jobs.size).to eq(1)
- expect(PostAction.flagged_posts_count).to eq(0)
+ expect(ReviewableFlaggedPost.pending.count).to eq(0)
end
it "can defer all posts based on `agree_with_first_reply_flag` param" do
- expect(PostAction.flagged_posts_count).to eq(2)
+ expect(ReviewableFlaggedPost.pending.count).to eq(2)
delete "/posts/destroy_many.json", params: { post_ids: [post1.id, post2.id], agree_with_first_reply_flag: false }
- expect(Jobs::SendSystemMessage.jobs.size).to eq(0)
- expect(PostAction.flagged_posts_count).to eq(0)
+ PostActionCreator.off_topic(moderator, post1)
+ PostActionCreator.off_topic(moderator, post2)
+ Jobs::SendSystemMessage.clear
end
end
end
@@ -468,7 +469,7 @@ describe PostsController do
end
context "removing a bookmark" do
- let(:post_action) { PostAction.act(user, post, PostActionType.types[:bookmark]) }
+ let(:post_action) { PostActionCreator.create(user, post, :bookmark).post_action }
let(:admin) { Fabricate(:admin) }
it "returns the right response when post is not bookmarked" do
@@ -799,10 +800,10 @@ describe PostsController do
user.reload
expect(user).to be_silenced
- qp = QueuedPost.first
+ rp = ReviewableQueuedPost.first
mod = Fabricate(:moderator)
- qp.approve!(mod)
+ rp.perform(mod, :approve)
user.reload
expect(user).not_to be_silenced
@@ -1449,14 +1450,14 @@ describe PostsController do
post_disagreed = create_post(user: user)
moderator = Fabricate(:moderator)
- PostAction.act(moderator, post_agreed, PostActionType.types[:spam])
- PostAction.act(moderator, post_deferred, PostActionType.types[:off_topic])
- PostAction.act(moderator, post_disagreed, PostActionType.types[:inappropriate])
+ r0 = PostActionCreator.spam(moderator, post_agreed).reviewable
+ r1 = PostActionCreator.off_topic(moderator, post_deferred).reviewable
+ r2 = PostActionCreator.inappropriate(moderator, post_disagreed).reviewable
admin = Fabricate(:admin)
- PostAction.agree_flags!(post_agreed, admin)
- PostAction.defer_flags!(post_deferred, admin)
- PostAction.clear_flags!(post_disagreed, admin)
+ r0.perform(admin, :agree_and_keep)
+ r1.perform(admin, :ignore)
+ r2.perform(admin, :disagree)
sign_in(Fabricate(:moderator))
get "/posts/#{user.username}/flagged.json"
diff --git a/spec/requests/queued_posts_controller_spec.rb b/spec/requests/queued_posts_controller_spec.rb
index d17d2c4367c..61928f21098 100644
--- a/spec/requests/queued_posts_controller_spec.rb
+++ b/spec/requests/queued_posts_controller_spec.rb
@@ -1,7 +1,7 @@
require 'rails_helper'
require_dependency 'queued_posts_controller'
-require_dependency 'queued_post'
+# NOTE: This controller only exists for backwards compatibility
describe QueuedPostsController do
context 'without authentication' do
it 'fails' do
@@ -30,7 +30,7 @@ describe QueuedPostsController do
describe '#update' do
before { sign_in(Fabricate(:moderator)) }
- let(:qp) { Fabricate(:queued_post) }
+ let(:qp) { Fabricate(:reviewable_queued_post) }
context 'not found' do
it 'returns json error' do
@@ -40,9 +40,7 @@ describe QueuedPostsController do
queued_post: { state: 'approved' }
}
- expect(response.status).to eq(422)
-
- expect(JSON.parse(response.body)["errors"].first).to eq(I18n.t('queue.not_found'))
+ expect(response.status).to eq(404)
end
end
@@ -54,9 +52,10 @@ describe QueuedPostsController do
}
expect(response.status).to eq(200)
+ json = ::JSON.parse(response.body)
+ qp_json = json['queued_posts']
- qp.reload
- expect(qp.state).to eq(QueuedPost.states[:approved])
+ expect(qp_json['state']).to eq(2)
end
end
@@ -69,8 +68,9 @@ describe QueuedPostsController do
expect(response.status).to eq(200)
- qp.reload
- expect(qp.state).to eq(QueuedPost.states[:rejected])
+ json = ::JSON.parse(response.body)
+ qp_json = json['queued_posts']
+ expect(qp_json['state']).to eq(3)
end
end
@@ -85,7 +85,7 @@ describe QueuedPostsController do
end
context 'when it is a topic' do
- let(:queued_topic) { Fabricate(:queued_topic) }
+ let(:queued_topic) { Fabricate(:reviewable_queued_post_topic,) }
it 'updates the topic attributes' do
put "/queued_posts/#{queued_topic.id}.json", params: {
@@ -95,14 +95,14 @@ describe QueuedPostsController do
expect(response.status).to eq(200)
queued_topic.reload
- expect(queued_topic.raw).to eq(changes[:raw])
- expect(queued_topic.post_options['title']).to eq(changes[:title])
- expect(queued_topic.post_options['category']).to eq(changes[:category_id])
- expect(queued_topic.post_options['tags']).to eq(changes[:tags])
+ expect(queued_topic.payload['raw']).to eq(changes[:raw])
+ expect(queued_topic.payload['title']).to eq(changes[:title])
+ expect(queued_topic.category_id).to eq(changes[:category_id])
+ expect(queued_topic.payload['tags']).to eq(changes[:tags])
end
it 'removes tags if not present' do
- queued_topic.post_options[:tags] = ['another-tag']
+ queued_topic.payload[:tags] = ['another-tag']
queued_topic.save!
put "/queued_posts/#{queued_topic.id}.json", params: {
@@ -112,29 +112,29 @@ describe QueuedPostsController do
expect(response.status).to eq(200)
queued_topic.reload
- expect(queued_topic.raw).to eq(changes[:raw])
- expect(queued_topic.post_options['title']).to eq(changes[:title])
- expect(queued_topic.post_options['category']).to eq(changes[:category_id])
- expect(queued_topic.post_options['tags']).to be_nil
+ expect(queued_topic.payload['raw']).to eq(changes[:raw])
+ expect(queued_topic.payload['title']).to eq(changes[:title])
+ expect(queued_topic.category_id).to eq(changes[:category_id])
+ expect(queued_topic.payload['tags']).to be_nil
end
end
context 'when it is a reply' do
- let(:queued_reply) { Fabricate(:queued_post) }
+ let(:queued_reply) { Fabricate(:reviewable_queued_post) }
it 'updates the reply attributes' do
put "/queued_posts/#{queued_reply.id}.json", params: {
queued_post: changes
}
- original_category = queued_reply.post_options['category']
+ original_category = queued_reply.category_id
expect(response.status).to eq(200)
queued_reply.reload
- expect(queued_reply.raw).to eq(changes[:raw])
- expect(queued_reply.post_options['title']).to be_nil
- expect(queued_reply.post_options['category']).to eq(original_category)
- expect(queued_reply.post_options['tags']).to be_nil
+ expect(queued_reply.payload['raw']).to eq(changes[:raw])
+ expect(queued_reply.payload['title']).to be_nil
+ expect(queued_reply.category_id).to eq(original_category)
+ expect(queued_reply.payload['tags']).to be_nil
end
end
end
diff --git a/spec/requests/reviewables_controller_spec.rb b/spec/requests/reviewables_controller_spec.rb
new file mode 100644
index 00000000000..656b61e358a
--- /dev/null
+++ b/spec/requests/reviewables_controller_spec.rb
@@ -0,0 +1,419 @@
+require 'rails_helper'
+
+describe ReviewablesController do
+
+ context "anonymous" do
+ it "denies listing" do
+ get "/review.json"
+ expect(response.code).to eq("403")
+ end
+
+ it "denies performing" do
+ put "/review/123/perform/approve.json"
+ expect(response.code).to eq("403")
+ end
+ end
+
+ context "when logged in" do
+ let(:admin) { Fabricate(:admin) }
+
+ before do
+ sign_in(admin)
+ end
+
+ context "#index" do
+ it "returns empty JSON when nothing to review" do
+ get "/review.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to eq([])
+ end
+
+ it "returns JSON with reviewable content" do
+ reviewable = Fabricate(:reviewable)
+
+ get "/review.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+
+ json_review = json['reviewables'][0]
+ expect(json_review['id']).to eq(reviewable.id)
+ expect(json_review['created_by_id']).to eq(reviewable.created_by_id)
+ expect(json_review['status']).to eq(Reviewable.statuses[:pending])
+ expect(json_review['type']).to eq('ReviewableUser')
+ expect(json_review['target_created_by_id']).to eq(reviewable.target_created_by_id)
+ expect(json_review['score']).to eq(reviewable.score)
+ expect(json_review['version']).to eq(reviewable.version)
+
+ expect(json['users'].any? { |u| u['id'] == reviewable.created_by_id }).to eq(true)
+ expect(json['users'].any? { |u| u['id'] == reviewable.target_created_by_id }).to eq(true)
+ end
+
+ it "supports filtering by score" do
+ get "/review.json?min_score=1000"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_blank
+ end
+
+ it "supports offsets" do
+ get "/review.json?offset=100"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_blank
+ end
+
+ it "supports filtering by type" do
+ Fabricate(:reviewable)
+ get "/review.json?type=ReviewableUser"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+ end
+
+ it "raises an error with an invalid type" do
+ get "/review.json?type=ReviewableMadeUp"
+ expect(response.code).to eq("500")
+ end
+
+ it "supports filtering by status" do
+ Fabricate(:reviewable, status: Reviewable.statuses[:approved])
+
+ get "/review.json?type=ReviewableUser&status=pending"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_blank
+
+ Fabricate(:reviewable, status: Reviewable.statuses[:approved])
+ get "/review.json?type=ReviewableUser&status=approved"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+
+ get "/review.json?type=ReviewableUser&status=reviewed"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+
+ get "/review.json?type=ReviewableUser&status=all"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+ end
+
+ it "raises an error with an invalid status" do
+ get "/review.json?status=xyz"
+ expect(response.code).to eq("500")
+ end
+
+ it "supports filtering by category_id" do
+ other_category = Fabricate(:category)
+ r = Fabricate(:reviewable)
+ get "/review.json?category_id=#{other_category.id}"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_blank
+
+ get "/review.json?category_id=#{r.category_id}"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+
+ # By default all categories are returned
+ get "/review.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewables']).to be_present
+ end
+
+ it "will use the ReviewableUser serializer for its fields" do
+ SiteSetting.must_approve_users = true
+ user = Fabricate(:user)
+ reviewable = ReviewableUser.find_by(target: user)
+
+ get "/review.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+
+ json_review = json['reviewables'][0]
+ expect(json_review['id']).to eq(reviewable.id)
+ expect(json_review['user_id']).to eq(user.id)
+ end
+ end
+
+ context "#show" do
+ context "basics" do
+ let(:reviewable) { Fabricate(:reviewable) }
+ before do
+ sign_in(Fabricate(:moderator))
+ end
+
+ it "returns the reviewable as json" do
+ get "/review/#{reviewable.id}.json"
+ expect(response.code).to eq("200")
+
+ json = ::JSON.parse(response.body)
+ expect(json['reviewable']['id']).to eq(reviewable.id)
+ end
+
+ it "returns 404 for a missing reviewable" do
+ get "/review/123456789.json"
+ expect(response.code).to eq("404")
+ end
+ end
+
+ context "conversation" do
+ let(:post) { Fabricate(:post) }
+ let(:user) { Fabricate(:user) }
+ let(:admin) { Fabricate(:admin) }
+ let(:result) { PostActionCreator.notify_moderators(user, post, 'this is the first post') }
+ let(:reviewable) { result.reviewable }
+
+ before do
+ PostCreator.create(
+ admin,
+ topic_id: result.reviewable_score.meta_topic_id,
+ raw: "this is the second post"
+ )
+ PostCreator.create(
+ admin,
+ topic_id: result.reviewable_score.meta_topic_id,
+ raw: "this is the third post"
+ )
+ end
+
+ it "returns the conversation" do
+ get "/review/#{reviewable.id}.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+
+ score = json['reviewable_scores'][0]
+ conversation_id = score['reviewable_conversation_id']
+
+ conversation = json['reviewable_conversations'].find { |c| c['id'] == conversation_id }
+ expect(conversation).to be_present
+ expect(conversation['has_more']).to eq(true)
+ expect(conversation['permalink']).to be_present
+
+ reply = json['conversation_posts'].find { |cp| cp['id'] == conversation['conversation_post_ids'][0] }
+ expect(reply['excerpt']).to be_present
+ expect(reply['user_id']).to eq(user.id)
+
+ reply = json['conversation_posts'].find { |cp| cp['id'] == conversation['conversation_post_ids'][1] }
+ expect(reply['excerpt']).to be_present
+ expect(reply['user_id']).to eq(admin.id)
+ end
+
+ end
+ end
+
+ context "#perform" do
+ let(:reviewable) { Fabricate(:reviewable) }
+ before do
+ sign_in(Fabricate(:moderator))
+ end
+
+ it "returns 404 when the reviewable does not exist" do
+ put "/review/12345/perform/approve.json?version=0"
+ expect(response.code).to eq("404")
+ end
+
+ it "validates the presenece of an action" do
+ put "/review/#{reviewable.id}/perform/nope.json?version=#{reviewable.version}"
+ expect(response.code).to eq("403")
+ end
+
+ it "ensures the user can see the reviewable" do
+ reviewable.update_column(:reviewable_by_moderator, false)
+ put "/review/#{reviewable.id}/perform/approve.json?version=#{reviewable.version}"
+ expect(response.code).to eq("404")
+ end
+
+ it "can properly return errors" do
+ qp = Fabricate(:reviewable_queued_post_topic, topic_id: -100)
+ put "/review/#{qp.id}/perform/approve.json?version=#{qp.version}"
+ expect(response.code).to eq("422")
+ result = ::JSON.parse(response.body)
+ expect(result['errors']).to be_present
+ end
+
+ it "requires a version parameter" do
+ put "/review/#{reviewable.id}/perform/approve.json"
+ expect(response.code).to eq("422")
+ result = ::JSON.parse(response.body)
+ expect(result['errors']).to be_present
+ end
+
+ it "succeeds for a valid action" do
+ other_reviewable = Fabricate(:reviewable)
+
+ put "/review/#{reviewable.id}/perform/approve.json?version=#{reviewable.version}"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewable_perform_result']['success']).to eq(true)
+ expect(json['reviewable_perform_result']['version']).to eq(1)
+ expect(json['reviewable_perform_result']['transition_to']).to eq('approved')
+ expect(json['reviewable_perform_result']['transition_to_id']).to eq(Reviewable.statuses[:approved])
+ expect(json['reviewable_perform_result']['remove_reviewable_ids']).to eq([reviewable.id])
+
+ expect(reviewable.reload.version).to eq(1)
+ expect(other_reviewable.reload.version).to eq(0)
+ end
+
+ describe "simultaneous perform" do
+ it "fails when the version is wrong" do
+ put "/review/#{reviewable.id}/perform/approve.json?version=#{reviewable.version + 1}"
+ expect(response.code).to eq("409")
+ json = ::JSON.parse(response.body)
+ expect(json['errors']).to be_present
+ end
+ end
+ end
+
+ context "#topics" do
+ let(:post0) { Fabricate(:post) }
+ let(:post1) { Fabricate(:post, topic: post0.topic) }
+ let(:post2) { Fabricate(:post) }
+ let(:user0) { Fabricate(:user) }
+ let(:user1) { Fabricate(:user) }
+
+ it "returns empty json for no reviewables" do
+ get "/review/topics.json"
+ expect(response.code).to eq("200")
+ json = ::JSON.parse(response.body)
+ expect(json['reviewable_topics']).to be_blank
+ end
+
+ it "returns json listing the topics " do
+ PostActionCreator.spam(user0, post0)
+ PostActionCreator.off_topic(user0, post1)
+ PostActionCreator.spam(user0, post2)
+ PostActionCreator.spam(user1, post2)
+
+ get "/review/topics.json"
+ expect(response.code).to eq("200")
+
+ json = ::JSON.parse(response.body)
+ expect(json['reviewable_topics']).to be_present
+
+ json_topic = json['reviewable_topics'].find { |rt| rt['id'] == post0.topic_id }
+ expect(json_topic['stats']['count']).to eq(2)
+ expect(json_topic['stats']['unique_users']).to eq(1)
+
+ json_topic = json['reviewable_topics'].find { |rt| rt['id'] == post2.topic_id }
+ expect(json_topic['stats']['count']).to eq(2)
+ expect(json_topic['stats']['unique_users']).to eq(2)
+ end
+ end
+
+ context "#update" do
+ let(:reviewable) { Fabricate(:reviewable) }
+ let(:reviewable_post) { Fabricate(:reviewable_queued_post) }
+ let(:reviewable_topic) { Fabricate(:reviewable_queued_post_topic) }
+ let(:moderator) { Fabricate(:moderator) }
+
+ before do
+ sign_in(moderator)
+ end
+
+ it "returns 404 when the reviewable does not exist" do
+ put "/review/12345.json?version=0"
+ expect(response.code).to eq("404")
+ end
+
+ it "returns access denied if there are no editable fields" do
+ put(
+ "/review/#{reviewable.id}.json?version=#{reviewable.version}",
+ params: { reviewable: { field: 'value' } }
+ )
+ expect(response.code).to eq("403")
+ end
+
+ it "returns access denied if you try to update a field that doesn't exist" do
+ put(
+ "/review/#{reviewable_post.id}.json?version=#{reviewable_post.version}",
+ params: { reviewable: { field: 'value' } }
+ )
+ expect(response.code).to eq("403")
+ end
+
+ it "requires a version parameter" do
+ put "/review/#{reviewable_post.id}.json"
+ expect(response.code).to eq("422")
+ end
+
+ it "fails if there is a version conflict" do
+ put "/review/#{reviewable_post.id}.json?version=#{reviewable_post.version + 2}",
+ params: {
+ reviewable: {
+ payload: {
+ raw: 'new raw content'
+ }
+ }
+ }
+
+ expect(response.code).to eq("409")
+ end
+
+ it "allows you to update a queued post" do
+ put "/review/#{reviewable_post.id}.json?version=#{reviewable_post.version}",
+ params: {
+ reviewable: {
+ payload: {
+ raw: 'new raw content'
+ }
+ }
+ }
+
+ expect(response.code).to eq("200")
+ reviewable_post.reload
+ expect(reviewable_post.payload['raw']).to eq('new raw content')
+
+ history = ReviewableHistory.find_by(
+ reviewable_id: reviewable_post.id,
+ created_by_id: moderator.id,
+ reviewable_history_type: ReviewableHistory.types[:edited]
+ )
+ expect(history).to be_present
+
+ json = ::JSON.parse(response.body)
+ expect(json['payload']['raw']).to eq('new raw content')
+ expect(json['version'] > 0).to eq(true)
+ end
+
+ it "allows you to update a queued post (for new topic)" do
+ new_category_id = Fabricate(:category).id
+
+ put "/review/#{reviewable_topic.id}.json?version=#{reviewable_topic.version}",
+ params: {
+ reviewable: {
+ payload: {
+ raw: 'new topic op',
+ title: 'new topic title',
+ tags: ['t2', 't3', 't1']
+ },
+ category_id: new_category_id
+ }
+ }
+
+ expect(response.code).to eq("200")
+ reviewable_topic.reload
+ expect(reviewable_topic.payload['raw']).to eq('new topic op')
+ expect(reviewable_topic.payload['title']).to eq('new topic title')
+ expect(reviewable_topic.payload['extra']).to eq('some extra data')
+ expect(reviewable_topic.payload['tags']).to eq(['t2', 't3', 't1'])
+ expect(reviewable_topic.category_id).to eq(new_category_id)
+
+ json = ::JSON.parse(response.body)
+ expect(json['payload']['raw']).to eq('new topic op')
+ expect(json['payload']['title']).to eq('new topic title')
+ expect(json['payload']['extra']).to be_blank
+ expect(json['category_id']).to eq(new_category_id.to_s)
+ end
+
+ end
+
+ end
+
+end
diff --git a/spec/requests/topics_controller_spec.rb b/spec/requests/topics_controller_spec.rb
index 4e7c55bb4c6..ad9910ee425 100644
--- a/spec/requests/topics_controller_spec.rb
+++ b/spec/requests/topics_controller_spec.rb
@@ -2013,7 +2013,7 @@ RSpec.describe TopicsController do
post = create_post
post2 = create_post(topic_id: post.topic_id)
- PostAction.act(user, post2, bookmark)
+ PostActionCreator.new(user, post2, bookmark).perform
put "/t/#{post.topic_id}/bookmark.json"
expect(PostAction.where(user_id: user.id, post_action_type: bookmark).count).to eq(2)
diff --git a/spec/requests/user_actions_controller_spec.rb b/spec/requests/user_actions_controller_spec.rb
index 2e68d54da0f..351e632db72 100644
--- a/spec/requests/user_actions_controller_spec.rb
+++ b/spec/requests/user_actions_controller_spec.rb
@@ -1,5 +1,4 @@
require 'rails_helper'
-require_dependency 'post_enqueuer'
describe UserActionsController do
context 'index' do
@@ -10,7 +9,7 @@ describe UserActionsController do
end
it "returns a 404 for a user with a hidden profile" do
- UserActionCreator.enable
+ UserActionManager.enable
post = Fabricate(:post)
post.user.user_option.update_column(:hide_profile_and_presence, true)
@@ -19,8 +18,8 @@ describe UserActionsController do
end
it 'renders list correctly' do
- UserActionCreator.enable
- post = Fabricate(:post)
+ UserActionManager.enable
+ post = create_post
get "/user_actions.json", params: { username: post.user.username }
@@ -35,12 +34,12 @@ describe UserActionsController do
end
it 'can be filtered by acting_username' do
- UserActionCreator.enable
+ UserActionManager.enable
PostActionNotifier.enable
post = Fabricate(:post)
user = Fabricate(:user)
- PostAction.act(user, post, PostActionType.types[:like])
+ PostActionCreator.like(user, post)
get "/user_actions.json", params: {
username: post.user.username,
@@ -87,37 +86,5 @@ describe UserActionsController do
expect(parsed["no_results_help"]).to eq(I18n.t("user_activity.no_bookmarks.others"))
end
- context "queued posts" do
- context "without access" do
- let(:user) { Fabricate(:user) }
- it "raises an exception" do
- get "/user_actions.json", params: {
- username: user.username, filter: UserAction::PENDING
- }
- expect(response).to be_forbidden
- end
- end
-
- context "with access" do
- let(:user) { sign_in(Fabricate(:user)) }
-
- it 'finds queued posts' do
- queued_post = PostEnqueuer.new(user, 'default').enqueue(raw: 'this is the raw enqueued content')
-
- get "/user_actions.json", params: {
- username: user.username, filter: UserAction::PENDING
- }
-
- expect(response.status).to eq(200)
- parsed = JSON.parse(response.body)
- actions = parsed["user_actions"]
- expect(actions.length).to eq(1)
-
- action = actions.first
- expect(action['username']).to eq(user.username)
- expect(action['excerpt']).to be_present
- end
- end
- end
end
end
diff --git a/spec/serializers/post_serializer_spec.rb b/spec/serializers/post_serializer_spec.rb
index 723ab53bcf5..00c78376de4 100644
--- a/spec/serializers/post_serializer_spec.rb
+++ b/spec/serializers/post_serializer_spec.rb
@@ -23,7 +23,7 @@ describe PostSerializer do
before do
acted_ids.each do |id|
- PostAction.act(actor, post, id)
+ PostActionCreator.new(actor, post, id).perform
end
post.reload
end
diff --git a/spec/serializers/reviewable_queued_post_serializer_spec.rb b/spec/serializers/reviewable_queued_post_serializer_spec.rb
new file mode 100644
index 00000000000..11bc89964f8
--- /dev/null
+++ b/spec/serializers/reviewable_queued_post_serializer_spec.rb
@@ -0,0 +1,65 @@
+require 'rails_helper'
+
+describe ReviewableQueuedPostSerializer do
+ let(:admin) { Fabricate(:admin) }
+
+ context "new topic" do
+ let(:reviewable) { Fabricate(:reviewable_queued_post_topic) }
+
+ it "allows us to edit category / title" do
+ json = ReviewableQueuedPostSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
+
+ payload = json[:payload]
+ expect(payload['raw']).to eq('hello world post contents.')
+ expect(payload['title']).to eq('queued post title')
+ expect(payload['tags']).to eq(['cool', 'neat'])
+ expect(json[:topic_id]).to be_blank
+ expect(json[:can_edit]).to eq(true)
+
+ fields = json[:editable_fields]
+ expect(fields).to be_present
+
+ category_field = fields.find { |f| f[:id] == 'category_id' }
+ expect(category_field).to be_present
+ expect(category_field[:type]).to eq(:category)
+
+ title_field = fields.find { |f| f[:id] == 'payload.title' }
+ expect(title_field).to be_present
+ expect(title_field[:type]).to eq(:text)
+
+ raw_field = fields.find { |f| f[:id] == 'payload.raw' }
+ expect(raw_field).to be_present
+ expect(raw_field[:type]).to eq(:editor)
+
+ tags_field = fields.find { |f| f[:id] == 'payload.tags' }
+ expect(tags_field).to be_present
+ expect(tags_field[:type]).to eq(:tags)
+ end
+ end
+
+ context "reply to an existing topic" do
+ let(:reviewable) { Fabricate(:reviewable_queued_post) }
+
+ it "includes correct user fields" do
+ json = ReviewableQueuedPostSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
+
+ payload = json[:payload]
+
+ expect(payload['raw']).to eq('hello world post contents.')
+ expect(payload['title']).to be_blank
+ expect(json[:topic_id]).to eq(reviewable.topic_id)
+ expect(json[:can_edit]).to eq(true)
+
+ fields = json[:editable_fields]
+ expect(fields).to be_present
+
+ expect(fields.any? { |f| f[:id] == 'payload.title' }).to eq(false)
+ expect(fields.any? { |f| f[:id] == 'category_id' }).to eq(false)
+
+ raw_field = fields.find { |f| f[:id] == 'payload.raw' }
+ expect(raw_field).to be_present
+ expect(raw_field[:type]).to eq(:editor)
+ end
+ end
+
+end
diff --git a/spec/serializers/reviewable_serializer_spec.rb b/spec/serializers/reviewable_serializer_spec.rb
new file mode 100644
index 00000000000..9c5558ad5e2
--- /dev/null
+++ b/spec/serializers/reviewable_serializer_spec.rb
@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+describe ReviewableSerializer do
+
+ let(:reviewable) { Fabricate(:reviewable_queued_post) }
+ let(:admin) { Fabricate(:admin) }
+
+ it "serializes all the fields" do
+ json = ReviewableSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
+
+ expect(json[:id]).to eq(reviewable.id)
+ expect(json[:status]).to eq(reviewable.status)
+ expect(json[:type]).to eq(reviewable.type)
+ expect(json[:created_at]).to eq(reviewable.created_at)
+ expect(json[:category_id]).to eq(reviewable.category_id)
+ expect(json[:can_edit]).to eq(true)
+ expect(json[:version]).to eq(0)
+ end
+
+ it "will not throw an error when the payload is `nil`" do
+ reviewable.payload = nil
+ json = ReviewableQueuedPostSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
+ expect(json['payload']).to be_blank
+ end
+
+end
diff --git a/spec/serializers/reviewable_user_serializer_spec.rb b/spec/serializers/reviewable_user_serializer_spec.rb
new file mode 100644
index 00000000000..8e6a63e51a9
--- /dev/null
+++ b/spec/serializers/reviewable_user_serializer_spec.rb
@@ -0,0 +1,16 @@
+require 'rails_helper'
+
+describe ReviewableUserSerializer do
+
+ let(:reviewable) { Fabricate(:reviewable) }
+ let(:admin) { Fabricate(:admin) }
+
+ it "includes the user fields for review" do
+ json = ReviewableUserSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
+ expect(json[:user_id]).to eq(reviewable.target_id)
+ expect(json[:username]).to eq(reviewable.target.username)
+ expect(json[:email]).to eq(reviewable.target.email)
+ expect(json[:name]).to eq(reviewable.target.name)
+ end
+
+end
diff --git a/spec/serializers/user_summary_serializer_spec.rb b/spec/serializers/user_summary_serializer_spec.rb
index 55a53f54cef..54354dabdf1 100644
--- a/spec/serializers/user_summary_serializer_spec.rb
+++ b/spec/serializers/user_summary_serializer_spec.rb
@@ -2,11 +2,11 @@ require 'rails_helper'
describe UserSummarySerializer do
it "returns expected data" do
- UserActionCreator.enable
+ UserActionManager.enable
user = Fabricate(:user)
liked_user = Fabricate(:user, name: "John Doe", username: "john_doe")
liked_post = create_post(user: liked_user)
- PostAction.act(user, liked_post, PostActionType.types[:like])
+ PostActionCreator.like(user, liked_post)
guardian = Guardian.new(user)
summary = UserSummary.new(user, guardian)
diff --git a/spec/services/auto_silence_spec.rb b/spec/services/auto_silence_spec.rb
index f86bcab24bd..aba66ed964d 100644
--- a/spec/services/auto_silence_spec.rb
+++ b/spec/services/auto_silence_spec.rb
@@ -3,8 +3,8 @@ require 'rails_helper'
describe SpamRule::AutoSilence do
before do
- SiteSetting.flags_required_to_hide_post = 0 # never
- SiteSetting.num_spam_flags_to_silence_new_user = 2
+ SiteSetting.score_required_to_hide_post = 0 # never
+ SiteSetting.spam_score_to_silence_new_user = 4.0
SiteSetting.num_users_to_silence_new_user = 2
end
@@ -19,44 +19,46 @@ describe SpamRule::AutoSilence do
end
it 'delivers punishment when user should be silenced' do
- SiteSetting.num_spam_flags_to_silence_new_user = 1
+ SiteSetting.spam_score_to_silence_new_user = 2.0
SiteSetting.num_users_to_silence_new_user = 1
- PostAction.act(Discourse.system_user, post, PostActionType.types[:spam])
+ PostActionCreator.spam(Discourse.system_user, post)
subject.perform
expect(post.user.reload).to be_silenced
end
end
- describe 'num_spam_flags_against_user' do
- let(:post) { Fabricate(:post) }
+ describe 'total_spam_score' do
+ let(:post) { Fabricate(:post) }
let(:enforcer) { described_class.new(post.user) }
- subject { enforcer.num_spam_flags_against_user }
+ let(:flagger) { Fabricate(:user) }
+ subject { enforcer.user_spam_stats.total_spam_score }
it 'returns 0 when there are no flags' do
expect(subject).to eq(0)
end
it 'returns 0 when there is one flag that has a reason other than spam' do
- Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:off_topic])
+ PostActionCreator.off_topic(flagger, post)
expect(subject).to eq(0)
end
- it 'returns 2 when there are two flags with spam as the reason' do
- 2.times { Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam]) }
- expect(subject).to eq(2)
+ it 'returns the score when there are two flags with spam as the reason' do
+ PostActionCreator.spam(Fabricate(:user), post)
+ PostActionCreator.spam(Fabricate(:user), post)
+ expect(subject).to eq(4.0)
end
- it 'returns 2 when there are two spam flags, each on a different post' do
- Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
- Fabricate(:flag, post: Fabricate(:post, user: post.user), post_action_type_id: PostActionType.types[:spam])
- expect(subject).to eq(2)
+ it 'returns the score when there are two spam flags, each on a different post' do
+ PostActionCreator.spam(Fabricate(:user), post)
+ PostActionCreator.spam(Fabricate(:user), Fabricate(:post, user: post.user))
+ expect(subject).to eq(4.0)
end
end
- describe 'num_users_who_flagged_spam_against_user' do
+ describe 'spam_user_count' do
let(:post) { Fabricate(:post) }
let(:enforcer) { described_class.new(post.user) }
- subject { enforcer.num_users_who_flagged_spam_against_user }
+ subject { enforcer.user_spam_stats.spam_user_count }
it 'returns 0 when there are no flags' do
expect(subject).to eq(0)
@@ -68,62 +70,24 @@ describe SpamRule::AutoSilence do
end
it 'returns 1 when there is one spam flag' do
- Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
+ PostActionCreator.spam(Fabricate(:user), post)
expect(subject).to eq(1)
end
it 'returns 2 when there are two spam flags from 2 users' do
- Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
- Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
+ PostActionCreator.spam(Fabricate(:user), post)
+ PostActionCreator.spam(Fabricate(:user), post)
expect(subject).to eq(2)
end
it 'returns 1 when there are two spam flags on two different posts from 1 user' do
flagger = Fabricate(:user)
- Fabricate(:flag, post: post, user: flagger, post_action_type_id: PostActionType.types[:spam])
- Fabricate(:flag, post: Fabricate(:post, user: post.user), user: flagger, post_action_type_id: PostActionType.types[:spam])
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger, Fabricate(:post, user: post.user))
expect(subject).to eq(1)
end
end
- describe 'num_tl3_flags_against_user' do
- let(:post) { Fabricate(:post) }
- let(:enforcer) { described_class.new(post.user) }
-
- it "counts flags of all types from tl3 users only" do
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 1), post_action_type_id: PostActionType.types[:inappropriate])
- expect(enforcer.num_tl3_flags_against_user).to eq(0)
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 3), post_action_type_id: PostActionType.types[:inappropriate])
- expect(enforcer.num_tl3_flags_against_user).to eq(1)
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 1), post_action_type_id: PostActionType.types[:spam])
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 3), post_action_type_id: PostActionType.types[:spam])
- expect(enforcer.num_tl3_flags_against_user).to eq(2)
- end
- end
-
- describe 'num_tl3_users_who_flagged' do
- let(:post) { Fabricate(:post) }
- let(:enforcer) { described_class.new(post.user) }
-
- it "counts only tl3 users who flagged with any type" do
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 1), post_action_type_id: PostActionType.types[:inappropriate])
- expect(enforcer.num_tl3_users_who_flagged).to eq(0)
-
- tl3_user1 = Fabricate(:user, trust_level: 3)
- Fabricate(:flag, post: post, user: tl3_user1, post_action_type_id: PostActionType.types[:inappropriate])
- expect(enforcer.num_tl3_users_who_flagged).to eq(1)
-
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 1), post_action_type_id: PostActionType.types[:spam])
- expect(enforcer.num_tl3_users_who_flagged).to eq(1)
-
- Fabricate(:flag, post: post, user: Fabricate(:user, trust_level: 3), post_action_type_id: PostActionType.types[:spam])
- expect(enforcer.num_tl3_users_who_flagged).to eq(2)
-
- Fabricate(:flag, post: Fabricate(:post, user: post.user), user: tl3_user1, post_action_type_id: PostActionType.types[:inappropriate])
- expect(enforcer.num_tl3_users_who_flagged).to eq(2)
- end
- end
-
describe 'silence_user' do
let!(:admin) { Fabricate(:admin) } # needed for SystemMessage
let(:user) { Fabricate(:user) }
@@ -175,8 +139,8 @@ describe SpamRule::AutoSilence do
context "higher trust levels or staff" do
it "should not autosilence any of them" do
- PostAction.act(flagger, post, PostActionType.types[:spam])
- PostAction.act(flagger2, post, PostActionType.types[:spam])
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger2, post)
enforcer = described_class.new(user)
expect(enforcer.should_autosilence?).to eq(true)
@@ -205,84 +169,50 @@ describe SpamRule::AutoSilence do
context 'new user' do
subject { described_class.new(user) }
+ let(:stats) { subject.user_spam_stats }
it 'returns false if there are no spam flags' do
- expect(subject.num_spam_flags_against_user).to eq(0)
- expect(subject.num_users_who_flagged_spam_against_user).to eq(0)
+ expect(stats.total_spam_score).to eq(0)
+ expect(stats.spam_user_count).to eq(0)
expect(subject.should_autosilence?).to eq(false)
end
it 'returns false if there are not received enough flags' do
- PostAction.act(flagger, post, PostActionType.types[:spam])
- expect(subject.num_spam_flags_against_user).to eq(1)
- expect(subject.num_users_who_flagged_spam_against_user).to eq(1)
+ PostActionCreator.spam(flagger, post)
+ expect(stats.total_spam_score).to eq(2.0)
+ expect(stats.spam_user_count).to eq(1)
expect(subject.should_autosilence?).to eq(false)
end
it 'returns false if there have not been enough users' do
- PostAction.act(flagger, post, PostActionType.types[:spam])
- PostAction.act(flagger, post2, PostActionType.types[:spam])
- expect(subject.num_spam_flags_against_user).to eq(2)
- expect(subject.num_users_who_flagged_spam_against_user).to eq(1)
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger, post2)
+ expect(stats.total_spam_score).to eq(4.0)
+ expect(stats.spam_user_count).to eq(1)
expect(subject.should_autosilence?).to eq(false)
end
- it 'returns false if num_spam_flags_to_silence_new_user is 0' do
- SiteSetting.num_spam_flags_to_silence_new_user = 0
- PostAction.act(flagger, post, PostActionType.types[:spam])
- PostAction.act(flagger2, post, PostActionType.types[:spam])
+ it 'returns false if spam_score_to_silence_new_user is 0' do
+ SiteSetting.spam_score_to_silence_new_user = 0
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger2, post)
expect(subject.should_autosilence?).to eq(false)
end
it 'returns false if num_users_to_silence_new_user is 0' do
SiteSetting.num_users_to_silence_new_user = 0
- PostAction.act(flagger, post, PostActionType.types[:spam])
- PostAction.act(flagger2, post, PostActionType.types[:spam])
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger2, post)
expect(subject.should_autosilence?).to eq(false)
end
it 'returns true when there are enough flags from enough users' do
- PostAction.act(flagger, post, PostActionType.types[:spam])
- PostAction.act(flagger2, post, PostActionType.types[:spam])
- expect(subject.num_spam_flags_against_user).to eq(2)
- expect(subject.num_users_who_flagged_spam_against_user).to eq(2)
+ PostActionCreator.spam(flagger, post)
+ PostActionCreator.spam(flagger2, post)
+ expect(stats.total_spam_score).to eq(4.0)
+ expect(stats.spam_user_count).to eq(2)
expect(subject.should_autosilence?).to eq(true)
end
-
- context "all types of flags" do
- let(:leader1) { Fabricate(:leader) }
- let(:leader2) { Fabricate(:leader) }
-
- before do
- SiteSetting.num_tl3_flags_to_silence_new_user = 3
- SiteSetting.num_tl3_users_to_silence_new_user = 2
- end
-
- it 'returns false if there are not enough flags' do
- PostAction.act(leader1, post, PostActionType.types[:inappropriate])
- expect(subject.num_tl3_flags_against_user).to eq(1)
- expect(subject.num_tl3_users_who_flagged).to eq(1)
- expect(subject.should_autosilence?).to be_falsey
- end
-
- it 'returns false if enough flags but not enough users' do
- PostAction.act(leader1, post, PostActionType.types[:inappropriate])
- PostAction.act(leader1, post2, PostActionType.types[:inappropriate])
- PostAction.act(leader1, Fabricate(:post, user: user), PostActionType.types[:inappropriate])
- expect(subject.num_tl3_flags_against_user).to eq(3)
- expect(subject.num_tl3_users_who_flagged).to eq(1)
- expect(subject.should_autosilence?).to eq(false)
- end
-
- it 'returns true if enough flags and users' do
- PostAction.act(leader1, post, PostActionType.types[:inappropriate])
- PostAction.act(leader1, post2, PostActionType.types[:inappropriate])
- PostAction.act(leader2, post, PostActionType.types[:inappropriate])
- expect(subject.num_tl3_flags_against_user).to eq(3)
- expect(subject.num_tl3_users_who_flagged).to eq(2)
- expect(subject.should_autosilence?).to eq(true)
- end
- end
end
context "silenced, but has higher trust level now" do
diff --git a/spec/services/badge_granter_spec.rb b/spec/services/badge_granter_spec.rb
index e79288ce7e1..c75f55b4d1b 100644
--- a/spec/services/badge_granter_spec.rb
+++ b/spec/services/badge_granter_spec.rb
@@ -58,7 +58,7 @@ describe BadgeGranter do
it 'can backfill the welcome badge' do
post = Fabricate(:post)
user2 = Fabricate(:user)
- PostAction.act(user2, post, PostActionType.types[:like])
+ PostActionCreator.like(user2, post)
UserBadge.destroy_all
BadgeGranter.backfill(Badge.find(Badge::Welcome))
@@ -258,12 +258,12 @@ describe BadgeGranter do
it "grants system like badges" do
post = create_post(user: user)
# Welcome badge
- action = PostAction.act(liker, post, PostActionType.types[:like])
+ action = PostActionCreator.like(liker, post).post_action
BadgeGranter.process_queue!
expect(UserBadge.find_by(user_id: user.id, badge_id: 5)).not_to eq(nil)
post = create_post(topic: post.topic, user: user)
- action = PostAction.act(liker, post, PostActionType.types[:like])
+ action = PostActionCreator.like(liker, post).post_action
# Nice post badge
post.update_attributes like_count: 10
diff --git a/spec/services/post_action_notifier_spec.rb b/spec/services/post_action_notifier_spec.rb
index 85d978fcf30..d2d049e0ccf 100644
--- a/spec/services/post_action_notifier_spec.rb
+++ b/spec/services/post_action_notifier_spec.rb
@@ -1,5 +1,4 @@
require 'rails_helper'
-require_dependency 'post_destroyer'
describe PostActionNotifier do
@@ -64,7 +63,7 @@ describe PostActionNotifier do
other_user = Fabricate(:user)
topic.allowed_users << user << other_user
expect {
- PostAction.act(other_user, mention_post, PostActionType.types[:like])
+ PostActionCreator.like(other_user, mention_post)
}.to change(user.notifications, :count)
end
end
diff --git a/spec/services/post_alerter_spec.rb b/spec/services/post_alerter_spec.rb
index c21405d6b24..cc6453d8a36 100644
--- a/spec/services/post_alerter_spec.rb
+++ b/spec/services/post_alerter_spec.rb
@@ -125,10 +125,10 @@ describe PostAlerter do
coding_horror = Fabricate(:coding_horror)
PostActionNotifier.enable
- SiteSetting.flags_required_to_hide_post = 2
+ SiteSetting.score_required_to_hide_post = 4.0
- PostAction.act(evil_trout, post, PostActionType.types[:spam])
- PostAction.act(walterwhite, post, PostActionType.types[:spam])
+ PostActionCreator.spam(evil_trout, post)
+ PostActionCreator.spam(walterwhite, post)
post.reload
expect(post.hidden).to eq(true)
@@ -146,8 +146,8 @@ describe PostAlerter do
expect(notification.post_number).to eq(post.post_number)
expect(notification.data_hash["display_username"]).to eq(post.user.username)
- PostAction.act(coding_horror, post, PostActionType.types[:spam])
- PostAction.act(walterwhite, post, PostActionType.types[:off_topic])
+ PostActionCreator.create(coding_horror, post, :spam)
+ PostActionCreator.create(walterwhite, post, :off_topic)
post.reload
expect(post.hidden).to eq(true)
diff --git a/spec/services/post_owner_changer_spec.rb b/spec/services/post_owner_changer_spec.rb
index aeeaeea605c..d6930518878 100644
--- a/spec/services/post_owner_changer_spec.rb
+++ b/spec/services/post_owner_changer_spec.rb
@@ -3,11 +3,11 @@ require "rails_helper"
describe PostOwnerChanger do
describe "change_owner!" do
let!(:editor) { Fabricate(:admin) }
- let(:topic) { Fabricate(:topic) }
let(:user_a) { Fabricate(:user) }
- let(:p1) { Fabricate(:post, topic: topic, post_number: 1) }
- let(:p2) { Fabricate(:post, topic: topic, post_number: 2) }
- let(:p3) { Fabricate(:post) }
+ let(:p1) { create_post(post_number: 1) }
+ let(:topic) { p1.topic }
+ let(:p2) { create_post(topic: topic, post_number: 2) }
+ let(:p3) { create_post }
it "raises an error with a parameter missing" do
expect {
@@ -23,10 +23,8 @@ describe PostOwnerChanger do
it "changes the user" do
bumped_at = topic.bumped_at
- freeze_time 2.days.from_now
-
old_user = p1.user
- PostAction.act(user_a, p1, PostActionType.types[:like])
+ PostActionCreator.like(user_a, p1)
p1.reload
expect(p1.topic.like_count).to eq(1)
PostOwnerChanger.new(post_ids: [p1.id], topic_id: topic.id, new_owner: user_a, acting_user: editor).change_owner!
@@ -84,7 +82,7 @@ describe PostOwnerChanger do
end
context "sets topic notification level for the new owner" do
- let(:p4) { Fabricate(:post, post_number: 2, topic: topic) }
+ let(:p4) { create_post(post_number: 2, topic: topic) }
it "'watching' if the first post gets a new owner" do
PostOwnerChanger.new(post_ids: [p1.id], topic_id: topic.id, new_owner: user_a, acting_user: editor).change_owner!
@@ -125,7 +123,7 @@ describe PostOwnerChanger do
UserAction.create!(action_type: UserAction::REPLY, user_id: p2user.id, acting_user_id: p2user.id,
target_post_id: p2.id, target_topic_id: p2.topic_id, created_at: p2.created_at)
- UserActionCreator.enable
+ UserActionManager.enable
end
subject(:change_owners) do
@@ -138,7 +136,7 @@ describe PostOwnerChanger do
end
it "updates users' topic and post counts" do
- PostAction.act(p2user, p1, PostActionType.types[:like])
+ PostActionCreator.like(p2user, p1)
expect(p1user.user_stat.reload.likes_received).to eq(1)
change_owners
@@ -190,16 +188,28 @@ describe PostOwnerChanger do
end
context 'private message topic' do
- let(:topic) { Fabricate(:private_message_topic) }
+ # let(:topic) { Fabricate(:private_message_topic) }
+ let(:pm) do
+ create_post(
+ archetype: 'private_message',
+ target_usernames: [p2user.username]
+ )
+ end
+ let(:pm_poster) { pm.user }
it "should update users' counts" do
- PostAction.act(p2user, p1, PostActionType.types[:like])
+ PostActionCreator.like(p2user, pm)
expect {
- change_owners
- }.to_not change { p1user.user_stat.post_count }
+ PostOwnerChanger.new(
+ post_ids: [pm.id],
+ topic_id: pm.topic_id,
+ new_owner: user_a,
+ acting_user: editor
+ ).change_owner!
+ }.to_not change { pm_poster.user_stat.post_count }
- expect(p1user.user_stat.likes_received).to eq(0)
+ expect(pm_poster.user_stat.likes_received).to eq(0)
user_a_stat = user_a.user_stat
expect(user_a_stat.first_post_created_at).to be_present
diff --git a/spec/services/staff_action_logger_spec.rb b/spec/services/staff_action_logger_spec.rb
index 41ea44c06c4..f2cfc054e4d 100644
--- a/spec/services/staff_action_logger_spec.rb
+++ b/spec/services/staff_action_logger_spec.rb
@@ -490,23 +490,20 @@ describe StaffActionLogger do
end
describe 'log_post_rejected' do
- let(:rejected_post) { Fabricate(:queued_post) }
+ let(:reviewable) { Fabricate(:reviewable_queued_post) }
- subject(:log_post_rejected) { described_class.new(admin).log_post_rejected(rejected_post) }
+ subject(:log_post_rejected) { described_class.new(admin).log_post_rejected(reviewable, DateTime.now) }
- it 'raises an error when post is nil' do
- expect { logger.log_post_rejected(nil) }.to raise_error(Discourse::InvalidParameters)
- end
-
- it 'raises an error when post is not a QueuedPosts' do
- expect { logger.log_post_rejected(1) }.to raise_error(Discourse::InvalidParameters)
+ it 'raises an error when reviewable not supplied' do
+ expect { logger.log_post_rejected(nil, DateTime.now) }.to raise_error(Discourse::InvalidParameters)
+ expect { logger.log_post_rejected(1, DateTime.now) }.to raise_error(Discourse::InvalidParameters)
end
it 'creates a new UserHistory record' do
expect { log_post_rejected }.to change { UserHistory.count }.by(1)
user_history = UserHistory.last
expect(user_history.action).to eq(UserHistory.actions[:post_rejected])
- expect(user_history.details).to include(rejected_post.raw)
+ expect(user_history.details).to include(reviewable.payload['raw'])
end
end
end
diff --git a/spec/services/user_destroyer_spec.rb b/spec/services/user_destroyer_spec.rb
index fdfa12b39f8..da654bb2db6 100644
--- a/spec/services/user_destroyer_spec.rb
+++ b/spec/services/user_destroyer_spec.rb
@@ -89,12 +89,12 @@ describe UserDestroyer do
end
end
- context "with a queued post" do
- let!(:qp) { Fabricate(:queued_post, user: user) }
+ context "with a reviewable post" do
+ let!(:reviewable) { Fabricate(:reviewable, created_by: user) }
it "removes the queued post" do
UserDestroyer.new(admin).destroy(user)
- expect(QueuedPost.where(user_id: user.id).count).to eq(0)
+ expect(Reviewable.where(created_by_id: user.id).count).to eq(0)
end
end
@@ -177,15 +177,15 @@ describe UserDestroyer do
before { destroy_opts[:delete_as_spammer] = true }
- it "agrees with flags on user's posts" do
+ it "approves reviewable flags" do
spammer_post = Fabricate(:post, user: @user)
- flag = PostAction.act(@admin, spammer_post, PostActionType.types[:inappropriate])
- expect(flag.agreed_at).to eq(nil)
+ reviewable = PostActionCreator.inappropriate(@admin, spammer_post).reviewable
+ expect(reviewable).to be_pending
destroy
- flag.reload
- expect(flag.agreed_at).not_to eq(nil)
+ reviewable.reload
+ expect(reviewable).to be_approved
end
end
@@ -335,7 +335,7 @@ describe UserDestroyer do
before do
@topic = Fabricate(:topic, user: Fabricate(:user))
@post = Fabricate(:post, user: @topic.user, topic: @topic)
- @like = PostAction.act(@user, @post, PostActionType.types[:like])
+ PostActionCreator.like(@user, @post)
end
it 'should destroy the like' do
diff --git a/spec/services/user_merger_spec.rb b/spec/services/user_merger_spec.rb
index dd9490d4908..4f5cdbf4dd1 100644
--- a/spec/services/user_merger_spec.rb
+++ b/spec/services/user_merger_spec.rb
@@ -162,17 +162,17 @@ describe UserMerger do
now = Time.zone.now
freeze_time(now - 1.day)
- PostAction.act(source_user, p1, PostActionType.types[:like])
- PostAction.act(source_user, p2, PostActionType.types[:like])
- PostAction.act(target_user, p2, PostActionType.types[:like])
- PostAction.act(target_user, p3, PostActionType.types[:like])
+ PostActionCreator.like(source_user, p1)
+ PostActionCreator.like(source_user, p2)
+ PostActionCreator.like(target_user, p2)
+ PostActionCreator.like(target_user, p3)
freeze_time(now)
- PostAction.act(source_user, p4, PostActionType.types[:like])
- PostAction.act(source_user, p5, PostActionType.types[:like])
- PostAction.act(target_user, p5, PostActionType.types[:like])
- PostAction.act(source_user, p6, PostActionType.types[:like])
- PostAction.remove_act(source_user, p6, PostActionType.types[:like])
+ PostActionCreator.like(source_user, p4)
+ PostActionCreator.like(source_user, p5)
+ PostActionCreator.like(target_user, p5)
+ PostActionCreator.like(source_user, p6)
+ PostActionDestroyer.destroy(source_user, p6, :like)
merge_users!
@@ -337,10 +337,10 @@ describe UserMerger do
type_ids = PostActionType.public_type_ids + [PostActionType.flag_types.values.first]
type_ids.each do |type|
- PostAction.act(source_user, p1, type)
- PostAction.act(source_user, p2, type)
- PostAction.act(target_user, p2, type)
- PostAction.act(target_user, p3, type)
+ PostActionCreator.new(source_user, p1, type).perform
+ PostActionCreator.new(source_user, p2, type).perform
+ PostActionCreator.new(target_user, p2, type).perform
+ PostActionCreator.new(target_user, p3, type).perform
end
merge_users!
@@ -359,16 +359,16 @@ describe UserMerger do
p3 = Fabricate(:post)
p4 = Fabricate(:post)
- action1 = PostAction.act(source_user, p1, PostActionType.flag_types[:off_topic])
+ action1 = PostActionCreator.create(source_user, p1, :off_topic).post_action
action1.update_attribute(:deleted_by_id, source_user.id)
- action2 = PostAction.act(source_user, p2, PostActionType.flag_types[:off_topic])
+ action2 = PostActionCreator.create(source_user, p2, :off_topic).post_action
action2.update_attribute(:deferred_by_id, source_user.id)
- action3 = PostAction.act(source_user, p3, PostActionType.flag_types[:off_topic])
+ action3 = PostActionCreator.create(source_user, p3, :off_topic).post_action
action3.update_attribute(:agreed_by_id, source_user.id)
- action4 = PostAction.act(source_user, p4, PostActionType.flag_types[:off_topic])
+ action4 = PostActionCreator.create(source_user, p4, :off_topic).post_action
action4.update_attribute(:disagreed_by_id, source_user.id)
merge_users!
@@ -452,8 +452,8 @@ describe UserMerger do
PostActionType.types.each do |type_name, type_id|
posts[type_name] = post = Fabricate(:post, user: walter)
- PostAction.act(source_user, post, type_id)
- PostAction.act(target_user, post, type_id)
+ PostActionCreator.new(source_user, post, type_id).perform
+ PostActionCreator.new(target_user, post, type_id).perform
end
merge_users!
@@ -465,17 +465,13 @@ describe UserMerger do
end
end
- it "updates queued posts" do
- topic = Fabricate(:topic)
- post1 = Fabricate(:queued_post, topic: topic, user: source_user)
- post2 = Fabricate(:queued_post, topic: topic, approved_by: source_user)
- post3 = Fabricate(:queued_post, topic: topic, rejected_by: source_user)
+ it "updates reviewables and reviewable history" do
+ reviewable = Fabricate(:reviewable_queued_post, created_by: source_user)
merge_users!
- expect(post1.reload.user).to eq(target_user)
- expect(post2.reload.approved_by).to eq(target_user)
- expect(post3.reload.rejected_by).to eq(target_user)
+ expect(reviewable.reload.created_by).to eq(target_user)
+ expect(reviewable.reviewable_histories.first.created_by).to eq(target_user)
end
describe 'search logs' do
@@ -683,14 +679,6 @@ describe UserMerger do
let(:post2) { Fabricate(:post) }
let(:post3) { Fabricate(:post) }
- def log_pending_action(user, post)
- UserAction.log_action!(action_type: UserAction::PENDING,
- user_id: user.id,
- acting_user_id: user.id,
- target_topic_id: post.topic.id,
- queued_post_id: post.id)
- end
-
def log_like_action(acting_user, user, post)
UserAction.log_action!(action_type: UserAction::LIKE,
user_id: user.id,
@@ -707,22 +695,6 @@ describe UserMerger do
target_post_id: -1)
end
- it "merges when target_post_id is not set" do
- a1 = log_pending_action(source_user, post1)
- _a2 = log_pending_action(source_user, post2)
- a3 = log_pending_action(target_user, post2)
- a4 = log_pending_action(target_user, post3)
-
- merge_users!
-
- expect(UserAction.count).to eq(3)
-
- action_ids = UserAction.where(action_type: UserAction::PENDING,
- user_id: target_user.id,
- acting_user_id: target_user.id).pluck(:id)
- expect(action_ids).to contain_exactly(a1.id, a3.id, a4.id)
- end
-
it "merges when target_post_id is set" do
_a1 = log_like_action(source_user, walter, post1)
a2 = log_like_action(target_user, walter, post1)
diff --git a/spec/services/username_changer_spec.rb b/spec/services/username_changer_spec.rb
index 9c45d9a3f0d..15bb760a13f 100644
--- a/spec/services/username_changer_spec.rb
+++ b/spec/services/username_changer_spec.rb
@@ -84,14 +84,10 @@ describe UsernameChanger do
let(:topic) { Fabricate(:topic, user: user) }
before do
- UserActionCreator.enable
+ UserActionManager.enable
Discourse.expects(:warn_exception).never
end
- after do
- UserActionCreator.disable
- end
-
def create_post_and_change_username(args = {}, &block)
post = create_post(args.merge(topic_id: topic.id))
diff --git a/spec/support/diagnostics_helper.rb b/spec/support/diagnostics_helper.rb
index 11d131c98d6..8756a9ddbb3 100644
--- a/spec/support/diagnostics_helper.rb
+++ b/spec/support/diagnostics_helper.rb
@@ -18,6 +18,7 @@ module MessageBus::DiagnosticsHelper
ensure
@tracking = nil
end
+
end
module MessageBus
diff --git a/spec/support/discourse_event_helper.rb b/spec/support/discourse_event_helper.rb
index 0309a5c6fab..6ad49077361 100644
--- a/spec/support/discourse_event_helper.rb
+++ b/spec/support/discourse_event_helper.rb
@@ -13,6 +13,12 @@ module DiscourseEvent::TestHelper
@events_trigger = nil
events_trigger
end
+
+ def track(event_type)
+ events = track_events { yield }
+ events.find { |e| e[:event_name] == event_type }
+ end
+
end
DiscourseEvent.singleton_class.prepend DiscourseEvent::TestHelper
diff --git a/test/javascripts/acceptance/admin-flags-test.js.es6 b/test/javascripts/acceptance/admin-flags-test.js.es6
deleted file mode 100644
index 0ce460f4a77..00000000000
--- a/test/javascripts/acceptance/admin-flags-test.js.es6
+++ /dev/null
@@ -1,128 +0,0 @@
-import { acceptance } from "helpers/qunit-helpers";
-acceptance("Admin - Flagging", { loggedIn: true });
-
-QUnit.test("flagged posts", async assert => {
- await visit("/admin/flags/active");
-
- assert.equal(find(".flagged-posts .flagged-post").length, 1);
- assert.equal(
- find(".flagged-post .flag-user").length,
- 1,
- "shows who flagged it"
- );
- assert.equal(find(".flagged-post-response").length, 2);
- assert.equal(find(".flagged-post-response:eq(0) img.avatar").length, 1);
- assert.equal(
- find(".flagged-post-user-details .username").length,
- 1,
- "shows the flagged username"
- );
-});
-
-QUnit.test("flagged posts - agree", async assert => {
- const agreeFlag = selectKit(".agree-flag");
-
- await visit("/admin/flags/active");
-
- await agreeFlag.expand();
- await agreeFlag.selectRowByValue("confirm-agree-keep");
-
- assert.equal(
- find(".admin-flags .flagged-post").length,
- 0,
- "post was removed"
- );
-});
-
-QUnit.test("flagged posts - agree + hide", async assert => {
- const agreeFlag = selectKit(".agree-flag");
-
- await visit("/admin/flags/active");
-
- await agreeFlag.expand();
- await agreeFlag.selectRowByValue("confirm-agree-hide");
-
- assert.equal(
- find(".admin-flags .flagged-post").length,
- 0,
- "post was removed"
- );
-});
-
-QUnit.test("flagged posts - agree + deleteSpammer", async assert => {
- const agreeFlag = selectKit(".agree-flag");
-
- await visit("/admin/flags/active");
-
- await agreeFlag.expand();
- await agreeFlag.selectRowByValue("delete-spammer");
-
- await click(".confirm-delete");
-
- assert.equal(
- find(".admin-flags .flagged-post").length,
- 0,
- "post was removed"
- );
-});
-
-QUnit.test("flagged posts - disagree", async assert => {
- await visit("/admin/flags/active");
- await click(".disagree-flag");
-
- assert.equal(find(".admin-flags .flagged-post").length, 0);
-});
-
-QUnit.test("flagged posts - defer", async assert => {
- await visit("/admin/flags/active");
- await click(".defer-flag");
-
- assert.equal(find(".admin-flags .flagged-post").length, 0);
-});
-
-QUnit.test("flagged posts - delete + defer", async assert => {
- const deleteFlag = selectKit(".delete-flag");
-
- await visit("/admin/flags/active");
-
- await deleteFlag.expand();
- await deleteFlag.selectRowByValue("delete-defer");
-
- assert.equal(find(".admin-flags .flagged-post").length, 0);
-});
-
-QUnit.test("flagged posts - delete + agree", async assert => {
- const deleteFlag = selectKit(".delete-flag");
-
- await visit("/admin/flags/active");
-
- await deleteFlag.expand();
- await deleteFlag.selectRowByValue("delete-agree");
-
- assert.equal(find(".admin-flags .flagged-post").length, 0);
-});
-
-QUnit.test("flagged posts - delete + deleteSpammer", async assert => {
- const deleteFlag = selectKit(".delete-flag");
-
- await visit("/admin/flags/active");
-
- await deleteFlag.expand();
- await deleteFlag.selectRowByValue("delete-spammer");
-
- await click(".confirm-delete");
-
- assert.equal(find(".admin-flags .flagged-post").length, 0);
-});
-
-QUnit.test("topics with flags", async assert => {
- await visit("/admin/flags/topics");
-
- assert.equal(find(".flagged-topics .flagged-topic").length, 1);
- assert.equal(find(".flagged-topic .flagged-topic-user").length, 2);
- assert.equal(find(".flagged-topic div.flag-counts").length, 3);
-
- await click(".flagged-topic .show-details");
-
- assert.equal(currentURL(), "/admin/flags/topics/280");
-});
diff --git a/test/javascripts/acceptance/queued-posts-test.js.es6 b/test/javascripts/acceptance/queued-posts-test.js.es6
deleted file mode 100644
index 561c821eb1c..00000000000
--- a/test/javascripts/acceptance/queued-posts-test.js.es6
+++ /dev/null
@@ -1,183 +0,0 @@
-import { acceptance } from "helpers/qunit-helpers";
-
-acceptance("Queued Posts", {
- loggedIn: true,
- settings: { tagging_enabled: true },
- pretend(server, helper) {
- server.get("/queued_posts", () => {
- return helper.response({
- users: [
- {
- id: 3,
- username: "test_user",
- avatar_template:
- "/letter_avatar_proxy/v2/letter/t/eada6e/{size}.png",
- active: true,
- admin: false,
- moderator: false,
- last_seen_at: "2017-08-11T20:48:05.405Z",
- last_emailed_at: null,
- created_at: "2017-08-07T02:23:33.309Z",
- last_seen_age: "1d",
- last_emailed_age: null,
- created_at_age: "6d",
- username_lower: "test_user",
- trust_level: 0,
- trust_level_locked: false,
- flag_level: 0,
- title: null,
- suspended_at: null,
- suspended_till: null,
- suspended: null,
- silenced: false,
- time_read: "19m",
- staged: false,
- days_visited: 4,
- posts_read_count: 12,
- topics_entered: 6,
- post_count: 2
- }
- ],
- queued_posts: [
- {
- id: 22,
- queue: "default",
- user_id: 3,
- state: 1,
- topic_id: null,
- approved_by_id: null,
- rejected_by_id: null,
- raw: "some content",
- post_options: {
- archetype: "regular",
- category: "1",
- typing_duration_msecs: "3200",
- composer_open_duration_msecs: "19007",
- visible: true,
- is_warning: false,
- title: "a new topic that needs to be reviewed",
- ip_address: "172.17.0.1",
- first_post_checks: true,
- is_poll: true
- },
- created_at: "2017-08-11T20:43:41.115Z",
- category_id: 1,
- can_delete_user: true
- }
- ],
- __rest_serializer: "1",
- refresh_queued_posts: "/queued_posts?status=new"
- });
- });
- }
-});
-
-QUnit.test(
- "For topics: body of post, title, category and tags are all editable",
- async assert => {
- await visit("/queued-posts");
- await click(".queued-posts .queued-post button.edit");
-
- assert.ok(exists(".d-editor-container"), "the body should be editable");
- assert.ok(
- exists(".edit-title .ember-text-field"),
- "the title should be editable"
- );
- assert.ok(exists(".category-chooser"), "category should be editable");
- assert.ok(exists(".tag-chooser"), "tags should be editable");
- }
-);
-
-QUnit.test("For replies: only the body of post is editable", async assert => {
- // prettier-ignore
- server.get("/queued_posts", () => { //eslint-disable-line no-undef
- return [
- 200,
- { "Content-Type": "application/json" },
- {
- users: [
- {
- id: 3,
- username: "test_user",
- avatar_template:
- "/letter_avatar_proxy/v2/letter/t/eada6e/{size}.png",
- active: true,
- admin: false,
- moderator: false,
- last_seen_at: "2017-08-11T20:48:05.405Z",
- last_emailed_at: null,
- created_at: "2017-08-07T02:23:33.309Z",
- last_seen_age: "1d",
- last_emailed_age: null,
- created_at_age: "6d",
- username_lower: "test_user",
- trust_level: 0,
- trust_level_locked: false,
- flag_level: 0,
- title: null,
- suspended_at: null,
- suspended_till: null,
- suspended: null,
- silenced: false,
- time_read: "19m",
- staged: false,
- days_visited: 4,
- posts_read_count: 12,
- topics_entered: 6,
- post_count: 2
- }
- ],
- topics: [
- {
- id: 11,
- title: "This is a topic",
- fancy_title: "This is a topic",
- slug: "this-is-a-topic",
- posts_count: 2
- }
- ],
- queued_posts: [
- {
- id: 4,
- queue: "default",
- user_id: 3,
- state: 1,
- topic_id: 11,
- approved_by_id: null,
- rejected_by_id: null,
- raw: "edited haahaasdfasdfasdfasdf",
- post_options: {
- archetype: "regular",
- category: "3",
- reply_to_post_number: "2",
- typing_duration_msecs: "1900",
- composer_open_duration_msecs: "12096",
- visible: true,
- is_warning: false,
- featured_link: "",
- ip_address: "172.17.0.1",
- first_post_checks: true,
- is_poll: true
- },
- created_at: "2017-08-07T19:11:52.018Z",
- category_id: 3,
- can_delete_user: true
- }
- ],
- __rest_serializer: "1",
- refresh_queued_posts: "/queued_posts?status=new"
- }
- ];
- });
-
- await visit("/queued-posts");
- await click(".queued-posts .queued-post button.edit");
-
- assert.ok(exists(".d-editor-container"), "the body should be editable");
- assert.notOk(
- exists(".edit-title .ember-text-field"),
- "title should not be editbale"
- );
- assert.notOk(exists(".category-chooser"), "category should not be editable");
- assert.notOk(exists("div.tag-chooser"), "tags should not be editable");
-});
diff --git a/test/javascripts/acceptance/review-test.js.es6 b/test/javascripts/acceptance/review-test.js.es6
new file mode 100644
index 00000000000..190e370ee02
--- /dev/null
+++ b/test/javascripts/acceptance/review-test.js.es6
@@ -0,0 +1,137 @@
+import { acceptance } from "helpers/qunit-helpers";
+
+acceptance("Review", {
+ loggedIn: true
+});
+
+const user = ".reviewable-item[data-reviewable-id=1234]";
+
+QUnit.test("It returns a list of reviewable items", async assert => {
+ await visit("/review");
+
+ assert.ok(find(".reviewable-item").length, "has a list of items");
+ assert.ok(find(user).length);
+ assert.ok(
+ find(`${user}.reviewable-user`).length,
+ "applies a class for the type"
+ );
+ assert.ok(
+ find(`${user} .reviewable-action.approve`).length,
+ "creates a button for approve"
+ );
+ assert.ok(
+ find(`${user} .reviewable-action.reject`).length,
+ "creates a button for reject"
+ );
+});
+
+QUnit.test("Grouped by topic", async assert => {
+ await visit("/review/topics");
+ assert.ok(
+ find(".reviewable-topic").length,
+ "it has a list of reviewable topics"
+ );
+});
+
+QUnit.test("Flag related", async assert => {
+ await visit("/review");
+
+ assert.ok(
+ find(".reviewable-flagged-post .post-contents .username a[href]").length,
+ "it has a link to the user"
+ );
+
+ assert.equal(
+ find(".reviewable-flagged-post .post-body")
+ .html()
+ .trim(),
+ "cooked content"
+ );
+
+ assert.equal(find(".reviewable-flagged-post .reviewable-score").length, 2);
+});
+
+QUnit.test("Flag related", async assert => {
+ await visit("/review/1");
+
+ assert.ok(
+ find(".reviewable-flagged-post").length,
+ "it shows the flagged post"
+ );
+});
+
+QUnit.test("Clicking the buttons triggers actions", async assert => {
+ await visit("/review");
+ await click(`${user} .reviewable-action.approve`);
+ assert.equal(find(user).length, 0, "it removes the reviewable on success");
+});
+
+QUnit.test("Editing a reviewable", async assert => {
+ const topic = ".reviewable-item[data-reviewable-id=4321]";
+ await visit("/review");
+ assert.ok(find(`${topic} .reviewable-action.approve`).length);
+ assert.ok(!find(`${topic} .category-name`).length);
+ assert.equal(find(`${topic} .discourse-tag:eq(0)`).text(), "hello");
+ assert.equal(find(`${topic} .discourse-tag:eq(1)`).text(), "world");
+
+ assert.equal(
+ find(`${topic} .post-body`)
+ .text()
+ .trim(),
+ "existing body"
+ );
+
+ await click(`${topic} .reviewable-action.edit`);
+ await click(`${topic} .reviewable-action.save-edit`);
+ assert.ok(
+ find(`${topic} .reviewable-action.approve`).length,
+ "saving without changes is a cancel"
+ );
+ await click(`${topic} .reviewable-action.edit`);
+
+ assert.equal(
+ find(`${topic} .reviewable-action.approve`).length,
+ 0,
+ "when editing actions are disabled"
+ );
+
+ await fillIn(".editable-field.payload-raw textarea", "new raw contents");
+ await click(`${topic} .reviewable-action.cancel-edit`);
+ assert.equal(
+ find(`${topic} .post-body`)
+ .text()
+ .trim(),
+ "existing body",
+ "cancelling does not update the value"
+ );
+
+ await click(`${topic} .reviewable-action.edit`);
+ let category = selectKit(`${topic} .category-id .select-kit`);
+ await category.expand();
+ await category.selectRowByValue("6");
+
+ let tags = selectKit(`${topic} .payload-tags .mini-tag-chooser`);
+ await tags.expand();
+ await tags.fillInFilter("monkey");
+ await tags.keyboard("enter");
+
+ await fillIn(".editable-field.payload-raw textarea", "new raw contents");
+ await click(`${topic} .reviewable-action.save-edit`);
+
+ assert.equal(find(`${topic} .discourse-tag:eq(0)`).text(), "hello");
+ assert.equal(find(`${topic} .discourse-tag:eq(1)`).text(), "world");
+ assert.equal(find(`${topic} .discourse-tag:eq(2)`).text(), "monkey");
+
+ assert.equal(
+ find(`${topic} .post-body`)
+ .text()
+ .trim(),
+ "new raw contents"
+ );
+ assert.equal(
+ find(`${topic} .category-name`)
+ .text()
+ .trim(),
+ "support"
+ );
+});
diff --git a/test/javascripts/fixtures/topic.js.es6 b/test/javascripts/fixtures/topic.js.es6
index fefcc524881..57f289abdd0 100644
--- a/test/javascripts/fixtures/topic.js.es6
+++ b/test/javascripts/fixtures/topic.js.es6
@@ -3441,7 +3441,6 @@ export default {
category_id: 1,
word_count: 198,
deleted_at: null,
- pending_posts_count: 0,
draft: null,
draft_key: "topic_28830",
draft_sequence: null,
@@ -3890,7 +3889,6 @@ export default {
category_id: 24,
word_count: 15,
deleted_at: null,
- pending_posts_count: 0,
user_id: 1,
draft: null,
draft_key: "topic_9",
@@ -4455,7 +4453,6 @@ export default {
category_id: 1,
word_count: 15,
deleted_at: null,
- pending_posts_count: 0,
user_id: 1,
draft: null,
draft_key: "topic_9",
@@ -4751,7 +4748,6 @@ export default {
category_id: 1,
word_count: 15,
deleted_at: null,
- pending_posts_count: 0,
user_id: 1,
draft: null,
draft_key: "topic_9",
diff --git a/test/javascripts/helpers/create-pretender.js.es6 b/test/javascripts/helpers/create-pretender.js.es6
index ab9b6a6b7dd..6a0a9eb7d65 100644
--- a/test/javascripts/helpers/create-pretender.js.es6
+++ b/test/javascripts/helpers/create-pretender.js.es6
@@ -1,18 +1,15 @@
-import storePretender from "helpers/store-pretender";
-import fixturePretender from "helpers/fixture-pretender";
-import flagPretender from "helpers/flag-pretender";
-
export function parsePostData(query) {
const result = {};
query.split("&").forEach(function(part) {
const item = part.split("=");
const firstSeg = decodeURIComponent(item[0]);
- const m = /^([^\[]+)\[([^\]]+)\]/.exec(firstSeg);
+ const m = /^([^\[]+)\[(.+)\]/.exec(firstSeg);
const val = decodeURIComponent(item[1]).replace(/\+/g, " ");
if (m) {
- result[m[1]] = result[m[1]] || {};
- result[m[1]][m[2]] = val;
+ let key = m[1];
+ result[key] = result[key] || {};
+ result[key][m[2].replace("][", ".")] = val;
} else {
result[firstSeg] = val;
}
@@ -38,9 +35,16 @@ export let fixturesByUrl;
export default function() {
const server = new Pretender(function() {
- storePretender.call(this, helpers);
- flagPretender.call(this, helpers);
- fixturesByUrl = fixturePretender.call(this, helpers);
+ // Autoload any `*-pretender` files
+ Object.keys(requirejs.entries).forEach(e => {
+ let m = e.match(/^helpers\/([a-z]+)\-pretender$/);
+ if (m && m[1] !== "create") {
+ let result = requirejs(e).default.call(this, helpers);
+ if (m[1] === "fixture") {
+ fixturesByUrl = result;
+ }
+ }
+ });
this.get("/admin/plugins", () => response({ plugins: [] }));
diff --git a/test/javascripts/helpers/flag-pretender.js.es6 b/test/javascripts/helpers/flag-pretender.js.es6
deleted file mode 100644
index ff342734cb6..00000000000
--- a/test/javascripts/helpers/flag-pretender.js.es6
+++ /dev/null
@@ -1,73 +0,0 @@
-export default function(helpers) {
- const { response, success } = helpers;
-
- const eviltrout = {
- id: 1,
- username: "eviltrout",
- avatar_template: "/images/avatar.png"
- };
- const sam = {
- id: 2,
- username: "sam",
- avatar_template: "/images/avatar.png",
- can_delete_all_posts: true,
- can_be_deleted: true,
- post_count: 1,
- topic_count: 0
- };
-
- this.get("/admin/flagged_topics", () => {
- return response(200, {
- flagged_topics: [
- {
- id: 280,
- user_ids: [eviltrout.id, sam.id],
- flag_counts: [
- { flag_type_id: 1, count: 3 },
- { flag_type_id: 2, count: 2 },
- { flag_type_id: 3, count: 1 }
- ]
- }
- ],
- users: [eviltrout, sam],
- __rest_serializer: "1"
- });
- });
-
- this.get("/admin/flags/active.json", () => {
- return response(200, {
- flagged_posts: [
- {
- id: 1,
- user_id: sam.id,
- post_action_ids: [1]
- }
- ],
- users: [eviltrout, sam],
- topics: [],
- post_actions: [
- {
- id: 1,
- user_id: eviltrout.id,
- post_action_type_id: 8,
- name_key: "spam",
- conversation: {
- response: {
- user_id: eviltrout.id,
- excerpt: "hello"
- },
- reply: {
- user_id: eviltrout.id,
- excerpt: "goodbye"
- }
- }
- }
- ],
- __rest_serializer: "1"
- });
- });
-
- this.post("/admin/flags/agree/1", success);
- this.post("/admin/flags/defer/1", success);
- this.post("/admin/flags/disagree/1", success);
-}
diff --git a/test/javascripts/helpers/review-pretender.js.es6 b/test/javascripts/helpers/review-pretender.js.es6
new file mode 100644
index 00000000000..80858c3115d
--- /dev/null
+++ b/test/javascripts/helpers/review-pretender.js.es6
@@ -0,0 +1,114 @@
+export default function(helpers) {
+ const { response } = helpers;
+
+ let flag = {
+ id: 6667,
+ type: "ReviewableFlaggedPost",
+ score: 3.0,
+ target_created_by_id: 1,
+ cooked: "cooked content",
+ reviewable_score_ids: [1, 2]
+ };
+
+ this.get("/review", () => {
+ return response(200, {
+ reviewables: [
+ {
+ id: 1234,
+ type: "ReviewableUser",
+ status: 0,
+ version: 0,
+ score: 4.0,
+ target_created_by_id: 1,
+ created_at: "2019-01-14T19:49:53.571Z",
+ username: "newbie",
+ email: "newbie@example.com",
+ bundled_action_ids: ["approve", "reject"]
+ },
+ {
+ id: 4321,
+ type: "ReviewableQueuedPost",
+ status: 0,
+ score: 4.0,
+ created_at: "2019-01-14T19:49:53.571Z",
+ target_created_by_id: 1,
+ payload: {
+ raw: "existing body",
+ tags: ["hello", "world"]
+ },
+ version: 1,
+ can_edit: true,
+ editable_fields: [
+ { id: "category_id", type: "category" },
+ { id: "payload.title", type: "text" },
+ { id: "payload.raw", type: "textarea" },
+ { id: "payload.tags", type: "tags" }
+ ],
+ bundled_action_ids: ["approve", "reject"]
+ },
+ flag
+ ],
+ bundled_actions: [
+ {
+ id: "approve",
+ action_ids: ["approve"]
+ },
+ {
+ id: "reject",
+ action_ids: ["reject"]
+ }
+ ],
+ actions: [
+ {
+ id: "approve",
+ label: "Approve",
+ icon: "far-thumbs-up"
+ },
+ {
+ id: "reject",
+ label: "Reject",
+ icon: "far-thumbs-down"
+ }
+ ],
+ reviewable_scores: [{ id: 1 }, { id: 2 }],
+ users: [{ id: 1, username: "eviltrout" }],
+ meta: {
+ total_rows_reviewables: 2,
+ types: {
+ created_by: "user",
+ target_created_by: "user"
+ }
+ },
+ __rest_serializer: "1"
+ });
+ });
+
+ this.get("/review/topics", () => {
+ return response(200, {
+ reviewable_topics: [{ id: 1234, title: "Cool topic" }]
+ });
+ });
+
+ this.get("/review/:id", () => {
+ return response(200, {
+ reviewable: flag
+ });
+ });
+
+ this.put("/review/:id/perform/:actionId", request => {
+ return response(200, {
+ reviewable_perform_result: {
+ success: true,
+ remove_reviewable_ids: [parseInt(request.params.id)]
+ }
+ });
+ });
+
+ this.put("/review/:id", request => {
+ let result = { payload: {} };
+ Object.entries(JSON.parse(request.requestBody).reviewable).forEach(t => {
+ Ember.set(result, t[0], t[1]);
+ });
+ return response(200, result);
+ });
+}
diff --git a/test/javascripts/widgets/hamburger-menu-test.js.es6 b/test/javascripts/widgets/hamburger-menu-test.js.es6
index ce9155a2e14..16c6ddbbb32 100644
--- a/test/javascripts/widgets/hamburger-menu-test.js.es6
+++ b/test/javascripts/widgets/hamburger-menu-test.js.es6
@@ -78,32 +78,18 @@ widgetTest("staff menu - admin", {
}
});
-widgetTest("queued posts", {
+widgetTest("reviewable content", {
template: '{{mount-widget widget="hamburger-menu"}}',
beforeEach() {
this.currentUser.setProperties({
staff: true,
- show_queued_posts: true,
- post_queue_new_count: 5
+ reviewable_count: 5
});
},
test(assert) {
- assert.ok(find(".queued-posts-link").length);
- assert.equal(find(".queued-posts").text(), "5");
- }
-});
-
-widgetTest("queued posts - disabled", {
- template: '{{mount-widget widget="hamburger-menu"}}',
-
- beforeEach() {
- this.currentUser.setProperties({ staff: true, show_queued_posts: false });
- },
-
- test(assert) {
- assert.ok(!find(".queued-posts-link").length);
+ assert.equal(this.$(".reviewables").text(), "5");
}
});
|