").html(text);
+ $div.find("code").each(function(index, code) {
+ codeArchive.push($(code).html());
+ return $(code).html(codeArchive.length - 1);
+ });
+ text = $div.html();
+ text = text.replace(/\\\$/g, ESCAPED_DOLLAR);
+ // suppressing Don't make functions within a loop.
+ /* jshint -W083 */
+ while (true) {
+ if (RE_INLINEMATH.test(text)) {
+ text = text.replace(RE_INLINEMATH, function($0, $1, $2, $3) {
+ processedText += $1 + processor("$" + $2 + "$", 'inline');
+ return $3;
+ });
+ } else if (RE_DISPLAYMATH.test(text)) {
+ text = text.replace(RE_DISPLAYMATH, function($0, $1, $2, $3) {
+ /*
+ bug fix, ordering is off
+ */
+ processedText = processor("$$" + $2 + "$$", 'display') + processedText;
+ processedText = $1 + processedText;
+ return $3;
+ });
+ } else {
+ processedText += text;
+ break;
+ }
+ }
+ /* jshint +W083 */
+ text = processedText;
+ text = text.replace(new RegExp(ESCAPED_DOLLAR, 'g'), '\\$');
+ text = text.replace(/\\\\\\\\/g, ESCAPED_BACKSLASH);
+ text = text.replace(/\\begin\{([a-z]*\*?)\}([\s\S]*?)\\end\{\1\}/img, function($0, $1, $2) {
+ return processor(("\\begin{" + $1 + "}") + $2 + ("\\end{" + $1 + "}"));
+ });
+ text = text.replace(new RegExp(ESCAPED_BACKSLASH, 'g'), '\\\\\\\\');
+ $div = $("
").html(text);
+ cnt = 0;
+ $div.find("code").each(function(index, code) {
+ $(code).html(processor(codeArchive[cnt], 'code'));
+ return cnt += 1;
+ });
+ text = $div.html();
+ return text;
+ };
+
+ DiscussionUtil.unescapeHighlightTag = function(text) {
+ return text.replace(
+ /\<\;highlight\>\;/g,
+ "
").replace(/\<\;\/highlight\>\;/g, ""
+ );
+ };
+
+ DiscussionUtil.stripHighlight = function(text) {
+ return text.replace(
+ /\&(amp\;)?lt\;highlight\&(amp\;)?gt\;/g, "").replace(/\&(amp\;)?lt\;\/highlight\&(amp\;)?gt\;/g, ""
+ );
+ };
+
+ DiscussionUtil.stripLatexHighlight = function(text) {
+ return this.processEachMathAndCode(text, this.stripHighlight);
+ };
+
+ DiscussionUtil.markdownWithHighlight = function(text) {
+ var converter;
+ text = text.replace(/^\>\;/gm, ">");
+ converter = Markdown.getMathCompatibleConverter();
+ text = this.unescapeHighlightTag(this.stripLatexHighlight(converter.makeHtml(text)));
+ return text.replace(/^>/gm, ">");
+ };
+
+ DiscussionUtil.abbreviateString = function(text, minLength) {
+ if (text.length < minLength) {
+ return text;
+ } else {
+ while (minLength < text.length && text[minLength] !== ' ') {
+ minLength++;
+ }
+ return text.substr(0, minLength) + gettext('…');
+ }
+ };
+
+ DiscussionUtil.abbreviateHTML = function(html, minLength) {
+ var $result, imagesToReplace, truncated_text;
+ truncated_text = jQuery.truncate(html, {
+ length: minLength,
+ noBreaks: true,
+ ellipsis: gettext('…')
+ });
+ $result = $("
" + truncated_text + "
");
+ imagesToReplace = $result.find("img:not(:first)");
+ if (imagesToReplace.length > 0) {
+ $result.append("
Some images in this post have been omitted
");
+ }
+ imagesToReplace.replaceWith("
image omitted");
+ return $result.html();
+ };
+
+ DiscussionUtil.getPaginationParams = function(curPage, numPages, pageUrlFunc) {
+ var delta, maxPage, minPage, pageInfo;
+ delta = 2;
+ minPage = Math.max(curPage - delta, 1);
+ maxPage = Math.min(curPage + delta, numPages);
+ pageInfo = function(pageNum) {
+ return {
+ number: pageNum,
+ url: pageUrlFunc(pageNum)
+ };
+ };
+ return {
+ page: curPage,
+ lowPages: _.range(minPage, curPage).map(pageInfo),
+ highPages: _.range(curPage + 1, maxPage + 1).map(pageInfo),
+ previous: curPage > 1 ? pageInfo(curPage - 1) : null,
+ next: curPage < numPages ? pageInfo(curPage + 1) : null,
+ leftdots: minPage > 2,
+ rightdots: maxPage < numPages - 1,
+ first: minPage > 1 ? pageInfo(1) : null,
+ last: maxPage < numPages ? pageInfo(numPages) : null
+ };
+ };
+
+ return DiscussionUtil;
+ }).call(this);
+}).call(window);
diff --git a/common/static/common/js/discussion/views/discussion_content_view.js b/common/static/common/js/discussion/views/discussion_content_view.js
new file mode 100644
index 0000000000..4623a49c45
--- /dev/null
+++ b/common/static/common/js/discussion/views/discussion_content_view.js
@@ -0,0 +1,520 @@
+/* globals DiscussionContentView, DiscussionUtil */
+(function() {
+ 'use strict';
+ var __hasProp = {}.hasOwnProperty,
+ __extends = function(child, parent) {
+ for (var key in parent) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ function ctor() {
+ this.constructor = child;
+ }
+
+ ctor.prototype = parent.prototype;
+ child.prototype = new ctor();
+ child.__super__ = parent.prototype;
+ return child;
+ };
+
+ if (typeof Backbone !== "undefined" && Backbone !== null) {
+ this.DiscussionContentView = (function(_super) {
+
+ __extends(DiscussionContentView, _super);
+
+ function DiscussionContentView() {
+ var self = this;
+ this.setWmdContent = function() {
+ return DiscussionContentView.prototype.setWmdContent.apply(self, arguments);
+ };
+ this.getWmdContent = function() {
+ return DiscussionContentView.prototype.getWmdContent.apply(self, arguments);
+ };
+ this.getWmdEditor = function() {
+ return DiscussionContentView.prototype.getWmdEditor.apply(self, arguments);
+ };
+ this.makeWmdEditor = function() {
+ return DiscussionContentView.prototype.makeWmdEditor.apply(self, arguments);
+ };
+ return DiscussionContentView.__super__.constructor.apply(this, arguments);
+ }
+
+ DiscussionContentView.prototype.events = {
+ "click .discussion-flag-abuse": "toggleFlagAbuse",
+ "keydown .discussion-flag-abuse": function(event) {
+ return DiscussionUtil.activateOnSpace(event, this.toggleFlagAbuse);
+ }
+ };
+
+ DiscussionContentView.prototype.attrRenderer = {
+ ability: function(ability) {
+ var action, selector, _ref, _results;
+ _ref = this.abilityRenderer;
+ _results = [];
+ for (action in _ref) {
+ if (_ref.hasOwnProperty(action)){
+ selector = _ref[action];
+ if (!ability[action]) {
+ _results.push(selector.disable.apply(this));
+ } else {
+ _results.push(selector.enable.apply(this));
+ }
+ }
+ }
+ return _results;
+ }
+ };
+
+ DiscussionContentView.prototype.abilityRenderer = {
+ editable: {
+ enable: function() {
+ return this.$(".action-edit").closest(".actions-item").removeClass("is-hidden");
+ },
+ disable: function() {
+ return this.$(".action-edit").closest(".actions-item").addClass("is-hidden");
+ }
+ },
+ can_delete: {
+ enable: function() {
+ return this.$(".action-delete").closest(".actions-item").removeClass("is-hidden");
+ },
+ disable: function() {
+ return this.$(".action-delete").closest(".actions-item").addClass("is-hidden");
+ }
+ },
+ can_openclose: {
+ enable: function() {
+ var self = this;
+ return _.each([".action-close", ".action-pin"], function(selector) {
+ return self.$(selector).closest(".actions-item").removeClass("is-hidden");
+ });
+ },
+ disable: function() {
+ var self = this;
+ return _.each([".action-close", ".action-pin"], function(selector) {
+ return self.$(selector).closest(".actions-item").addClass("is-hidden");
+ });
+ }
+ },
+ can_report: {
+ enable: function() {
+ return this.$(".action-report").closest(".actions-item").removeClass("is-hidden");
+ },
+ disable: function() {
+ return this.$(".action-report").closest(".actions-item").addClass("is-hidden");
+ }
+ },
+ can_vote: {
+ enable: function() {
+ return this.$(".action-vote").closest(".actions-item").removeClass("is-hidden");
+ },
+ disable: function() {
+ return this.$(".action-vote").closest(".actions-item").addClass("is-hidden");
+ }
+ }
+ };
+
+ DiscussionContentView.prototype.renderPartialAttrs = function() {
+ var attr, value, _ref, _results;
+ _ref = this.model.changedAttributes();
+ _results = [];
+ for (attr in _ref) {
+ if (_ref.hasOwnProperty(attr)) {
+ value = _ref[attr];
+ if (this.attrRenderer[attr]) {
+ _results.push(this.attrRenderer[attr].apply(this, [value]));
+ } else {
+ _results.push(void 0);
+ }
+ }
+ }
+ return _results;
+ };
+
+ DiscussionContentView.prototype.renderAttrs = function() {
+ var attr, value, _ref, _results;
+ _ref = this.model.attributes;
+ _results = [];
+ for (attr in _ref) {
+ if (_ref.hasOwnProperty(attr)) {
+ value = _ref[attr];
+ if (this.attrRenderer[attr]) {
+ _results.push(this.attrRenderer[attr].apply(this, [value]));
+ } else {
+ _results.push(void 0);
+ }
+ }
+ }
+ return _results;
+ };
+
+ DiscussionContentView.prototype.makeWmdEditor = function(cls_identifier) {
+ if (!this.$el.find(".wmd-panel").length) {
+ return DiscussionUtil.makeWmdEditor(this.$el, $.proxy(this.$, this), cls_identifier);
+ }
+ };
+
+ DiscussionContentView.prototype.getWmdEditor = function(cls_identifier) {
+ return DiscussionUtil.getWmdEditor(this.$el, $.proxy(this.$, this), cls_identifier);
+ };
+
+ DiscussionContentView.prototype.getWmdContent = function(cls_identifier) {
+ return DiscussionUtil.getWmdContent(this.$el, $.proxy(this.$, this), cls_identifier);
+ };
+
+ DiscussionContentView.prototype.setWmdContent = function(cls_identifier, text) {
+ return DiscussionUtil.setWmdContent(this.$el, $.proxy(this.$, this), cls_identifier, text);
+ };
+
+ DiscussionContentView.prototype.initialize = function() {
+ var self = this;
+ this.model.bind('change', this.renderPartialAttrs, this);
+ return this.listenTo(this.model, "change:endorsed", function() {
+ if (self.model instanceof Comment) {
+ return self.trigger("comment:endorse");
+ }
+ });
+ };
+
+ return DiscussionContentView;
+
+ })(Backbone.View);
+ this.DiscussionContentShowView = (function(_super) {
+ __extends(DiscussionContentShowView, _super);
+
+ function DiscussionContentShowView() {
+ var self = this;
+ this.toggleClose = function() {
+ return DiscussionContentShowView.prototype.toggleClose.apply(self, arguments);
+ };
+ this.toggleReport = function() {
+ return DiscussionContentShowView.prototype.toggleReport.apply(self, arguments);
+ };
+ this.togglePin = function() {
+ return DiscussionContentShowView.prototype.togglePin.apply(self, arguments);
+ };
+ this.toggleVote = function() {
+ return DiscussionContentShowView.prototype.toggleVote.apply(self, arguments);
+ };
+ this.toggleEndorse = function() {
+ return DiscussionContentShowView.prototype.toggleEndorse.apply(self, arguments);
+ };
+ this.toggleFollow = function() {
+ return DiscussionContentShowView.prototype.toggleFollow.apply(self, arguments);
+ };
+ this.handleSecondaryActionBlur = function() {
+ return DiscussionContentShowView.prototype.handleSecondaryActionBlur.apply(self, arguments);
+ };
+ this.handleSecondaryActionEscape = function() {
+ return DiscussionContentShowView.prototype.handleSecondaryActionEscape.apply(self, arguments);
+ };
+ this.toggleSecondaryActions = function() {
+ return DiscussionContentShowView.prototype.toggleSecondaryActions.apply(self, arguments);
+ };
+ this.updateButtonState = function() {
+ return DiscussionContentShowView.prototype.updateButtonState.apply(self, arguments);
+ };
+ return DiscussionContentShowView.__super__.constructor.apply(this, arguments);
+ }
+
+ DiscussionContentShowView.prototype.events = _.reduce(
+ [
+ [".action-follow", "toggleFollow"],
+ [".action-answer", "toggleEndorse"],
+ [".action-endorse", "toggleEndorse"],
+ [".action-vote", "toggleVote"],
+ [".action-more", "toggleSecondaryActions"],
+ [".action-pin", "togglePin"],
+ [".action-edit", "edit"],
+ [".action-delete", "_delete"],
+ [".action-report", "toggleReport"],
+ [".action-close", "toggleClose"]
+ ],
+ function(obj, event) {
+ var funcName, selector;
+ selector = event[0];
+ funcName = event[1];
+ obj["click " + selector] = function(event) {
+ return this[funcName](event);
+ };
+ obj["keydown " + selector] = function(event) {
+ return DiscussionUtil.activateOnSpace(event, this[funcName]);
+ };
+ return obj;
+ },
+ {}
+ );
+
+ DiscussionContentShowView.prototype.updateButtonState = function(selector, checked) {
+ var $button;
+ $button = this.$(selector);
+ $button.toggleClass("is-checked", checked);
+ return $button.attr("aria-checked", checked);
+ };
+
+ DiscussionContentShowView.prototype.attrRenderer = $.extend(
+ {},
+ DiscussionContentView.prototype.attrRenderer,
+ {
+ subscribed: function(subscribed) {
+ return this.updateButtonState(".action-follow", subscribed);
+ },
+ endorsed: function(endorsed) {
+ var $button, selector;
+ selector = this.model.get("thread").get("thread_type") === "question" ?
+ ".action-answer" :
+ ".action-endorse";
+ this.updateButtonState(selector, endorsed);
+ $button = this.$(selector);
+ $button.closest(".actions-item").toggleClass("is-hidden", !this.model.canBeEndorsed());
+ return $button.toggleClass("is-checked", endorsed);
+ },
+ votes: function(votes) {
+ var button, numVotes, selector, votesHtml, votesCountMsg;
+ selector = ".action-vote";
+ this.updateButtonState(selector, window.user.voted(this.model));
+ button = this.$el.find(selector);
+ numVotes = votes.up_count;
+ votesCountMsg = ngettext(
+ "there is currently %(numVotes)s vote", "there are currently %(numVotes)s votes", numVotes
+ );
+ button.find(".js-sr-vote-count").html(interpolate(votesCountMsg, {numVotes: numVotes }, true));
+ votesHtml = interpolate(ngettext("%(numVotes)s Vote", "%(numVotes)s Votes", numVotes), {
+ numVotes: numVotes
+ }, true);
+ button.find(".vote-count").html(votesHtml);
+ return this.$el.find('.display-vote .vote-count').html(votesHtml);
+ },
+ pinned: function(pinned) {
+ this.updateButtonState(".action-pin", pinned);
+ return this.$(".post-label-pinned").toggleClass("is-hidden", !pinned);
+ },
+ abuse_flaggers: function() {
+ var flagged;
+ flagged = this.model.isFlagged();
+ this.updateButtonState(".action-report", flagged);
+ return this.$(".post-label-reported").toggleClass("is-hidden", !flagged);
+ },
+ closed: function(closed) {
+ this.updateButtonState(".action-close", closed);
+ this.$(".post-label-closed").toggleClass("is-hidden", !closed);
+ return this.$(".display-vote").toggle(closed);
+ }
+ }
+ );
+
+ DiscussionContentShowView.prototype.toggleSecondaryActions = function(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ this.secondaryActionsExpanded = !this.secondaryActionsExpanded;
+ this.$(".action-more").toggleClass("is-expanded", this.secondaryActionsExpanded);
+ this.$(".actions-dropdown")
+ .toggleClass("is-expanded", this.secondaryActionsExpanded)
+ .attr("aria-expanded", this.secondaryActionsExpanded);
+
+ if (this.secondaryActionsExpanded) {
+ if (event.type === "keydown") {
+ this.$(".action-list-item:first").focus();
+ }
+ $("body").on("click", this.toggleSecondaryActions);
+ $("body").on("keydown", this.handleSecondaryActionEscape);
+ return this.$(".action-list-item").on("blur", this.handleSecondaryActionBlur);
+ } else {
+ $("body").off("click", this.toggleSecondaryActions);
+ $("body").off("keydown", this.handleSecondaryActionEscape);
+ return this.$(".action-list-item").off("blur", this.handleSecondaryActionBlur);
+ }
+ };
+
+ DiscussionContentShowView.prototype.handleSecondaryActionEscape = function(event) {
+ if (event.keyCode === 27) {
+ this.toggleSecondaryActions(event);
+ return this.$(".action-more").focus();
+ }
+ };
+
+ DiscussionContentShowView.prototype.handleSecondaryActionBlur = function(event) {
+ var self = this;
+ return setTimeout(function() {
+ if (self.secondaryActionsExpanded && self.$(".actions-dropdown :focus").length === 0) {
+ return self.toggleSecondaryActions(event);
+ }
+ }, 10);
+ };
+
+ DiscussionContentShowView.prototype.toggleFollow = function(event) {
+ var is_subscribing, msg, url;
+ event.preventDefault();
+ is_subscribing = !this.model.get("subscribed");
+ url = this.model.urlFor(is_subscribing ? "follow" : "unfollow");
+ if (is_subscribing) {
+ msg = gettext("We had some trouble subscribing you to this thread. Please try again.");
+ } else {
+ msg = gettext("We had some trouble unsubscribing you from this thread. Please try again.");
+ }
+ return DiscussionUtil.updateWithUndo(this.model, {
+ "subscribed": is_subscribing
+ }, {
+ url: url,
+ type: "POST",
+ $elem: $(event.currentTarget)
+ }, msg);
+ };
+
+ DiscussionContentShowView.prototype.toggleEndorse = function(event) {
+ var beforeFunc, is_endorsing, msg, updates, url,
+ self = this;
+ event.preventDefault();
+ is_endorsing = !this.model.get("endorsed");
+ url = this.model.urlFor("endorse");
+ updates = {
+ endorsed: is_endorsing,
+ endorsement: is_endorsing ? {
+ username: DiscussionUtil.getUser().get("username"),
+ user_id: DiscussionUtil.getUser().id,
+ time: new Date().toISOString()
+ } : null
+ };
+ if (this.model.get('thread').get('thread_type') === 'question') {
+ if (is_endorsing) {
+ msg = gettext("We had some trouble marking this response as an answer. Please try again.");
+ } else {
+ msg = gettext("We had some trouble removing this response as an answer. Please try again.");
+ }
+ } else {
+ if (is_endorsing) {
+ msg = gettext("We had some trouble marking this response endorsed. Please try again.");
+ } else {
+ msg = gettext("We had some trouble removing this endorsement. Please try again.");
+ }
+ }
+ beforeFunc = function() {
+ return self.trigger("comment:endorse");
+ };
+ return DiscussionUtil.updateWithUndo(this.model, updates, {
+ url: url,
+ type: "POST",
+ data: {
+ endorsed: is_endorsing
+ },
+ beforeSend: beforeFunc,
+ $elem: $(event.currentTarget)
+ }, msg).always(this.trigger("comment:endorse"));
+ };
+
+ DiscussionContentShowView.prototype.toggleVote = function(event) {
+ var is_voting, updates, url, user,
+ self = this;
+ event.preventDefault();
+ user = DiscussionUtil.getUser();
+ is_voting = !user.voted(this.model);
+ url = this.model.urlFor(is_voting ? "upvote" : "unvote");
+ updates = {
+ upvoted_ids: (is_voting ? _.union : _.difference)(user.get('upvoted_ids'), [this.model.id])
+ };
+ return DiscussionUtil.updateWithUndo(user, updates, {
+ url: url,
+ type: "POST",
+ $elem: $(event.currentTarget)
+ }, gettext("We had some trouble saving your vote. Please try again.")).done(function() {
+ if (is_voting) {
+ return self.model.vote();
+ } else {
+ return self.model.unvote();
+ }
+ });
+ };
+
+ DiscussionContentShowView.prototype.togglePin = function(event) {
+ var is_pinning, msg, url;
+ event.preventDefault();
+ is_pinning = !this.model.get("pinned");
+ url = this.model.urlFor(is_pinning ? "pinThread" : "unPinThread");
+ if (is_pinning) {
+ msg = gettext("We had some trouble pinning this thread. Please try again.");
+ } else {
+ msg = gettext("We had some trouble unpinning this thread. Please try again.");
+ }
+ return DiscussionUtil.updateWithUndo(this.model, {
+ pinned: is_pinning
+ }, {
+ url: url,
+ type: "POST",
+ $elem: $(event.currentTarget)
+ }, msg);
+ };
+
+ DiscussionContentShowView.prototype.toggleReport = function(event) {
+ var is_flagging, msg, updates, url;
+ event.preventDefault();
+ if (this.model.isFlagged()) {
+ is_flagging = false;
+ msg = gettext("We had some trouble removing your flag on this post. Please try again.");
+ } else {
+ is_flagging = true;
+ msg = gettext("We had some trouble reporting this post. Please try again.");
+ }
+ url = this.model.urlFor(is_flagging ? "flagAbuse" : "unFlagAbuse");
+ updates = {
+ abuse_flaggers: (is_flagging ? _.union : _.difference)(
+ this.model.get("abuse_flaggers"), [DiscussionUtil.getUser().id]
+ )
+ };
+ return DiscussionUtil.updateWithUndo(this.model, updates, {
+ url: url,
+ type: "POST",
+ $elem: $(event.currentTarget)
+ }, msg);
+ };
+
+ DiscussionContentShowView.prototype.toggleClose = function(event) {
+ var is_closing, msg, updates;
+ event.preventDefault();
+ is_closing = !this.model.get('closed');
+ if (is_closing) {
+ msg = gettext("We had some trouble closing this thread. Please try again.");
+ } else {
+ msg = gettext("We had some trouble reopening this thread. Please try again.");
+ }
+ updates = {
+ closed: is_closing
+ };
+ return DiscussionUtil.updateWithUndo(this.model, updates, {
+ url: this.model.urlFor("close"),
+ type: "POST",
+ data: updates,
+ $elem: $(event.currentTarget)
+ }, msg);
+ };
+
+ DiscussionContentShowView.prototype.getAuthorDisplay = function() {
+ return _.template($("#post-user-display-template").html())({
+ username: this.model.get('username') || null,
+ user_url: this.model.get('user_url'),
+ is_community_ta: this.model.get('community_ta_authored'),
+ is_staff: this.model.get('staff_authored')
+ });
+ };
+
+ DiscussionContentShowView.prototype.getEndorserDisplay = function() {
+ var endorsement;
+ endorsement = this.model.get('endorsement');
+ if (endorsement && endorsement.username) {
+ return _.template($("#post-user-display-template").html())({
+ username: endorsement.username,
+ user_url: DiscussionUtil.urlFor('user_profile', endorsement.user_id),
+ is_community_ta: DiscussionUtil.isTA(endorsement.user_id),
+ is_staff: DiscussionUtil.isStaff(endorsement.user_id)
+ });
+ } else {
+ return null;
+ }
+ };
+
+ return DiscussionContentShowView;
+
+ }).call(this, this.DiscussionContentView);
+ }
+
+}).call(window);
diff --git a/common/static/coffee/src/discussion/views/discussion_thread_edit_view.js b/common/static/common/js/discussion/views/discussion_thread_edit_view.js
similarity index 96%
rename from common/static/coffee/src/discussion/views/discussion_thread_edit_view.js
rename to common/static/common/js/discussion/views/discussion_thread_edit_view.js
index 8f954c5668..30ca60e92d 100644
--- a/common/static/coffee/src/discussion/views/discussion_thread_edit_view.js
+++ b/common/static/common/js/discussion/views/discussion_thread_edit_view.js
@@ -1,4 +1,5 @@
-(function(Backbone) {
+/* globals DiscussionTopicMenuView, DiscussionUtil */
+(function() {
'use strict';
if (Backbone) {
this.DiscussionThreadEditView = Backbone.View.extend({
@@ -50,7 +51,7 @@
return this;
},
- isTabMode: function () {
+ isTabMode: function() {
return this.mode === 'tab';
},
@@ -85,7 +86,7 @@
this.model.set(postData).unset('abbreviatedBody');
this.trigger('thread:updated');
if (this.threadType !== threadType) {
- this.model.set("thread_type", threadType)
+ this.model.set("thread_type", threadType);
this.model.trigger('thread:thread_type_updated');
this.trigger('comment:endorse');
}
@@ -109,4 +110,4 @@
}
});
}
-}).call(this, Backbone);
+}).call(window); // jshint ignore:line
diff --git a/common/static/common/js/discussion/views/discussion_thread_list_view.js b/common/static/common/js/discussion/views/discussion_thread_list_view.js
new file mode 100644
index 0000000000..7fe06e33e6
--- /dev/null
+++ b/common/static/common/js/discussion/views/discussion_thread_list_view.js
@@ -0,0 +1,792 @@
+/* globals Content, Discussion, DiscussionUtil */
+(function() {
+ 'use strict';
+ var __hasProp = {}.hasOwnProperty,
+ __extends = function(child, parent) {
+ for (var key in parent) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ function ctor() {
+ this.constructor = child;
+ }
+
+ ctor.prototype = parent.prototype;
+ child.prototype = new ctor();
+ child.__super__ = parent.prototype;
+ return child;
+ };
+
+ if (typeof Backbone !== "undefined" && Backbone !== null) {
+ this.DiscussionThreadListView = (function(_super) {
+ __extends(DiscussionThreadListView, _super);
+
+ function DiscussionThreadListView() {
+ var self = this;
+ this.updateEmailNotifications = function() {
+ return DiscussionThreadListView.prototype.updateEmailNotifications.apply(self, arguments);
+ };
+ this.retrieveFollowed = function() {
+ return DiscussionThreadListView.prototype.retrieveFollowed.apply(self, arguments);
+ };
+ this.chooseCohort = function() {
+ return DiscussionThreadListView.prototype.chooseCohort.apply(self, arguments);
+ };
+ this.chooseFilter = function() {
+ return DiscussionThreadListView.prototype.chooseFilter.apply(self, arguments);
+ };
+ this.filterTopics = function() {
+ return DiscussionThreadListView.prototype.filterTopics.apply(self, arguments);
+ };
+ this.toggleBrowseMenu = function() {
+ return DiscussionThreadListView.prototype.toggleBrowseMenu.apply(self, arguments);
+ };
+ this.hideBrowseMenu = function() {
+ return DiscussionThreadListView.prototype.hideBrowseMenu.apply(self, arguments);
+ };
+ this.showBrowseMenu = function() {
+ return DiscussionThreadListView.prototype.showBrowseMenu.apply(self, arguments);
+ };
+ this.isBrowseMenuVisible = function() {
+ return DiscussionThreadListView.prototype.isBrowseMenuVisible.apply(self, arguments);
+ };
+ this.threadRemoved = function() {
+ return DiscussionThreadListView.prototype.threadRemoved.apply(self, arguments);
+ };
+ this.threadSelected = function() {
+ return DiscussionThreadListView.prototype.threadSelected.apply(self, arguments);
+ };
+ this.renderThread = function() {
+ return DiscussionThreadListView.prototype.renderThread.apply(self, arguments);
+ };
+ this.loadMorePages = function() {
+ return DiscussionThreadListView.prototype.loadMorePages.apply(self, arguments);
+ };
+ this.showMetadataAccordingToSort = function() {
+ return DiscussionThreadListView.prototype.showMetadataAccordingToSort.apply(self, arguments);
+ };
+ this.renderThreads = function() {
+ return DiscussionThreadListView.prototype.renderThreads.apply(self, arguments);
+ };
+ this.updateSidebar = function() {
+ return DiscussionThreadListView.prototype.updateSidebar.apply(self, arguments);
+ };
+ this.addAndSelectThread = function() {
+ return DiscussionThreadListView.prototype.addAndSelectThread.apply(self, arguments);
+ };
+ this.reloadDisplayedCollection = function() {
+ return DiscussionThreadListView.prototype.reloadDisplayedCollection.apply(self, arguments);
+ };
+ this.clearSearchAlerts = function() {
+ return DiscussionThreadListView.prototype.clearSearchAlerts.apply(self, arguments);
+ };
+ this.removeSearchAlert = function() {
+ return DiscussionThreadListView.prototype.removeSearchAlert.apply(self, arguments);
+ };
+ this.addSearchAlert = function() {
+ return DiscussionThreadListView.prototype.addSearchAlert.apply(self, arguments);
+ };
+ return DiscussionThreadListView.__super__.constructor.apply(this, arguments);
+ }
+
+ DiscussionThreadListView.prototype.events = {
+ "click .forum-nav-browse": "toggleBrowseMenu",
+ "keypress .forum-nav-browse-filter-input": function(event) {
+ return DiscussionUtil.ignoreEnterKey(event);
+ },
+ "keyup .forum-nav-browse-filter-input": "filterTopics",
+ "click .forum-nav-browse-menu-wrapper": "ignoreClick",
+ "click .forum-nav-browse-title": "selectTopicHandler",
+ "keydown .forum-nav-search-input": "performSearch",
+ "click .fa-search": "performSearch",
+ "change .forum-nav-sort-control": "sortThreads",
+ "click .forum-nav-thread-link": "threadSelected",
+ "click .forum-nav-load-more-link": "loadMorePages",
+ "change .forum-nav-filter-main-control": "chooseFilter",
+ "change .forum-nav-filter-cohort-control": "chooseCohort"
+ };
+
+ DiscussionThreadListView.prototype.initialize = function(options) {
+ var self = this;
+ this.courseSettings = options.courseSettings;
+ this.displayedCollection = new Discussion(this.collection.models, {
+ pages: this.collection.pages
+ });
+ this.collection.on("change", this.reloadDisplayedCollection);
+ this.discussionIds = "";
+ this.collection.on("reset", function(discussion) {
+ var board;
+ board = $(".current-board").html();
+ self.displayedCollection.current_page = discussion.current_page;
+ self.displayedCollection.pages = discussion.pages;
+ return self.displayedCollection.reset(discussion.models);
+ });
+ this.collection.on("add", this.addAndSelectThread);
+ this.sidebar_padding = 10;
+ this.boardName = null;
+ this.template = _.template($("#thread-list-template").html());
+ this.current_search = "";
+ this.mode = 'all';
+ this.searchAlertCollection = new Backbone.Collection([], {
+ model: Backbone.Model
+ });
+ this.searchAlertCollection.on("add", function(searchAlert) {
+ var content;
+ content = _.template($("#search-alert-template").html())({
+ 'message': searchAlert.attributes.message,
+ 'cid': searchAlert.cid
+ });
+ self.$(".search-alerts").append(content);
+ return self.$("#search-alert-" + searchAlert.cid + " a.dismiss")
+ .bind("click", searchAlert, function(event) {
+ return self.removeSearchAlert(event.data.cid);
+ });
+ });
+ this.searchAlertCollection.on("remove", function(searchAlert) {
+ return self.$("#search-alert-" + searchAlert.cid).remove();
+ });
+ return this.searchAlertCollection.on("reset", function() {
+ return self.$(".search-alerts").empty();
+ });
+ };
+
+ DiscussionThreadListView.prototype.addSearchAlert = function(message) {
+ var m;
+ m = new Backbone.Model({
+ "message": message
+ });
+ this.searchAlertCollection.add(m);
+ return m;
+ };
+
+ DiscussionThreadListView.prototype.removeSearchAlert = function(searchAlert) {
+ return this.searchAlertCollection.remove(searchAlert);
+ };
+
+ DiscussionThreadListView.prototype.clearSearchAlerts = function() {
+ return this.searchAlertCollection.reset();
+ };
+
+ DiscussionThreadListView.prototype.reloadDisplayedCollection = function(thread) {
+ var active, content, current_el, thread_id;
+ this.clearSearchAlerts();
+ thread_id = thread.get('id');
+ content = this.renderThread(thread);
+ current_el = this.$(".forum-nav-thread[data-id=" + thread_id + "]");
+ active = current_el.has(".forum-nav-thread-link.is-active").length !== 0;
+ current_el.replaceWith(content);
+ this.showMetadataAccordingToSort();
+ if (active) {
+ return this.setActiveThread(thread_id);
+ }
+ };
+
+ /*
+ TODO fix this entire chain of events
+ */
+
+
+ DiscussionThreadListView.prototype.addAndSelectThread = function(thread) {
+ var commentable_id, menuItem,
+ self = this;
+ commentable_id = thread.get("commentable_id");
+ menuItem = this.$(".forum-nav-browse-menu-item[data-discussion-id]").filter(function() {
+ return $(this).data("discussion-id") === commentable_id;
+ });
+ this.setCurrentTopicDisplay(this.getPathText(menuItem));
+ return this.retrieveDiscussion(commentable_id, function() {
+ return self.trigger("thread:created", thread.get('id'));
+ });
+ };
+
+ DiscussionThreadListView.prototype.updateSidebar = function() {
+ var amount, browseFilterHeight, discussionBody, discussionBottomOffset, discussionsBodyBottom,
+ discussionsBodyTop, headerHeight, refineBarHeight, scrollTop, sidebar, sidebarHeight, topOffset,
+ windowHeight;
+ scrollTop = $(window).scrollTop();
+ windowHeight = $(window).height();
+ discussionBody = $(".discussion-column");
+ discussionsBodyTop = discussionBody[0] ? discussionBody.offset().top : void 0;
+ discussionsBodyBottom = discussionsBodyTop + discussionBody.outerHeight();
+ sidebar = $(".forum-nav");
+ if (scrollTop > discussionsBodyTop - this.sidebar_padding) {
+ sidebar.css('top', scrollTop - discussionsBodyTop + this.sidebar_padding);
+ } else {
+ sidebar.css('top', '0');
+ }
+ sidebarHeight = windowHeight - Math.max(discussionsBodyTop - scrollTop, this.sidebar_padding);
+ topOffset = scrollTop + windowHeight;
+ discussionBottomOffset = discussionsBodyBottom + this.sidebar_padding;
+ amount = Math.max(topOffset - discussionBottomOffset, 0);
+ sidebarHeight = sidebarHeight - this.sidebar_padding - amount;
+ sidebarHeight = Math.min(sidebarHeight + 1, discussionBody.outerHeight());
+ sidebar.css('height', sidebarHeight);
+ headerHeight = this.$(".forum-nav-header").outerHeight();
+ refineBarHeight = this.$(".forum-nav-refine-bar").outerHeight();
+ browseFilterHeight = this.$(".forum-nav-browse-filter").outerHeight();
+ this.$('.forum-nav-thread-list')
+ .css('height', (sidebarHeight - headerHeight - refineBarHeight - 2) + 'px');
+ this.$('.forum-nav-browse-menu')
+ .css('height', (sidebarHeight - headerHeight - browseFilterHeight - 2) + 'px');
+ };
+
+ DiscussionThreadListView.prototype.ignoreClick = function(event) {
+ return event.stopPropagation();
+ };
+
+ DiscussionThreadListView.prototype.render = function() {
+ var self = this;
+ this.timer = 0;
+ this.$el.html(this.template({
+ isCohorted: this.courseSettings.get("is_cohorted"),
+ isPrivilegedUser: DiscussionUtil.isPrivilegedUser()
+ }));
+ this.$(".forum-nav-sort-control option").removeProp("selected");
+ this.$(".forum-nav-sort-control option[value=" + this.collection.sort_preference + "]")
+ .prop("selected", true);
+ $(window).bind("load scroll resize", this.updateSidebar);
+ this.displayedCollection.on("reset", this.renderThreads);
+ this.displayedCollection.on("thread:remove", this.renderThreads);
+ this.displayedCollection.on("change:commentable_id", function() {
+ if (self.mode === "commentables") {
+ return self.retrieveDiscussions(self.discussionIds.split(","));
+ }
+ });
+ this.renderThreads();
+ return this;
+ };
+
+ DiscussionThreadListView.prototype.renderThreads = function() {
+ var content, rendered, thread, _i, _len, _ref;
+ this.$(".forum-nav-thread-list").html("");
+ rendered = $("
");
+ _ref = this.displayedCollection.models;
+ for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+ thread = _ref[_i];
+ content = this.renderThread(thread);
+ rendered.append(content);
+ }
+ this.$(".forum-nav-thread-list").html(rendered.html());
+ this.showMetadataAccordingToSort();
+ this.renderMorePages();
+ this.updateSidebar();
+ return this.trigger("threads:rendered");
+ };
+
+ DiscussionThreadListView.prototype.showMetadataAccordingToSort = function() {
+ var commentCounts, voteCounts;
+ voteCounts = this.$(".forum-nav-thread-votes-count");
+ commentCounts = this.$(".forum-nav-thread-comments-count");
+ voteCounts.hide();
+ commentCounts.hide();
+ switch (this.$(".forum-nav-sort-control").val()) {
+ case "activity":
+ case "comments":
+ return commentCounts.show();
+ case "votes":
+ return voteCounts.show();
+ }
+ };
+
+ DiscussionThreadListView.prototype.renderMorePages = function() {
+ if (this.displayedCollection.hasMorePages()) {
+ return this.$(".forum-nav-thread-list")
+ .append(
+ "
" +
+ " " + gettext("Load more") + "" +
+ ""
+ );
+ }
+ };
+
+ DiscussionThreadListView.prototype.getLoadingContent = function(srText) {
+ return '
' +
+ ' ' + srText + '' +
+ '
';
+ };
+
+ DiscussionThreadListView.prototype.loadMorePages = function(event) {
+ var error, lastThread, loadMoreElem, loadingElem, options, _ref,
+ self = this;
+ if (event) {
+ event.preventDefault();
+ }
+ loadMoreElem = this.$(".forum-nav-load-more");
+ loadMoreElem.html(this.getLoadingContent(gettext("Loading more threads")));
+ loadingElem = loadMoreElem.find(".forum-nav-loading");
+ DiscussionUtil.makeFocusTrap(loadingElem);
+ loadingElem.focus();
+ options = {
+ filter: this.filter
+ };
+ switch (this.mode) {
+ case 'search':
+ options.search_text = this.current_search;
+ if (this.group_id) {
+ options.group_id = this.group_id;
+ }
+ break;
+ case 'followed':
+ options.user_id = window.user.id;
+ break;
+ case 'commentables':
+ options.commentable_ids = this.discussionIds;
+ if (this.group_id) {
+ options.group_id = this.group_id;
+ }
+ break;
+ case 'all':
+ if (this.group_id) {
+ options.group_id = this.group_id;
+ }
+ }
+ _ref = this.collection.last();
+ lastThread = _ref ? _ref.get('id') : void 0;
+ if (lastThread) {
+ this.once("threads:rendered", function() {
+ var classSelector =
+ ".forum-nav-thread[data-id='" + lastThread + "'] + .forum-nav-thread " +
+ ".forum-nav-thread-link";
+ return $(classSelector).focus();
+ });
+ } else {
+ this.once("threads:rendered", function() {
+ var _ref1 = $(".forum-nav-thread-link").first();
+ return _ref1 ? _ref1.focus() : void 0;
+ });
+ }
+ error = function() {
+ self.renderThreads();
+ DiscussionUtil.discussionAlert(
+ gettext("Sorry"), gettext("We had some trouble loading more threads. Please try again.")
+ );
+ };
+ return this.collection.retrieveAnotherPage(this.mode, options, {
+ sort_key: this.$(".forum-nav-sort-control").val()
+ }, error);
+ };
+
+ DiscussionThreadListView.prototype.renderThread = function(thread) {
+ var content, unreadCount;
+ content = $(_.template($("#thread-list-item-template").html())(thread.toJSON()));
+ unreadCount = thread.get('unread_comments_count') + (thread.get("read") ? 0 : 1);
+ if (unreadCount > 0) {
+ content.find('.forum-nav-thread-comments-count').attr(
+ "data-tooltip",
+ interpolate(
+ ngettext('%(unread_count)s new comment', '%(unread_count)s new comments', unreadCount),
+ {unread_count: unreadCount},
+ true
+ )
+ );
+ }
+ return content;
+ };
+
+ DiscussionThreadListView.prototype.threadSelected = function(e) {
+ var thread_id;
+ thread_id = $(e.target).closest(".forum-nav-thread").attr("data-id");
+ this.setActiveThread(thread_id);
+ this.trigger("thread:selected", thread_id);
+ return false;
+ };
+
+ DiscussionThreadListView.prototype.threadRemoved = function(thread_id) {
+ return this.trigger("thread:removed", thread_id);
+ };
+
+ DiscussionThreadListView.prototype.setActiveThread = function(thread_id) {
+ this.$(".forum-nav-thread-link").find(".sr").remove();
+ this.$(".forum-nav-thread[data-id!='" + thread_id + "'] .forum-nav-thread-link")
+ .removeClass("is-active");
+ this.$(".forum-nav-thread[data-id='" + thread_id + "'] .forum-nav-thread-link")
+ .addClass("is-active").find(".forum-nav-thread-wrapper-1")
+ .prepend('
' + gettext("Current conversation") + '');
+ };
+
+ DiscussionThreadListView.prototype.goHome = function() {
+ var thread_id, url;
+ this.template = _.template($("#discussion-home-template").html());
+ $(".forum-content").html(this.template);
+ $(".forum-nav-thread-list a").removeClass("is-active").find(".sr").remove();
+ $("input.email-setting").bind("click", this.updateEmailNotifications);
+ url = DiscussionUtil.urlFor("notifications_status", window.user.get("id"));
+ DiscussionUtil.safeAjax({
+ url: url,
+ type: "GET",
+ success: function(response) {
+ if (response.status) {
+ return $('input.email-setting').attr('checked', 'checked');
+ } else {
+ return $('input.email-setting').removeAttr('checked');
+ }
+ }
+ });
+ thread_id = null;
+ return this.trigger("thread:removed");
+ /*
+ select all threads
+ */
+
+ };
+
+ DiscussionThreadListView.prototype.isBrowseMenuVisible = function() {
+ return this.$(".forum-nav-browse-menu-wrapper").is(":visible");
+ };
+
+ DiscussionThreadListView.prototype.showBrowseMenu = function() {
+ if (!this.isBrowseMenuVisible()) {
+ this.$(".forum-nav-browse").addClass("is-active");
+ this.$(".forum-nav-browse-menu-wrapper").show();
+ this.$(".forum-nav-thread-list-wrapper").hide();
+ $(".forum-nav-browse-filter-input").focus();
+ $("body").bind("click", this.hideBrowseMenu);
+ return this.updateSidebar();
+ }
+ };
+
+ DiscussionThreadListView.prototype.hideBrowseMenu = function() {
+ if (this.isBrowseMenuVisible()) {
+ this.$(".forum-nav-browse").removeClass("is-active");
+ this.$(".forum-nav-browse-menu-wrapper").hide();
+ this.$(".forum-nav-thread-list-wrapper").show();
+ $("body").unbind("click", this.hideBrowseMenu);
+ return this.updateSidebar();
+ }
+ };
+
+ DiscussionThreadListView.prototype.toggleBrowseMenu = function(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ if (this.isBrowseMenuVisible()) {
+ return this.hideBrowseMenu();
+ } else {
+ return this.showBrowseMenu();
+ }
+ };
+
+ DiscussionThreadListView.prototype.getPathText = function(item) {
+ var path, pathTitles;
+ path = item.parents(".forum-nav-browse-menu-item").andSelf();
+ pathTitles = path.children(".forum-nav-browse-title").map(function(i, elem) {
+ return $(elem).text();
+ }).get();
+ return pathTitles.join(" / ");
+ };
+
+ DiscussionThreadListView.prototype.filterTopics = function(event) {
+ var items, query,
+ self = this;
+ query = $(event.target).val();
+ items = this.$(".forum-nav-browse-menu-item");
+ if (query.length === 0) {
+ return items.show();
+ } else {
+ items.hide();
+ return items.each(function(i, item) {
+ var path, pathText;
+ item = $(item);
+ if (!item.is(":visible")) {
+ pathText = self.getPathText(item).toLowerCase();
+ if (query.split(" ").every(function(term) {
+ return pathText.search(term.toLowerCase()) !== -1;
+ })) {
+ path = item.parents(".forum-nav-browse-menu-item").andSelf();
+ return path.add(item.find(".forum-nav-browse-menu-item")).show();
+ }
+ }
+ });
+ }
+ };
+
+ DiscussionThreadListView.prototype.setCurrentTopicDisplay = function(text) {
+ return this.$(".forum-nav-browse-current").text(this.fitName(text));
+ };
+
+ DiscussionThreadListView.prototype.getNameWidth = function(name) {
+ var test, width;
+ test = $("
");
+ test.css({
+ "font-size": this.$(".forum-nav-browse-current").css('font-size'),
+ opacity: 0,
+ position: 'absolute',
+ left: -1000,
+ top: -1000
+ });
+ $("body").append(test);
+ test.html(name);
+ width = test.width();
+ test.remove();
+ return width;
+ };
+
+ DiscussionThreadListView.prototype.fitName = function(name) {
+ var partialName, path, prefix, rawName, width, x;
+ this.maxNameWidth = this.$(".forum-nav-browse").width() -
+ this.$(".forum-nav-browse .icon").outerWidth(true) -
+ this.$(".forum-nav-browse-drop-arrow").outerWidth(true);
+ width = this.getNameWidth(name);
+ if (width < this.maxNameWidth) {
+ return name;
+ }
+ path = (function() {
+ var _i, _len, _ref, _results;
+ _ref = name.split("/");
+ _results = [];
+ for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+ x = _ref[_i];
+ _results.push(x.replace(/^\s+|\s+$/g, ""));
+ }
+ return _results;
+ })();
+ prefix = "";
+ while (path.length > 1) {
+ prefix = gettext("…") + "/";
+ path.shift();
+ partialName = prefix + path.join("/");
+ if (this.getNameWidth(partialName) < this.maxNameWidth) {
+ return partialName;
+ }
+ }
+ rawName = path[0];
+ name = prefix + rawName;
+ while (this.getNameWidth(name) > this.maxNameWidth) {
+ rawName = rawName.slice(0, rawName.length - 1);
+ name = prefix + rawName + gettext("…");
+ }
+ return name;
+ };
+
+ DiscussionThreadListView.prototype.selectTopicHandler = function(event) {
+ event.preventDefault();
+ return this.selectTopic($(event.target));
+ };
+
+ DiscussionThreadListView.prototype.selectTopic = function($target) {
+ var allItems, discussionIds, item;
+ this.hideBrowseMenu();
+ this.clearSearch();
+ item = $target.closest('.forum-nav-browse-menu-item');
+ this.setCurrentTopicDisplay(this.getPathText(item));
+ if (item.hasClass("forum-nav-browse-menu-all")) {
+ this.discussionIds = "";
+ this.$('.forum-nav-filter-cohort').show();
+ return this.retrieveAllThreads();
+ } else if (item.hasClass("forum-nav-browse-menu-following")) {
+ this.retrieveFollowed();
+ return this.$('.forum-nav-filter-cohort').hide();
+ } else {
+ allItems = item.find(".forum-nav-browse-menu-item").andSelf();
+ discussionIds = allItems.filter("[data-discussion-id]").map(function(i, elem) {
+ return $(elem).data("discussion-id");
+ }).get();
+ this.retrieveDiscussions(discussionIds);
+ return this.$(".forum-nav-filter-cohort").toggle(item.data('cohorted') === true);
+ }
+ };
+
+ DiscussionThreadListView.prototype.chooseFilter = function() {
+ this.filter = $(".forum-nav-filter-main-control :selected").val();
+ return this.retrieveFirstPage();
+ };
+
+ DiscussionThreadListView.prototype.chooseCohort = function() {
+ this.group_id = this.$('.forum-nav-filter-cohort-control :selected').val();
+ return this.retrieveFirstPage();
+ };
+
+ DiscussionThreadListView.prototype.retrieveDiscussion = function(discussion_id, callback) {
+ var url, self = this;
+ url = DiscussionUtil.urlFor("retrieve_discussion", discussion_id);
+ return DiscussionUtil.safeAjax({
+ url: url,
+ type: "GET",
+ success: function(response) {
+ self.collection.current_page = response.page;
+ self.collection.pages = response.num_pages;
+ self.collection.reset(response.discussion_data);
+ Content.loadContentInfos(response.annotated_content_info);
+ self.displayedCollection.reset(self.collection.models);
+ if (callback) {
+ return callback();
+ }
+ }
+ });
+ };
+
+ DiscussionThreadListView.prototype.retrieveDiscussions = function(discussion_ids) {
+ this.discussionIds = discussion_ids.join(',');
+ this.mode = 'commentables';
+ return this.retrieveFirstPage();
+ };
+
+ DiscussionThreadListView.prototype.retrieveAllThreads = function() {
+ this.mode = 'all';
+ return this.retrieveFirstPage();
+ };
+
+ DiscussionThreadListView.prototype.retrieveFirstPage = function(event) {
+ this.collection.current_page = 0;
+ this.collection.reset();
+ return this.loadMorePages(event);
+ };
+
+ DiscussionThreadListView.prototype.sortThreads = function(event) {
+ this.displayedCollection.setSortComparator(this.$(".forum-nav-sort-control").val());
+ return this.retrieveFirstPage(event);
+ };
+
+ DiscussionThreadListView.prototype.performSearch = function(event) {
+ /*
+ event.which 13 represent the Enter button
+ */
+
+ var text;
+ if (event.which === 13 || event.type === 'click') {
+ event.preventDefault();
+ this.hideBrowseMenu();
+ this.setCurrentTopicDisplay(gettext("Search Results"));
+ text = this.$(".forum-nav-search-input").val();
+ return this.searchFor(text);
+ }
+ };
+
+ DiscussionThreadListView.prototype.searchFor = function(text) {
+ var url,
+ self = this;
+ this.clearSearchAlerts();
+ this.clearFilters();
+ this.mode = 'search';
+ this.current_search = text;
+ url = DiscussionUtil.urlFor("search");
+ /*
+ TODO: This might be better done by setting discussion.current_page=0 and
+ calling discussion.loadMorePages
+ Mainly because this currently does not reset any pagination variables which could cause problems.
+ This doesn't use pagination either.
+ */
+
+ return DiscussionUtil.safeAjax({
+ $elem: this.$(".forum-nav-search-input"),
+ data: {
+ text: text
+ },
+ url: url,
+ type: "GET",
+ dataType: 'json',
+ $loading: $,
+ loadingCallback: function() {
+ return self.$(".forum-nav-thread-list")
+ .html(
+ "
" +
+ self.getLoadingContent(gettext("Loading thread list")) +
+ ""
+ );
+ },
+ loadedCallback: function() {
+ return self.$(".forum-nav-thread-list .forum-nav-load-more").remove();
+ },
+ success: function(response, textStatus) {
+ var message, noResponseMsg;
+ if (textStatus === 'success') {
+ self.collection.reset(response.discussion_data);
+ Content.loadContentInfos(response.annotated_content_info);
+ self.collection.current_page = response.page;
+ self.collection.pages = response.num_pages;
+ if (!_.isNull(response.corrected_text)) {
+ noResponseMsg = _.escape(
+ gettext(
+ 'No results found for %(original_query)s. ' +
+ 'Showing results for %(suggested_query)s.'
+ )
+ );
+ message = interpolate(
+ noResponseMsg,
+ {
+ "original_query": "
" + _.escape(text) + "",
+ "suggested_query": "
" + response.corrected_text + ""
+ },
+ true
+ );
+ self.addSearchAlert(message);
+ } else if (response.discussion_data.length === 0) {
+ self.addSearchAlert(gettext('No threads matched your query.'));
+ }
+ self.displayedCollection.reset(self.collection.models);
+ if (text) {
+ return self.searchForUser(text);
+ }
+ }
+ }
+ });
+ };
+
+ DiscussionThreadListView.prototype.searchForUser = function(text) {
+ var self = this;
+ return DiscussionUtil.safeAjax({
+ data: {
+ username: text
+ },
+ url: DiscussionUtil.urlFor("users"),
+ type: "GET",
+ dataType: 'json',
+ error: function() {
+ },
+ success: function(response) {
+ var message;
+ if (response.users.length > 0) {
+ message = interpolate(_.escape(gettext('Show posts by %(username)s.')), {
+ "username": _.template('
<%- username %>')({
+ url: DiscussionUtil.urlFor("user_profile", response.users[0].id),
+ username: response.users[0].username
+ })
+ }, true);
+ return self.addSearchAlert(message);
+ }
+ }
+ });
+ };
+
+ DiscussionThreadListView.prototype.clearSearch = function() {
+ this.$(".forum-nav-search-input").val("");
+ this.current_search = "";
+ return this.clearSearchAlerts();
+ };
+
+ DiscussionThreadListView.prototype.clearFilters = function() {
+ this.$(".forum-nav-filter-main-control").val("all");
+ return this.$(".forum-nav-filter-cohort-control").val("all");
+ };
+
+ DiscussionThreadListView.prototype.retrieveFollowed = function() {
+ this.mode = 'followed';
+ return this.retrieveFirstPage();
+ };
+
+ DiscussionThreadListView.prototype.updateEmailNotifications = function() {
+ if ($('input.email-setting').attr('checked')) {
+ return DiscussionUtil.safeAjax({
+ url: DiscussionUtil.urlFor("enable_notifications"),
+ type: "POST",
+ error: function() {
+ return $('input.email-setting').removeAttr('checked');
+ }
+ });
+ } else {
+ return DiscussionUtil.safeAjax({
+ url: DiscussionUtil.urlFor("disable_notifications"),
+ type: "POST",
+ error: function() {
+ return $('input.email-setting').attr('checked', 'checked');
+ }
+ });
+ }
+ };
+
+ return DiscussionThreadListView;
+
+ }).call(this, Backbone.View);
+ }
+
+}).call(window);
diff --git a/common/static/common/js/discussion/views/discussion_thread_profile_view.js b/common/static/common/js/discussion/views/discussion_thread_profile_view.js
new file mode 100644
index 0000000000..31abb9a7c8
--- /dev/null
+++ b/common/static/common/js/discussion/views/discussion_thread_profile_view.js
@@ -0,0 +1,72 @@
+/* globals DiscussionUtil, MathJax */
+(function() {
+ 'use strict';
+ var __hasProp = {}.hasOwnProperty,
+ __extends = function(child, parent) {
+ for (var key in parent) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ function ctor() {
+ this.constructor = child;
+ }
+
+ ctor.prototype = parent.prototype;
+ child.prototype = new ctor();
+ child.__super__ = parent.prototype;
+ return child;
+ };
+
+ if (typeof Backbone !== "undefined" && Backbone !== null) {
+ this.DiscussionThreadProfileView = (function(_super) {
+
+ __extends(DiscussionThreadProfileView, _super);
+
+ function DiscussionThreadProfileView() {
+ return DiscussionThreadProfileView.__super__.constructor.apply(this, arguments);
+ }
+
+ DiscussionThreadProfileView.prototype.render = function() {
+ var element, params;
+ this.convertMath();
+ this.abbreviateBody();
+ params = $.extend(this.model.toJSON(), {
+ permalink: this.model.urlFor('retrieve')
+ });
+ if (!this.model.get('anonymous')) {
+ params = $.extend(params, {
+ user: {
+ username: this.model.username,
+ user_url: this.model.user_url
+ }
+ });
+ }
+ this.$el.html(_.template($("#profile-thread-template").html())(params));
+ this.$("span.timeago").timeago();
+ element = this.$(".post-body");
+ if (typeof MathJax !== "undefined" && MathJax !== null) {
+ MathJax.Hub.Queue(["Typeset", MathJax.Hub, element[0]]);
+ }
+ return this;
+ };
+
+ DiscussionThreadProfileView.prototype.convertMath = function() {
+ return this.model.set(
+ 'markdownBody',
+ DiscussionUtil.postMathJaxProcessor(DiscussionUtil.markdownWithHighlight(this.model.get('body')))
+ );
+ };
+
+ DiscussionThreadProfileView.prototype.abbreviateBody = function() {
+ var abbreviated;
+ abbreviated = DiscussionUtil.abbreviateHTML(this.model.get('markdownBody'), 140);
+ return this.model.set('abbreviatedBody', abbreviated);
+ };
+
+ return DiscussionThreadProfileView;
+
+ })(Backbone.View);
+ }
+
+}).call(window);
diff --git a/common/static/common/js/discussion/views/discussion_thread_show_view.js b/common/static/common/js/discussion/views/discussion_thread_show_view.js
new file mode 100644
index 0000000000..a5fc0fc12d
--- /dev/null
+++ b/common/static/common/js/discussion/views/discussion_thread_show_view.js
@@ -0,0 +1,91 @@
+/* globals DiscussionUtil, DiscussionContentShowView, MathJax */
+(function() {
+ 'use strict';
+ var __hasProp = {}.hasOwnProperty,
+ __extends = function(child, parent) {
+ for (var key in parent) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ function ctor() {
+ this.constructor = child;
+ }
+
+ ctor.prototype = parent.prototype;
+ child.prototype = new ctor();
+ child.__super__ = parent.prototype;
+ return child;
+ };
+
+ if (typeof Backbone !== "undefined" && Backbone !== null) {
+ this.DiscussionThreadShowView = (function(_super) {
+
+ __extends(DiscussionThreadShowView, _super);
+
+ function DiscussionThreadShowView() {
+ return DiscussionThreadShowView.__super__.constructor.apply(this, arguments);
+ }
+
+ DiscussionThreadShowView.prototype.initialize = function(options) {
+ var _ref;
+ DiscussionThreadShowView.__super__.initialize.call(this);
+ this.mode = options.mode || "inline";
+ if ((_ref = this.mode) !== "tab" && _ref !== "inline") {
+ throw new Error("invalid mode: " + this.mode);
+ }
+ };
+
+ DiscussionThreadShowView.prototype.renderTemplate = function() {
+ var context;
+ this.template = _.template($("#thread-show-template").html());
+ context = $.extend({
+ mode: this.mode,
+ flagged: this.model.isFlagged(),
+ author_display: this.getAuthorDisplay(),
+ cid: this.model.cid,
+ readOnly: $('.discussion-module').data('read-only')
+ }, this.model.attributes);
+ return this.template(context);
+ };
+
+ DiscussionThreadShowView.prototype.render = function() {
+ this.$el.html(this.renderTemplate());
+ this.delegateEvents();
+ this.renderAttrs();
+ this.$("span.timeago").timeago();
+ this.convertMath();
+ this.highlight(this.$(".post-body"));
+ this.highlight(this.$("h1,h3"));
+ return this;
+ };
+
+ DiscussionThreadShowView.prototype.convertMath = function() {
+ var element;
+ element = this.$(".post-body");
+ element.html(DiscussionUtil.postMathJaxProcessor(DiscussionUtil.markdownWithHighlight(element.text())));
+ if (typeof MathJax !== "undefined" && MathJax !== null) {
+ return MathJax.Hub.Queue(["Typeset", MathJax.Hub, element[0]]);
+ }
+ };
+
+ DiscussionThreadShowView.prototype.edit = function(event) {
+ return this.trigger("thread:edit", event);
+ };
+
+ DiscussionThreadShowView.prototype._delete = function(event) {
+ return this.trigger("thread:_delete", event);
+ };
+
+ DiscussionThreadShowView.prototype.highlight = function(el) {
+ if (el.html()) {
+ return el.html(el.html().replace(/<mark>/g, "
").replace(/<\/mark>/g, ""));
+ }
+ };
+
+ return DiscussionThreadShowView;
+
+ })(DiscussionContentShowView);
+ }
+
+}).call(window);
diff --git a/common/static/common/js/discussion/views/discussion_thread_view.js b/common/static/common/js/discussion/views/discussion_thread_view.js
new file mode 100644
index 0000000000..2854690369
--- /dev/null
+++ b/common/static/common/js/discussion/views/discussion_thread_view.js
@@ -0,0 +1,489 @@
+/* globals
+ Comments, Content, DiscussionContentView, DiscussionThreadEditView,
+ DiscussionThreadShowView, DiscussionUtil, ThreadResponseView
+*/
+(function() {
+ 'use strict';
+ var __hasProp = {}.hasOwnProperty,
+ __extends = function(child, parent) {
+ for (var key in parent) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ function ctor() {
+ this.constructor = child;
+ }
+
+ ctor.prototype = parent.prototype;
+ child.prototype = new ctor();
+ child.__super__ = parent.prototype;
+ return child;
+ };
+
+ if (typeof Backbone !== "undefined" && Backbone !== null) {
+ this.DiscussionThreadView = (function(_super) {
+ var INITIAL_RESPONSE_PAGE_SIZE, SUBSEQUENT_RESPONSE_PAGE_SIZE;
+
+ __extends(DiscussionThreadView, _super);
+
+ function DiscussionThreadView() {
+ var self = this;
+ this._delete = function() {
+ return DiscussionThreadView.prototype._delete.apply(self, arguments);
+ };
+ this.closeEditView = function() {
+ return DiscussionThreadView.prototype.closeEditView.apply(self, arguments);
+ };
+ this.edit = function() {
+ return DiscussionThreadView.prototype.edit.apply(self, arguments);
+ };
+ this.endorseThread = function() {
+ return DiscussionThreadView.prototype.endorseThread.apply(self, arguments);
+ };
+ this.addComment = function() {
+ return DiscussionThreadView.prototype.addComment.apply(self, arguments);
+ };
+ this.renderAddResponseButton = function() {
+ return DiscussionThreadView.prototype.renderAddResponseButton.apply(self, arguments);
+ };
+ this.renderResponseToList = function() {
+ return DiscussionThreadView.prototype.renderResponseToList.apply(self, arguments);
+ };
+ this.renderResponseCountAndPagination = function() {
+ return DiscussionThreadView.prototype.renderResponseCountAndPagination.apply(self, arguments);
+ };
+ return DiscussionThreadView.__super__.constructor.apply(this, arguments);
+ }
+
+ INITIAL_RESPONSE_PAGE_SIZE = 25;
+
+ SUBSEQUENT_RESPONSE_PAGE_SIZE = 100;
+
+ DiscussionThreadView.prototype.events = {
+ "click .discussion-submit-post": "submitComment",
+ "click .add-response-btn": "scrollToAddResponse",
+ "click .forum-thread-expand": "expand",
+ "click .forum-thread-collapse": "collapse"
+ };
+
+ DiscussionThreadView.prototype.$ = function(selector) {
+ return this.$el.find(selector);
+ };
+
+ DiscussionThreadView.prototype.isQuestion = function() {
+ return this.model.get("thread_type") === "question";
+ };
+
+ DiscussionThreadView.prototype.initialize = function(options) {
+ var _ref,
+ self = this;
+ DiscussionThreadView.__super__.initialize.call(this);
+ this.mode = options.mode || "inline";
+ this.context = options.context || "course";
+ this.options = _.extend({}, options);
+ if ((_ref = this.mode) !== "tab" && _ref !== "inline") {
+ throw new Error("invalid mode: " + this.mode);
+ }
+ this.readOnly = $(".discussion-module").data('read-only');
+ this.model.collection.on("reset", function(collection) {
+ var id;
+ id = self.model.get("id");
+ if (collection.get(id)) {
+ self.model = collection.get(id);
+ }
+ });
+ this.createShowView();
+ this.responses = new Comments();
+ this.loadedResponses = false;
+ if (this.isQuestion()) {
+ this.markedAnswers = new Comments();
+ }
+ };
+
+ DiscussionThreadView.prototype.rerender = function() {
+ if (this.showView) {
+ this.showView.undelegateEvents();
+ }
+ this.undelegateEvents();
+ this.$el.empty();
+ this.initialize({
+ mode: this.mode,
+ model: this.model,
+ el: this.el,
+ course_settings: this.options.course_settings,
+ topicId: this.topicId
+ });
+ return this.render();
+ };
+
+ DiscussionThreadView.prototype.renderTemplate = function() {
+ var container, templateData;
+ this.template = _.template($("#thread-template").html());
+ container = $("#discussion-container");
+ if (!container.length) {
+ container = $(".discussion-module");
+ }
+ templateData = _.extend(this.model.toJSON(), {
+ readOnly: this.readOnly,
+ can_create_comment: container.data("user-create-comment")
+ });
+ return this.template(templateData);
+ };
+
+ DiscussionThreadView.prototype.render = function() {
+ var self = this;
+ this.$el.html(this.renderTemplate());
+ this.delegateEvents();
+ this.renderShowView();
+ this.renderAttrs();
+ this.$("span.timeago").timeago();
+ this.makeWmdEditor("reply-body");
+ this.renderAddResponseButton();
+ this.responses.on("add", function(response) {
+ return self.renderResponseToList(response, ".js-response-list", {});
+ });
+ if (this.isQuestion()) {
+ this.markedAnswers.on("add", function(response) {
+ return self.renderResponseToList(response, ".js-marked-answer-list", {
+ collapseComments: true
+ });
+ });
+ }
+ if (this.mode === "tab") {
+ setTimeout(function() {
+ return self.loadInitialResponses();
+ }, 100);
+ return this.$(".post-tools").hide();
+ } else {
+ return this.collapse();
+ }
+ };
+
+ DiscussionThreadView.prototype.attrRenderer = $.extend({}, DiscussionContentView.prototype.attrRenderer, {
+ closed: function(closed) {
+ this.$(".discussion-reply-new").toggle(!closed);
+ this.$('.comment-form').closest('li').toggle(!closed);
+ this.$(".action-vote").toggle(!closed);
+ this.$(".display-vote").toggle(closed);
+ return this.renderAddResponseButton();
+ }
+ });
+
+ DiscussionThreadView.prototype.expand = function(event) {
+ if (event) {
+ event.preventDefault();
+ }
+ this.$el.addClass("expanded");
+ this.$el.find(".post-body").text(this.model.get("body"));
+ this.showView.convertMath();
+ this.$el.find(".forum-thread-expand").hide();
+ this.$el.find(".forum-thread-collapse").show();
+ this.$el.find(".post-extended-content").show();
+ if (!this.loadedResponses) {
+ return this.loadInitialResponses();
+ }
+ };
+
+ DiscussionThreadView.prototype.collapse = function(event) {
+ if (event) {
+ event.preventDefault();
+ }
+ this.$el.removeClass("expanded");
+ this.$el.find(".post-body").text(this.getAbbreviatedBody());
+ this.showView.convertMath();
+ this.$el.find(".forum-thread-expand").show();
+ this.$el.find(".forum-thread-collapse").hide();
+ return this.$el.find(".post-extended-content").hide();
+ };
+
+ DiscussionThreadView.prototype.getAbbreviatedBody = function() {
+ var abbreviated, cached;
+ cached = this.model.get("abbreviatedBody");
+ if (cached) {
+ return cached;
+ } else {
+ abbreviated = DiscussionUtil.abbreviateString(this.model.get("body"), 140);
+ this.model.set("abbreviatedBody", abbreviated);
+ return abbreviated;
+ }
+ };
+
+ DiscussionThreadView.prototype.cleanup = function() {
+ if (this.responsesRequest) {
+ return this.responsesRequest.abort();
+ }
+ };
+
+ DiscussionThreadView.prototype.loadResponses = function(responseLimit, elem, firstLoad) {
+ var takeFocus,
+ self = this;
+ takeFocus = this.mode === "tab" ? false : true;
+ this.responsesRequest = DiscussionUtil.safeAjax({
+ url: DiscussionUtil.urlFor(
+ 'retrieve_single_thread', this.model.get('commentable_id'), this.model.id
+ ),
+ data: {
+ resp_skip: this.responses.size(),
+ resp_limit: responseLimit ? responseLimit : void 0
+ },
+ $elem: elem,
+ $loading: elem,
+ takeFocus: takeFocus,
+ complete: function() {
+ self.responsesRequest = null;
+ },
+ success: function(data) {
+ Content.loadContentInfos(data.annotated_content_info);
+ if (self.isQuestion()) {
+ self.markedAnswers.add(data.content.endorsed_responses);
+ }
+ self.responses.add(
+ self.isQuestion() ? data.content.non_endorsed_responses : data.content.children
+ );
+ self.renderResponseCountAndPagination(
+ self.isQuestion() ?
+ data.content.non_endorsed_resp_total :
+ data.content.resp_total
+ );
+ self.trigger("thread:responses:rendered");
+ self.loadedResponses = true;
+ return self.$el.find('.discussion-article[data-id="' + self.model.id + '"]').focus();
+ },
+ error: function(xhr, textStatus) {
+ if (textStatus === 'abort') {
+ return;
+ }
+ if (xhr.status === 404) {
+ DiscussionUtil.discussionAlert(
+ gettext("Sorry"),
+ gettext("The thread you selected has been deleted. Please select another thread.")
+ );
+ } else if (firstLoad) {
+ DiscussionUtil.discussionAlert(
+ gettext("Sorry"),
+ gettext("We had some trouble loading responses. Please reload the page.")
+ );
+ } else {
+ DiscussionUtil.discussionAlert(
+ gettext("Sorry"),
+ gettext("We had some trouble loading more responses. Please try again.")
+ );
+ }
+ }
+ });
+ };
+
+ DiscussionThreadView.prototype.loadInitialResponses = function() {
+ return this.loadResponses(INITIAL_RESPONSE_PAGE_SIZE, this.$el.find(".js-response-list"), true);
+ };
+
+ DiscussionThreadView.prototype.renderResponseCountAndPagination = function(responseTotal) {
+ var buttonText, loadMoreButton, responseCountFormat, responseLimit, responsePagination,
+ responsesRemaining, showingResponsesText, self = this;
+ if (this.isQuestion() && this.markedAnswers.length !== 0) {
+ responseCountFormat = ngettext(
+ "%(numResponses)s other response", "%(numResponses)s other responses", responseTotal
+ );
+ } else {
+ responseCountFormat = ngettext(
+ "%(numResponses)s response", "%(numResponses)s responses", responseTotal
+ );
+ }
+ this.$el.find(".response-count").html(interpolate(responseCountFormat, {
+ numResponses: responseTotal
+ }, true));
+ responsePagination = this.$el.find(".response-pagination");
+ responsePagination.empty();
+ if (responseTotal > 0) {
+ responsesRemaining = responseTotal - this.responses.size();
+ if (responsesRemaining === 0) {
+ showingResponsesText = gettext("Showing all responses");
+ }
+ else {
+ showingResponsesText = interpolate(
+ ngettext(
+ "Showing first response", "Showing first %(numResponses)s responses",
+ this.responses.size()
+ ),
+ { numResponses: this.responses.size() },
+ true
+ );
+ }
+
+ responsePagination.append($("
")
+ .addClass("response-display-count").html(_.escape(showingResponsesText)));
+ if (responsesRemaining > 0) {
+ if (responsesRemaining < SUBSEQUENT_RESPONSE_PAGE_SIZE) {
+ responseLimit = null;
+ buttonText = gettext("Load all responses");
+ } else {
+ responseLimit = SUBSEQUENT_RESPONSE_PAGE_SIZE;
+ buttonText = interpolate(gettext("Load next %(numResponses)s responses"), {
+ numResponses: responseLimit
+ }, true);
+ }
+ loadMoreButton = $("
'
- window.MathJax = { Hub: { Queue: -> } }
-
- makeView = (thread) ->
- view = new DiscussionThreadProfileView(model: thread)
- spyConvertMath(view)
- return view
-
- makeThread = (threadData) ->
- thread = new Thread(threadData)
- thread.discussion = new Discussion()
- return thread
-
- spyConvertMath = (view) ->
- spyOn(view, "convertMath").and.callFake( ->
- @model.set('markdownBody', @model.get('body'))
- )
-
- checkPostWithImages = (numberOfImages, truncatedText, threadData, imageTag) ->
- expectedHtml = '