mirror of
https://github.com/zulip/zulip.git
synced 2025-11-06 15:03:34 +00:00
c97ce3a082
This change makes it so we now keep track of full stream information for both subscribed and unsubscribed streams in our frontend. Previously, any unsubscribed streams had no associated data. (imported from commit c445b19abe11c43c710c264fffcf3af5097deb6c)
971 lines
33 KiB
JavaScript
971 lines
33 KiB
JavaScript
var subs = (function () {
|
|
|
|
var exports = {};
|
|
|
|
var stream_info = {}; // Maps lowercase stream name to stream properties object
|
|
// We fetch the stream colors asynchronous while the message feed is
|
|
// getting constructed, so we may need to go back and color streams
|
|
// that have already been rendered.
|
|
var initial_color_fetch = true;
|
|
|
|
var default_color = "#c2c2c2";
|
|
// Auto-assigned colors should be from the default palette so it's easy to undo
|
|
// changes, so if that pallete changes, change these colors.
|
|
var stream_assignment_colors = ["#76ce90", "#fae589", "#a6c7e5", "#e79ab5",
|
|
"#bfd56f", "#f4ae55", "#b0a5fd", "#addfe5",
|
|
"#f5ce6e", "#c2726a", "#94c849", "#bd86e5",
|
|
"#ee7e4a", "#a6dcbf", "#95a5fd", "#53a063",
|
|
"#9987e1", "#e4523d", "#c2c2c2", "#4f8de4",
|
|
"#c6a8ad", "#e7cc4d", "#c8bebf", "#a47462"];
|
|
|
|
// Clone stream_assignement_colors
|
|
var available_colors = stream_assignment_colors.slice(0);
|
|
|
|
var next_sub_id = 0;
|
|
|
|
function add_sub(stream_name, sub) {
|
|
stream_info[stream_name.toLowerCase()] = sub;
|
|
}
|
|
|
|
function get_sub(stream_name) {
|
|
return stream_info[stream_name.toLowerCase()];
|
|
}
|
|
|
|
// Classes which could be returned by get_color_class.
|
|
exports.color_classes = 'dark_background';
|
|
|
|
function pick_color() {
|
|
if (available_colors.length === 0) {
|
|
// We've used all the palette colors, so start re-using them.
|
|
return stream_assignment_colors[exports.subscribed_streams().length
|
|
% stream_assignment_colors.length];
|
|
}
|
|
|
|
return available_colors[0];
|
|
}
|
|
|
|
function mark_color_used(color) {
|
|
var i;
|
|
for (i = 0; i < available_colors.length; ++i) {
|
|
if (available_colors[i] === color) {
|
|
available_colors.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
exports.subscribed_streams = function () {
|
|
// TODO: Object.keys() compatibility
|
|
var list = [];
|
|
$.each(Object.keys(stream_info), function (idx, key) {
|
|
var sub = stream_info[key];
|
|
if (sub.subscribed) {
|
|
list.push(sub.name);
|
|
}
|
|
});
|
|
list.sort();
|
|
return list;
|
|
};
|
|
|
|
exports.maybe_toggle_all_messages = function () {
|
|
var show_all_messages = false;
|
|
$.each(stream_info, function (idx, stream) {
|
|
if (!stream.in_home_view) {
|
|
show_all_messages = true;
|
|
return false;
|
|
}
|
|
});
|
|
|
|
var all_messages = $("#global_filters [data-name='all']")[0];
|
|
if (!show_all_messages) {
|
|
$(all_messages).addClass('hidden-filter');
|
|
} else {
|
|
$(all_messages).removeClass('hidden-filter');
|
|
}
|
|
};
|
|
|
|
function should_render_subscribers() {
|
|
return page_params.domain !== 'mit.edu';
|
|
}
|
|
|
|
function should_list_all_streams() {
|
|
return page_params.domain !== 'mit.edu';
|
|
}
|
|
|
|
function update_table_stream_color(table, stream_name, color) {
|
|
var color_class = exports.get_color_class(color);
|
|
function fixup(elem) {
|
|
elem.css("background-color", color)
|
|
.removeClass(exports.color_classes)
|
|
.addClass(color_class);
|
|
}
|
|
|
|
$.each(table.find(".stream_label"), function () {
|
|
if ($(this).text() === stream_name) {
|
|
var parent_label = $(this).parent("td");
|
|
fixup(parent_label);
|
|
fixup(parent_label.prev("td"));
|
|
}
|
|
});
|
|
}
|
|
|
|
exports.stream_id = function(stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
if (sub === undefined) {
|
|
blueslip.error("Tried to get subs.stream_id for a stream user is not subscribed to!");
|
|
return 0;
|
|
}
|
|
return parseInt(sub.id, 10);
|
|
};
|
|
|
|
exports.canonicalized_name = function (stream_name) {
|
|
return stream_name.toString().toLowerCase();
|
|
};
|
|
|
|
function update_stream_sidebar_swatch_color(stream_name, color) {
|
|
var id = exports.stream_id(stream_name);
|
|
$("#stream_sidebar_swatch_" + id).css('background-color', color);
|
|
}
|
|
|
|
function update_historical_message_color(stream_name, color) {
|
|
update_table_stream_color($(".focused_table"), stream_name, color);
|
|
if ($(".focused_table").attr("id") !== "#zhome") {
|
|
update_table_stream_color($("#zhome"), stream_name, color);
|
|
}
|
|
}
|
|
|
|
function update_stream_color(stream_name, color, opts) {
|
|
opts = $.extend({}, {update_historical: false}, opts);
|
|
var sub = get_sub(stream_name);
|
|
sub.color = color;
|
|
var id = parseInt(sub.id, 10);
|
|
$("#subscription_" + id + " .color_swatch").css('background-color', color);
|
|
if (opts.update_historical) {
|
|
update_historical_message_color(stream_name, color);
|
|
}
|
|
update_stream_sidebar_swatch_color(stream_name, color);
|
|
}
|
|
|
|
function set_stream_property(stream_name, property, value) {
|
|
$.ajax({
|
|
type: 'POST',
|
|
url: '/json/subscriptions/property',
|
|
dataType: 'json',
|
|
data: {
|
|
"property": property,
|
|
"stream_name": stream_name,
|
|
"value": value
|
|
},
|
|
timeout: 10*1000
|
|
});
|
|
}
|
|
|
|
function stream_home_view_clicked(e) {
|
|
var sub_row = $(e.target).closest('.subscription_row');
|
|
var stream = sub_row.find('.subscription_name').text();
|
|
subs.toggle_home(stream);
|
|
}
|
|
|
|
exports.toggle_home = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
sub.in_home_view = ! sub.in_home_view;
|
|
|
|
setTimeout(function () {
|
|
home_msg_list.clear({clear_selected_id: false});
|
|
|
|
// Remember the scroll position as the adding or removing this
|
|
// number of rows might cause the page to scroll in unexpected ways
|
|
var saved_ypos = window.scrollY;
|
|
|
|
// Recreate the home_msg_list with the newly filtered all_msg_list
|
|
add_messages(all_msg_list.all(), home_msg_list);
|
|
|
|
// Ensure we're still at the same scroll position
|
|
window.scrollTo(0, saved_ypos);
|
|
|
|
// In case we added messages to what's visible in the home view, we need to re-scroll to make
|
|
// sure the pointer is still visible. We don't want the auto-scroll handler to move our pointer
|
|
// to the old scroll location before we have a chance to update it.
|
|
recenter_pointer_on_display = true;
|
|
suppress_scroll_pointer_update = true;
|
|
|
|
if (! home_msg_list.empty()) {
|
|
process_loaded_for_unread(home_msg_list.all());
|
|
}
|
|
}, 0);
|
|
|
|
exports.maybe_toggle_all_messages();
|
|
set_stream_property(stream_name, 'in_home_view', sub.in_home_view);
|
|
var li = $("#stream_filters li[data-name='" + encodeURIComponent(stream_name) + "']");
|
|
if (sub.in_home_view) {
|
|
li.removeClass("out_of_home_view");
|
|
} else {
|
|
li.addClass("out_of_home_view");
|
|
}
|
|
};
|
|
|
|
function stream_notifications_clicked(e) {
|
|
var sub_row = $(e.target).closest('.subscription_row');
|
|
var stream = sub_row.find('.subscription_name').text();
|
|
|
|
var sub = get_sub(stream);
|
|
sub.notifications = ! sub.notifications;
|
|
set_stream_property(stream, 'notifications', sub.notifications);
|
|
}
|
|
|
|
function set_color(stream_name, color) {
|
|
update_stream_color(stream_name, color, {update_historical: true});
|
|
set_stream_property(stream_name, 'color', color);
|
|
}
|
|
|
|
var stream_color_palette = [
|
|
['a47462', 'c2726a', 'e4523d', 'e7664d', 'ee7e4a', 'f4ae55'],
|
|
['76ce90', '53a063', '94c849', 'bfd56f', 'fae589', 'f5ce6e'],
|
|
['a6dcbf', 'addfe5', 'a6c7e5', '4f8de4', '95a5fd', 'b0a5fd'],
|
|
['c2c2c2', 'c8bebf', 'c6a8ad', 'e79ab5', 'bd86e5', '9987e1']
|
|
];
|
|
|
|
function picker_do_change_color (color) {
|
|
var stream_name = $(this).attr('stream_name');
|
|
var hex_color = color.toHexString();
|
|
set_color(stream_name, hex_color);
|
|
}
|
|
|
|
exports.sidebar_popover_colorpicker_options = {
|
|
clickoutFiresChange: true,
|
|
showPaletteOnly: true,
|
|
showPalette: true,
|
|
flat: true,
|
|
palette: stream_color_palette,
|
|
change: picker_do_change_color
|
|
};
|
|
|
|
exports.sidebar_popover_colorpicker_options_full = {
|
|
clickoutFiresChange: true,
|
|
showPalette: true,
|
|
flat: true,
|
|
cancelText: "",
|
|
chooseText: "choose",
|
|
palette: stream_color_palette,
|
|
change: picker_do_change_color
|
|
};
|
|
|
|
var subscriptions_table_colorpicker_options = {
|
|
clickoutFiresChange: true,
|
|
showPalette: true,
|
|
palette: stream_color_palette,
|
|
change: picker_do_change_color
|
|
};
|
|
|
|
function create_sub(stream_name, attrs) {
|
|
var sub = get_sub(stream_name);
|
|
if (sub !== undefined) {
|
|
// We've already created this subscription, no need to continue.
|
|
return sub;
|
|
}
|
|
|
|
sub = $.extend({}, {name: stream_name, id: next_sub_id++,
|
|
render_subscribers: should_render_subscribers(),
|
|
subscribed: true, in_home_view: true, invite_only: false,
|
|
notifications: false}, attrs);
|
|
if (sub.color === undefined) {
|
|
sub.color = pick_color();
|
|
}
|
|
mark_color_used(sub.color);
|
|
|
|
add_sub(stream_name, sub);
|
|
$(document).trigger($.Event('sub_obj_created.zephyr', {sub: sub}));
|
|
return sub;
|
|
}
|
|
|
|
function button_for_sub(sub) {
|
|
var id = parseInt(sub.id, 10);
|
|
return $("#subscription_" + id + " .sub_unsub_button");
|
|
}
|
|
|
|
function settings_for_sub(sub) {
|
|
var id = parseInt(sub.id, 10);
|
|
return $("#subscription_settings_" + id);
|
|
}
|
|
|
|
function add_sub_to_table(sub) {
|
|
$('#create_stream_row').after(
|
|
templates.render('subscription', {subscriptions: [sub]}));
|
|
settings_for_sub(sub).collapse('show');
|
|
}
|
|
|
|
function format_member_list_elem(name, email) {
|
|
return name + ' <' + email + '>';
|
|
}
|
|
|
|
function add_to_member_list(ul, name, email) {
|
|
var member;
|
|
if (email === undefined) {
|
|
member = name;
|
|
} else {
|
|
member = format_member_list_elem(name, email);
|
|
}
|
|
$('<li>').prependTo(ul).text(member);
|
|
}
|
|
|
|
function mark_subscribed(stream_name, attrs) {
|
|
var sub = get_sub(stream_name);
|
|
|
|
if (sub === undefined) {
|
|
// Create a new stream.
|
|
sub = create_sub(stream_name, attrs);
|
|
add_sub_to_table(sub);
|
|
} else if (! sub.subscribed) {
|
|
// Add yourself to an existing stream.
|
|
sub.subscribed = true;
|
|
set_color(stream_name, pick_color());
|
|
mark_color_used(sub.color);
|
|
var settings = settings_for_sub(sub);
|
|
var button = button_for_sub(sub);
|
|
if (button.length !== 0) {
|
|
button.text("Unsubscribe").removeClass("btn-primary");
|
|
// Add the user to the member list if they're currently
|
|
// viewing the members of this stream
|
|
if (sub.render_subscribers && settings.hasClass('in')) {
|
|
var members = settings.find(".subscriber_list_container ul");
|
|
add_to_member_list(members, page_params.fullname, page_params.email);
|
|
}
|
|
} else {
|
|
add_sub_to_table(sub);
|
|
}
|
|
|
|
// Display the swatch and subscription settings
|
|
var sub_row = settings.closest('.subscription_row');
|
|
sub_row.find(".color_swatch").addClass('in');
|
|
sub_row.find(".regular_subscription_settings").collapse('show');
|
|
} else {
|
|
// Already subscribed
|
|
return;
|
|
}
|
|
|
|
if (current_msg_list.narrowed) {
|
|
current_msg_list.update_trailing_bookend();
|
|
}
|
|
|
|
// Update unread counts as the new stream in sidebar might
|
|
// need its unread counts re-calculated
|
|
process_loaded_for_unread(all_msg_list.all());
|
|
|
|
typeahead_helper.update_autocomplete();
|
|
|
|
$(document).trigger($.Event('subscription_add_done.zephyr', {sub: sub}));
|
|
}
|
|
|
|
function mark_unsubscribed(stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
|
|
if (sub === undefined) {
|
|
// We don't know about this stream
|
|
return;
|
|
} else if (sub.subscribed) {
|
|
stream_list.remove_narrow_filter(stream_name, 'stream');
|
|
sub.subscribed = false;
|
|
button_for_sub(sub).text("Subscribe").addClass("btn-primary");
|
|
var settings = settings_for_sub(sub);
|
|
if (settings.hasClass('in')) {
|
|
settings.collapse('hide');
|
|
}
|
|
|
|
// Hide the swatch and subscription settings
|
|
var sub_row = settings.closest('.subscription_row');
|
|
sub_row.find(".color_swatch").removeClass('in');
|
|
if (sub.render_subscribers) {
|
|
// TODO: having a completely empty settings div messes
|
|
// with Bootstrap's collapser. We currently just ensure
|
|
// that it's not empty on the MIT realm, even though it
|
|
// looks weird
|
|
sub_row.find(".regular_subscription_settings").collapse('hide');
|
|
}
|
|
} else {
|
|
// Already unsubscribed
|
|
return;
|
|
}
|
|
|
|
if (current_msg_list.narrowed) {
|
|
current_msg_list.update_trailing_bookend();
|
|
}
|
|
|
|
typeahead_helper.update_autocomplete();
|
|
|
|
$(document).trigger($.Event('subscription_remove_done.zephyr', {sub: sub}));
|
|
}
|
|
|
|
$(function () {
|
|
$(document).on('subscription_add.zephyr', function (e) {
|
|
mark_subscribed(e.subscription.name, e.subscription);
|
|
});
|
|
$(document).on('subscription_remove.zephyr', function (e) {
|
|
mark_unsubscribed(e.subscription.name);
|
|
});
|
|
|
|
$(document).on('click', '.subs_set_all_users', function (e) {
|
|
$('#people_to_add :checkbox').attr('checked', true);
|
|
e.preventDefault();
|
|
});
|
|
$(document).on('click', '.subs_unset_all_users', function (e) {
|
|
$('#people_to_add :checkbox').attr('checked', false);
|
|
e.preventDefault();
|
|
});
|
|
});
|
|
|
|
exports.get_color = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
if (sub === undefined) {
|
|
return default_color;
|
|
}
|
|
return sub.color;
|
|
};
|
|
|
|
var lightness_threshold;
|
|
$(function () {
|
|
// sRGB color component for dark label text.
|
|
// 0x33 to match the color #333333 set by Bootstrap.
|
|
var label_color = 0x33;
|
|
var lightness = colorspace.luminance_to_lightness(
|
|
colorspace.sRGB_to_linear(label_color));
|
|
|
|
// Compute midpoint lightness between that and white (100).
|
|
lightness_threshold = (lightness + 100) / 2;
|
|
});
|
|
|
|
// From a background color (in format "#fff" or "#ffffff")
|
|
// pick a CSS class (or empty string) to determine the
|
|
// text label color etc.
|
|
//
|
|
// It would be better to work with an actual data structure
|
|
// rather than a hex string, but we have to deal with values
|
|
// already saved on the server, etc.
|
|
//
|
|
// This gets called on every message, so cache the results.
|
|
exports.get_color_class = util.memoize(function (color) {
|
|
var match, i, lightness, channel = [0, 0, 0], mult = 1;
|
|
|
|
match = /^#([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})$/.exec(color);
|
|
if (!match) {
|
|
// 3-digit shorthand; Spectrum gives this e.g. for pure black.
|
|
// Multiply each digit by 16+1.
|
|
mult = 17;
|
|
|
|
match = /^#([\da-fA-F])([\da-fA-F])([\da-fA-F])$/.exec(color);
|
|
if (!match) {
|
|
// Can't understand color.
|
|
return '';
|
|
}
|
|
}
|
|
|
|
// CSS colors are specified in the sRGB color space.
|
|
// Convert to linear intensity values.
|
|
for (i=0; i<3; i++) {
|
|
channel[i] = colorspace.sRGB_to_linear(mult * parseInt(match[i+1], 16));
|
|
}
|
|
|
|
// Compute perceived lightness as CIE L*.
|
|
lightness = colorspace.luminance_to_lightness(
|
|
colorspace.rgb_luminance(channel));
|
|
|
|
// Determine if we're past the midpoint between the
|
|
// dark and light label lightness.
|
|
return (lightness < lightness_threshold) ? 'dark_background' : '';
|
|
});
|
|
|
|
exports.get_invite_only = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
if (sub === undefined) {
|
|
return false;
|
|
}
|
|
return sub.invite_only;
|
|
};
|
|
|
|
exports.receives_notifications = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
if (sub === undefined) {
|
|
return false;
|
|
}
|
|
return sub.notifications;
|
|
};
|
|
|
|
function populate_subscriptions(subs, subscribed) {
|
|
var sub_rows = [];
|
|
subs.sort(function (a, b) {
|
|
return util.strcmp(a.name, b.name);
|
|
});
|
|
subs.forEach(function (elem) {
|
|
var stream_name = elem.name;
|
|
var sub = create_sub(stream_name, {color: elem.color, in_home_view: elem.in_home_view,
|
|
invite_only: elem.invite_only,
|
|
notifications: elem.notifications, subscribed: subscribed});
|
|
sub_rows.push(sub);
|
|
});
|
|
|
|
stream_list.sort_narrow_list();
|
|
return sub_rows;
|
|
}
|
|
|
|
exports.reload_subscriptions = function (opts) {
|
|
var on_success;
|
|
opts = $.extend({}, {clear_first: false, custom_callbacks: false}, opts);
|
|
|
|
if (! opts.custom_callbacks) {
|
|
on_success = function (data) {
|
|
if (data) {
|
|
populate_subscriptions(data.subscriptions, true);
|
|
}
|
|
};
|
|
}
|
|
|
|
if (opts.clear_first) {
|
|
stream_info = {};
|
|
stream_list.remove_all_narrow_filters();
|
|
}
|
|
|
|
return $.ajax({
|
|
type: 'POST',
|
|
url: '/json/subscriptions/list',
|
|
dataType: 'json',
|
|
timeout: 10*1000,
|
|
success: on_success
|
|
});
|
|
};
|
|
|
|
exports.setup_page = function () {
|
|
util.make_loading_indicator($('#subs_page_loading_indicator'));
|
|
|
|
function populate_and_fill(stream_data, subscription_data) {
|
|
var all_streams = [];
|
|
var our_subs = [];
|
|
var sub_rows = [];
|
|
|
|
/* arguments are [ "success", statusText, jqXHR ] */
|
|
if (stream_data.length > 2 && stream_data[2]) {
|
|
var stream_response = JSON.parse(stream_data[2].responseText);
|
|
all_streams = stream_response.streams;
|
|
}
|
|
if (subscription_data.length > 2 && subscription_data[2]) {
|
|
var subs_response = JSON.parse(subscription_data[2].responseText);
|
|
our_subs = subs_response.subscriptions;
|
|
}
|
|
|
|
populate_subscriptions(our_subs, true);
|
|
|
|
all_streams.forEach(function (stream) {
|
|
var sub = exports.get(stream);
|
|
if (!sub) {
|
|
sub = create_sub(stream, {subscribed: false});
|
|
}
|
|
sub_rows.push(sub);
|
|
});
|
|
|
|
sub_rows.sort(function (streama, streamb) {
|
|
if (streama.subscribed && !streamb.subscribed) {
|
|
return -1;
|
|
} else if (streamb.subscribed && !streama.subscribed) {
|
|
return 1;
|
|
} else {
|
|
return util.strcmp(streama.name, streamb.name);
|
|
}
|
|
});
|
|
|
|
$('#subscriptions_table tr:gt(0)').remove();
|
|
$('#subscriptions_table').append(
|
|
templates.render('subscription', {subscriptions: sub_rows}));
|
|
|
|
util.destroy_loading_indicator($('#subs_page_loading_indicator'));
|
|
$('#create_stream_name').focus().select();
|
|
}
|
|
|
|
function failed_listing(xhr, error) {
|
|
util.destroy_loading_indicator($('#subs_page_loading_indicator'));
|
|
ui.report_error("Error listing streams or subscriptions", xhr, $("#subscriptions-status"));
|
|
}
|
|
|
|
var requests = [];
|
|
if (should_list_all_streams()) {
|
|
// This query must go first to prevent a race when we are not
|
|
// listing all streams
|
|
var req = $.ajax({
|
|
type: 'POST',
|
|
url: '/json/get_public_streams',
|
|
dataType: 'json',
|
|
timeout: 10*1000
|
|
});
|
|
requests.push(req);
|
|
} else {
|
|
// Handing an object to $.when() means that it counts as a 'success' with the
|
|
// object delivered directly to the callback
|
|
requests.push({streams: []});
|
|
$('#create_stream_button').val("Subscribe");
|
|
}
|
|
|
|
requests.push(exports.reload_subscriptions({custom_callbacks: true}));
|
|
|
|
// Trigger finished callback when:
|
|
// * Both AJAX requests are finished, if we sent themm both
|
|
// * Just one AJAX is finished if should_list_all_streams() is false
|
|
$.when.apply(this, requests).then(populate_and_fill, failed_listing);
|
|
};
|
|
|
|
exports.get = function (stream_name) {
|
|
return get_sub(stream_name);
|
|
};
|
|
|
|
exports.in_home_view = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
return sub !== undefined && sub.in_home_view;
|
|
};
|
|
|
|
exports.is_subscribed = function (stream_name) {
|
|
var sub = get_sub(stream_name);
|
|
return sub !== undefined && sub.subscribed;
|
|
};
|
|
|
|
function ajaxSubscribe(stream) {
|
|
// Subscribe yourself to a single stream.
|
|
var true_stream_name;
|
|
|
|
return $.ajax({
|
|
type: "POST",
|
|
url: "/json/subscriptions/add",
|
|
dataType: 'json', // This seems to be ignored. We still get back an xhr.
|
|
data: {"subscriptions": JSON.stringify([stream]) },
|
|
success: function (resp, statusText, xhr, form) {
|
|
$("#create_stream_name").val("");
|
|
|
|
var res = $.parseJSON(xhr.responseText);
|
|
if (!$.isEmptyObject(res.already_subscribed)) {
|
|
// Display the canonical stream capitalization.
|
|
true_stream_name = res.already_subscribed[page_params.email][0];
|
|
ui.report_success("Already subscribed to " + true_stream_name,
|
|
$("#subscriptions-status"));
|
|
}
|
|
// The rest of the work is done via the subscribe event we will get
|
|
},
|
|
error: function (xhr) {
|
|
ui.report_error("Error adding subscription", xhr, $("#subscriptions-status"));
|
|
$("#create_stream_name").focus();
|
|
}
|
|
});
|
|
}
|
|
|
|
function ajaxUnsubscribe(stream) {
|
|
$.ajax({
|
|
type: "POST",
|
|
url: "/json/subscriptions/remove",
|
|
dataType: 'json', // This seems to be ignored. We still get back an xhr.
|
|
data: {"subscriptions": JSON.stringify([stream]) },
|
|
success: function (resp, statusText, xhr, form) {
|
|
var name, res = $.parseJSON(xhr.responseText);
|
|
$("#subscriptions-status").hide();
|
|
// The rest of the work is done via the unsubscribe event we will get
|
|
},
|
|
error: function (xhr) {
|
|
ui.report_error("Error removing subscription", xhr, $("#subscriptions-status"));
|
|
$("#create_stream_name").focus();
|
|
}
|
|
});
|
|
}
|
|
|
|
function ajaxSubscribeForCreation(stream, principals, invite_only) {
|
|
// Subscribe yourself and possible other people to a new stream.
|
|
return $.ajax({
|
|
type: "POST",
|
|
url: "/json/subscriptions/add",
|
|
dataType: 'json', // This seems to be ignored. We still get back an xhr.
|
|
data: {"subscriptions": JSON.stringify([stream]),
|
|
"principals": JSON.stringify(principals),
|
|
"invite_only": JSON.stringify(invite_only)
|
|
},
|
|
success: function (data) {
|
|
$("#create_stream_name").val("");
|
|
$("#subscriptions-status").hide();
|
|
$('#stream-creation').modal("hide");
|
|
// The rest of the work is done via the subscribe event we will get
|
|
},
|
|
error: function (xhr) {
|
|
ui.report_error("Error creating stream", xhr, $("#subscriptions-status"));
|
|
$('#stream-creation').modal("hide");
|
|
}
|
|
});
|
|
}
|
|
|
|
// The tutorial bot needs this function to add you to the
|
|
// tutorial-yourname stream.
|
|
exports.tutorial_subscribe_or_add_me_to = function (stream_name) {
|
|
var stream_status = compose.check_stream_existence(stream_name);
|
|
if (stream_status === 'does-not-exist') {
|
|
return ajaxSubscribeForCreation(stream_name, [page_params.email], false);
|
|
} else {
|
|
return ajaxSubscribe(stream_name);
|
|
}
|
|
};
|
|
|
|
exports.tutorial_unsubscribe_me_from = function (stream_name) {
|
|
ajaxUnsubscribe(stream_name);
|
|
};
|
|
|
|
function people_cmp(person1, person2) {
|
|
// Compares objects of the form used in people_list.
|
|
var name_cmp = util.strcmp(person1.full_name, person2.full_name);
|
|
if (name_cmp < 0) {
|
|
return -1;
|
|
} else if (name_cmp > 0) {
|
|
return 1;
|
|
}
|
|
return util.strcmp(person1.email, person2.email);
|
|
}
|
|
|
|
function show_new_stream_modal() {
|
|
var people_minus_you_and_maybe_humbuggers = [];
|
|
$.each(page_params.people_list, function (idx, person) {
|
|
if (person.email !== page_params.email &&
|
|
(page_params.domain === "humbughq.com" ||
|
|
person.email.split('@')[1] !== "humbughq.com"
|
|
)
|
|
) {
|
|
people_minus_you_and_maybe_humbuggers.push({"email": person.email,
|
|
"full_name": person.full_name});
|
|
}
|
|
});
|
|
|
|
$('#people_to_add').html(templates.render('new_stream_users', {
|
|
users: people_minus_you_and_maybe_humbuggers.sort(people_cmp)
|
|
}));
|
|
$('#stream-creation').modal("show");
|
|
}
|
|
|
|
$(function () {
|
|
var i;
|
|
// Populate stream_info with data handed over to client-side template.
|
|
populate_subscriptions(page_params.stream_list, true);
|
|
populate_subscriptions(page_params.unsubbed_info, false);
|
|
|
|
$("#add_new_subscription").on("submit", function (e) {
|
|
e.preventDefault();
|
|
|
|
if (!should_list_all_streams()) {
|
|
ajaxSubscribe($("#create_stream_name").val());
|
|
return;
|
|
}
|
|
|
|
var stream = $.trim($("#create_stream_name").val());
|
|
var stream_status = compose.check_stream_existence(stream);
|
|
if (stream_status === "does-not-exist") {
|
|
$("#stream_name").text(stream);
|
|
show_new_stream_modal();
|
|
} else {
|
|
ajaxSubscribe(stream);
|
|
}
|
|
});
|
|
|
|
$("#stream_creation_form").on("submit", function (e) {
|
|
e.preventDefault();
|
|
var stream = $.trim($("#create_stream_name").val());
|
|
var principals = [];
|
|
$("#stream_creation_form input:checkbox[name=user]:checked").each(function () {
|
|
principals.push($(this).val());
|
|
});
|
|
// You are always subscribed to streams you create.
|
|
principals.push(page_params.email);
|
|
ajaxSubscribeForCreation(stream,
|
|
principals,
|
|
$('#stream_creation_form input[name=privacy]:checked').val() === "invite-only"
|
|
);
|
|
});
|
|
|
|
$("#subscriptions_table").on("click", ".sub_unsub_button", function (e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
var sub_row = $(e.target).closest('.subscription_row');
|
|
var stream_name = sub_row.find('.subscription_name').text();
|
|
var sub = get_sub(stream_name);
|
|
|
|
if (sub.subscribed) {
|
|
ajaxUnsubscribe(stream_name);
|
|
} else {
|
|
ajaxSubscribe(stream_name);
|
|
}
|
|
});
|
|
|
|
$("#subscriptions_table").on("show", ".subscription_settings", function (e) {
|
|
var subrow = $(e.target).closest('.subscription_row');
|
|
var colorpicker = subrow.find('.colorpicker');
|
|
colorpicker.spectrum(subscriptions_table_colorpicker_options);
|
|
|
|
// To figure out the worst case for an expanded row's height, we do some math:
|
|
// .subscriber_list_container max-height,
|
|
// .subscriber_list_settings,
|
|
// .regular_subscription_settings
|
|
// .subscription_header line-height,
|
|
// .subscription_header padding
|
|
var expanded_row_size = 200 + 30 + 100 + 30 + 5;
|
|
var cover = subrow.position().top + expanded_row_size -
|
|
viewport.height() + $("#top_navbar").height() - viewport.scrollTop();
|
|
if (cover > 0) {
|
|
$('html, body').animate({
|
|
scrollTop: viewport.scrollTop() + cover + 5
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
$("#subscriptions_table").on("click", ".sub_setting_checkbox", function (e) {
|
|
var control = $(e.target).closest('.sub_setting_checkbox').find('.sub_setting_control');
|
|
// A hack. Don't change the state of the checkbox if we
|
|
// clicked on the checkbox itself.
|
|
if (control[0] !== e.target) {
|
|
control.prop("checked", ! control.prop("checked"));
|
|
}
|
|
});
|
|
$("#subscriptions_table").on("click", "#sub_setting_in_home_view", stream_home_view_clicked);
|
|
$("#subscriptions_table").on("click", "#sub_setting_notifications", stream_notifications_clicked);
|
|
|
|
if (! should_render_subscribers()) {
|
|
return;
|
|
}
|
|
|
|
// From here down is only stuff that happens when we're rendering
|
|
// the subscriber settings
|
|
|
|
$("#subscriptions_table").on("submit", ".subscriber_list_add form", function (e) {
|
|
e.preventDefault();
|
|
var sub_row = $(e.target).closest('.subscription_row');
|
|
var stream = sub_row.find('.subscription_name').text();
|
|
var text_box = sub_row.find('input[name="principal"]');
|
|
var principal = $.trim(text_box.val());
|
|
// TODO: clean up this error handling
|
|
var error_elem = sub_row.find('.subscriber_list_container .alert-error');
|
|
var warning_elem = sub_row.find('.subscriber_list_container .alert-warning');
|
|
var list = sub_row.find('.subscriber_list_container ul');
|
|
|
|
$.ajax({
|
|
type: "POST",
|
|
url: "/json/subscriptions/add",
|
|
dataType: 'json',
|
|
data: {"subscriptions": JSON.stringify([stream]),
|
|
"principals": JSON.stringify([principal])},
|
|
success: function (data) {
|
|
text_box.val('');
|
|
|
|
if (data.subscribed.hasOwnProperty(principal)) {
|
|
error_elem.addClass("hide");
|
|
warning_elem.addClass("hide");
|
|
if (principal === page_params.email) {
|
|
// mark_subscribed adds the user to the member list
|
|
mark_subscribed(stream);
|
|
} else {
|
|
add_to_member_list(list, people_dict[principal].full_name, principal);
|
|
}
|
|
} else {
|
|
error_elem.addClass("hide");
|
|
warning_elem.removeClass("hide").text("User already subscribed");
|
|
}
|
|
},
|
|
error: function (xhr) {
|
|
warning_elem.addClass("hide");
|
|
error_elem.removeClass("hide").text("Could not add user to this stream");
|
|
}
|
|
});
|
|
});
|
|
|
|
$("#subscriptions_table").on("show", ".regular_subscription_settings", function (e) {
|
|
// We want 'show' events that originate from
|
|
// 'regular_subscription_settings' divs not to trigger the
|
|
// handler for the entire subscription_settings div
|
|
e.stopPropagation();
|
|
});
|
|
|
|
$("#subscriptions_table").on("show", ".subscription_settings", function (e) {
|
|
var sub_row = $(e.target).closest('.subscription_row');
|
|
var stream = sub_row.find('.subscription_name').text();
|
|
var warning_elem = sub_row.find('.subscriber_list_container .alert-warning');
|
|
var error_elem = sub_row.find('.subscriber_list_container .alert-error');
|
|
var list = sub_row.find('.subscriber_list_container ul');
|
|
var indicator_elem = sub_row.find('.subscriber_list_loading_indicator');
|
|
|
|
warning_elem.addClass('hide');
|
|
error_elem.addClass('hide');
|
|
list.empty();
|
|
|
|
util.make_loading_indicator(indicator_elem);
|
|
|
|
$.ajax({
|
|
type: "POST",
|
|
url: "/json/get_subscribers",
|
|
dataType: 'json', // This seems to be ignored. We still get back an xhr.
|
|
data: {stream: stream},
|
|
success: function (data) {
|
|
util.destroy_loading_indicator(indicator_elem);
|
|
var subscribers = $.map(data.subscribers, function (elem) {
|
|
var person = people_dict[elem];
|
|
if (person === undefined) {
|
|
return elem;
|
|
}
|
|
return format_member_list_elem(people_dict[elem].full_name, elem);
|
|
});
|
|
$.each(subscribers.sort().reverse(), function (idx, elem) {
|
|
// add_to_member_list *prepends* the element,
|
|
// so we need to sort in reverse order for it to
|
|
// appear in alphabetical order.
|
|
add_to_member_list(list, elem);
|
|
});
|
|
},
|
|
error: function (xhr) {
|
|
util.destroy_loading_indicator(indicator_elem);
|
|
error_elem.removeClass("hide").text("Could not fetch subscriber list");
|
|
}
|
|
});
|
|
|
|
sub_row.find('input[name="principal"]').typeahead({
|
|
source: typeahead_helper.private_message_typeahead_list,
|
|
items: 4,
|
|
highlighter: function (item) {
|
|
var query = this.query;
|
|
return typeahead_helper.highlight_with_escaping(query, item);
|
|
},
|
|
matcher: function (item) {
|
|
var query = $.trim(this.query);
|
|
if (query === '') {
|
|
return false;
|
|
}
|
|
// Case-insensitive.
|
|
return (item.toLowerCase().indexOf(query.toLowerCase()) !== -1);
|
|
},
|
|
updater: function (item) {
|
|
return typeahead_helper.private_message_mapped[item].email;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
function focus_on_narrowed_stream() {
|
|
var operators = narrow.operators();
|
|
if (operators.length === 0) {
|
|
return;
|
|
}
|
|
var stream_name = operators[0][1];
|
|
var sub = get_sub(stream_name);
|
|
if (sub !== undefined) {
|
|
// This stream is in the list, so focus on it.
|
|
$('html, body').animate({
|
|
scrollTop: settings_for_sub(sub).offset().top
|
|
});
|
|
} else {
|
|
// This stream doesn't exist, so prep for creating it.
|
|
$("#create_stream_name").val(stream_name);
|
|
}
|
|
}
|
|
|
|
exports.show_and_focus_on_narrow = function () {
|
|
$("#gear-menu a[href='#subscriptions']").one('shown',
|
|
focus_on_narrowed_stream);
|
|
ui.change_tab_to("#subscriptions");
|
|
};
|
|
|
|
return exports;
|
|
|
|
}());
|