web/src/settings_users.ts - main - githubmirror/zulip

web/src/settings_users.ts
809 строк29 KB
Anders Kaseorg
eslint: Fix unicorn/prefer-location-assign.
29 июл 2026, 02:35
29 июл 2026, 02:354a9ac4e
import {$} from "jquery";
import assert from "minimalistic-assert";
import type * as tippy from "tippy.js";

import render_settings_user_list_row from "../templates/settings/settings_user_list_row.hbs";

import {compute_active_status, post_presence_response_schema} from "./activity.ts";
import * as blueslip from "./blueslip.ts";
import * as browser_history from "./browser_history.ts";
import * as channel from "./channel.ts";
import * as dialog_widget from "./dialog_widget.ts";
import * as dropdown_widget from "./dropdown_widget.ts";
import {$t} from "./i18n.ts";
import type {ListWidget as ListWidgetType} from "./list_widget.ts";
import * as ListWidget from "./list_widget.ts";
import * as loading from "./loading.ts";
import {page_params} from "./page_params.ts";
import * as people from "./people.ts";
import type {User} from "./people.ts";
import * as presence from "./presence.ts";
import * as scroll_util from "./scroll_util.ts";
import * as settings_config from "./settings_config.ts";
import * as setting_invites from "./settings_invites.ts";
import {current_user} from "./state_data.ts";
import * as timerender from "./timerender.ts";
import * as user_deactivation_ui from "./user_deactivation_ui.ts";
import * as user_profile from "./user_profile.ts";
import * as user_sort from "./user_sort.ts";
import * as util from "./util.ts";

export const active_user_list_dropdown_widget_name = "active_user_list_select_user_role";
export const deactivated_user_list_dropdown_widget_name = "deactivated_user_list_select_user_role";
export const imported_user_list_dropdown_widget_name = "imported_user_list_select_user_role";

let should_redraw_active_users_list = false;
let should_redraw_deactivated_users_list = false;
let should_redraw_imported_users_list = false;
let presence_data_fetched = false;
let active_users_role_dropdown: dropdown_widget.DropdownWidget | undefined;
let deactivated_users_role_dropdown: dropdown_widget.DropdownWidget | undefined;
let imported_users_role_dropdown: dropdown_widget.DropdownWidget | undefined;

type UserSettingsSection = {
    dropdown_widget_name: string;
    filters: {
        text_search: string;
        role_code: number;
    };
    handle_events: () => void;
    create_table: (active_users: number[]) => void;
    list_widget: ListWidgetType<number, User> | undefined;
};

const active_section: UserSettingsSection = {
    dropdown_widget_name: active_user_list_dropdown_widget_name,
    filters: {
        text_search: "",
        // 0 role_code signifies All roles for our filter.
        role_code: 0,
    },
    handle_events: active_handle_events,
    create_table: active_create_table,
    list_widget: undefined,
};

const deactivated_section: UserSettingsSection = {
    dropdown_widget_name: deactivated_user_list_dropdown_widget_name,
    filters: {
        text_search: "",
        // 0 role_code signifies All roles for our filter.
        role_code: 0,
    },
    handle_events: deactivated_handle_events,
    create_table: deactivated_create_table,
    list_widget: undefined,
};

const imported_section: UserSettingsSection = {
    dropdown_widget_name: imported_user_list_dropdown_widget_name,
    filters: {
        text_search: "",
        // 0 role_code signifies All roles for our filter.
        role_code: 0,
    },
    handle_events: imported_handle_events,
    create_table: imported_create_table,
    list_widget: undefined,
};

function sort_last_active(a: User, b: User): number {
    return util.compare_a_b(
        presence.last_active_date(a.user_id) ?? 0,
        presence.last_active_date(b.user_id) ?? 0,
    );
}

function get_user_info_row(user_id: number): JQuery {
    return $(`tr.user_row[data-user-id='${CSS.escape(user_id.toString())}']`);
}

export function allow_sorting_deactivated_users_list_by_email(): boolean {
    const deactivated_users = people.get_non_active_realm_users();
    const deactivated_humans_with_visible_email = deactivated_users.filter(
        (user) => !user.is_bot && user.delivery_email,
    );

    return deactivated_humans_with_visible_email.length > 0;
}

export function update_view_on_deactivate(user_id: number, is_bot: boolean): void {
    const $row = get_user_info_row(user_id);
    if ($row.length === 0) {
        return;
    }

    const $button = $row.find("button.deactivate");
    $button.prop("disabled", false);
    $row.find("i.deactivated-user-icon").show();
    $button.addClass("icon-button-success reactivate");
    $button.removeClass("icon-button-danger deactivate");
    if (is_bot) {
        $button.closest("span").addClass("reactivate-bot-tooltip");
        $button.closest("span").removeClass("deactivate-bot-tooltip");
    } else {
        $button.closest("span").addClass("reactivate-user-tooltip");
        $button.closest("span").removeClass("deactivate-user-tooltip");
    }
    $button
        .empty()
        .append(
            $("<i>").addClass(["zulip-icon", "zulip-icon-user-plus"]).attr("aria-hidden", "true"),
        );
    $row.removeClass("active-user");
    $row.addClass("deactivated_user");

    if (!is_bot) {
        should_redraw_active_users_list = true;
        should_redraw_deactivated_users_list = true;
        if (active_users_role_dropdown) {
            active_users_role_dropdown.render(active_section.filters.role_code);
        }
        if (deactivated_users_role_dropdown) {
            deactivated_users_role_dropdown.render(deactivated_section.filters.role_code);
        }
        const user = people.get_by_user_id(user_id);
        if (user.is_imported_stub) {
            should_redraw_imported_users_list = true;
            if (imported_users_role_dropdown) {
                imported_users_role_dropdown.render(imported_section.filters.role_code);
            }
        }
    }
}

export function update_view_on_reactivate(user_id: number, is_bot: boolean): void {
    const $row = get_user_info_row(user_id);
    if ($row.length === 0) {
        return;
    }

    const $button = $row.find("button.reactivate");
    $row.find("i.deactivated-user-icon").hide();
    $button.addClass("icon-button-danger deactivate");
    $button.removeClass("icon-button-success reactivate");
    if (is_bot) {
        $button.closest("span").addClass("deactivate-bot-tooltip");
        $button.closest("span").removeClass("reactivate-bot-tooltip");
    } else {
        $button.closest("span").addClass("deactivate-user-tooltip");
        $button.closest("span").removeClass("reactivate-user-tooltip");
    }
    $button
        .empty()
        .append($("<i>").addClass(["zulip-icon", "zulip-icon-user-x"]).attr("aria-hidden", "true"));
    $row.removeClass("deactivated_user");
    $row.addClass("active-user");

    if (!is_bot) {
        should_redraw_active_users_list = true;
        should_redraw_deactivated_users_list = true;
        if (active_users_role_dropdown) {
            active_users_role_dropdown.render(active_section.filters.role_code);
        }
        if (deactivated_users_role_dropdown) {
            deactivated_users_role_dropdown.render(deactivated_section.filters.role_code);
        }
        const user = people.get_by_user_id(user_id);
        if (user.is_imported_stub) {
            should_redraw_imported_users_list = true;
            if (imported_users_role_dropdown) {
                imported_users_role_dropdown.render(imported_section.filters.role_code);
            }
        }
    }
}

function add_value_to_filters(
    section: UserSettingsSection,
    key: "role_code" | "text_search",
    value: number | string,
): void {
    if (key === "role_code") {
        assert(typeof value === "number");
        section.filters.role_code = value;
    } else {
        assert(key === "text_search");
        assert(typeof value === "string");
        section.filters.text_search = value;
    }
    // This hard_redraw will rerun the relevant predicate function
    // and in turn apply the new filters.
    assert(section.list_widget !== undefined);
    section.list_widget.hard_redraw();
}

function are_filters_active(
    filters: UserSettingsSection["filters"],
    $search_input: JQuery,
): boolean {
    const search_value = String($search_input.val()).trim();
    return Boolean(search_value) || filters.role_code !== 0;
}

function role_selected_handler(
    event: JQuery.ClickEvent,
    dropdown: tippy.Instance,
    widget: dropdown_widget.DropdownWidget,
): void {
    event.preventDefault();
    event.stopPropagation();

    const role_code = Number($(event.currentTarget).attr("data-unique-id"));
    switch (widget.widget_name) {
        case active_section.dropdown_widget_name:
            add_value_to_filters(active_section, "role_code", role_code);
            break;
        case deactivated_section.dropdown_widget_name:
            add_value_to_filters(deactivated_section, "role_code", role_code);
            break;
        case imported_section.dropdown_widget_name:
            add_value_to_filters(imported_section, "role_code", role_code);
            break;
        default:
            blueslip.error("No dropdown widget with the given name", {
                widget_name: widget.widget_name,
            });
    }

    dropdown.hide();
    widget.render();
}

function count_users_by_role(user_ids: number[]): Record<number, number> {
    const role_counts: Record<number, number> = {};

    for (const user_id of user_ids) {
        const user = people.get_by_user_id(user_id);
        const role_code = user.role;

        role_counts[role_code] = (role_counts[role_code] ?? 0) + 1;
    }

    return role_counts;
}

function get_roles_with_counts(user_ids: number[]): dropdown_widget.Option[] {
    const role_counts = count_users_by_role(user_ids);
    return [
        {
            unique_id: 0,
            name: $t({defaultMessage: "All roles ({count})"}, {count: user_ids.length}),
        },
        ...Object.values(settings_config.user_role_values)
            .map((user_role_value) => ({
                unique_id: user_role_value.code,
                name: $t(
                    // This translation is a noop except for RTL languages
                    {defaultMessage: "{description} ({count})"},
                    {
                        description: user_role_value.description,
                        count: role_counts[user_role_value.code] ?? 0,
                    },
                ),
            }))
            .toReversed(),
    ];
}

function get_roles_count_for_active_users(): dropdown_widget.Option[] {
    const active_user_ids = people.get_realm_active_human_user_ids_for_users_panel();
    return get_roles_with_counts(active_user_ids);
}

function get_roles_count_for_deactivated_users(): dropdown_widget.Option[] {
    const deactivated_user_ids = people.get_non_active_human_ids();
    return get_roles_with_counts(deactivated_user_ids);
}

function get_roles_count_for_imported_users(): dropdown_widget.Option[] {
    const imported_user_ids = people.get_realm_active_imported_stub_user_ids();
    return get_roles_with_counts(imported_user_ids);
}

function create_role_filter_dropdown(
    $events_container: JQuery,
    section: UserSettingsSection,
    get_role_options: () => dropdown_widget.Option[],
): dropdown_widget.DropdownWidget {
    return new dropdown_widget.DropdownWidget({
        widget_name: section.dropdown_widget_name,
        unique_id_type: "number",
        get_options: get_role_options,
        $events_container,
        item_click_callback: role_selected_handler,
        default_id: section.filters.role_code,
        tippy_props: {
            offset: [0, 0],
        },
    });
}

function initialize_user_sections(
    active_user_ids: number[],
    deactivated_user_ids: number[],
    imported_user_ids?: number[],
): void {
    active_section.create_table(active_user_ids);
    deactivated_section.create_table(deactivated_user_ids);
    active_users_role_dropdown = create_role_filter_dropdown(
        $("#admin-user-list"),
        active_section,
        get_roles_count_for_active_users,
    );
    deactivated_users_role_dropdown = create_role_filter_dropdown(
        $("#admin-deactivated-users-list"),
        deactivated_section,
        get_roles_count_for_deactivated_users,
    );
    active_users_role_dropdown.setup();
    deactivated_users_role_dropdown.setup();

    if (imported_user_ids !== undefined) {
        // Imported stub user IDs are not passed when re-rendering
        // the table after fetching presence data, because we do
        // not show last active date in the imported users table.
        imported_section.create_table(imported_user_ids);
        imported_users_role_dropdown = create_role_filter_dropdown(
            $("#admin-imported-users-list"),
            imported_section,
            get_roles_count_for_imported_users,
        );
        imported_users_role_dropdown.setup();
    }
}

function populate_users(): void {
    const active_user_ids = people.get_realm_active_human_user_ids_for_users_panel();
    const deactivated_user_ids = people.get_non_active_human_ids();
    const imported_user_ids = people.get_realm_active_imported_stub_user_ids();

    if (!presence_data_fetched) {
        fetch_presence_user_setting({
            render_table() {
                const active_user_ids = people.get_realm_active_human_user_ids_for_users_panel();
                const deactivated_user_ids = people.get_non_active_human_ids();
                presence_data_fetched = true;
                initialize_user_sections(active_user_ids, deactivated_user_ids);
            },
        });
    }
    initialize_user_sections(active_user_ids, deactivated_user_ids, imported_user_ids);
}

function reset_scrollbar($sel: JQuery): () => void {
    return function () {
        scroll_util.reset_scrollbar($sel);
    };
}

function get_last_active(user: User): string {
    const last_active_date = presence.last_active_date(user.user_id);
    if (!last_active_date && presence_data_fetched) {
        return timerender.render_now(new Date(user.date_joined)).time_str;
    }
    if (!last_active_date) {
        setTimeout(() => {
            loading.make_indicator(
                $(
                    `.user_row[data-user-id='${CSS.escape(user.user_id.toString())}'] .loading-placeholder`,
                ),
            );
        }, 0);
        return "";
    }
    return timerender.render_now(last_active_date).time_str;
}

function human_info(person: User): {
    is_bot: false;
    user_role_text: string | undefined;
    is_active: boolean;
    user_id: number;
    full_name: string;
    bot_owner_id: number | null;
    can_modify: boolean;
    is_current_user: boolean;
    cannot_deactivate: boolean;
    display_email: string | null;
    img_src: string;
    last_active_date: string;
} {
    return {
        is_bot: false,
        user_role_text: people.get_user_type(person.user_id),
        is_active: people.is_person_active(person.user_id),
        user_id: person.user_id,
        full_name: person.full_name,
        bot_owner_id: person.is_bot ? person.bot_owner_id : null,
        can_modify: current_user.is_admin,
        is_current_user: people.is_my_user_id(person.user_id),
        cannot_deactivate:
            person.is_owner && (!current_user.is_owner || people.is_current_user_only_owner()),
        display_email: person.delivery_email,
        img_src: people.small_avatar_url_for_person(person),
        // TODO: This is not shown in deactivated users table and it is
        // controlled by `display_last_active_column` We might just want
        // to show this for deactivated users, too, even though it might
        // usually just be undefined.
        last_active_date: get_last_active(person),
    };
}

export function set_text_search_value($table: JQuery, value: string): void {
    $table.closest(".user-or-bot-settings-section").find(".search").val(value);
}

function active_create_table(active_users: number[]): void {
    const $users_table = $("#admin_users_table");
    active_section.list_widget = ListWidget.create($users_table, active_users, {
        name: "users_table_list",
        get_item: people.get_by_user_id,
        modifier_html(item) {
            return render_settings_user_list_row({
                ...human_info(item),
                display_last_active_column: true,
            });
        },
        filter: {
            predicate(person) {
                return people.predicate_for_user_settings_filters(person, active_section.filters);
            },
            is_active() {
                const $search_input = $("#admin-active-users-list .search");
                return are_filters_active(active_section.filters, $search_input);
            },
            onupdate: reset_scrollbar($users_table),
        },
        $parent_container: $("#admin-active-users-list").expectOne(),
        init_sort: "full_name_alphabetic",
        sort_fields: {
            email: user_sort.sort_email,
            last_active: sort_last_active,
            role: user_sort.sort_role,
            id: user_sort.sort_user_id,
            ...ListWidget.generic_sort_functions("alphabetic", ["full_name"]),
        },
        $simplebar_container: $("#admin-active-users-list .progressive-table-wrapper"),
    });
    loading.destroy_indicator($("#admin_page_users_loading_indicator"));
    set_text_search_value($users_table, active_section.filters.text_search);
    $("#admin_users_table").show();
}

export function handle_clear_button_for_table_search_input($tbody: JQuery): void {
    const $container = $tbody.closest(".user-or-bot-settings-section");
    $container.on("click", ".clear-filter", (e) => {
        e.stopPropagation();
        e.preventDefault();
        const $filter = $container.find(".search");
        set_text_search_value($tbody, "");
        $filter.trigger("input");
    });
}

function deactivated_create_table(deactivated_users: number[]): void {
    const $deactivated_users_table = $("#admin_deactivated_users_table");
    deactivated_section.list_widget = ListWidget.create(
        $deactivated_users_table,
        deactivated_users,
        {
            name: "deactivated_users_table_list",
            get_item: people.get_by_user_id,
            modifier_html(item) {
                return render_settings_user_list_row({
                    ...human_info(item),
                    display_last_active_column: false,
                });
            },
            filter: {
                predicate(person) {
                    return people.predicate_for_user_settings_filters(
                        person,
                        deactivated_section.filters,
                    );
                },
                is_active() {
                    const $search_input = $("#admin-deactivated-users-list .search");
                    return are_filters_active(deactivated_section.filters, $search_input);
                },
                onupdate: reset_scrollbar($deactivated_users_table),
            },
            $parent_container: $("#admin-deactivated-users-list").expectOne(),
            init_sort: "full_name_alphabetic",
            sort_fields: {
                email: user_sort.sort_email,
                role: user_sort.sort_role,
                id: user_sort.sort_user_id,
                ...ListWidget.generic_sort_functions("alphabetic", ["full_name"]),
            },
            $simplebar_container: $("#admin-deactivated-users-list .progressive-table-wrapper"),
        },
    );
    loading.destroy_indicator($("#admin_page_deactivated_users_loading_indicator"));
    set_text_search_value($deactivated_users_table, deactivated_section.filters.text_search);
    $("#admin_deactivated_users_table").show();
}

function imported_create_table(imported_users: number[]): void {
    const $imported_users_table = $("#admin_imported_users_table");
    imported_section.list_widget = ListWidget.create($imported_users_table, imported_users, {
        name: "imported_users_table_list",
        get_item: people.get_by_user_id,
        modifier_html(item) {
            return render_settings_user_list_row({
                ...human_info(item),
                display_last_active_column: false,
            });
        },
        filter: {
            predicate(person) {
                return people.predicate_for_user_settings_filters(person, imported_section.filters);
            },
            is_active() {
                const $search_input = $("#admin-imported-users-list .search");
                return are_filters_active(imported_section.filters, $search_input);
            },
            onupdate: reset_scrollbar($imported_users_table),
        },
        $parent_container: $("#admin-imported-users-list").expectOne(),
        init_sort: "full_name_alphabetic",
        sort_fields: {
            email: user_sort.sort_email,
            role: user_sort.sort_role,
            id: user_sort.sort_user_id,
            ...ListWidget.generic_sort_functions("alphabetic", ["full_name"]),
        },
        $simplebar_container: $("#admin-imported-users-list .progressive-table-wrapper"),
    });
    loading.destroy_indicator($("#admin_page_imported_users_loading_indicator"));
    set_text_search_value($imported_users_table, imported_section.filters.text_search);
    $("#admin_imported_users_table").show();
}

export function update_user_data(
    user_id: number,
    new_data: {full_name?: string; role?: number},
): void {
    const $user_row = get_user_info_row(user_id);

    if ($user_row.length === 0) {
        return;
    }

    if (new_data.full_name !== undefined) {
        // Update the full name in the table
        $user_row.find(".pill-container .view_user_profile .pill-value").text(new_data.full_name);
    }

    if (new_data.role !== undefined) {
        const user_type = people.get_user_type(user_id);
        if (user_type) {
            $user_row.find(".user_role").text(user_type);
        }
    }
}

export function redraw_deactivated_users_list(): void {
    if (!should_redraw_deactivated_users_list || !deactivated_section.list_widget) {
        return;
    }
    const deactivated_user_ids = people.get_non_active_human_ids();
    deactivated_section.list_widget.replace_list_data(deactivated_user_ids);
    should_redraw_deactivated_users_list = false;
}

export function redraw_active_users_list(): void {
    if (!should_redraw_active_users_list || !active_section.list_widget) {
        return;
    }
    const active_user_ids = people.get_realm_active_human_user_ids_for_users_panel();
    active_section.list_widget.replace_list_data(active_user_ids);
    should_redraw_active_users_list = false;
}

export function redraw_imported_users_list(force_update = false): void {
    if ((!force_update && !should_redraw_imported_users_list) || !imported_section.list_widget) {
        return;
    }

    const imported_user_ids = people.get_realm_active_imported_stub_user_ids();
    imported_section.list_widget.replace_list_data(imported_user_ids);
    should_redraw_imported_users_list = false;
    // This is needed to make sure that the imported user is shown
    // in "Users" tab.
    should_redraw_active_users_list = true;
}

function start_data_load(): void {
    loading.make_indicator($("#admin_page_users_loading_indicator"), {
        text: $t({defaultMessage: "Loading…"}),
    });
    loading.make_indicator($("#admin_page_deactivated_users_loading_indicator"), {
        text: $t({defaultMessage: "Loading…"}),
    });
    loading.make_indicator($("#admin_page_imported_users_loading_indicator"), {
        text: $t({defaultMessage: "Loading…"}),
    });
    $("#admin_deactivated_users_table").hide();
    $("#admin_users_table").hide();
    $("#admin_imported_users_table").hide();

    populate_users();
}

function handle_deactivation($tbody: JQuery): void {
    $tbody.on("click", ".deactivate", (e) => {
        // This click event must not get propagated to parent container otherwise the modal
        // will not show up because of a call to `close_active` in `settings.ts`.
        e.preventDefault();
        e.stopPropagation();

        const $row = $(e.target).closest(".user_row");
        const user_id = Number($row.attr("data-user-id"));

        let url = "/json/users/" + encodeURIComponent(user_id);
        if (user_id === current_user.user_id) {
            url = "/json/users/me";
        }

        function handle_confirm(): void {
            const data: Record<string, unknown> = {};

            const deactivation_actions: Record<string, boolean> = {};
            for (const elem of $(".deactivate-actions input[type='checkbox']:checked")) {
                deactivation_actions[$(elem).attr("data-key")!] = true;
            }
            data["actions"] = JSON.stringify(deactivation_actions);

            // Handle deactivation notification
            if ($(".send_email").is(":checked")) {
                data["deactivation_notification_comment"] = $(".email_field_textarea").val();
            }

            if (user_id === current_user.user_id) {
                dialog_widget.submit_api_request(channel.del, url, data, {
                    success_continuation() {
                        window.location.assign("/login/");
                    },
                });
            } else {
                dialog_widget.submit_api_request(channel.del, url, data);
            }
        }

        user_deactivation_ui.confirm_deactivation(user_id, handle_confirm, true);
    });
}

export function handle_reactivation($tbody: JQuery): void {
    $tbody.on("click", ".reactivate", (e) => {
        e.preventDefault();
        e.stopPropagation();

        // Go up the tree until we find the user row, then grab the email element
        const $button_elem = $(e.target);
        const $row = $button_elem.closest(".user_row");
        const user_id = Number.parseInt($row.attr("data-user-id")!, 10);

        function handle_confirm(): void {
            const url = "/json/users/" + encodeURIComponent(user_id) + "/reactivate";
            dialog_widget.submit_api_request(channel.post, url, {});
        }

        user_deactivation_ui.confirm_reactivation(user_id, handle_confirm, true);
    });
}

export function handle_edit_form($tbody: JQuery): void {
    $tbody.on("click", ".open-user-form", function (this: HTMLElement, e) {
        e.stopPropagation();
        e.preventDefault();

        const user_id = Number.parseInt($(this).closest("tr").attr("data-user-id")!, 10);
        if (people.is_my_user_id(user_id)) {
            browser_history.go_to_location("#settings/profile");
            return;
        }

        user_profile.show_user_profile(user_id, "manage-profile-tab");
    });
}

function handle_filter_change($tbody: JQuery, section: UserSettingsSection): void {
    // This duplicates the built-in search filter live-update logic in
    // ListWidget for the input.list_widget_filter event type, but we
    // can't use that, because we're also filtering on Role with our
    // custom predicate.
    $tbody
        .closest(".user-or-bot-settings-section")
        .find<HTMLInputElement>(".search")
        .on("input.list_widget_filter", function (this: HTMLInputElement) {
            add_value_to_filters(section, "text_search", this.value.toLocaleLowerCase());
        });
}

function active_handle_events(): void {
    const $tbody = $("#admin_users_table").expectOne();

    handle_filter_change($tbody, active_section);
    handle_deactivation($tbody);
    handle_reactivation($tbody);
    handle_edit_form($tbody);
    handle_clear_button_for_table_search_input($tbody);
}

function deactivated_handle_events(): void {
    const $tbody = $("#admin_deactivated_users_table").expectOne();

    handle_filter_change($tbody, deactivated_section);
    handle_deactivation($tbody);
    handle_reactivation($tbody);
    handle_edit_form($tbody);
    handle_clear_button_for_table_search_input($tbody);
}

function imported_handle_events(): void {
    const $tbody = $("#admin_imported_users_table").expectOne();

    handle_filter_change($tbody, imported_section);
    handle_deactivation($tbody);
    handle_reactivation($tbody);
    handle_edit_form($tbody);
    handle_clear_button_for_table_search_input($tbody);
}

export function set_up_humans(): void {
    start_data_load();
    active_section.handle_events();
    deactivated_section.handle_events();
    imported_section.handle_events();
    setting_invites.set_up();
}

type FetchPresenceUserSettingParams = {
    render_table: () => void;
};

export function fetch_presence_user_setting({render_table}: FetchPresenceUserSettingParams): void {
    if (page_params.is_spectator) {
        render_table();
        return;
    }

    channel.post({
        url: "/json/users/me/presence",
        data: {
            status: compute_active_status(),
            ping_only: false,
            last_update_id: -1,
            history_limit_days: 365 * 1000,
        },
        success(response) {
            const data = post_presence_response_schema.parse(response);

            if (data.presences) {
                assert(
                    data.presences !== undefined,
                    "Presences should be present if not a ping only presence request",
                );
                assert(
                    data.server_timestamp !== undefined,
                    "Server timestamp should be present if not a ping only presence request",
                );
                assert(
                    data.presence_last_update_id !== undefined,
                    "Presence last update id should be present if not a ping only presence request",
                );

                // the next regular default presence check in with the server should naturally pick up from here.
                presence.set_info(
                    data.presences,
                    data.server_timestamp,
                    data.presence_last_update_id,
                );
            }
            render_table();
        },
    });
}